2024-08-07 11:13  Xiao Zeng <zengx...@eswincomputing.com> wrote: 

The existing test cases 'gcc.dg/portal/float16 complex.c' for gcc are
already good, so no new test cases were added.

Of course, more test cases are always good, and if necessary, I will
supplement the test cases.
>
>gcc/ChangeLog:
>
>       * builtin-types.def (BT_COMPLEX_BFLOAT16): Support BF16 node.
>       (BT_BFLOAT16_PTR): Ditto.
>       (BT_FN_BFLOAT16): New.
>       (BT_FN_BFLOAT16_BFLOAT16): Ditto.
>       (BT_FN_COMPLEX_BFLOAT16_COMPLEX_BFLOAT16): Ditto.
>       (BT_FN_BFLOAT16_COMPLEX_BFLOAT16): Ditto.
>       (BT_FN_INT_BFLOAT16): Ditto.
>       (BT_FN_LONG_BFLOAT16): Ditto.
>       (BT_FN_LONGLONG_BFLOAT16): Ditto.
>       (BT_FN_BFLOAT16_BFLOAT16_BFLOAT16PTR): Ditto.
>       (BT_FN_BFLOAT16_BFLOAT16_INT): Ditto.
>       (BT_FN_BFLOAT16_BFLOAT16_INTPTR): Ditto.
>       (BT_FN_BFLOAT16_BFLOAT16_LONG): Ditto.
>       (BT_FN_COMPLEX_BFLOAT16_COMPLEX_BFLOAT16_COMPLEX_BFLOAT16): Ditto.
>       (BT_FN_BFLOAT16_BFLOAT16_BFLOAT16_BFLOAT16): Ditto.
>       (BT_FN_BFLOAT16_BFLOAT16_BFLOAT16_INTPTR): Ditto.
>       * builtins.cc (expand_builtin_classify_type): Support BF16.
>       (mathfn_built_in_2): Ditto.
>       (CASE_MATHFN_FLOATN): Ditto.
>       * builtins.def (DEF_GCC_FLOATN_NX_BUILTINS): Ditto.
>       (DEF_EXT_LIB_FLOATN_NX_BUILTINS): Ditto.
>       (BUILT_IN_NANSF16B): Added in general processing, redundant
>       is removed here.
>       (BUILT_IN_NEXTAFTERF16B): Ditto.
>       * fold-const-call.cc (fold_const_call): Ditto.
>       (fold_const_call_sss): Ditto.
>       * gencfn-macros.cc: Support BF16.
>       * match.pd: Like FP16, add optimization for BF16.
>       * tree.h (CASE_FLT_FN_FLOATN_NX): Support BF16.
>
>gcc/c-family/ChangeLog:
>
>       * c-cppbuiltin.cc (c_cpp_builtins): Modify suffix names to avoid
>       conflicts.
>
>libgcc/ChangeLog:
>
>       * Makefile.in: Add _mulbc3 and _divbc3.
>       * libgcc2.c (if): Ditto.
>       (defined): Ditto.
>       (MTYPE): Macros defined for BF16.
>       (CTYPE): Ditto.
>       (AMTYPE): Ditto.
>       (MODE): Ditto.
>       (CEXT): Ditto.
>       (NOTRUNC): Ditto.
>       * libgcc2.h (LIBGCC2_HAS_BF_MODE): Support BF16.
>       (__attribute__): Ditto.
>       (__divbc3): Add __divbc3 declaration.
>       (__mulbc3): Add __mulbc3 declaration.
>
>Signed-off-by: Xiao Zeng <zengx...@eswincomputing.com>
>---
> gcc/builtin-types.def        | 30 ++++++++++++++++++++++++++++++
> gcc/builtins.cc              |  6 ++++++
> gcc/builtins.def             | 22 +++++++++++-----------
> gcc/c-family/c-cppbuiltin.cc |  2 +-
> gcc/fold-const-call.cc       |  2 --
> gcc/gencfn-macros.cc         |  5 +++--
> gcc/match.pd                 |  9 ++++++---
> gcc/tree.h                   |  2 +-
> libgcc/Makefile.in           |  6 +++---
> libgcc/libgcc2.c             | 20 ++++++++++++++------
> libgcc/libgcc2.h             | 14 ++++++++++++++
> 11 files changed, 89 insertions(+), 29 deletions(-)
>
>diff --git a/gcc/builtin-types.def b/gcc/builtin-types.def
>index c97d6bad1de..6980873f2f1 100644
>--- a/gcc/builtin-types.def
>+++ b/gcc/builtin-types.def
>@@ -109,6 +109,10 @@ DEF_PRIMITIVE_TYPE (BT_FLOAT128X, (float128x_type_node
> DEF_PRIMITIVE_TYPE (BT_COMPLEX_FLOAT, complex_float_type_node)
> DEF_PRIMITIVE_TYPE (BT_COMPLEX_DOUBLE, complex_double_type_node)
> DEF_PRIMITIVE_TYPE (BT_COMPLEX_LONGDOUBLE, complex_long_double_type_node)
>+DEF_PRIMITIVE_TYPE (BT_COMPLEX_BFLOAT16, (bfloat16_type_node
>+      ? build_complex_type
>+      (bfloat16_type_node)
>+      : error_mark_node))
> DEF_PRIMITIVE_TYPE (BT_COMPLEX_FLOAT16, (float16_type_node
> ? build_complex_type
> (float16_type_node)
>@@ -163,6 +167,9 @@ DEF_PRIMITIVE_TYPE (BT_CONST_DOUBLE_PTR,
>      (build_qualified_type (double_type_node,
>          TYPE_QUAL_CONST)))
> DEF_PRIMITIVE_TYPE (BT_LONGDOUBLE_PTR, long_double_ptr_type_node)
>+DEF_PRIMITIVE_TYPE (BT_BFLOAT16_PTR, (bfloat16_type_node
>+            ? build_pointer_type (bfloat16_type_node)
>+            : error_mark_node))
> DEF_PRIMITIVE_TYPE (BT_FLOAT16_PTR, (float16_type_node
>       ? build_pointer_type (float16_type_node)
>       : error_mark_node))
>@@ -239,6 +246,7 @@ DEF_FUNCTION_TYPE_0 (BT_FN_DOUBLE, BT_DOUBLE)
>    distinguish it from two types in sequence, "long" followed by
>    "double".  */
> DEF_FUNCTION_TYPE_0 (BT_FN_LONGDOUBLE, BT_LONGDOUBLE)
>+DEF_FUNCTION_TYPE_0 (BT_FN_BFLOAT16, BT_BFLOAT16)
> DEF_FUNCTION_TYPE_0 (BT_FN_FLOAT16, BT_FLOAT16)
> DEF_FUNCTION_TYPE_0 (BT_FN_FLOAT32, BT_FLOAT32)
> DEF_FUNCTION_TYPE_0 (BT_FN_FLOAT64, BT_FLOAT64)
>@@ -257,6 +265,7 @@ DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT_FLOAT, BT_FLOAT, BT_FLOAT)
> DEF_FUNCTION_TYPE_1 (BT_FN_DOUBLE_DOUBLE, BT_DOUBLE, BT_DOUBLE)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONGDOUBLE_LONGDOUBLE,
>      BT_LONGDOUBLE, BT_LONGDOUBLE)
>+DEF_FUNCTION_TYPE_1 (BT_FN_BFLOAT16_BFLOAT16, BT_BFLOAT16, BT_BFLOAT16)
> DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT16_FLOAT16, BT_FLOAT16, BT_FLOAT16)
> DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT32_FLOAT32, BT_FLOAT32, BT_FLOAT32)
> DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT64_FLOAT64, BT_FLOAT64, BT_FLOAT64)
>@@ -270,6 +279,8 @@ DEF_FUNCTION_TYPE_1 (BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE,
>      BT_COMPLEX_DOUBLE, BT_COMPLEX_DOUBLE)
> DEF_FUNCTION_TYPE_1 (BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE,
>      BT_COMPLEX_LONGDOUBLE, BT_COMPLEX_LONGDOUBLE)
>+DEF_FUNCTION_TYPE_1 (BT_FN_COMPLEX_BFLOAT16_COMPLEX_BFLOAT16,
>+           BT_COMPLEX_BFLOAT16, BT_COMPLEX_BFLOAT16)
> DEF_FUNCTION_TYPE_1 (BT_FN_COMPLEX_FLOAT16_COMPLEX_FLOAT16,
>      BT_COMPLEX_FLOAT16, BT_COMPLEX_FLOAT16)
> DEF_FUNCTION_TYPE_1 (BT_FN_COMPLEX_FLOAT32_COMPLEX_FLOAT32,
>@@ -290,6 +301,8 @@ DEF_FUNCTION_TYPE_1 (BT_FN_DOUBLE_COMPLEX_DOUBLE,
>      BT_DOUBLE, BT_COMPLEX_DOUBLE)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONGDOUBLE_COMPLEX_LONGDOUBLE,
>      BT_LONGDOUBLE, BT_COMPLEX_LONGDOUBLE)
>+DEF_FUNCTION_TYPE_1 (BT_FN_BFLOAT16_COMPLEX_BFLOAT16,
>+           BT_BFLOAT16, BT_COMPLEX_BFLOAT16)
> DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT16_COMPLEX_FLOAT16,
>      BT_FLOAT16, BT_COMPLEX_FLOAT16)
> DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT32_COMPLEX_FLOAT32,
>@@ -324,6 +337,7 @@ DEF_FUNCTION_TYPE_1 (BT_FN_INT_PTR, BT_INT, BT_PTR)
> DEF_FUNCTION_TYPE_1 (BT_FN_INT_FLOAT, BT_INT, BT_FLOAT)
> DEF_FUNCTION_TYPE_1 (BT_FN_INT_DOUBLE, BT_INT, BT_DOUBLE)
> DEF_FUNCTION_TYPE_1 (BT_FN_INT_LONGDOUBLE, BT_INT, BT_LONGDOUBLE)
>+DEF_FUNCTION_TYPE_1 (BT_FN_INT_BFLOAT16, BT_INT, BT_BFLOAT16)
> DEF_FUNCTION_TYPE_1 (BT_FN_INT_FLOAT16, BT_INT, BT_FLOAT16)
> DEF_FUNCTION_TYPE_1 (BT_FN_INT_FLOAT32, BT_INT, BT_FLOAT32)
> DEF_FUNCTION_TYPE_1 (BT_FN_INT_FLOAT64, BT_INT, BT_FLOAT64)
>@@ -337,6 +351,7 @@ DEF_FUNCTION_TYPE_1 (BT_FN_INT_DFLOAT128, BT_INT, 
>BT_DFLOAT128)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONG_FLOAT, BT_LONG, BT_FLOAT)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONG_DOUBLE, BT_LONG, BT_DOUBLE)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONG_LONGDOUBLE, BT_LONG, BT_LONGDOUBLE)
>+DEF_FUNCTION_TYPE_1 (BT_FN_LONG_BFLOAT16, BT_LONG, BT_BFLOAT16)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONG_FLOAT16, BT_LONG, BT_FLOAT16)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONG_FLOAT32, BT_LONG, BT_FLOAT32)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONG_FLOAT64, BT_LONG, BT_FLOAT64)
>@@ -347,6 +362,7 @@ DEF_FUNCTION_TYPE_1 (BT_FN_LONG_FLOAT128X, BT_LONG, 
>BT_FLOAT128X)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONGLONG_FLOAT, BT_LONGLONG, BT_FLOAT)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONGLONG_DOUBLE, BT_LONGLONG, BT_DOUBLE)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONGLONG_LONGDOUBLE, BT_LONGLONG, BT_LONGDOUBLE)
>+DEF_FUNCTION_TYPE_1 (BT_FN_LONGLONG_BFLOAT16, BT_LONGLONG, BT_BFLOAT16)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONGLONG_FLOAT16, BT_LONGLONG, BT_FLOAT16)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONGLONG_FLOAT32, BT_LONGLONG, BT_FLOAT32)
> DEF_FUNCTION_TYPE_1 (BT_FN_LONGLONG_FLOAT64, BT_LONGLONG, BT_FLOAT64)
>@@ -525,6 +541,8 @@ DEF_FUNCTION_TYPE_2 (BT_FN_DOUBLE_DOUBLE_DOUBLEPTR,
>      BT_DOUBLE, BT_DOUBLE, BT_DOUBLE_PTR)
> DEF_FUNCTION_TYPE_2 (BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLEPTR,
>      BT_LONGDOUBLE, BT_LONGDOUBLE, BT_LONGDOUBLE_PTR)
>+DEF_FUNCTION_TYPE_2 (BT_FN_BFLOAT16_BFLOAT16_BFLOAT16PTR,
>+           BT_BFLOAT16, BT_BFLOAT16, BT_BFLOAT16_PTR)
> DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT16_FLOAT16_FLOAT16PTR,
>      BT_FLOAT16, BT_FLOAT16, BT_FLOAT16_PTR)
> DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT32_FLOAT32_FLOAT32PTR,
>@@ -549,6 +567,8 @@ DEF_FUNCTION_TYPE_2 (BT_FN_DOUBLE_DOUBLE_INT,
>      BT_DOUBLE, BT_DOUBLE, BT_INT)
> DEF_FUNCTION_TYPE_2 (BT_FN_LONGDOUBLE_LONGDOUBLE_INT,
>      BT_LONGDOUBLE, BT_LONGDOUBLE, BT_INT)
>+DEF_FUNCTION_TYPE_2 (BT_FN_BFLOAT16_BFLOAT16_INT,
>+           BT_BFLOAT16, BT_BFLOAT16, BT_INT)
> DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT16_FLOAT16_INT,
>      BT_FLOAT16, BT_FLOAT16, BT_INT)
> DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT32_FLOAT32_INT,
>@@ -569,6 +589,8 @@ DEF_FUNCTION_TYPE_2 (BT_FN_DOUBLE_DOUBLE_INTPTR,
>      BT_DOUBLE, BT_DOUBLE, BT_INT_PTR)
> DEF_FUNCTION_TYPE_2 (BT_FN_LONGDOUBLE_LONGDOUBLE_INTPTR,
>      BT_LONGDOUBLE, BT_LONGDOUBLE, BT_INT_PTR)
>+DEF_FUNCTION_TYPE_2 (BT_FN_BFLOAT16_BFLOAT16_INTPTR,
>+           BT_BFLOAT16, BT_BFLOAT16, BT_INT_PTR)
> DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT16_FLOAT16_INTPTR,
>      BT_FLOAT16, BT_FLOAT16, BT_INT_PTR)
> DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT32_FLOAT32_INTPTR,
>@@ -595,6 +617,8 @@ DEF_FUNCTION_TYPE_2 (BT_FN_DOUBLE_DOUBLE_LONG,
>      BT_DOUBLE, BT_DOUBLE, BT_LONG)
> DEF_FUNCTION_TYPE_2 (BT_FN_LONGDOUBLE_LONGDOUBLE_LONG,
>      BT_LONGDOUBLE, BT_LONGDOUBLE, BT_LONG)
>+DEF_FUNCTION_TYPE_2 (BT_FN_BFLOAT16_BFLOAT16_LONG,
>+           BT_BFLOAT16, BT_BFLOAT16, BT_LONG)
> DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT16_FLOAT16_LONG,
>      BT_FLOAT16, BT_FLOAT16, BT_LONG)
> DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT32_FLOAT32_LONG,
>@@ -621,6 +645,8 @@ DEF_FUNCTION_TYPE_2 
>(BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE_COMPLEX_DOUBLE,
>      BT_COMPLEX_DOUBLE, BT_COMPLEX_DOUBLE, BT_COMPLEX_DOUBLE)
> DEF_FUNCTION_TYPE_2 
> (BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE,
>      BT_COMPLEX_LONGDOUBLE, BT_COMPLEX_LONGDOUBLE, BT_COMPLEX_LONGDOUBLE)
>+DEF_FUNCTION_TYPE_2 (BT_FN_COMPLEX_BFLOAT16_COMPLEX_BFLOAT16_COMPLEX_BFLOAT16,
>+           BT_COMPLEX_BFLOAT16, BT_COMPLEX_BFLOAT16, BT_COMPLEX_BFLOAT16)
> DEF_FUNCTION_TYPE_2 (BT_FN_COMPLEX_FLOAT16_COMPLEX_FLOAT16_COMPLEX_FLOAT16,
>      BT_COMPLEX_FLOAT16, BT_COMPLEX_FLOAT16, BT_COMPLEX_FLOAT16)
> DEF_FUNCTION_TYPE_2 (BT_FN_COMPLEX_FLOAT32_COMPLEX_FLOAT32_COMPLEX_FLOAT32,
>@@ -728,6 +754,8 @@ DEF_FUNCTION_TYPE_3 (BT_FN_DOUBLE_DOUBLE_DOUBLE_DOUBLE,
>      BT_DOUBLE, BT_DOUBLE, BT_DOUBLE, BT_DOUBLE)
> DEF_FUNCTION_TYPE_3 (BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE,
>      BT_LONGDOUBLE, BT_LONGDOUBLE, BT_LONGDOUBLE, BT_LONGDOUBLE)
>+DEF_FUNCTION_TYPE_3 (BT_FN_BFLOAT16_BFLOAT16_BFLOAT16_BFLOAT16,
>+           BT_BFLOAT16, BT_BFLOAT16, BT_BFLOAT16, BT_BFLOAT16)
> DEF_FUNCTION_TYPE_3 (BT_FN_FLOAT16_FLOAT16_FLOAT16_FLOAT16,
>      BT_FLOAT16, BT_FLOAT16, BT_FLOAT16, BT_FLOAT16)
> DEF_FUNCTION_TYPE_3 (BT_FN_FLOAT32_FLOAT32_FLOAT32_FLOAT32,
>@@ -748,6 +776,8 @@ DEF_FUNCTION_TYPE_3 (BT_FN_DOUBLE_DOUBLE_DOUBLE_INTPTR,
>      BT_DOUBLE, BT_DOUBLE, BT_DOUBLE, BT_INT_PTR)
> DEF_FUNCTION_TYPE_3 (BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE_INTPTR,
>      BT_LONGDOUBLE, BT_LONGDOUBLE, BT_LONGDOUBLE, BT_INT_PTR)
>+DEF_FUNCTION_TYPE_3 (BT_FN_BFLOAT16_BFLOAT16_BFLOAT16_INTPTR,
>+           BT_BFLOAT16, BT_BFLOAT16, BT_BFLOAT16, BT_INT_PTR)
> DEF_FUNCTION_TYPE_3 (BT_FN_FLOAT16_FLOAT16_FLOAT16_INTPTR,
>      BT_FLOAT16, BT_FLOAT16, BT_FLOAT16, BT_INT_PTR)
> DEF_FUNCTION_TYPE_3 (BT_FN_FLOAT32_FLOAT32_FLOAT32_INTPTR,
>diff --git a/gcc/builtins.cc b/gcc/builtins.cc
>index 0b902896ddd..d0fc8e755e8 100644
>--- a/gcc/builtins.cc
>+++ b/gcc/builtins.cc
>@@ -1918,6 +1918,7 @@ expand_builtin_classify_type (tree exp)
>   fcodef32 = BUILT_IN_##MATHFN##F32; fcodef64 = BUILT_IN_##MATHFN##F64 ; \
>   fcodef128 = BUILT_IN_##MATHFN##F128 ; fcodef32x = BUILT_IN_##MATHFN##F32X ; 
>\
>   fcodef64x = BUILT_IN_##MATHFN##F64X ; fcodef128x = BUILT_IN_##MATHFN##F128X 
>;\
>+  fcodef16b = BUILT_IN_##MATHFN##F16B ; \
>   break;
> /* Similar to above, but appends _R after any F/L suffix.  */
> #define CASE_MATHFN_REENT(MATHFN) \
>@@ -1937,6 +1938,7 @@ mathfn_built_in_2 (tree type, combined_fn fn)
> {
>   tree mtype;
>   built_in_function fcode, fcodef, fcodel;
>+  built_in_function fcodef16b = END_BUILTINS;
>   built_in_function fcodef16 = END_BUILTINS;
>   built_in_function fcodef32 = END_BUILTINS;
>   built_in_function fcodef64 = END_BUILTINS;
>@@ -2055,6 +2057,8 @@ mathfn_built_in_2 (tree type, combined_fn fn)
>     return fcodef;
>   else if (mtype == long_double_type_node)
>     return fcodel;
>+  else if (mtype == bfloat16_type_node)
>+    return fcodef16b;
>   else if (mtype == float16_type_node)
>     return fcodef16;
>   else if (mtype == float32_type_node)
>@@ -2137,6 +2141,8 @@ mathfn_built_in_type (combined_fn fn)
>
> #define CASE_MATHFN_FLOATN(MATHFN)    \
>   CASE_MATHFN(MATHFN) \
>+  case CFN_BUILT_IN_##MATHFN##F16B:   \
>+    return bfloat16_type_node;        \
>   case CFN_BUILT_IN_##MATHFN##F16:    \
>     return float16_type_node; \
>   case CFN_BUILT_IN_##MATHFN##F32:    \
>diff --git a/gcc/builtins.def b/gcc/builtins.def
>index f6f3e104f6a..ffd427d7d93 100644
>--- a/gcc/builtins.def
>+++ b/gcc/builtins.def
>@@ -77,11 +77,12 @@ along with GCC; see the file COPYING3.  If not see
>   DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, TYPE, BT_LAST,    \
>        false, false, false, ATTRS, true, true)
>
>-/* A set of GCC builtins for _FloatN and _FloatNx types.  TYPE_MACRO
>-   is called with an argument such as FLOAT32 to produce the enum
>-   value for the type.  */
>+/* A set of GCC builtins for __bf16, _FloatN and _FloatNx types.
>+   TYPE_MACRO is called with an argument such as FLOAT32 to produce
>+   the enum value for the type.  */
> #undef DEF_GCC_FLOATN_NX_BUILTINS
> #define DEF_GCC_FLOATN_NX_BUILTINS(ENUM, NAME, TYPE_MACRO, ATTRS)     \
>+  DEF_GCC_BUILTIN (ENUM ## F16B, NAME "f16b", TYPE_MACRO (BFLOAT16), ATTRS) \
>   DEF_GCC_BUILTIN (ENUM ## F16, NAME "f16", TYPE_MACRO (FLOAT16), ATTRS) \
>   DEF_GCC_BUILTIN (ENUM ## F32, NAME "f32", TYPE_MACRO (FLOAT32), ATTRS) \
>   DEF_GCC_BUILTIN (ENUM ## F64, NAME "f64", TYPE_MACRO (FLOAT64), ATTRS) \
>@@ -110,12 +111,12 @@ along with GCC; see the file COPYING3.  If not see
>   DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE,  \
>        true, true, true, ATTRS, false, true)
>
>-/* A set of GCC builtins for _FloatN and _FloatNx types.  TYPE_MACRO is called
>-   with an argument such as FLOAT32 to produce the enum value for the type.  
>If
>-   we are compiling for the C language with GNU extensions, we enable the name
>-   without the __builtin_ prefix as well as the name with the __builtin_
>-   prefix.  C++ does not enable these names by default because a class based
>-   library should use the __builtin_ names.  */
>+/* A set of GCC builtins for __bf16, _FloatN and _FloatNx types.
>+   TYPE_MACRO is called with an argument such as FLOAT32 to produce the enum
>+   value for the type.  If we are compiling for the C language with GNU
>+   extensions, we enable the name without the __builtin_ prefix as well as the
>+   name with the __builtin_ prefix.  C++ does not enable these names by 
>default
>+   because a class based library should use the __builtin_ names.  */
> #undef DEF_FLOATN_BUILTIN
> #define DEF_FLOATN_BUILTIN(ENUM, NAME, TYPE, ATTRS)   \
>   DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE,  \
>@@ -123,6 +124,7 @@ along with GCC; see the file COPYING3.  If not see
>        false, true)
> #undef DEF_EXT_LIB_FLOATN_NX_BUILTINS
> #define DEF_EXT_LIB_FLOATN_NX_BUILTINS(ENUM, NAME, TYPE_MACRO, ATTRS) \
>+  DEF_FLOATN_BUILTIN (ENUM ## F16B, NAME "f16b", TYPE_MACRO (BFLOAT16), 
>ATTRS) \
>   DEF_FLOATN_BUILTIN (ENUM ## F16, NAME "f16", TYPE_MACRO (FLOAT16), ATTRS) \
>   DEF_FLOATN_BUILTIN (ENUM ## F32, NAME "f32", TYPE_MACRO (FLOAT32), ATTRS) \
>   DEF_FLOATN_BUILTIN (ENUM ## F64, NAME "f64", TYPE_MACRO (FLOAT64), ATTRS) \
>@@ -576,7 +578,6 @@ 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)
>@@ -591,7 +592,6 @@ DEF_C99_BUILTIN        (BUILT_IN_NEXTAFTERF, "nextafterf", 
>BT_FN_FLOAT_FLOAT_FLO
> DEF_C99_BUILTIN        (BUILT_IN_NEXTAFTERL, "nextafterl", 
> BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_ERRNO)
> #define NEXTAFTER_TYPE(F) BT_FN_##F##_##F##_##F
> DEF_EXT_LIB_FLOATN_NX_BUILTINS (BUILT_IN_NEXTAFTER, "nextafter", 
> NEXTAFTER_TYPE, ATTR_MATHFN_ERRNO)
>-DEF_GCC_BUILTIN        (BUILT_IN_NEXTAFTERF16B, "nextafterf16b", 
>BT_FN_BFLOAT16_BFLOAT16_BFLOAT16, ATTR_MATHFN_ERRNO)
> DEF_C99_BUILTIN        (BUILT_IN_NEXTTOWARD, "nexttoward", 
> BT_FN_DOUBLE_DOUBLE_LONGDOUBLE, ATTR_MATHFN_ERRNO)
> DEF_C99_BUILTIN        (BUILT_IN_NEXTTOWARDF, "nexttowardf", 
> BT_FN_FLOAT_FLOAT_LONGDOUBLE, ATTR_MATHFN_ERRNO)
> DEF_C99_BUILTIN        (BUILT_IN_NEXTTOWARDL, "nexttowardl", 
> BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_ERRNO)
>diff --git a/gcc/c-family/c-cppbuiltin.cc b/gcc/c-family/c-cppbuiltin.cc
>index a80372c8991..273bb9cf028 100644
>--- a/gcc/c-family/c-cppbuiltin.cc
>+++ b/gcc/c-family/c-cppbuiltin.cc
>@@ -1422,7 +1422,7 @@ c_cpp_builtins (cpp_reader *pfile)
>   else if (bfloat16_type_node
>    && mode == TYPE_MODE (bfloat16_type_node))
>     {
>-            memcpy (suffix, "bf16", 5);
>+            memcpy (suffix, "f16b", 5);
>       memcpy (float_h_prefix, "BFLT16", 7);
>     }
>   else
>diff --git a/gcc/fold-const-call.cc b/gcc/fold-const-call.cc
>index 47bf8d64391..ed1ec0ab3ee 100644
>--- a/gcc/fold-const-call.cc
>+++ b/gcc/fold-const-call.cc
>@@ -1354,7 +1354,6 @@ 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:
>@@ -1462,7 +1461,6 @@ fold_const_call_sss (real_value *result, combined_fn fn,
>
>     CASE_CFN_NEXTAFTER:
>     CASE_CFN_NEXTAFTER_FN:
>-    case CFN_BUILT_IN_NEXTAFTERF16B:
>     CASE_CFN_NEXTTOWARD:
>       return fold_const_nextafter (result, arg0, arg1, format);
>
>diff --git a/gcc/gencfn-macros.cc b/gcc/gencfn-macros.cc
>index 2581e758fe6..8c78ef084fe 100644
>--- a/gcc/gencfn-macros.cc
>+++ b/gcc/gencfn-macros.cc
>@@ -156,10 +156,11 @@ const char *const internal_fn_int_names[] = {
>
> static const char *const flt_suffixes[] = { "F", "", "L", NULL };
> static const char *const fltfn_suffixes[] = { "F16", "F32", "F64", "F128",
>-            "F32X", "F64X", "F128X", NULL };
>+            "F32X", "F64X", "F128X","F16B",
>+            NULL };
> static const char *const fltall_suffixes[] = { "F", "", "L", "F16", "F32",
>        "F64", "F128", "F32X", "F64X",
>-             "F128X", NULL };
>+             "F128X", "F16B", NULL };
> static const char *const int_suffixes[] = { "", "L", "LL", "IMAX", NULL };
>
> static const char *const *const suffix_lists[] = {
>diff --git a/gcc/match.pd b/gcc/match.pd
>index c9c8478d286..ca01c6714d8 100644
>--- a/gcc/match.pd
>+++ b/gcc/match.pd
>@@ -8386,7 +8386,8 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
> #if GIMPLE
> (match float16_value_p
>  @0
>- (if (TYPE_MAIN_VARIANT (TREE_TYPE (@0)) == float16_type_node)))
>+ (if ((TYPE_MAIN_VARIANT (TREE_TYPE (@0)) == float16_type_node) ||
>+      (TYPE_MAIN_VARIANT (TREE_TYPE (@0)) == bfloat16_type_node))))
> (for froms (BUILT_IN_TRUNCL BUILT_IN_TRUNC BUILT_IN_TRUNCF
>     BUILT_IN_FLOORL BUILT_IN_FLOOR BUILT_IN_FLOORF
>     BUILT_IN_CEILL BUILT_IN_CEIL BUILT_IN_CEILF
>@@ -8403,8 +8404,10 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
>   IFN_NEARBYINT IFN_NEARBYINT IFN_NEARBYINT
>   IFN_RINT IFN_RINT IFN_RINT
>   IFN_SQRT IFN_SQRT IFN_SQRT)
>- /* (_Float16) round ((doube) x) -> __built_in_roundf16 (x), etc.,
>-    if x is a _Float16.  */
>+ /* 1 (_Float16) round ((doube) x) -> __built_in_roundf16 (x), etc.,
>+    if x is a _Float16.
>+    2 (__bf16) round ((doube) x) -> __built_in_roundf16b (x), etc.,
>+    if x is a __bf16.  */
>  (simplify
>    (convert (froms (convert float16_value_p@0)))
>      (if (optimize
>diff --git a/gcc/tree.h b/gcc/tree.h
>index 5dcbb2fb5dd..67fc2a2e614 100644
>--- a/gcc/tree.h
>+++ b/gcc/tree.h
>@@ -310,7 +310,7 @@ code_helper::is_builtin_fn () const
> #define CASE_FLT_FN(FN) case FN: case FN##F: case FN##L
> #define CASE_FLT_FN_FLOATN_NX(FN)        \
>   case FN##F16: case FN##F32: case FN##F64: case FN##F128: \
>-  case FN##F32X: case FN##F64X: case FN##F128X
>+  case FN##F32X: case FN##F64X: case FN##F128X: case FN##F16B
> #define CASE_FLT_FN_REENT(FN) case FN##_R: case FN##F_R: case FN##L_R
> #define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL: case FN##IMAX
>
>diff --git a/libgcc/Makefile.in b/libgcc/Makefile.in
>index 0e46e9ef768..b71fd5e2250 100644
>--- a/libgcc/Makefile.in
>+++ b/libgcc/Makefile.in
>@@ -450,9 +450,9 @@ lib2funcs = _muldi3 _negdi2 _lshrdi3 _ashldi3 _ashrdi3 
>_cmpdi2 _ucmpdi2       \
>     _negvsi2 _negvdi2 _ctors _ffssi2 _ffsdi2 _clz _clzsi2 _clzdi2  \
>     _ctzsi2 _ctzdi2 _popcount_tab _popcountsi2 _popcountdi2      \
>     _paritysi2 _paritydi2 _powisf2 _powidf2 _powixf2 _powitf2    \
>-          _mulhc3 _mulsc3 _muldc3 _mulxc3 _multc3 _divhc3 _divsc3        \
>-          _divdc3 _divxc3 _divtc3 _bswapsi2 _bswapdi2 _clrsbsi2          \
>-          _clrsbdi2 _mulbitint3
>+          _mulhc3 _mulbc3 _mulsc3 _muldc3 _mulxc3 _multc3 _divhc3        \
>+          _divbc3 _divsc3 _divdc3 _divxc3 _divtc3 _bswapsi2 _bswapdi2    \
>+          _clrsbsi2 _clrsbdi2 _mulbitint3
>
> # The floating-point conversion routines that involve a single-word integer.
> # XX stands for the integer mode.
>diff --git a/libgcc/libgcc2.c b/libgcc/libgcc2.c
>index 3fcb85c5b92..512ca92bfb9 100644
>--- a/libgcc/libgcc2.c
>+++ b/libgcc/libgcc2.c
>@@ -2591,6 +2591,7 @@ NAME (TYPE x, int m)
> #endif
>
>
> #if((defined(L_mulhc3) || defined(L_divhc3)) && LIBGCC2_HAS_HF_MODE) \
>+    || ((defined(L_mulbc3) || defined(L_divbc3)) && LIBGCC2_HAS_BF_MODE) \
>     || ((defined(L_mulsc3) || defined(L_divsc3)) && LIBGCC2_HAS_SF_MODE) \
>     || ((defined(L_muldc3) || defined(L_divdc3)) && LIBGCC2_HAS_DF_MODE) \
>     || ((defined(L_mulxc3) || defined(L_divxc3)) && LIBGCC2_HAS_XF_MODE) \
>@@ -2607,6 +2608,13 @@ NAME (TYPE x, int m)
> # define MODE hc
> # define CEXT __LIBGCC_HF_FUNC_EXT__
> # define NOTRUNC (!__LIBGCC_HF_EXCESS_PRECISION__)
>+#elif defined(L_mulbc3) || defined(L_divbc3)
>+# define MTYPE  BFtype
>+# define CTYPE  BCtype
>+# define AMTYPE SFtype
>+# define MODE   bc
>+# define CEXT   __LIBGCC_BF_FUNC_EXT__
>+# define NOTRUNC (!__LIBGCC_BF_EXCESS_PRECISION__)
> #elif defined(L_mulsc3) || defined(L_divsc3)
> # define MTYPE        SFtype
> # define CTYPE        SCtype
>@@ -2690,8 +2698,8 @@ extern void *compile_type_assert[sizeof(INFINITY) == 
>sizeof(MTYPE) ? 1 : -1];
> # define TRUNC(x)     __asm__ ("" : "=m"(x) : "m"(x))
> #endif
>
>-#if defined(L_mulhc3) || defined(L_mulsc3) || defined(L_muldc3) \
>-    || defined(L_mulxc3) || defined(L_multc3)
>+#if defined(L_mulhc3) || defined(L_mulbc3) || defined(L_mulsc3) \
>+    || defined(L_muldc3) || defined(L_mulxc3) || defined(L_multc3)
>
> CTYPE
> CONCAT3(__mul,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
>@@ -2760,16 +2768,16 @@ CONCAT3(__mul,MODE,3) (MTYPE a, MTYPE b, MTYPE c, 
>MTYPE d)
> }
> #endif /* complex multiply */
>
>-#if defined(L_divhc3) || defined(L_divsc3) || defined(L_divdc3) \
>-    || defined(L_divxc3) || defined(L_divtc3)
>+#if defined(L_divhc3) || defined(L_divbc3) || defined(L_divsc3) \
>+    || defined(L_divdc3) || defined(L_divxc3) || defined(L_divtc3)
>
> CTYPE
> CONCAT3(__div,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
> {
>-#if defined(L_divhc3) \
>+#if (defined(L_divhc3) || defined(L_divbc3) ) \
>   || (defined(L_divsc3) && defined(__LIBGCC_HAVE_HWDBL__) )
>
>-  /* Half precision is handled with float precision.
>+  /* _Float16 and __bf16 are handled with float precision.
>      float is handled with double precision when double precision
>      hardware is available.
>      Due to the additional precision, the simple complex divide
>diff --git a/libgcc/libgcc2.h b/libgcc/libgcc2.h
>index b358b3a2b50..ee99badde86 100644
>--- a/libgcc/libgcc2.h
>+++ b/libgcc/libgcc2.h
>@@ -43,6 +43,12 @@ extern void __eprintf (const char *, const char *, unsigned 
>int, const char *)
> #define LIBGCC2_HAS_HF_MODE 0
> #endif
>
>+#ifdef __LIBGCC_HAS_BF_MODE__
>+#define LIBGCC2_HAS_BF_MODE 1
>+#else
>+#define LIBGCC2_HAS_BF_MODE 0
>+#endif
>+
> #ifdef __LIBGCC_HAS_SF_MODE__
> #define LIBGCC2_HAS_SF_MODE 1
> #else
>@@ -146,6 +152,10 @@ typedef unsigned int UTItype      __attribute__ ((mode 
>(TI)));
> typedef       float HFtype    __attribute__ ((mode (HF)));
> typedef _Complex float HCtype __attribute__ ((mode (HC)));
> #endif
>+#if LIBGCC2_HAS_BF_MODE
>+typedef       float BFtype    __attribute__ ((mode (BF)));
>+typedef _Complex float BCtype __attribute__ ((mode (BC)));
>+#endif
> #if LIBGCC2_HAS_SF_MODE
> typedef float SFtype  __attribute__ ((mode (SF)));
> typedef _Complex float SCtype __attribute__ ((mode (SC)));
>@@ -465,6 +475,10 @@ extern SItype __negvsi2 (SItype);
> extern HCtype __divhc3 (HFtype, HFtype, HFtype, HFtype);
> extern HCtype __mulhc3 (HFtype, HFtype, HFtype, HFtype);
> #endif
>+#if LIBGCC2_HAS_BF_MODE
>+extern BCtype __divbc3 (BFtype, BFtype, BFtype, BFtype);
>+extern BCtype __mulbc3 (BFtype, BFtype, BFtype, BFtype);
>+#endif
> #if LIBGCC2_HAS_SF_MODE
> extern DWtype __fixsfdi (SFtype);
> extern SFtype __floatdisf (DWtype);
>--
>2.43.0
Thanks
Xiao Zeng

Reply via email to