diff options
Diffstat (limited to 'gcc')
29 files changed, 721 insertions, 301 deletions
diff --git a/gcc/builtin-types.def b/gcc/builtin-types.def index 3a7cecd..df3a88f2 100644 --- a/gcc/builtin-types.def +++ b/gcc/builtin-types.def @@ -82,6 +82,9 @@ DEF_PRIMITIVE_TYPE (BT_UNWINDWORD, (*lang_hooks.types.type_for_mode) DEF_PRIMITIVE_TYPE (BT_FLOAT, float_type_node) DEF_PRIMITIVE_TYPE (BT_DOUBLE, double_type_node) DEF_PRIMITIVE_TYPE (BT_LONGDOUBLE, long_double_type_node) +DEF_PRIMITIVE_TYPE (BT_BFLOAT16, (bfloat16_type_node + ? bfloat16_type_node + : error_mark_node)) DEF_PRIMITIVE_TYPE (BT_FLOAT16, (float16_type_node ? float16_type_node : error_mark_node)) @@ -264,6 +267,7 @@ DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT_CONST_STRING, BT_FLOAT, BT_CONST_STRING) DEF_FUNCTION_TYPE_1 (BT_FN_DOUBLE_CONST_STRING, BT_DOUBLE, BT_CONST_STRING) DEF_FUNCTION_TYPE_1 (BT_FN_LONGDOUBLE_CONST_STRING, BT_LONGDOUBLE, BT_CONST_STRING) +DEF_FUNCTION_TYPE_1 (BT_FN_BFLOAT16_CONST_STRING, BT_BFLOAT16, BT_CONST_STRING) DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT16_CONST_STRING, BT_FLOAT16, BT_CONST_STRING) DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT32_CONST_STRING, BT_FLOAT32, BT_CONST_STRING) DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT64_CONST_STRING, BT_FLOAT64, BT_CONST_STRING) diff --git a/gcc/builtins.def b/gcc/builtins.def index 109b387..5f2e627 100644 --- a/gcc/builtins.def +++ b/gcc/builtins.def @@ -514,6 +514,7 @@ DEF_GCC_BUILTIN (BUILT_IN_NANSF, "nansf", BT_FN_FLOAT_CONST_STRING, ATTR_ DEF_GCC_BUILTIN (BUILT_IN_NANSL, "nansl", BT_FN_LONGDOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) DEF_GCC_FLOATN_NX_BUILTINS (BUILT_IN_NANS, "nans", NAN_TYPE, ATTR_CONST_NOTHROW_NONNULL) #undef NAN_TYPE +DEF_GCC_BUILTIN (BUILT_IN_NANSF16B, "nansf16b", BT_FN_BFLOAT16_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) DEF_GCC_BUILTIN (BUILT_IN_NANSD32, "nansd32", BT_FN_DFLOAT32_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) DEF_GCC_BUILTIN (BUILT_IN_NANSD64, "nansd64", BT_FN_DFLOAT64_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) DEF_GCC_BUILTIN (BUILT_IN_NANSD128, "nansd128", BT_FN_DFLOAT128_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) diff --git a/gcc/c-family/c-cppbuiltin.cc b/gcc/c-family/c-cppbuiltin.cc index 2e39acb..cdb658f 100644 --- a/gcc/c-family/c-cppbuiltin.cc +++ b/gcc/c-family/c-cppbuiltin.cc @@ -1260,6 +1260,13 @@ c_cpp_builtins (cpp_reader *pfile) builtin_define_float_constants (prefix, ggc_strdup (csuffix), "%s", csuffix, FLOATN_NX_TYPE_NODE (i)); } + if (bfloat16_type_node) + { + if (c_dialect_cxx () && cxx_dialect > cxx20) + cpp_define (pfile, "__STDCPP_BFLOAT16_T__=1"); + builtin_define_float_constants ("BFLT16", "BF16", "%s", + "BF16", bfloat16_type_node); + } /* For float.h. */ if (targetm.decimal_float_supported_p ()) @@ -1370,6 +1377,12 @@ c_cpp_builtins (cpp_reader *pfile) suffix[0] = 'l'; memcpy (float_h_prefix, "LDBL", 5); } + else if (bfloat16_type_node + && mode == TYPE_MODE (bfloat16_type_node)) + { + memcpy (suffix, "bf16", 5); + memcpy (float_h_prefix, "BFLT16", 7); + } else { bool found_suffix = false; @@ -1396,22 +1409,28 @@ c_cpp_builtins (cpp_reader *pfile) machine_mode float16_type_mode = (float16_type_node ? TYPE_MODE (float16_type_node) : VOIDmode); + machine_mode bfloat16_type_mode = (bfloat16_type_node + ? TYPE_MODE (bfloat16_type_node) + : VOIDmode); switch (targetm.c.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT)) { case FLT_EVAL_METHOD_UNPREDICTABLE: case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE: excess_precision = (mode == float16_type_mode + || mode == bfloat16_type_mode || mode == TYPE_MODE (float_type_node) || mode == TYPE_MODE (double_type_node)); break; case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE: excess_precision = (mode == float16_type_mode + || mode == bfloat16_type_mode || mode == TYPE_MODE (float_type_node)); break; case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT: - excess_precision = mode == float16_type_mode; + excess_precision = (mode == float16_type_mode + || mode == bfloat16_type_mode); break; case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16: excess_precision = false; diff --git a/gcc/c-family/c-lex.cc b/gcc/c-family/c-lex.cc index 11f2b78..89c65ac 100644 --- a/gcc/c-family/c-lex.cc +++ b/gcc/c-family/c-lex.cc @@ -1000,6 +1000,22 @@ interpret_float (const cpp_token *token, unsigned int flags, pedwarn (input_location, OPT_Wpedantic, "non-standard suffix on floating constant"); } + else if ((flags & CPP_N_BFLOAT16) != 0) + { + type = bfloat16_type_node; + if (type == NULL_TREE) + { + error ("unsupported non-standard suffix on floating constant"); + return error_mark_node; + } + if (!c_dialect_cxx ()) + pedwarn (input_location, OPT_Wpedantic, + "non-standard suffix on floating constant"); + else if (cxx_dialect < cxx23) + pedwarn (input_location, OPT_Wpedantic, + "%<bf16%> or %<BF16%> suffix on floating constant only " + "available with %<-std=c++2b%> or %<-std=gnu++2b%>"); + } else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE) type = long_double_type_node; else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc index 0176580..fdb96c2 100644 --- a/gcc/c/c-typeck.cc +++ b/gcc/c/c-typeck.cc @@ -3678,6 +3678,9 @@ convert_arguments (location_t loc, vec<location_t> arg_loc, tree typelist, promote_float_arg = false; break; } + /* Don't promote __bf16 either. */ + if (TYPE_MAIN_VARIANT (valtype) == bfloat16_type_node) + promote_float_arg = false; } if (type != NULL_TREE) diff --git a/gcc/config/i386/i386-builtin-types.def b/gcc/config/i386/i386-builtin-types.def index 63a360b..2c27a4e 100644 --- a/gcc/config/i386/i386-builtin-types.def +++ b/gcc/config/i386/i386-builtin-types.def @@ -69,7 +69,7 @@ DEF_PRIMITIVE_TYPE (UINT16, short_unsigned_type_node) DEF_PRIMITIVE_TYPE (INT64, long_long_integer_type_node) DEF_PRIMITIVE_TYPE (UINT64, long_long_unsigned_type_node) DEF_PRIMITIVE_TYPE (FLOAT16, ix86_float16_type_node) -DEF_PRIMITIVE_TYPE (BFLOAT16, ix86_bf16_type_node) +DEF_PRIMITIVE_TYPE (BFLOAT16, bfloat16_type_node) DEF_PRIMITIVE_TYPE (FLOAT, float_type_node) DEF_PRIMITIVE_TYPE (DOUBLE, double_type_node) DEF_PRIMITIVE_TYPE (FLOAT80, float80_type_node) diff --git a/gcc/config/i386/i386-builtins.cc b/gcc/config/i386/i386-builtins.cc index b91aba1..b5c651a 100644 --- a/gcc/config/i386/i386-builtins.cc +++ b/gcc/config/i386/i386-builtins.cc @@ -126,7 +126,6 @@ BDESC_VERIFYS (IX86_BUILTIN_MAX, static GTY(()) tree ix86_builtin_type_tab[(int) IX86_BT_LAST_CPTR + 1]; tree ix86_float16_type_node = NULL_TREE; -tree ix86_bf16_type_node = NULL_TREE; tree ix86_bf16_ptr_type_node = NULL_TREE; /* Retrieve an element from the above table, building some of @@ -1372,16 +1371,18 @@ ix86_register_float16_builtin_type (void) static void ix86_register_bf16_builtin_type (void) { - ix86_bf16_type_node = make_node (REAL_TYPE); - TYPE_PRECISION (ix86_bf16_type_node) = 16; - SET_TYPE_MODE (ix86_bf16_type_node, BFmode); - layout_type (ix86_bf16_type_node); + if (bfloat16_type_node == NULL_TREE) + { + bfloat16_type_node = make_node (REAL_TYPE); + TYPE_PRECISION (bfloat16_type_node) = 16; + SET_TYPE_MODE (bfloat16_type_node, BFmode); + layout_type (bfloat16_type_node); + } if (!maybe_get_identifier ("__bf16") && TARGET_SSE2) { - lang_hooks.types.register_builtin_type (ix86_bf16_type_node, - "__bf16"); - ix86_bf16_ptr_type_node = build_pointer_type (ix86_bf16_type_node); + lang_hooks.types.register_builtin_type (bfloat16_type_node, "__bf16"); + ix86_bf16_ptr_type_node = build_pointer_type (bfloat16_type_node); } } diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc index ff4de2d..480db35 100644 --- a/gcc/config/i386/i386.cc +++ b/gcc/config/i386/i386.cc @@ -2423,6 +2423,7 @@ classify_argument (machine_mode mode, const_tree type, classes[1] = X86_64_SSEUP_CLASS; return 2; case E_HCmode: + case E_BCmode: classes[0] = X86_64_SSE_CLASS; if (!(bit_offset % 64)) return 1; @@ -22428,7 +22429,7 @@ ix86_libgcc_floating_mode_supported_p (scalar_float_mode mode) be defined by the C front-end for AVX512FP16 intrinsics. We will issue an error in ix86_expand_move for HFmode if AVX512FP16 isn't enabled. */ - return ((mode == HFmode && TARGET_SSE2) + return (((mode == HFmode || mode == BFmode) && TARGET_SSE2) ? true : default_libgcc_floating_mode_supported_p (mode)); } @@ -22731,7 +22732,7 @@ ix86_mangle_type (const_tree type) switch (TYPE_MODE (type)) { case E_BFmode: - return "u6__bf16"; + return "DF16b"; case E_HFmode: /* _Float16 is "DF16_". Align with clang's decision in https://reviews.llvm.org/D33719. */ @@ -22747,55 +22748,6 @@ ix86_mangle_type (const_tree type) } } -/* Return the diagnostic message string if conversion from FROMTYPE to - TOTYPE is not allowed, NULL otherwise. */ - -static const char * -ix86_invalid_conversion (const_tree fromtype, const_tree totype) -{ - if (element_mode (fromtype) != element_mode (totype)) - { - /* Do no allow conversions to/from BFmode scalar types. */ - if (TYPE_MODE (fromtype) == BFmode) - return N_("invalid conversion from type %<__bf16%>"); - if (TYPE_MODE (totype) == BFmode) - return N_("invalid conversion to type %<__bf16%>"); - } - - /* Conversion allowed. */ - return NULL; -} - -/* Return the diagnostic message string if the unary operation OP is - not permitted on TYPE, NULL otherwise. */ - -static const char * -ix86_invalid_unary_op (int op, const_tree type) -{ - /* Reject all single-operand operations on BFmode except for &. */ - if (element_mode (type) == BFmode && op != ADDR_EXPR) - return N_("operation not permitted on type %<__bf16%>"); - - /* Operation allowed. */ - return NULL; -} - -/* Return the diagnostic message string if the binary operation OP is - not permitted on TYPE1 and TYPE2, NULL otherwise. */ - -static const char * -ix86_invalid_binary_op (int op ATTRIBUTE_UNUSED, const_tree type1, - const_tree type2) -{ - /* Reject all 2-operand operations on BFmode. */ - if (element_mode (type1) == BFmode - || element_mode (type2) == BFmode) - return N_("operation not permitted on type %<__bf16%>"); - - /* Operation allowed. */ - return NULL; -} - static GTY(()) tree ix86_tls_stack_chk_guard_decl; static tree @@ -24853,15 +24805,6 @@ ix86_libgcc_floating_mode_supported_p #undef TARGET_MANGLE_TYPE #define TARGET_MANGLE_TYPE ix86_mangle_type -#undef TARGET_INVALID_CONVERSION -#define TARGET_INVALID_CONVERSION ix86_invalid_conversion - -#undef TARGET_INVALID_UNARY_OP -#define TARGET_INVALID_UNARY_OP ix86_invalid_unary_op - -#undef TARGET_INVALID_BINARY_OP -#define TARGET_INVALID_BINARY_OP ix86_invalid_binary_op - #undef TARGET_STACK_PROTECT_GUARD #define TARGET_STACK_PROTECT_GUARD ix86_stack_protect_guard diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md index 8e84752..6688d92 100644 --- a/gcc/config/i386/i386.md +++ b/gcc/config/i386/i386.md @@ -1644,6 +1644,48 @@ DONE; }) +(define_expand "cbranchbf4" + [(set (reg:CC FLAGS_REG) + (compare:CC (match_operand:BF 1 "cmp_fp_expander_operand") + (match_operand:BF 2 "cmp_fp_expander_operand"))) + (set (pc) (if_then_else + (match_operator 0 "comparison_operator" + [(reg:CC FLAGS_REG) + (const_int 0)]) + (label_ref (match_operand 3)) + (pc)))] + "" +{ + rtx op1 = gen_lowpart (HImode, operands[1]); + if (CONST_INT_P (op1)) + op1 = simplify_const_unary_operation (FLOAT_EXTEND, SFmode, + operands[1], BFmode); + else + { + rtx t1 = gen_reg_rtx (SImode); + emit_insn (gen_zero_extendhisi2 (t1, op1)); + emit_insn (gen_ashlsi3 (t1, t1, GEN_INT (16))); + op1 = gen_lowpart (SFmode, t1); + } + rtx op2 = gen_lowpart (HImode, operands[2]); + if (CONST_INT_P (op2)) + op2 = simplify_const_unary_operation (FLOAT_EXTEND, SFmode, + operands[2], BFmode); + else + { + rtx t2 = gen_reg_rtx (SImode); + emit_insn (gen_zero_extendhisi2 (t2, op2)); + emit_insn (gen_ashlsi3 (t2, t2, GEN_INT (16))); + op2 = gen_lowpart (SFmode, t2); + } + do_compare_rtx_and_jump (op1, op2, GET_CODE (operands[0]), 0, + SFmode, NULL_RTX, NULL, + as_a <rtx_code_label *> (operands[3]), + /* Unfortunately this isn't propagated. */ + profile_probability::even ()); + DONE; +}) + (define_expand "cstorehf4" [(set (reg:CC FLAGS_REG) (compare:CC (match_operand:HF 2 "cmp_fp_expander_operand") @@ -1659,6 +1701,45 @@ DONE; }) +(define_expand "cstorebf4" + [(set (reg:CC FLAGS_REG) + (compare:CC (match_operand:BF 2 "cmp_fp_expander_operand") + (match_operand:BF 3 "cmp_fp_expander_operand"))) + (set (match_operand:QI 0 "register_operand") + (match_operator 1 "comparison_operator" + [(reg:CC FLAGS_REG) + (const_int 0)]))] + "" +{ + rtx op1 = gen_lowpart (HImode, operands[2]); + if (CONST_INT_P (op1)) + op1 = simplify_const_unary_operation (FLOAT_EXTEND, SFmode, + operands[2], BFmode); + else + { + rtx t1 = gen_reg_rtx (SImode); + emit_insn (gen_zero_extendhisi2 (t1, op1)); + emit_insn (gen_ashlsi3 (t1, t1, GEN_INT (16))); + op1 = gen_lowpart (SFmode, t1); + } + rtx op2 = gen_lowpart (HImode, operands[3]); + if (CONST_INT_P (op2)) + op2 = simplify_const_unary_operation (FLOAT_EXTEND, SFmode, + operands[3], BFmode); + else + { + rtx t2 = gen_reg_rtx (SImode); + emit_insn (gen_zero_extendhisi2 (t2, op2)); + emit_insn (gen_ashlsi3 (t2, t2, GEN_INT (16))); + op2 = gen_lowpart (SFmode, t2); + } + rtx res = emit_store_flag_force (operands[0], GET_CODE (operands[1]), + op1, op2, SFmode, 0, 1); + if (!rtx_equal_p (res, operands[0])) + emit_move_insn (operands[0], res); + DONE; +}) + (define_expand "cstore<mode>4" [(set (reg:CC FLAGS_REG) (compare:CC (match_operand:MODEF 2 "cmp_fp_expander_operand") diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 1534c87..e2607f0 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -8741,6 +8741,8 @@ extended_float_type_p (tree type) for (int i = 0; i < NUM_FLOATN_NX_TYPES; ++i) if (type == FLOATN_TYPE_NODE (i)) return true; + if (type == bfloat16_type_node) + return true; return false; } diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc index 634f60c..da0e142 100644 --- a/gcc/cp/typeck.cc +++ b/gcc/cp/typeck.cc @@ -293,6 +293,10 @@ cp_compare_floating_point_conversion_ranks (tree t1, tree t2) if (mv2 == FLOATN_NX_TYPE_NODE (i)) extended2 = i + 1; } + if (mv1 == bfloat16_type_node) + extended1 = true; + if (mv2 == bfloat16_type_node) + extended2 = true; if (extended2 && !extended1) { int ret = cp_compare_floating_point_conversion_ranks (t2, t1); @@ -390,7 +394,9 @@ cp_compare_floating_point_conversion_ranks (tree t1, tree t2) if (cnt > 1 && mv2 == long_double_type_node) return -2; /* Otherwise, they have equal rank, but extended types - (other than std::bfloat16_t) have higher subrank. */ + (other than std::bfloat16_t) have higher subrank. + std::bfloat16_t shouldn't have equal rank to any standard + floating point type. */ return 1; } diff --git a/gcc/expmed.cc b/gcc/expmed.cc index 6f7f99a..323565f 100644 --- a/gcc/expmed.cc +++ b/gcc/expmed.cc @@ -2705,7 +2705,7 @@ expand_shift (enum tree_code code, machine_mode mode, rtx shifted, /* Likewise, but return 0 if that cannot be done. */ -static rtx +rtx maybe_expand_shift (enum tree_code code, machine_mode mode, rtx shifted, int amount, rtx target, int unsignedp) { diff --git a/gcc/expmed.h b/gcc/expmed.h index 0b2538c..f50f323 100644 --- a/gcc/expmed.h +++ b/gcc/expmed.h @@ -707,6 +707,8 @@ extern rtx expand_variable_shift (enum tree_code, machine_mode, rtx, tree, rtx, int); extern rtx expand_shift (enum tree_code, machine_mode, rtx, poly_int64, rtx, int); +extern rtx maybe_expand_shift (enum tree_code, machine_mode, rtx, int, rtx, + int); #ifdef GCC_OPTABS_H extern rtx expand_divmod (int, enum tree_code, machine_mode, rtx, rtx, rtx, int, enum optab_methods = OPTAB_LIB_WIDEN); diff --git a/gcc/expr.cc b/gcc/expr.cc index b897b6d..4c892d6 100644 --- a/gcc/expr.cc +++ b/gcc/expr.cc @@ -344,7 +344,11 @@ convert_mode_scalar (rtx to, rtx from, int unsignedp) gcc_assert ((GET_MODE_PRECISION (from_mode) != GET_MODE_PRECISION (to_mode)) || (DECIMAL_FLOAT_MODE_P (from_mode) - != DECIMAL_FLOAT_MODE_P (to_mode))); + != DECIMAL_FLOAT_MODE_P (to_mode)) + || (REAL_MODE_FORMAT (from_mode) == &arm_bfloat_half_format + && REAL_MODE_FORMAT (to_mode) == &ieee_half_format) + || (REAL_MODE_FORMAT (to_mode) == &arm_bfloat_half_format + && REAL_MODE_FORMAT (from_mode) == &ieee_half_format)); if (GET_MODE_PRECISION (from_mode) == GET_MODE_PRECISION (to_mode)) /* Conversion between decimal float and binary float, same size. */ @@ -364,6 +368,150 @@ convert_mode_scalar (rtx to, rtx from, int unsignedp) return; } +#ifdef HAVE_SFmode + if (REAL_MODE_FORMAT (from_mode) == &arm_bfloat_half_format + && REAL_MODE_FORMAT (SFmode) == &ieee_single_format) + { + if (GET_MODE_PRECISION (to_mode) > GET_MODE_PRECISION (SFmode)) + { + /* To cut down on libgcc size, implement + BFmode -> {DF,XF,TF}mode conversions by + BFmode -> SFmode -> {DF,XF,TF}mode conversions. */ + rtx temp = gen_reg_rtx (SFmode); + convert_mode_scalar (temp, from, unsignedp); + convert_mode_scalar (to, temp, unsignedp); + return; + } + if (REAL_MODE_FORMAT (to_mode) == &ieee_half_format) + { + /* Similarly, implement BFmode -> HFmode as + BFmode -> SFmode -> HFmode conversion where SFmode + has superset of BFmode values. We don't need + to handle sNaNs by raising exception and turning + into into qNaN though, as that can be done in the + SFmode -> HFmode conversion too. */ + rtx temp = gen_reg_rtx (SFmode); + int save_flag_finite_math_only = flag_finite_math_only; + flag_finite_math_only = true; + convert_mode_scalar (temp, from, unsignedp); + flag_finite_math_only = save_flag_finite_math_only; + convert_mode_scalar (to, temp, unsignedp); + return; + } + if (to_mode == SFmode + && !HONOR_NANS (from_mode) + && !HONOR_NANS (to_mode) + && optimize_insn_for_speed_p ()) + { + /* If we don't expect sNaNs, for BFmode -> SFmode we can just + shift the bits up. */ + machine_mode fromi_mode, toi_mode; + if (int_mode_for_size (GET_MODE_BITSIZE (from_mode), + 0).exists (&fromi_mode) + && int_mode_for_size (GET_MODE_BITSIZE (to_mode), + 0).exists (&toi_mode)) + { + start_sequence (); + rtx fromi = lowpart_subreg (fromi_mode, from, from_mode); + rtx tof = NULL_RTX; + if (fromi) + { + rtx toi = gen_reg_rtx (toi_mode); + convert_mode_scalar (toi, fromi, 1); + toi + = maybe_expand_shift (LSHIFT_EXPR, toi_mode, toi, + GET_MODE_PRECISION (to_mode) + - GET_MODE_PRECISION (from_mode), + NULL_RTX, 1); + if (toi) + { + tof = lowpart_subreg (to_mode, toi, toi_mode); + if (tof) + emit_move_insn (to, tof); + } + } + insns = get_insns (); + end_sequence (); + if (tof) + { + emit_insn (insns); + return; + } + } + } + } + if (REAL_MODE_FORMAT (from_mode) == &ieee_single_format + && REAL_MODE_FORMAT (to_mode) == &arm_bfloat_half_format + && !HONOR_NANS (from_mode) + && !HONOR_NANS (to_mode) + && !flag_rounding_math + && optimize_insn_for_speed_p ()) + { + /* If we don't expect qNaNs nor sNaNs and can assume rounding + to nearest, we can expand the conversion inline as + (fromi + 0x7fff + ((fromi >> 16) & 1)) >> 16. */ + machine_mode fromi_mode, toi_mode; + if (int_mode_for_size (GET_MODE_BITSIZE (from_mode), + 0).exists (&fromi_mode) + && int_mode_for_size (GET_MODE_BITSIZE (to_mode), + 0).exists (&toi_mode)) + { + start_sequence (); + rtx fromi = lowpart_subreg (fromi_mode, from, from_mode); + rtx tof = NULL_RTX; + do + { + if (!fromi) + break; + int shift = (GET_MODE_PRECISION (from_mode) + - GET_MODE_PRECISION (to_mode)); + rtx temp1 + = maybe_expand_shift (RSHIFT_EXPR, fromi_mode, fromi, + shift, NULL_RTX, 1); + if (!temp1) + break; + rtx temp2 + = expand_binop (fromi_mode, and_optab, temp1, const1_rtx, + NULL_RTX, 1, OPTAB_DIRECT); + if (!temp2) + break; + rtx temp3 + = expand_binop (fromi_mode, add_optab, fromi, + gen_int_mode ((HOST_WIDE_INT_1U + << (shift - 1)) - 1, + fromi_mode), NULL_RTX, + 1, OPTAB_DIRECT); + if (!temp3) + break; + rtx temp4 + = expand_binop (fromi_mode, add_optab, temp3, temp2, + NULL_RTX, 1, OPTAB_DIRECT); + if (!temp4) + break; + rtx temp5 = maybe_expand_shift (RSHIFT_EXPR, fromi_mode, + temp4, shift, NULL_RTX, 1); + if (!temp5) + break; + rtx temp6 = lowpart_subreg (toi_mode, temp5, fromi_mode); + if (!temp6) + break; + tof = lowpart_subreg (to_mode, force_reg (toi_mode, temp6), + toi_mode); + if (tof) + emit_move_insn (to, tof); + } + while (0); + insns = get_insns (); + end_sequence (); + if (tof) + { + emit_insn (insns); + return; + } + } + } +#endif + /* Otherwise use a libcall. */ libcall = convert_optab_libfunc (tab, to_mode, from_mode); diff --git a/gcc/fold-const-call.cc b/gcc/fold-const-call.cc index 7295387..7e0d671 100644 --- a/gcc/fold-const-call.cc +++ b/gcc/fold-const-call.cc @@ -1301,6 +1301,7 @@ fold_const_call (combined_fn fn, tree type, tree arg) CASE_CFN_NANS: CASE_FLT_FN_FLOATN_NX (CFN_BUILT_IN_NANS): + case CFN_BUILT_IN_NANSF16B: case CFN_BUILT_IN_NANSD32: case CFN_BUILT_IN_NANSD64: case CFN_BUILT_IN_NANSD128: diff --git a/gcc/testsuite/g++.target/i386/bfloat_cpp_typecheck.C b/gcc/testsuite/g++.target/i386/bfloat_cpp_typecheck.C index b800a6d..2567129 100644 --- a/gcc/testsuite/g++.target/i386/bfloat_cpp_typecheck.C +++ b/gcc/testsuite/g++.target/i386/bfloat_cpp_typecheck.C @@ -5,6 +5,6 @@ void foo (void) { __bf16 (); /* { dg-bogus {invalid conversion to type '__bf16'} } */ __bf16 a = __bf16(); /* { dg-bogus {invalid conversion to type '__bf16'} } */ - __bf16 (0x1234); /* { dg-error {invalid conversion to type '__bf16'} } */ - __bf16 (0.1); /* { dg-error {invalid conversion to type '__bf16'} } */ + __bf16 (0x1234); /* { dg-bogus {invalid conversion to type '__bf16'} } */ + __bf16 (0.1); /* { dg-bogus {invalid conversion to type '__bf16'} } */ } diff --git a/gcc/testsuite/gcc.dg/torture/bfloat16-basic.c b/gcc/testsuite/gcc.dg/torture/bfloat16-basic.c new file mode 100644 index 0000000..09e54d4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/bfloat16-basic.c @@ -0,0 +1,11 @@ +/* Test __bf16. */ +/* { dg-do run } */ +/* { dg-options "" } */ +/* { dg-add-options bfloat16 } */ +/* { dg-require-effective-target bfloat16_runtime } */ + +#define TYPE __bf16 +#define CST(C) CONCAT (C, bf16) +#define CSTU(C) CONCAT (C, BF16) + +#include "floatn-basic.h" diff --git a/gcc/testsuite/gcc.dg/torture/bfloat16-builtin-issignaling-1.c b/gcc/testsuite/gcc.dg/torture/bfloat16-builtin-issignaling-1.c new file mode 100644 index 0000000..0e428db --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/bfloat16-builtin-issignaling-1.c @@ -0,0 +1,21 @@ +/* Test __bf16 __builtin_issignaling. */ +/* { dg-do run } */ +/* { dg-options "" } */ +/* { dg-add-options bfloat16 } */ +/* { dg-add-options ieee } */ +/* { dg-require-effective-target bfloat16_runtime } */ +/* { dg-additional-options "-fsignaling-nans" } */ +/* Workaround for PR57484 on ia32: */ +/* { dg-additional-options "-msse2 -mfpmath=sse" { target { ia32 && sse2_runtime } } } */ + +#define CONCATX(X, Y) X ## Y +#define CONCAT(X, Y) CONCATX (X, Y) + +#define TYPE __bf16 +#define CST(C) CONCAT (C, bf16) +#define FN(F) CONCAT (F, f16b) +#define NAN(x) ((__bf16) __builtin_nanf (x)) +#define INF ((__bf16) __builtin_inff ()) +#define EXT 0 + +#include "builtin-issignaling-1.c" diff --git a/gcc/testsuite/gcc.dg/torture/bfloat16-builtin.c b/gcc/testsuite/gcc.dg/torture/bfloat16-builtin.c new file mode 100644 index 0000000..ce02f6f --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/bfloat16-builtin.c @@ -0,0 +1,47 @@ +/* Test __bf16 built-in functions. */ +/* { dg-do run } */ +/* { dg-options "" } */ +/* { dg-add-options bfloat16 } */ +/* { dg-add-options ieee } */ +/* { dg-require-effective-target bfloat16_runtime } */ + +extern void exit (int); +extern void abort (void); + +extern __bf16 test_type; +extern __typeof (__builtin_nansf16b ("")) test_type; + +volatile __bf16 inf_cst = (__bf16) __builtin_inff (); +volatile __bf16 huge_val_cst = (__bf16) __builtin_huge_valf (); +volatile __bf16 nan_cst = (__bf16) __builtin_nanf (""); +volatile __bf16 nans_cst = __builtin_nansf16b (""); +volatile __bf16 neg0 = -0.0bf16, neg1 = -1.0bf16, one = 1.0; + +int +main (void) +{ + volatile __bf16 r; + if (!__builtin_isinf (inf_cst)) + abort (); + if (!__builtin_isinf (huge_val_cst)) + abort (); + if (inf_cst != huge_val_cst) + abort (); + if (!__builtin_isnan (nan_cst)) + abort (); + if (!__builtin_isnan (nans_cst)) + abort (); + r = __builtin_fabsf (neg1); + if (r != 1.0bf16) + abort (); + r = __builtin_copysignf (one, neg0); + if (r != neg1) + abort (); + r = __builtin_copysignf (inf_cst, neg1); + if (r != -huge_val_cst) + abort (); + r = __builtin_copysignf (-inf_cst, one); + if (r != huge_val_cst) + abort (); + exit (0); +} diff --git a/gcc/testsuite/gcc.dg/torture/bfloat16-complex.c b/gcc/testsuite/gcc.dg/torture/bfloat16-complex.c new file mode 100644 index 0000000..fa27a77 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/bfloat16-complex.c @@ -0,0 +1,61 @@ +/* Test __bf16 complex arithmetic. */ +/* { dg-do run } */ +/* { dg-options "" } */ +/* { dg-add-options bfloat16 } */ +/* { dg-require-effective-target bfloat16_runtime } */ + +extern void exit (int); +extern void abort (void); + +volatile __bf16 a = 1.0bf16; +typedef _Complex float __cbf16 __attribute__((__mode__(__BC__))); +volatile __cbf16 b = __builtin_complex (2.0bf16, 3.0bf16); +volatile __cbf16 c = __builtin_complex (2.0bf16, 3.0bf16); +volatile __cbf16 d = __builtin_complex (2.0bf16, 3.0bf16); + +__cbf16 +fn (__cbf16 arg) +{ + return arg / 4; +} + +int +main (void) +{ + volatile __cbf16 r; + if (b != c) + abort (); + if (b != d) + abort (); + r = a + b; + if (__real__ r != 3.0bf16 || __imag__ r != 3.0bf16) + abort (); + r += d; + if (__real__ r != 5.0bf16 || __imag__ r != 6.0bf16) + abort (); + r -= a; + if (__real__ r != 4.0bf16 || __imag__ r != 6.0bf16) + abort (); + r /= (a + a); + if (__real__ r != 2.0bf16 || __imag__ r != 3.0bf16) + abort (); + r *= (a + a); + if (__real__ r != 4.0bf16 || __imag__ r != 6.0bf16) + abort (); + r -= b; + if (__real__ r != 2.0bf16 || __imag__ r != 3.0bf16) + abort (); + r *= r; + if (__real__ r != -5.0bf16 || __imag__ r != 12.0bf16) + abort (); + /* Division may not be exact, so round result before comparing. */ + r /= b; + r += __builtin_complex (100.0bf16, 100.0bf16); + r -= __builtin_complex (100.0bf16, 100.0bf16); + if (r != b) + abort (); + r = fn (r); + if (__real__ r != 0.5bf16 || __imag__ r != 0.75bf16) + abort (); + exit (0); +} diff --git a/gcc/testsuite/gcc.dg/torture/builtin-issignaling-1.c b/gcc/testsuite/gcc.dg/torture/builtin-issignaling-1.c index fddca6c..60125b2 100644 --- a/gcc/testsuite/gcc.dg/torture/builtin-issignaling-1.c +++ b/gcc/testsuite/gcc.dg/torture/builtin-issignaling-1.c @@ -4,7 +4,7 @@ /* Workaround for PR57484 on ia32: */ /* { dg-additional-options "-msse2 -mfpmath=sse" { target { ia32 && sse2_runtime } } } */ -#ifndef EXT +#if !defined(EXT) && !defined(TYPE) int f1 (void) { @@ -41,31 +41,42 @@ f6 (long double x) return __builtin_issignaling (x); } #else -#define CONCATX(X, Y) X ## Y -#define CONCAT(X, Y) CONCATX (X, Y) -#define CONCAT3(X, Y, Z) CONCAT (CONCAT (X, Y), Z) -#define CONCAT4(W, X, Y, Z) CONCAT (CONCAT (CONCAT (W, X), Y), Z) +#ifndef TYPE +# define CONCATX(X, Y) X ## Y +# define CONCAT(X, Y) CONCATX (X, Y) +# define CONCAT3(X, Y, Z) CONCAT (CONCAT (X, Y), Z) +# define CONCAT4(W, X, Y, Z) CONCAT (CONCAT (CONCAT (W, X), Y), Z) -#if EXT -# define TYPE CONCAT3 (_Float, WIDTH, x) -# define CST(C) CONCAT4 (C, f, WIDTH, x) -# define FN(F) CONCAT4 (F, f, WIDTH, x) -#else -# define TYPE CONCAT (_Float, WIDTH) -# define CST(C) CONCAT3 (C, f, WIDTH) -# define FN(F) CONCAT3 (F, f, WIDTH) +# if EXT +# define TYPE CONCAT3 (_Float, WIDTH, x) +# define CST(C) CONCAT4 (C, f, WIDTH, x) +# define FN(F) CONCAT4 (F, f, WIDTH, x) +# else +# define TYPE CONCAT (_Float, WIDTH) +# define CST(C) CONCAT3 (C, f, WIDTH) +# define FN(F) CONCAT3 (F, f, WIDTH) +# endif +#endif +#ifndef NANS +# define NANS(x) FN (__builtin_nans) (x) +#endif +#ifndef NAN +# define NAN(x) FN (__builtin_nan) (x) +#endif +#ifndef INF +# define INF FN (__builtin_inf) () #endif int f1 (void) { - return __builtin_issignaling (FN (__builtin_nans) ("")); + return __builtin_issignaling (NANS ("")); } int f2 (void) { - return __builtin_issignaling (FN (__builtin_nan) ("")); + return __builtin_issignaling (NAN ("")); } int @@ -118,10 +129,10 @@ main () if (!f6 (z)) __builtin_abort (); #else - if (f4 (w) || !f4 (FN (__builtin_nans) ("0x123")) || f4 (CST (42.0)) || f4 (FN (__builtin_nan) ("0x234")) - || f4 (FN (__builtin_inf) ()) || f4 (-FN (__builtin_inf) ()) || f4 (CST (-42.0)) || f4 (CST (-0.0)) || f4 (CST (0.0))) + if (f4 (w) || !f4 (NANS ("0x123")) || f4 (CST (42.0)) || f4 (NAN ("0x234")) + || f4 (INF) || f4 (-INF) || f4 (CST (-42.0)) || f4 (CST (-0.0)) || f4 (CST (0.0))) __builtin_abort (); - w = FN (__builtin_nans) (""); + w = NANS (""); asm volatile ("" : : : "memory"); if (!f4 (w)) __builtin_abort (); diff --git a/gcc/testsuite/gcc.dg/torture/floatn-basic.h b/gcc/testsuite/gcc.dg/torture/floatn-basic.h index 9131f46..6540b53 100644 --- a/gcc/testsuite/gcc.dg/torture/floatn-basic.h +++ b/gcc/testsuite/gcc.dg/torture/floatn-basic.h @@ -9,14 +9,16 @@ #define CONCAT3(X, Y, Z) CONCAT (CONCAT (X, Y), Z) #define CONCAT4(W, X, Y, Z) CONCAT (CONCAT (CONCAT (W, X), Y), Z) -#if EXT -# define TYPE CONCAT3 (_Float, WIDTH, x) -# define CST(C) CONCAT4 (C, f, WIDTH, x) -# define CSTU(C) CONCAT4 (C, F, WIDTH, x) -#else -# define TYPE CONCAT (_Float, WIDTH) -# define CST(C) CONCAT3 (C, f, WIDTH) -# define CSTU(C) CONCAT3 (C, F, WIDTH) +#ifndef TYPE +# if EXT +# define TYPE CONCAT3 (_Float, WIDTH, x) +# define CST(C) CONCAT4 (C, f, WIDTH, x) +# define CSTU(C) CONCAT4 (C, F, WIDTH, x) +# else +# define TYPE CONCAT (_Float, WIDTH) +# define CST(C) CONCAT3 (C, f, WIDTH) +# define CSTU(C) CONCAT3 (C, F, WIDTH) +# endif #endif extern void exit (int); diff --git a/gcc/testsuite/gcc.target/i386/sse2-bfloat16-scalar-typecheck.c b/gcc/testsuite/gcc.target/i386/sse2-bfloat16-scalar-typecheck.c index 52b53b9..d1a76db 100644 --- a/gcc/testsuite/gcc.target/i386/sse2-bfloat16-scalar-typecheck.c +++ b/gcc/testsuite/gcc.target/i386/sse2-bfloat16-scalar-typecheck.c @@ -12,8 +12,8 @@ double is_a_double; float *float_ptr; -__bf16 foo1 (void) { return (__bf16) 0x1234; } /* { dg-error {invalid conversion to type '__bf16'} } */ -__bf16 foo2 (void) { return (__bf16) (short) 0x1234; } /* { dg-error {invalid conversion to type '__bf16'} } */ +__bf16 foo1 (void) { return (__bf16) 0x1234; } +__bf16 foo2 (void) { return (__bf16) (short) 0x1234; } __bf16 footest (__bf16 scalar0) { @@ -22,87 +22,87 @@ __bf16 footest (__bf16 scalar0) __bf16 scalar1_1; __bf16 scalar1_2 = glob_bfloat; - __bf16 scalar1_3 = 0; /* { dg-error {invalid conversion to type '__bf16'} } */ - __bf16 scalar1_4 = 0.1; /* { dg-error {invalid conversion to type '__bf16'} } */ - __bf16 scalar1_5 = is_a_float; /* { dg-error {invalid conversion to type '__bf16'} } */ - __bf16 scalar1_6 = is_an_int; /* { dg-error {invalid conversion to type '__bf16'} } */ - __bf16 scalar1_7 = is_a_float16; /* { dg-error {invalid conversion to type '__bf16'} } */ - __bf16 scalar1_8 = is_a_double; /* { dg-error {invalid conversion to type '__bf16'} } */ - __bf16 scalar1_9 = is_a_short_int; /* { dg-error {invalid conversion to type '__bf16'} } */ - - int initi_1_1 = glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ - float initi_1_2 = glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ - _Float16 initi_1_3 = glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ - short initi_1_4 = glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ - double initi_1_5 = glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ + __bf16 scalar1_3 = 0; + __bf16 scalar1_4 = 0.1; + __bf16 scalar1_5 = is_a_float; + __bf16 scalar1_6 = is_an_int; + __bf16 scalar1_7 = is_a_float16; + __bf16 scalar1_8 = is_a_double; + __bf16 scalar1_9 = is_a_short_int; + + int initi_1_1 = glob_bfloat; + float initi_1_2 = glob_bfloat; + _Float16 initi_1_3 = glob_bfloat; + short initi_1_4 = glob_bfloat; + double initi_1_5 = glob_bfloat; __bf16 scalar2_1 = {}; __bf16 scalar2_2 = { glob_bfloat }; - __bf16 scalar2_3 = { 0 }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __bf16 scalar2_4 = { 0.1 }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __bf16 scalar2_5 = { is_a_float }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __bf16 scalar2_6 = { is_an_int }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __bf16 scalar2_7 = { is_a_float16 }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __bf16 scalar2_8 = { is_a_double }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __bf16 scalar2_9 = { is_a_short_int }; /* { dg-error {invalid conversion to type '__bf16'} } */ - - int initi_2_1 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - float initi_2_2 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - _Float16 initi_2_3 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - short initi_2_4 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - double initi_2_5 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ + __bf16 scalar2_3 = { 0 }; + __bf16 scalar2_4 = { 0.1 }; + __bf16 scalar2_5 = { is_a_float }; + __bf16 scalar2_6 = { is_an_int }; + __bf16 scalar2_7 = { is_a_float16 }; + __bf16 scalar2_8 = { is_a_double }; + __bf16 scalar2_9 = { is_a_short_int }; + + int initi_2_1 = { glob_bfloat }; + float initi_2_2 = { glob_bfloat }; + _Float16 initi_2_3 = { glob_bfloat }; + short initi_2_4 = { glob_bfloat }; + double initi_2_5 = { glob_bfloat }; /* Assignments. */ glob_bfloat = glob_bfloat; - glob_bfloat = 0; /* { dg-error {invalid conversion to type '__bf16'} } */ - glob_bfloat = 0.1; /* { dg-error {invalid conversion to type '__bf16'} } */ - glob_bfloat = is_a_float; /* { dg-error {invalid conversion to type '__bf16'} } */ - glob_bfloat = is_an_int; /* { dg-error {invalid conversion to type '__bf16'} } */ - glob_bfloat = is_a_float16; /* { dg-error {invalid conversion to type '__bf16'} } */ - glob_bfloat = is_a_double; /* { dg-error {invalid conversion to type '__bf16'} } */ - glob_bfloat = is_a_short_int; /* { dg-error {invalid conversion to type '__bf16'} } */ - - is_an_int = glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ - is_a_float = glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ - is_a_float16 = glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ - is_a_double = glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ - is_a_short_int = glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ + glob_bfloat = 0; + glob_bfloat = 0.1; + glob_bfloat = is_a_float; + glob_bfloat = is_an_int; + glob_bfloat = is_a_float16; + glob_bfloat = is_a_double; + glob_bfloat = is_a_short_int; + + is_an_int = glob_bfloat; + is_a_float = glob_bfloat; + is_a_float16 = glob_bfloat; + is_a_double = glob_bfloat; + is_a_short_int = glob_bfloat; /* Casting. */ (void) glob_bfloat; (__bf16) glob_bfloat; - (int) glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ - (float) glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ - (_Float16) glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ - (double) glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ - (short) glob_bfloat; /* { dg-error {invalid conversion from type '__bf16'} } */ + (int) glob_bfloat; + (float) glob_bfloat; + (_Float16) glob_bfloat; + (double) glob_bfloat; + (short) glob_bfloat; - (__bf16) is_an_int; /* { dg-error {invalid conversion to type '__bf16'} } */ - (__bf16) is_a_float; /* { dg-error {invalid conversion to type '__bf16'} } */ - (__bf16) is_a_float16; /* { dg-error {invalid conversion to type '__bf16'} } */ - (__bf16) is_a_double; /* { dg-error {invalid conversion to type '__bf16'} } */ - (__bf16) is_a_short_int; /* { dg-error {invalid conversion to type '__bf16'} } */ + (__bf16) is_an_int; + (__bf16) is_a_float; + (__bf16) is_a_float16; + (__bf16) is_a_double; + (__bf16) is_a_short_int; /* Compound literals. */ (__bf16) {}; (__bf16) { glob_bfloat }; - (__bf16) { 0 }; /* { dg-error {invalid conversion to type '__bf16'} } */ - (__bf16) { 0.1 }; /* { dg-error {invalid conversion to type '__bf16'} } */ - (__bf16) { is_a_float }; /* { dg-error {invalid conversion to type '__bf16'} } */ - (__bf16) { is_an_int }; /* { dg-error {invalid conversion to type '__bf16'} } */ - (__bf16) { is_a_float16 }; /* { dg-error {invalid conversion to type '__bf16'} } */ - (__bf16) { is_a_double }; /* { dg-error {invalid conversion to type '__bf16'} } */ - (__bf16) { is_a_short_int }; /* { dg-error {invalid conversion to type '__bf16'} } */ - - (int) { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - (float) { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - (_Float16) { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - (double) { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - (short) { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ + (__bf16) { 0 }; + (__bf16) { 0.1 }; + (__bf16) { is_a_float }; + (__bf16) { is_an_int }; + (__bf16) { is_a_float16 }; + (__bf16) { is_a_double }; + (__bf16) { is_a_short_int }; + + (int) { glob_bfloat }; + (float) { glob_bfloat }; + (_Float16) { glob_bfloat }; + (double) { glob_bfloat }; + (short) { glob_bfloat }; /* Arrays and Structs. */ @@ -145,16 +145,16 @@ __bf16 footest (__bf16 scalar0) bfloat_ptr = &bfloat_ptr3[1]; /* Simple comparison. */ - scalar0 > glob_bfloat; /* { dg-error {operation not permitted on type '__bf16'} } */ - glob_bfloat == scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ - scalar0 > is_a_float; /* { dg-error {operation not permitted on type '__bf16'} } */ - is_a_float == scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ - scalar0 > 0; /* { dg-error {operation not permitted on type '__bf16'} } */ - 0 == scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ - scalar0 > 0.1; /* { dg-error {operation not permitted on type '__bf16'} } */ - 0.1 == scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ - scalar0 > is_an_int; /* { dg-error {operation not permitted on type '__bf16'} } */ - is_an_int == scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ + scalar0 > glob_bfloat; + glob_bfloat == scalar0; + scalar0 > is_a_float; + is_a_float == scalar0; + scalar0 > 0; + 0 == scalar0; + scalar0 > 0.1; + 0.1 == scalar0; + scalar0 > is_an_int; + is_an_int == scalar0; /* Pointer comparison. */ @@ -174,41 +174,41 @@ __bf16 footest (__bf16 scalar0) /* Conditional expressions. */ 0 ? scalar0 : scalar0; - 0 ? scalar0 : is_a_float; /* { dg-error {invalid conversion from type '__bf16'} } */ - 0 ? is_a_float : scalar0; /* { dg-error {invalid conversion from type '__bf16'} } */ - 0 ? scalar0 : 0; /* { dg-error {invalid conversion to type '__bf16'} } */ - 0 ? 0 : scalar0; /* { dg-error {invalid conversion to type '__bf16'} } */ - 0 ? 0.1 : scalar0; /* { dg-error {invalid conversion from type '__bf16'} } */ - 0 ? scalar0 : 0.1; /* { dg-error {invalid conversion from type '__bf16'} } */ + 0 ? scalar0 : is_a_float; + 0 ? is_a_float : scalar0; + 0 ? scalar0 : 0; + 0 ? 0 : scalar0; + 0 ? 0.1 : scalar0; + 0 ? scalar0 : 0.1; 0 ? bfloat_ptr : bfloat_ptr2; 0 ? bfloat_ptr : float_ptr; /* { dg-warning {pointer type mismatch in conditional expression} } */ 0 ? float_ptr : bfloat_ptr; /* { dg-warning {pointer type mismatch in conditional expression} } */ - scalar0 ? scalar0 : scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ - scalar0 ? is_a_float : scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ - scalar0 ? scalar0 : is_a_float; /* { dg-error {operation not permitted on type '__bf16'} } */ - scalar0 ? is_a_float : is_a_float; /* { dg-error {operation not permitted on type '__bf16'} } */ + scalar0 ? scalar0 : scalar0; + scalar0 ? is_a_float : scalar0; + scalar0 ? scalar0 : is_a_float; + scalar0 ? is_a_float : is_a_float; /* Unary operators. */ - +scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ - -scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ - ~scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ - !scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ + +scalar0; + -scalar0; + ~scalar0; /* { dg-error {wrong type argument to bit-complement} } */ + !scalar0; *scalar0; /* { dg-error {invalid type argument of unary '\*'} } */ - __real scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ - __imag scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ - ++scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ - --scalar0; /* { dg-error {operation not permitted on type '__bf16'} } */ - scalar0++; /* { dg-error {operation not permitted on type '__bf16'} } */ - scalar0--; /* { dg-error {operation not permitted on type '__bf16'} } */ + __real scalar0; + __imag scalar0; + ++scalar0; + --scalar0; + scalar0++; + scalar0--; /* Binary arithmetic operations. */ - scalar0 = glob_bfloat + *bfloat_ptr; /* { dg-error {operation not permitted on type '__bf16'} } */ - scalar0 = glob_bfloat + 0.1; /* { dg-error {operation not permitted on type '__bf16'} } */ - scalar0 = glob_bfloat + 0; /* { dg-error {operation not permitted on type '__bf16'} } */ - scalar0 = glob_bfloat + is_a_float; /* { dg-error {operation not permitted on type '__bf16'} } */ + scalar0 = glob_bfloat + *bfloat_ptr; + scalar0 = glob_bfloat + 0.1; + scalar0 = glob_bfloat + 0; + scalar0 = glob_bfloat + is_a_float; return scalar0; } diff --git a/gcc/testsuite/gcc.target/i386/vect-bfloat16-typecheck_1.c b/gcc/testsuite/gcc.target/i386/vect-bfloat16-typecheck_1.c index 3804bac..8bc3f4a 100644 --- a/gcc/testsuite/gcc.target/i386/vect-bfloat16-typecheck_1.c +++ b/gcc/testsuite/gcc.target/i386/vect-bfloat16-typecheck_1.c @@ -48,20 +48,20 @@ __m128bf16 footest (__m128bf16 vector0) __m128bf16 vector2_1 = {}; __m128bf16 vector2_2 = { glob_bfloat }; __m128bf16 vector2_3 = { glob_bfloat, glob_bfloat, glob_bfloat, glob_bfloat }; - __m128bf16 vector2_4 = { 0 }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __m128bf16 vector2_5 = { 0.1 }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __m128bf16 vector2_6 = { is_a_float16 }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __m128bf16 vector2_7 = { is_a_float }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __m128bf16 vector2_8 = { is_an_int }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __m128bf16 vector2_9 = { is_a_short_int }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __m128bf16 vector2_10 = { 0.0, 0, is_a_short_int, is_a_float }; /* { dg-error {invalid conversion to type '__bf16'} } */ - - __v8si initi_2_1 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - __m256 initi_2_2 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - __m128h initi_2_3 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - __m128 initi_2_4 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - __v4si initi_2_5 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - __v4hi initi_2_6 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ + __m128bf16 vector2_4 = { 0 }; + __m128bf16 vector2_5 = { 0.1 }; + __m128bf16 vector2_6 = { is_a_float16 }; + __m128bf16 vector2_7 = { is_a_float }; + __m128bf16 vector2_8 = { is_an_int }; + __m128bf16 vector2_9 = { is_a_short_int }; + __m128bf16 vector2_10 = { 0.0, 0, is_a_short_int, is_a_float }; + + __v8si initi_2_1 = { glob_bfloat }; + __m256 initi_2_2 = { glob_bfloat }; + __m128h initi_2_3 = { glob_bfloat }; + __m128 initi_2_4 = { glob_bfloat }; + __v4si initi_2_5 = { glob_bfloat }; + __v4hi initi_2_6 = { glob_bfloat }; /* Assignments to/from vectors. */ @@ -85,25 +85,25 @@ __m128bf16 footest (__m128bf16 vector0) /* Assignments to/from elements. */ vector2_3[0] = glob_bfloat; - vector2_3[0] = is_an_int; /* { dg-error {invalid conversion to type '__bf16'} } */ - vector2_3[0] = is_a_short_int; /* { dg-error {invalid conversion to type '__bf16'} } */ - vector2_3[0] = is_a_float; /* { dg-error {invalid conversion to type '__bf16'} } */ - vector2_3[0] = is_a_float16; /* { dg-error {invalid conversion to type '__bf16'} } */ - vector2_3[0] = 0; /* { dg-error {invalid conversion to type '__bf16'} } */ - vector2_3[0] = 0.1; /* { dg-error {invalid conversion to type '__bf16'} } */ + vector2_3[0] = is_an_int; + vector2_3[0] = is_a_short_int; + vector2_3[0] = is_a_float; + vector2_3[0] = is_a_float16; + vector2_3[0] = 0; + vector2_3[0] = 0.1; glob_bfloat = vector2_3[0]; - is_an_int = vector2_3[0]; /* { dg-error {invalid conversion from type '__bf16'} } */ - is_a_short_int = vector2_3[0]; /* { dg-error {invalid conversion from type '__bf16'} } */ - is_a_float = vector2_3[0]; /* { dg-error {invalid conversion from type '__bf16'} } */ - is_a_float16 = vector2_3[0]; /* { dg-error {invalid conversion from type '__bf16'} } */ + is_an_int = vector2_3[0]; + is_a_short_int = vector2_3[0]; + is_a_float = vector2_3[0]; + is_a_float16 = vector2_3[0]; /* Compound literals. */ (__m128bf16) {}; - (__m128bf16) { 0 }; /* { dg-error {invalid conversion to type '__bf16'} } */ - (__m128bf16) { 0.1 }; /* { dg-error {invalid conversion to type '__bf16'} } */ + (__m128bf16) { 0 }; + (__m128bf16) { 0.1 }; (__m128bf16) { is_a_float_vec }; /* { dg-error {incompatible types when initializing type '__bf16' using type '__m256'} } */ (__m128bf16) { is_an_int_vec }; /* { dg-error {incompatible types when initializing type '__bf16' using type '__v8si'} } */ (__m128bf16) { is_a_float_pair }; /* { dg-error {incompatible types when initializing type '__bf16' using type '__m128'} } */ @@ -186,16 +186,16 @@ __m128bf16 footest (__m128bf16 vector0) bfloat_ptr = &bfloat_ptr3[1]; /* Simple comparison. */ - vector0 > glob_bfloat_vec; /* { dg-error {operation not permitted on type '__bf16'} } */ - glob_bfloat_vec == vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0 > is_a_float_vec; /* { dg-error {operation not permitted on type '__bf16'} } */ - is_a_float_vec == vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0 > 0; /* { dg-error {operation not permitted on type '__bf16'} } */ - 0 == vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0 > 0.1; /* { dg-error {operation not permitted on type '__bf16'} } */ - 0.1 == vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0 > is_an_int_vec; /* { dg-error {operation not permitted on type '__bf16'} } */ - is_an_int_vec == vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ + vector0 > glob_bfloat_vec; + glob_bfloat_vec == vector0; + vector0 > is_a_float_vec; /* { dg-error {comparing vectors with different element types} } */ + is_a_float_vec == vector0; /* { dg-error {comparing vectors with different element types} } */ + vector0 > 0; + 0 == vector0; + vector0 > 0.1; /* { dg-error {conversion of scalar 'double' to vector '__m128bf16'} } */ + 0.1 == vector0; /* { dg-error {conversion of scalar 'double' to vector '__m128bf16'} } */ + vector0 > is_an_int_vec; /* { dg-error {comparing vectors with different element types} } */ + is_an_int_vec == vector0; /* { dg-error {comparing vectors with different element types} } */ /* Pointer comparison. */ @@ -234,24 +234,24 @@ __m128bf16 footest (__m128bf16 vector0) /* Unary operators. */ - +vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - -vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - ~vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - !vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ + +vector0; + -vector0; + ~vector0; /* { dg-error {wrong type argument to bit-complement} } */ + !vector0; /* { dg-error {wrong type argument to unary exclamation mark} } */ *vector0; /* { dg-error {invalid type argument of unary '\*'} } */ - __real vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - __imag vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - ++vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - --vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0++; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0--; /* { dg-error {operation not permitted on type '__bf16'} } */ + __real vector0; /* { dg-error {wrong type argument to __real} } */ + __imag vector0; /* { dg-error {wrong type argument to __imag} } */ + ++vector0; + --vector0; + vector0++; + vector0--; /* Binary arithmetic operations. */ - vector0 = glob_bfloat_vec + *bfloat_ptr; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0 = glob_bfloat_vec + 0.1; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0 = glob_bfloat_vec + 0; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0 = glob_bfloat_vec + is_a_float_vec; /* { dg-error {operation not permitted on type '__bf16'} } */ + vector0 = glob_bfloat_vec + *bfloat_ptr; + vector0 = glob_bfloat_vec + 0.1; /* { dg-error {conversion of scalar 'double' to vector '__m128bf16'} } */ + vector0 = glob_bfloat_vec + 0; + vector0 = glob_bfloat_vec + is_a_float_vec; /* { dg-error {invalid operands to binary \+} } */ return vector0; } diff --git a/gcc/testsuite/gcc.target/i386/vect-bfloat16-typecheck_2.c b/gcc/testsuite/gcc.target/i386/vect-bfloat16-typecheck_2.c index f63b41d8..2a8a535 100644 --- a/gcc/testsuite/gcc.target/i386/vect-bfloat16-typecheck_2.c +++ b/gcc/testsuite/gcc.target/i386/vect-bfloat16-typecheck_2.c @@ -45,19 +45,19 @@ __m256bf16 footest (__m256bf16 vector0) __m256bf16 vector2_1 = {}; __m256bf16 vector2_2 = { glob_bfloat }; __m256bf16 vector2_3 = { glob_bfloat, glob_bfloat, glob_bfloat, glob_bfloat }; - __m256bf16 vector2_4 = { 0 }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __m256bf16 vector2_5 = { 0.1 }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __m256bf16 vector2_6 = { is_a_float16 }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __m256bf16 vector2_7 = { is_a_float }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __m256bf16 vector2_8 = { is_an_int }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __m256bf16 vector2_9 = { is_a_short_int }; /* { dg-error {invalid conversion to type '__bf16'} } */ - __m256bf16 vector2_10 = { 0.0, 0, is_a_short_int, is_a_float }; /* { dg-error "invalid conversion to type '__bf16'" } */ - - __v8si initi_2_1 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - __m256 initi_2_2 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - __m256h initi_2_3 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - __m256i initi_2_5 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ - __v16hi initi_2_6 = { glob_bfloat }; /* { dg-error {invalid conversion from type '__bf16'} } */ + __m256bf16 vector2_4 = { 0 }; + __m256bf16 vector2_5 = { 0.1 }; + __m256bf16 vector2_6 = { is_a_float16 }; + __m256bf16 vector2_7 = { is_a_float }; + __m256bf16 vector2_8 = { is_an_int }; + __m256bf16 vector2_9 = { is_a_short_int }; + __m256bf16 vector2_10 = { 0.0, 0, is_a_short_int, is_a_float }; + + __v8si initi_2_1 = { glob_bfloat }; + __m256 initi_2_2 = { glob_bfloat }; + __m256h initi_2_3 = { glob_bfloat }; + __m256i initi_2_5 = { glob_bfloat }; + __v16hi initi_2_6 = { glob_bfloat }; /* Assignments to/from vectors. */ @@ -79,25 +79,25 @@ __m256bf16 footest (__m256bf16 vector0) /* Assignments to/from elements. */ vector2_3[0] = glob_bfloat; - vector2_3[0] = is_an_int; /* { dg-error {invalid conversion to type '__bf16'} } */ - vector2_3[0] = is_a_short_int; /* { dg-error {invalid conversion to type '__bf16'} } */ - vector2_3[0] = is_a_float; /* { dg-error {invalid conversion to type '__bf16'} } */ - vector2_3[0] = is_a_float16; /* { dg-error {invalid conversion to type '__bf16'} } */ - vector2_3[0] = 0; /* { dg-error {invalid conversion to type '__bf16'} } */ - vector2_3[0] = 0.1; /* { dg-error {invalid conversion to type '__bf16'} } */ + vector2_3[0] = is_an_int; + vector2_3[0] = is_a_short_int; + vector2_3[0] = is_a_float; + vector2_3[0] = is_a_float16; + vector2_3[0] = 0; + vector2_3[0] = 0.1; glob_bfloat = vector2_3[0]; - is_an_int = vector2_3[0]; /* { dg-error {invalid conversion from type '__bf16'} } */ - is_a_short_int = vector2_3[0]; /* { dg-error {invalid conversion from type '__bf16'} } */ - is_a_float = vector2_3[0]; /* { dg-error {invalid conversion from type '__bf16'} } */ - is_a_float16 = vector2_3[0]; /* { dg-error {invalid conversion from type '__bf16'} } */ + is_an_int = vector2_3[0]; + is_a_short_int = vector2_3[0]; + is_a_float = vector2_3[0]; + is_a_float16 = vector2_3[0]; /* Compound literals. */ (__m256bf16) {}; - (__m256bf16) { 0 }; /* { dg-error {invalid conversion to type '__bf16'} } */ - (__m256bf16) { 0.1 }; /* { dg-error {invalid conversion to type '__bf16'} } */ + (__m256bf16) { 0 }; + (__m256bf16) { 0.1 }; (__m256bf16) { is_a_float_vec }; /* { dg-error {incompatible types when initializing type '__bf16' using type '__m256'} } */ (__m256bf16) { is_an_int_vec }; /* { dg-error {incompatible types when initializing type '__bf16' using type '__v8si'} } */ (__m256bf16) { is_a_long_int_pair }; /* { dg-error {incompatible types when initializing type '__bf16' using type '__m256i'} } */ @@ -176,16 +176,16 @@ __m256bf16 footest (__m256bf16 vector0) bfloat_ptr = &bfloat_ptr3[1]; /* Simple comparison. */ - vector0 > glob_bfloat_vec; /* { dg-error {operation not permitted on type '__bf16'} } */ - glob_bfloat_vec == vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0 > is_a_float_vec; /* { dg-error {operation not permitted on type '__bf16'} } */ - is_a_float_vec == vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0 > 0; /* { dg-error {operation not permitted on type '__bf16'} } */ - 0 == vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0 > 0.1; /* { dg-error {operation not permitted on type '__bf16'} } */ - 0.1 == vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0 > is_an_int_vec; /* { dg-error {operation not permitted on type '__bf16'} } */ - is_an_int_vec == vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ + vector0 > glob_bfloat_vec; + glob_bfloat_vec == vector0; + vector0 > is_a_float_vec; /* { dg-error {comparing vectors with different element types} } */ + is_a_float_vec == vector0; /* { dg-error {comparing vectors with different element types} } */ + vector0 > 0; + 0 == vector0; + vector0 > 0.1; /* { dg-error {conversion of scalar 'double' to vector '__m256bf16'} } */ + 0.1 == vector0; /* { dg-error {conversion of scalar 'double' to vector '__m256bf16'} } */ + vector0 > is_an_int_vec; /* { dg-error {comparing vectors with different element types} } */ + is_an_int_vec == vector0; /* { dg-error {comparing vectors with different element types} } */ /* Pointer comparison. */ @@ -224,24 +224,24 @@ __m256bf16 footest (__m256bf16 vector0) /* Unary operators. */ - +vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - -vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - ~vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - !vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ + +vector0; + -vector0; + ~vector0; /* { dg-error {wrong type argument to bit-complement} } */ + !vector0; /* { dg-error {wrong type argument to unary exclamation mark} } */ *vector0; /* { dg-error {invalid type argument of unary '\*'} } */ - __real vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - __imag vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - ++vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - --vector0; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0++; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0--; /* { dg-error {operation not permitted on type '__bf16'} } */ + __real vector0; /* { dg-error {wrong type argument to __real} } */ + __imag vector0; /* { dg-error {wrong type argument to __imag} } */ + ++vector0; + --vector0; + vector0++; + vector0--; /* Binary arithmetic operations. */ - vector0 = glob_bfloat_vec + *bfloat_ptr; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0 = glob_bfloat_vec + 0.1; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0 = glob_bfloat_vec + 0; /* { dg-error {operation not permitted on type '__bf16'} } */ - vector0 = glob_bfloat_vec + is_a_float_vec; /* { dg-error {operation not permitted on type '__bf16'} } */ + vector0 = glob_bfloat_vec + *bfloat_ptr; + vector0 = glob_bfloat_vec + 0.1; /* { dg-error {conversion of scalar 'double' to vector '__m256bf16'} } */ + vector0 = glob_bfloat_vec + 0; + vector0 = glob_bfloat_vec + is_a_float_vec; /* { dg-error {invalid operands to binary \+} } */ return vector0; } diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp index fdd88e6..8d45bc2 100644 --- a/gcc/testsuite/lib/target-supports.exp +++ b/gcc/testsuite/lib/target-supports.exp @@ -3416,6 +3416,22 @@ proc check_effective_target_base_quadfloat_support { } { return 1 } +# Return 1 if the target supports the __bf16 type, 0 otherwise. + +proc check_effective_target_bfloat16 {} { + return [check_no_compiler_messages_nocache bfloat16 object { + __bf16 foo (__bf16 x) { return x + x; } + } [add_options_for_bfloat16 ""]] +} + +proc check_effective_target_bfloat16_runtime {} { + return [check_effective_target_bfloat16] +} + +proc add_options_for_bfloat16 { flags } { + return "$flags" +} + # Return 1 if the target supports all four forms of fused multiply-add # (fma, fms, fnma, and fnms) for both float and double. diff --git a/gcc/tree-core.h b/gcc/tree-core.h index c4f2cea..80b886c 100644 --- a/gcc/tree-core.h +++ b/gcc/tree-core.h @@ -665,6 +665,9 @@ enum tree_index { TI_DOUBLE_TYPE, TI_LONG_DOUBLE_TYPE, + /* __bf16 type if supported (used in C++ as std::bfloat16_t). */ + TI_BFLOAT16_TYPE, + /* The _FloatN and _FloatNx types must be consecutive, and in the same sequence as the corresponding complex types, which must also be consecutive; _FloatN must come before _FloatNx; the order must diff --git a/gcc/tree.cc b/gcc/tree.cc index c4ead94..81a6cea 100644 --- a/gcc/tree.cc +++ b/gcc/tree.cc @@ -7711,7 +7711,7 @@ excess_precision_type (tree type) = (flag_excess_precision == EXCESS_PRECISION_FAST ? EXCESS_PRECISION_TYPE_FAST : (flag_excess_precision == EXCESS_PRECISION_FLOAT16 - ? EXCESS_PRECISION_TYPE_FLOAT16 :EXCESS_PRECISION_TYPE_STANDARD)); + ? EXCESS_PRECISION_TYPE_FLOAT16 : EXCESS_PRECISION_TYPE_STANDARD)); enum flt_eval_method target_flt_eval_method = targetm.c.excess_precision (requested_type); @@ -7736,6 +7736,9 @@ excess_precision_type (tree type) machine_mode float16_type_mode = (float16_type_node ? TYPE_MODE (float16_type_node) : VOIDmode); + machine_mode bfloat16_type_mode = (bfloat16_type_node + ? TYPE_MODE (bfloat16_type_node) + : VOIDmode); machine_mode float_type_mode = TYPE_MODE (float_type_node); machine_mode double_type_mode = TYPE_MODE (double_type_node); @@ -7747,16 +7750,19 @@ excess_precision_type (tree type) switch (target_flt_eval_method) { case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT: - if (type_mode == float16_type_mode) + if (type_mode == float16_type_mode + || type_mode == bfloat16_type_mode) return float_type_node; break; case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE: if (type_mode == float16_type_mode + || type_mode == bfloat16_type_mode || type_mode == float_type_mode) return double_type_node; break; case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE: if (type_mode == float16_type_mode + || type_mode == bfloat16_type_mode || type_mode == float_type_mode || type_mode == double_type_mode) return long_double_type_node; @@ -7774,16 +7780,19 @@ excess_precision_type (tree type) switch (target_flt_eval_method) { case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT: - if (type_mode == float16_type_mode) + if (type_mode == float16_type_mode + || type_mode == bfloat16_type_mode) return complex_float_type_node; break; case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE: if (type_mode == float16_type_mode + || type_mode == bfloat16_type_mode || type_mode == float_type_mode) return complex_double_type_node; break; case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE: if (type_mode == float16_type_mode + || type_mode == bfloat16_type_mode || type_mode == float_type_mode || type_mode == double_type_mode) return complex_long_double_type_node; @@ -9462,6 +9471,17 @@ build_common_tree_nodes (bool signed_char) SET_TYPE_MODE (FLOATN_NX_TYPE_NODE (i), mode); } float128t_type_node = float128_type_node; +#ifdef HAVE_BFmode + if (REAL_MODE_FORMAT (BFmode) == &arm_bfloat_half_format + && targetm.scalar_mode_supported_p (BFmode) + && targetm.libgcc_floating_mode_supported_p (BFmode)) + { + bfloat16_type_node = make_node (REAL_TYPE); + TYPE_PRECISION (bfloat16_type_node) = GET_MODE_PRECISION (BFmode); + layout_type (bfloat16_type_node); + SET_TYPE_MODE (bfloat16_type_node, BFmode); + } +#endif float_ptr_type_node = build_pointer_type (float_type_node); double_ptr_type_node = build_pointer_type (double_type_node); @@ -4291,6 +4291,7 @@ tree_strip_any_location_wrapper (tree exp) #define float_type_node global_trees[TI_FLOAT_TYPE] #define double_type_node global_trees[TI_DOUBLE_TYPE] #define long_double_type_node global_trees[TI_LONG_DOUBLE_TYPE] +#define bfloat16_type_node global_trees[TI_BFLOAT16_TYPE] /* Nodes for particular _FloatN and _FloatNx types in sequence. */ #define FLOATN_TYPE_NODE(IDX) global_trees[TI_FLOATN_TYPE_FIRST + (IDX)] |