From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 111795 invoked by alias); 9 Dec 2016 13:15:50 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 111414 invoked by uid 89); 9 Dec 2016 13:15:39 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-4.9 required=5.0 tests=BAYES_00,RP_MATCHES_RCVD,SPF_PASS autolearn=ham version=3.3.2 spammy=mini, 575,7, 5757, 9988 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:15:18 +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 0E6FB707; Fri, 9 Dec 2016 05:15:16 -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 6C0D43F477 for ; Fri, 9 Dec 2016 05:15:15 -0800 (PST) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, richard.sandiford@arm.com Subject: [34/67] Add a SCALAR_INT_TYPE_MODE macro References: <87h96dp8u6.fsf@e105548-lin.cambridge.arm.com> Date: Fri, 09 Dec 2016 13:15:00 -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: <87eg1hjlb2.fsf@e105548-lin.cambridge.arm.com> User-Agent: Gnus/5.130012 (Ma Gnus v0.12) Emacs/24.3 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-SW-Source: 2016-12/txt/msg00806.txt.bz2 This patch adds a SCALAR_INT_TYPE_MODE macro that asserts that the type has a scalar integer mode and returns it as a scalar_int_mode. gcc/ 2016-11-24 Richard Sandiford Alan Hayward David Sherwood * tree.h (SCALAR_INT_TYPE_MODE): New macro. * builtins.c (expand_builtin_signbit): Use it. * cfgexpand.c (expand_debug_expr): Likewise. * dojump.c (do_jump): Likewise. (do_compare_and_jump): Likewise. * dwarf2cfi.c (expand_builtin_init_dwarf_reg_sizes): Likewise. * expmed.c (make_tree): Likewise. * expr.c (expand_expr_real_2): Likewise. (expand_expr_real_1): Likewise. (try_casesi): Likewise. * fold-const-call.c (fold_const_call_ss): Likewise. * fold-const.c (unextend): Likewise. (extract_muldiv_1): Likewise. (fold_single_bit_test): Likewise. (native_encode_int): Likewise. (native_encode_string): Likewise. (native_interpret_int): Likewise. * gimple-fold.c (gimple_fold_builtin_memset): Likewise. * internal-fn.c (expand_addsub_overflow): Likewise. (expand_neg_overflow): Likewise. (expand_mul_overflow): Likewise. (expand_arith_overflow): Likewise. * match.pd: Likewise. * stor-layout.c (layout_type): Likewise. * tree-cfg.c (verify_gimple_assign_ternary): Likewise. * tree-ssa-math-opts.c (convert_mult_to_widen): Likewise. * tree-ssanames.c (get_range_info): Likewise. * tree-switch-conversion.c (array_value_type) Likewise.: * tree-vect-patterns.c (vect_recog_rotate_pattern): Likewise. (vect_recog_divmod_pattern): Likewise. (vect_recog_mixed_size_cond_pattern): Likewise. * tree-vrp.c (extract_range_basic): Likewise. (simplify_float_conversion_using_ranges): Likewise. * tree.c (int_fits_type_p): Likewise. * ubsan.c (instrument_bool_enum_load): Likewise. * varasm.c (mergeable_string_section): Likewise. (narrowing_initializer_constant_valid_p): Likewise. (output_constant): Likewise. gcc/cp/ 2016-11-24 Richard Sandiford Alan Hayward David Sherwood * cvt.c (cp_convert_to_pointer): Use SCALAR_INT_TYPE_MODE. gcc/fortran/ 2016-11-24 Richard Sandiford Alan Hayward David Sherwood * target-memory.c (size_integer): Use SCALAR_INT_TYPE_MODE. (size_logical): Likewise. gcc/objc/ 2016-11-24 Richard Sandiford Alan Hayward David Sherwood * objc-encoding.c (encode_type): Use SCALAR_INT_TYPE_MODE. diff --git a/gcc/builtins.c b/gcc/builtins.c index 00a0a73..cf22e96 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -5223,7 +5223,7 @@ expand_builtin_signbit (tree exp, rtx target) arg = CALL_EXPR_ARG (exp, 0); fmode = SCALAR_FLOAT_TYPE_MODE (TREE_TYPE (arg)); - rmode = TYPE_MODE (TREE_TYPE (exp)); + rmode = SCALAR_INT_TYPE_MODE (TREE_TYPE (exp)); fmt = REAL_MODE_FORMAT (fmode); arg = builtin_save_expr (arg); diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c index 1427a97..dbb7bca 100644 --- a/gcc/cfgexpand.c +++ b/gcc/cfgexpand.c @@ -4128,7 +4128,7 @@ expand_debug_expr (tree exp) machine_mode inner_mode = VOIDmode; int unsignedp = TYPE_UNSIGNED (TREE_TYPE (exp)); addr_space_t as; - scalar_int_mode op0_mode, op1_mode; + scalar_int_mode op0_mode, op1_mode, addr_mode; switch (TREE_CODE_CLASS (TREE_CODE (exp))) { @@ -4903,7 +4903,8 @@ expand_debug_expr (tree exp) } as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp))); - op0 = convert_debug_memory_address (mode, XEXP (op0, 0), as); + addr_mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (exp)); + op0 = convert_debug_memory_address (addr_mode, XEXP (op0, 0), as); return op0; diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c index 400566f..971a1b0 100644 --- a/gcc/cp/cvt.c +++ b/gcc/cp/cvt.c @@ -234,8 +234,8 @@ cp_convert_to_pointer (tree type, tree expr, bool dofold, /* Modes may be different but sizes should be the same. There is supposed to be some integral type that is the same width as a pointer. */ - gcc_assert (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))) - == GET_MODE_SIZE (TYPE_MODE (type))); + gcc_assert (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (expr))) + == GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type))); return convert_to_pointer_maybe_fold (type, expr, dofold); } diff --git a/gcc/dojump.c b/gcc/dojump.c index dbc76dc..749742b 100644 --- a/gcc/dojump.c +++ b/gcc/dojump.c @@ -575,7 +575,7 @@ do_jump (tree exp, rtx_code_label *if_false_label, if (TREE_CODE (shift) == INTEGER_CST && compare_tree_int (shift, 0) >= 0 && compare_tree_int (shift, HOST_BITS_PER_WIDE_INT) < 0 - && prefer_and_bit_test (TYPE_MODE (argtype), + && prefer_and_bit_test (SCALAR_INT_TYPE_MODE (argtype), TREE_INT_CST_LOW (shift))) { unsigned HOST_WIDE_INT mask @@ -1185,17 +1185,14 @@ do_compare_and_jump (tree treeop0, tree treeop1, enum rtx_code signed_code, return; type = TREE_TYPE (treeop0); - mode = TYPE_MODE (type); if (TREE_CODE (treeop0) == INTEGER_CST && (TREE_CODE (treeop1) != INTEGER_CST - || (GET_MODE_BITSIZE (mode) - > GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (treeop1)))))) - { - /* op0 might have been replaced by promoted constant, in which - case the type of second argument should be used. */ - type = TREE_TYPE (treeop1); - mode = TYPE_MODE (type); - } + || (GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (type)) + > GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (treeop1)))))) + /* op0 might have been replaced by promoted constant, in which + case the type of second argument should be used. */ + type = TREE_TYPE (treeop1); + mode = TYPE_MODE (type); unsignedp = TYPE_UNSIGNED (type); code = unsignedp ? unsigned_code : signed_code; diff --git a/gcc/dwarf2cfi.c b/gcc/dwarf2cfi.c index b93faa8..d7b0e5c 100644 --- a/gcc/dwarf2cfi.c +++ b/gcc/dwarf2cfi.c @@ -301,7 +301,7 @@ void expand_builtin_init_dwarf_reg_sizes (tree address) { unsigned int i; - machine_mode mode = TYPE_MODE (char_type_node); + scalar_int_mode mode = SCALAR_INT_TYPE_MODE (char_type_node); rtx addr = expand_normal (address); rtx mem = gen_rtx_MEM (BLKmode, addr); diff --git a/gcc/expmed.c b/gcc/expmed.c index d3eb5d6..f056e96 100644 --- a/gcc/expmed.c +++ b/gcc/expmed.c @@ -5185,7 +5185,7 @@ make_tree (tree type, rtx x) address mode to pointer mode. */ if (POINTER_TYPE_P (type)) x = convert_memory_address_addr_space - (TYPE_MODE (type), x, TYPE_ADDR_SPACE (TREE_TYPE (type))); + (SCALAR_INT_TYPE_MODE (type), x, TYPE_ADDR_SPACE (TREE_TYPE (type))); /* Note that we do *not* use SET_DECL_RTL here, because we do not want set_decl_rtl to go adjusting REG_ATTRS for this temporary. */ diff --git a/gcc/expr.c b/gcc/expr.c index ea66027..fb7709a 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -9018,11 +9018,12 @@ expand_expr_real_2 (sepops ops, rtx target, machine_mode tmode, instead. */ if (reduce_bit_field && TYPE_UNSIGNED (type)) { + int_mode = SCALAR_INT_TYPE_MODE (type); wide_int mask = wi::mask (TYPE_PRECISION (type), - false, GET_MODE_PRECISION (mode)); + false, GET_MODE_PRECISION (int_mode)); - temp = expand_binop (mode, xor_optab, op0, - immed_wide_int_const (mask, mode), + temp = expand_binop (int_mode, xor_optab, op0, + immed_wide_int_const (mask, int_mode), target, 1, OPTAB_LIB_WIDEN); } else @@ -9112,7 +9113,7 @@ expand_expr_real_2 (sepops ops, rtx target, machine_mode tmode, if (is_gimple_assign (def) && gimple_assign_rhs_code (def) == NOP_EXPR) { - machine_mode rmode = TYPE_MODE + scalar_int_mode rmode = SCALAR_INT_TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (def))); if (GET_MODE_SIZE (rmode) < GET_MODE_SIZE (int_mode) @@ -9874,15 +9875,16 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, return decl_rtl; case INTEGER_CST: - /* Given that TYPE_PRECISION (type) is not always equal to - GET_MODE_PRECISION (TYPE_MODE (type)), we need to extend from - the former to the latter according to the signedness of the - type. */ - temp = immed_wide_int_const (wi::to_wide - (exp, - GET_MODE_PRECISION (TYPE_MODE (type))), - TYPE_MODE (type)); - return temp; + { + /* Given that TYPE_PRECISION (type) is not always equal to + GET_MODE_PRECISION (TYPE_MODE (type)), we need to extend from + the former to the latter according to the signedness of the + type. */ + scalar_int_mode mode = SCALAR_INT_TYPE_MODE (type); + temp = immed_wide_int_const + (wi::to_wide (exp, GET_MODE_PRECISION (mode)), mode); + return temp; + } case VECTOR_CST: { @@ -10341,7 +10343,8 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, if (DECL_BIT_FIELD (field)) { HOST_WIDE_INT bitsize = TREE_INT_CST_LOW (DECL_SIZE (field)); - machine_mode imode = TYPE_MODE (TREE_TYPE (field)); + scalar_int_mode imode + = SCALAR_INT_TYPE_MODE (TREE_TYPE (field)); if (TYPE_UNSIGNED (TREE_TYPE (field))) { @@ -11470,10 +11473,10 @@ try_casesi (tree index_type, tree index_expr, tree minval, tree range, if (! targetm.have_casesi ()) return 0; - /* Convert the index to SImode. */ - if (GET_MODE_BITSIZE (TYPE_MODE (index_type)) > GET_MODE_BITSIZE (index_mode)) + /* The index must be some form of integer. Convert it to SImode. */ + scalar_int_mode omode = SCALAR_INT_TYPE_MODE (index_type); + if (GET_MODE_BITSIZE (omode) > GET_MODE_BITSIZE (index_mode)) { - machine_mode omode = TYPE_MODE (index_type); rtx rangertx = expand_normal (range); /* We must handle the endpoints in the original mode. */ @@ -11490,7 +11493,7 @@ try_casesi (tree index_type, tree index_expr, tree minval, tree range, } else { - if (TYPE_MODE (index_type) != index_mode) + if (omode != index_mode) { index_type = lang_hooks.types.type_for_mode (index_mode, 0); index_expr = fold_convert (index_type, index_expr); diff --git a/gcc/fold-const-call.c b/gcc/fold-const-call.c index f978da3..62eb859 100644 --- a/gcc/fold-const-call.c +++ b/gcc/fold-const-call.c @@ -844,7 +844,8 @@ fold_const_call_ss (wide_int *result, combined_fn fn, const wide_int_ref &arg, int tmp; if (wi::ne_p (arg, 0)) tmp = wi::clz (arg); - else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (arg_type), tmp)) + else if (!CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (arg_type), + tmp)) tmp = TYPE_PRECISION (arg_type); *result = wi::shwi (tmp, precision); return true; @@ -855,7 +856,8 @@ fold_const_call_ss (wide_int *result, combined_fn fn, const wide_int_ref &arg, int tmp; if (wi::ne_p (arg, 0)) tmp = wi::ctz (arg); - else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (arg_type), tmp)) + else if (!CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (arg_type), + tmp)) tmp = TYPE_PRECISION (arg_type); *result = wi::shwi (tmp, precision); return true; diff --git a/gcc/fold-const.c b/gcc/fold-const.c index c4a2ae3..088751f 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -5317,7 +5317,7 @@ static tree unextend (tree c, int p, int unsignedp, tree mask) { tree type = TREE_TYPE (c); - int modesize = GET_MODE_BITSIZE (TYPE_MODE (type)); + int modesize = GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (type)); tree temp; if (p == modesize || unsignedp) @@ -5907,8 +5907,9 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type, { tree type = TREE_TYPE (t); enum tree_code tcode = TREE_CODE (t); - tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type)) - > GET_MODE_SIZE (TYPE_MODE (type))) + tree ctype = (wide_type != 0 + && (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (wide_type)) + > GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type))) ? wide_type : type); tree t1, t2; int same_p = tcode == code; @@ -6605,7 +6606,7 @@ fold_single_bit_test (location_t loc, enum tree_code code, tree inner = TREE_OPERAND (arg0, 0); tree type = TREE_TYPE (arg0); int bitnum = tree_log2 (TREE_OPERAND (arg0, 1)); - machine_mode operand_mode = TYPE_MODE (type); + scalar_int_mode operand_mode = SCALAR_INT_TYPE_MODE (type); int ops_unsigned; tree signed_type, unsigned_type, intermediate_type; tree tem, one; @@ -6893,7 +6894,7 @@ static int native_encode_int (const_tree expr, unsigned char *ptr, int len, int off) { tree type = TREE_TYPE (expr); - int total_bytes = GET_MODE_SIZE (TYPE_MODE (type)); + int total_bytes = GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type)); int byte, offset, word, words; unsigned char value; @@ -7103,7 +7104,8 @@ native_encode_string (const_tree expr, unsigned char *ptr, int len, int off) if (TREE_CODE (type) != ARRAY_TYPE || TREE_CODE (TREE_TYPE (type)) != INTEGER_TYPE - || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type))) != BITS_PER_UNIT + || (GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (type))) + != BITS_PER_UNIT) || !tree_fits_shwi_p (TYPE_SIZE_UNIT (type))) return 0; total_bytes = tree_to_shwi (TYPE_SIZE_UNIT (type)); @@ -7175,7 +7177,7 @@ native_encode_expr (const_tree expr, unsigned char *ptr, int len, int off) static tree native_interpret_int (tree type, const unsigned char *ptr, int len) { - int total_bytes = GET_MODE_SIZE (TYPE_MODE (type)); + int total_bytes = GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type)); if (total_bytes > len || total_bytes * BITS_PER_UNIT > HOST_BITS_PER_DOUBLE_INT) diff --git a/gcc/fortran/target-memory.c b/gcc/fortran/target-memory.c index b498f19..7f24dbb 100644 --- a/gcc/fortran/target-memory.c +++ b/gcc/fortran/target-memory.c @@ -39,7 +39,7 @@ along with GCC; see the file COPYING3. If not see static size_t size_integer (int kind) { - return GET_MODE_SIZE (TYPE_MODE (gfc_get_int_type (kind)));; + return GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (gfc_get_int_type (kind))); } @@ -60,7 +60,7 @@ size_complex (int kind) static size_t size_logical (int kind) { - return GET_MODE_SIZE (TYPE_MODE (gfc_get_logical_type (kind)));; + return GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (gfc_get_logical_type (kind))); } diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index c6b5411..558f6cb 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -1118,7 +1118,7 @@ gimple_fold_builtin_memset (gimple_stmt_iterator *gsi, tree c, tree len) return NULL_TREE; length = tree_to_uhwi (len); - if (GET_MODE_SIZE (TYPE_MODE (etype)) != length + if (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (etype)) != length || get_pointer_alignment (dest) / BITS_PER_UNIT < length) return NULL_TREE; diff --git a/gcc/internal-fn.c b/gcc/internal-fn.c index 49075c2..3b06dc2 100644 --- a/gcc/internal-fn.c +++ b/gcc/internal-fn.c @@ -657,7 +657,7 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs, do_pending_stack_adjust (); rtx op0 = expand_normal (arg0); rtx op1 = expand_normal (arg1); - machine_mode mode = TYPE_MODE (TREE_TYPE (arg0)); + scalar_int_mode mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (arg0)); int prec = GET_MODE_PRECISION (mode); rtx sgn = immed_wide_int_const (wi::min_value (prec, SIGNED), mode); bool do_xor = false; @@ -1107,7 +1107,7 @@ expand_neg_overflow (location_t loc, tree lhs, tree arg1, bool is_ubsan, do_pending_stack_adjust (); op1 = expand_normal (arg1); - machine_mode mode = TYPE_MODE (TREE_TYPE (arg1)); + scalar_int_mode mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (arg1)); if (lhs) { target = expand_expr (lhs, NULL_RTX, VOIDmode, EXPAND_WRITE); @@ -1201,7 +1201,7 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1, op0 = expand_normal (arg0); op1 = expand_normal (arg1); - machine_mode mode = TYPE_MODE (TREE_TYPE (arg0)); + scalar_int_mode mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (arg0)); bool uns = unsr_p; if (lhs) { @@ -2118,7 +2118,7 @@ expand_arith_overflow (enum tree_code code, gimple *stmt) /* The infinity precision result will always fit into result. */ rtx target = expand_expr (lhs, NULL_RTX, VOIDmode, EXPAND_WRITE); write_complex_part (target, const0_rtx, true); - machine_mode mode = TYPE_MODE (type); + scalar_int_mode mode = SCALAR_INT_TYPE_MODE (type); struct separate_ops ops; ops.code = code; ops.type = type; diff --git a/gcc/match.pd b/gcc/match.pd index feaa4a1..a4d5f4e 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -2936,7 +2936,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) associated with the mode of @1, so the sign bit is specified by this mode. Check that @1 is the signed max associated with this sign bit. */ - && prec == GET_MODE_PRECISION (TYPE_MODE (arg1_type)) + && prec == GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (arg1_type)) /* signed_type does not work on pointer types. */ && INTEGRAL_TYPE_P (arg1_type)) /* The following case also applies to X < signed_max+1 diff --git a/gcc/objc/objc-encoding.c b/gcc/objc/objc-encoding.c index 3b72dd2..a22970b 100644 --- a/gcc/objc/objc-encoding.c +++ b/gcc/objc/objc-encoding.c @@ -626,7 +626,7 @@ encode_type (tree type, int curtype, int format) case INTEGER_TYPE: { char c; - switch (GET_MODE_BITSIZE (TYPE_MODE (type))) + switch (GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (type))) { case 8: c = TYPE_UNSIGNED (type) ? 'C' : 'c'; break; case 16: c = TYPE_UNSIGNED (type) ? 'S' : 's'; break; diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c index a1b6c94..9acd90e 100644 --- a/gcc/stor-layout.c +++ b/gcc/stor-layout.c @@ -2235,7 +2235,7 @@ layout_type (tree type) case POINTER_TYPE: case REFERENCE_TYPE: { - machine_mode mode = TYPE_MODE (type); + scalar_int_mode mode = SCALAR_INT_TYPE_MODE (type); TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (mode)); TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (mode)); TYPE_UNSIGNED (type) = 1; diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index 6cb5b6f..d83c405 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -4146,7 +4146,7 @@ verify_gimple_assign_ternary (gassign *stmt) } if (TREE_CODE (TREE_TYPE (rhs3_type)) != INTEGER_TYPE - || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs3_type))) + || GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (rhs3_type))) != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type)))) { error ("invalid mask type in vector permute expression"); diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c index e0883ff..4d6e4d9 100644 --- a/gcc/tree-ssa-math-opts.c +++ b/gcc/tree-ssa-math-opts.c @@ -3133,8 +3133,8 @@ convert_mult_to_widen (gimple *stmt, gimple_stmt_iterator *gsi) if (!is_widening_mult_p (stmt, &type1, &rhs1, &type2, &rhs2)) return false; - to_mode = TYPE_MODE (type); - from_mode = TYPE_MODE (type1); + to_mode = SCALAR_INT_TYPE_MODE (type); + from_mode = SCALAR_INT_TYPE_MODE (type1); from_unsigned1 = TYPE_UNSIGNED (type1); from_unsigned2 = TYPE_UNSIGNED (type2); diff --git a/gcc/tree-ssanames.c b/gcc/tree-ssanames.c index bd5d10a..7a777c1 100644 --- a/gcc/tree-ssanames.c +++ b/gcc/tree-ssanames.c @@ -378,7 +378,7 @@ get_range_info (const_tree name, wide_int *min, wide_int *max) /* Return VR_VARYING for SSA_NAMEs with NULL RANGE_INFO or SSA_NAMEs with integral types width > 2 * HOST_BITS_PER_WIDE_INT precision. */ - if (!ri || (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (name))) + if (!ri || (GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (TREE_TYPE (name))) > 2 * HOST_BITS_PER_WIDE_INT)) return VR_VARYING; diff --git a/gcc/tree-switch-conversion.c b/gcc/tree-switch-conversion.c index 62c3a78..e4c8a60 100644 --- a/gcc/tree-switch-conversion.c +++ b/gcc/tree-switch-conversion.c @@ -951,7 +951,7 @@ array_value_type (gswitch *swtch, tree type, int num, if (!INTEGRAL_TYPE_P (type)) return type; - machine_mode type_mode = TYPE_MODE (type); + scalar_int_mode type_mode = SCALAR_INT_TYPE_MODE (type); machine_mode mode = get_narrowest_mode (type_mode); if (GET_MODE_SIZE (type_mode) <= GET_MODE_SIZE (mode)) return type; @@ -998,8 +998,8 @@ array_value_type (gswitch *swtch, tree type, int num, if (sign == 0) sign = TYPE_UNSIGNED (type) ? 1 : -1; smaller_type = lang_hooks.types.type_for_mode (mode, sign >= 0); - if (GET_MODE_SIZE (TYPE_MODE (type)) - <= GET_MODE_SIZE (TYPE_MODE (smaller_type))) + if (GET_MODE_SIZE (type_mode) + <= GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (smaller_type))) return type; return smaller_type; diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c index 835d9b5..e677238 100644 --- a/gcc/tree-vect-patterns.c +++ b/gcc/tree-vect-patterns.c @@ -1882,13 +1882,14 @@ vect_recog_rotate_pattern (vec *stmts, tree *type_in, tree *type_out) } def = NULL_TREE; + scalar_int_mode mode = SCALAR_INT_TYPE_MODE (type); if (TREE_CODE (oprnd1) == INTEGER_CST - || TYPE_MODE (TREE_TYPE (oprnd1)) == TYPE_MODE (type)) + || TYPE_MODE (TREE_TYPE (oprnd1)) == mode) def = oprnd1; else if (def_stmt && gimple_assign_cast_p (def_stmt)) { tree rhs1 = gimple_assign_rhs1 (def_stmt); - if (TYPE_MODE (TREE_TYPE (rhs1)) == TYPE_MODE (type) + if (TYPE_MODE (TREE_TYPE (rhs1)) == mode && TYPE_PRECISION (TREE_TYPE (rhs1)) == TYPE_PRECISION (type)) def = rhs1; @@ -1909,16 +1910,16 @@ vect_recog_rotate_pattern (vec *stmts, tree *type_in, tree *type_out) append_pattern_def_seq (stmt_vinfo, def_stmt); } stype = TREE_TYPE (def); + scalar_int_mode smode = SCALAR_INT_TYPE_MODE (stype); if (TREE_CODE (def) == INTEGER_CST) { if (!tree_fits_uhwi_p (def) - || tree_to_uhwi (def) >= GET_MODE_PRECISION (TYPE_MODE (type)) + || tree_to_uhwi (def) >= GET_MODE_PRECISION (mode) || integer_zerop (def)) return NULL; def2 = build_int_cst (stype, - GET_MODE_PRECISION (TYPE_MODE (type)) - - tree_to_uhwi (def)); + GET_MODE_PRECISION (mode) - tree_to_uhwi (def)); } else { @@ -1944,8 +1945,7 @@ vect_recog_rotate_pattern (vec *stmts, tree *type_in, tree *type_out) } def2 = vect_recog_temp_ssa_var (stype, NULL); - tree mask - = build_int_cst (stype, GET_MODE_PRECISION (TYPE_MODE (stype)) - 1); + tree mask = build_int_cst (stype, GET_MODE_PRECISION (smode) - 1); def_stmt = gimple_build_assign (def2, BIT_AND_EXPR, gimple_assign_lhs (def_stmt), mask); if (ext_def) @@ -2588,6 +2588,7 @@ vect_recog_divmod_pattern (vec *stmts, || TYPE_PRECISION (itype) != GET_MODE_PRECISION (TYPE_MODE (itype))) return NULL; + scalar_int_mode itype_mode = SCALAR_INT_TYPE_MODE (itype); vectype = get_vectype_for_scalar_type (itype); if (vectype == NULL_TREE) return NULL; @@ -2655,7 +2656,7 @@ vect_recog_divmod_pattern (vec *stmts, = build_nonstandard_integer_type (prec, 1); tree vecutype = get_vectype_for_scalar_type (utype); tree shift - = build_int_cst (utype, GET_MODE_BITSIZE (TYPE_MODE (itype)) + = build_int_cst (utype, GET_MODE_BITSIZE (itype_mode) - tree_log2 (oprnd1)); tree var = vect_recog_temp_ssa_var (utype, NULL); @@ -2721,7 +2722,7 @@ vect_recog_divmod_pattern (vec *stmts, unsigned HOST_WIDE_INT mh, ml; int pre_shift, post_shift; unsigned HOST_WIDE_INT d = (TREE_INT_CST_LOW (oprnd1) - & GET_MODE_MASK (TYPE_MODE (itype))); + & GET_MODE_MASK (itype_mode)); tree t1, t2, t3, t4; if (d >= (HOST_WIDE_INT_1U << (prec - 1))) @@ -3066,7 +3067,8 @@ vect_recog_mixed_size_cond_pattern (vec *stmts, tree *type_in, HOST_WIDE_INT cmp_mode_size = GET_MODE_UNIT_BITSIZE (TYPE_MODE (comp_vectype)); - if (GET_MODE_BITSIZE (TYPE_MODE (type)) == cmp_mode_size) + scalar_int_mode type_mode = SCALAR_INT_TYPE_MODE (type); + if (GET_MODE_BITSIZE (type_mode) == cmp_mode_size) return NULL; vectype = get_vectype_for_scalar_type (type); @@ -3091,7 +3093,7 @@ vect_recog_mixed_size_cond_pattern (vec *stmts, tree *type_in, if (!expand_vec_cond_expr_p (vecitype, comp_vectype, TREE_CODE (cond_expr))) return NULL; - if (GET_MODE_BITSIZE (TYPE_MODE (type)) > cmp_mode_size) + if (GET_MODE_BITSIZE (type_mode) > cmp_mode_size) { if ((TREE_CODE (then_clause) == INTEGER_CST && !int_fits_type_p (then_clause, itype)) diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index 9a5f69d..acd536c 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -3824,6 +3824,7 @@ extract_range_basic (value_range *vr, gimple *stmt) int mini, maxi, zerov = 0, prec; enum tree_code subcode = ERROR_MARK; combined_fn cfn = gimple_call_combined_fn (stmt); + scalar_int_mode mode; switch (cfn) { @@ -3887,10 +3888,9 @@ extract_range_basic (value_range *vr, gimple *stmt) prec = TYPE_PRECISION (TREE_TYPE (arg)); mini = 0; maxi = prec; - if (optab_handler (clz_optab, TYPE_MODE (TREE_TYPE (arg))) - != CODE_FOR_nothing - && CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (TREE_TYPE (arg)), - zerov) + mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (arg)); + if (optab_handler (clz_optab, mode) != CODE_FOR_nothing + && CLZ_DEFINED_VALUE_AT_ZERO (mode, zerov) /* Handle only the single common value. */ && zerov != prec) /* Magic value to give up, unless vr0 proves @@ -3942,10 +3942,9 @@ extract_range_basic (value_range *vr, gimple *stmt) prec = TYPE_PRECISION (TREE_TYPE (arg)); mini = 0; maxi = prec - 1; - if (optab_handler (ctz_optab, TYPE_MODE (TREE_TYPE (arg))) - != CODE_FOR_nothing - && CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (TREE_TYPE (arg)), - zerov)) + mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (arg)); + if (optab_handler (ctz_optab, mode) != CODE_FOR_nothing + && CTZ_DEFINED_VALUE_AT_ZERO (mode, zerov)) { /* Handle only the two common values. */ if (zerov == -1) @@ -9982,13 +9981,13 @@ simplify_float_conversion_using_ranges (gimple_stmt_iterator *gsi, return false; /* First check if we can use a signed type in place of an unsigned. */ + scalar_int_mode rhs_mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (rhs1)); if (TYPE_UNSIGNED (TREE_TYPE (rhs1)) - && (can_float_p (fltmode, TYPE_MODE (TREE_TYPE (rhs1)), 0) - != CODE_FOR_nothing) + && can_float_p (fltmode, rhs_mode, 0) != CODE_FOR_nothing && range_fits_type_p (vr, TYPE_PRECISION (TREE_TYPE (rhs1)), SIGNED)) - mode = TYPE_MODE (TREE_TYPE (rhs1)); + mode = rhs_mode; /* If we can do the conversion in the current input mode do nothing. */ - else if (can_float_p (fltmode, TYPE_MODE (TREE_TYPE (rhs1)), + else if (can_float_p (fltmode, rhs_mode, TYPE_UNSIGNED (TREE_TYPE (rhs1))) != CODE_FOR_nothing) return false; /* Otherwise search for a mode we can use, starting from the narrowest diff --git a/gcc/tree.c b/gcc/tree.c index 5124576..b58f503 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -9199,7 +9199,7 @@ retry: /* Third, unsigned integers with top bit set never fit signed types. */ if (!TYPE_UNSIGNED (type) && sgn_c == UNSIGNED) { - int prec = GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (c))) - 1; + int prec = GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (TREE_TYPE (c))) - 1; if (prec < TYPE_PRECISION (TREE_TYPE (c))) { /* When a tree_cst is converted to a wide-int, the precision diff --git a/gcc/tree.h b/gcc/tree.h index 7791c22..1c2f71f 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -1829,6 +1829,8 @@ extern void protected_set_expr_location (tree, location_t); ((const machine_mode &) \ (VECTOR_TYPE_P (TYPE_CHECK (NODE)) \ ? vector_type_mode (NODE) : machine_mode ((NODE)->type_common.mode))) +#define SCALAR_INT_TYPE_MODE(NODE) \ + (as_a (TYPE_CHECK (NODE)->type_common.mode)) #define SCALAR_FLOAT_TYPE_MODE(NODE) \ (as_a (TYPE_CHECK (NODE)->type_common.mode)) #define SET_TYPE_MODE(NODE, MODE) \ diff --git a/gcc/ubsan.c b/gcc/ubsan.c index d5422a1..10f3eaa 100644 --- a/gcc/ubsan.c +++ b/gcc/ubsan.c @@ -1360,7 +1360,7 @@ instrument_bool_enum_load (gimple_stmt_iterator *gsi) && TREE_TYPE (type) != NULL_TREE && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE && (TYPE_PRECISION (TREE_TYPE (type)) - < GET_MODE_PRECISION (TYPE_MODE (type)))) + < GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (type)))) { minv = TYPE_MIN_VALUE (TREE_TYPE (type)); maxv = TYPE_MAX_VALUE (TREE_TYPE (type)); @@ -1368,7 +1368,7 @@ instrument_bool_enum_load (gimple_stmt_iterator *gsi) else return; - int modebitsize = GET_MODE_BITSIZE (TYPE_MODE (type)); + int modebitsize = GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (type)); HOST_WIDE_INT bitsize, bitpos; tree offset; machine_mode mode; @@ -1380,7 +1380,7 @@ instrument_bool_enum_load (gimple_stmt_iterator *gsi) if ((VAR_P (base) && DECL_HARD_REGISTER (base)) || (bitpos % modebitsize) != 0 || bitsize != modebitsize - || GET_MODE_BITSIZE (TYPE_MODE (utype)) != modebitsize + || GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (utype)) != modebitsize || TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME) return; diff --git a/gcc/varasm.c b/gcc/varasm.c index 320a5a6..b9206b8 100644 --- a/gcc/varasm.c +++ b/gcc/varasm.c @@ -783,7 +783,7 @@ mergeable_string_section (tree decl ATTRIBUTE_UNUSED, && (len = int_size_in_bytes (TREE_TYPE (decl))) > 0 && TREE_STRING_LENGTH (decl) >= len) { - machine_mode mode; + scalar_int_mode mode; unsigned int modesize; const char *str; HOST_WIDE_INT i; @@ -791,7 +791,7 @@ mergeable_string_section (tree decl ATTRIBUTE_UNUSED, const char *prefix = function_mergeable_rodata_prefix (); char *name = (char *) alloca (strlen (prefix) + 30); - mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl))); + mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (TREE_TYPE (decl))); modesize = GET_MODE_BITSIZE (mode); if (modesize >= 8 && modesize <= 256 && (modesize & (modesize - 1)) == 0) @@ -4281,8 +4281,8 @@ narrowing_initializer_constant_valid_p (tree value, tree endtype, tree *cache) tree inner = TREE_OPERAND (op0, 0); if (inner == error_mark_node || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner))) - || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0))) - > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner))))) + || (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (op0))) + > GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (inner))))) break; op0 = inner; } @@ -4293,8 +4293,8 @@ narrowing_initializer_constant_valid_p (tree value, tree endtype, tree *cache) tree inner = TREE_OPERAND (op1, 0); if (inner == error_mark_node || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner))) - || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1))) - > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner))))) + || (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (op1))) + > GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (inner))))) break; op1 = inner; } @@ -4712,7 +4712,7 @@ output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align, if (TREE_CODE (exp) == NOP_EXPR && POINTER_TYPE_P (TREE_TYPE (exp)) && targetm.addr_space.valid_pointer_mode - (TYPE_MODE (TREE_TYPE (exp)), + (SCALAR_INT_TYPE_MODE (TREE_TYPE (exp)), TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp))))) { tree saved_type = TREE_TYPE (exp); @@ -4722,7 +4722,7 @@ output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align, while (TREE_CODE (exp) == NOP_EXPR && POINTER_TYPE_P (TREE_TYPE (exp)) && targetm.addr_space.valid_pointer_mode - (TYPE_MODE (TREE_TYPE (exp)), + (SCALAR_INT_TYPE_MODE (TREE_TYPE (exp)), TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp))))) exp = TREE_OPERAND (exp, 0);