From patchwork Wed Jun 22 23:27:59 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Joseph Myers X-Patchwork-Id: 639442 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3rZgkz2gD5z9sxS for ; Thu, 23 Jun 2016 09:28:26 +1000 (AEST) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b=lNv5jNZe; dkim-atps=neutral DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:cc:subject:in-reply-to:message-id:references :mime-version:content-type; q=dns; s=default; b=QioL9dmORrUNJy2m 03kBbVWswlGj/vec9xHGlzyctTCxamAN5tAnkAe1MlWj9xj7CHbdjRLsmBZh2QyK T+T5Bk7dm9ExwAmJhnVRUmJPz1BenhrDuhLORvmOm7jS0X7rbczOLhaJm+IuhYIs 0qlKeGcN2Ne20VeunPyP3KbJxhk= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:cc:subject:in-reply-to:message-id:references :mime-version:content-type; s=default; bh=o1oVP1b614WtHli5UXLWhC SE2R4=; b=lNv5jNZePRdz6q4OdJcohcvsjhH3FlU2y1VLK7iz8D0Anvh6NtL1yI /glomaBwQX3FpCLyP1rO2Hi/bcyslLmNlXz71CrcxacBp5x9XG9/a9dj4Cl1sPR9 2T5PQAkSlZ4/NqHS2e7pN24WnxQfZbbawrU2WNtv89BRxjFqC2+z0= Received: (qmail 50741 invoked by alias); 22 Jun 2016 23:28:18 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 50732 invoked by uid 89); 22 Jun 2016 23:28:18 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-0.6 required=5.0 tests=AWL, BAYES_50, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.2 spammy=float128, ANSI, ansi, extend.texi X-HELO: relay1.mentorg.com Received: from relay1.mentorg.com (HELO relay1.mentorg.com) (192.94.38.131) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-GCM-SHA384 encrypted) ESMTPS; Wed, 22 Jun 2016 23:28:07 +0000 Received: from nat-ies.mentorg.com ([192.94.31.2] helo=SVR-IES-FEM-01.mgc.mentorg.com) by relay1.mentorg.com with esmtp id 1bFrYw-0004dN-Nx from joseph_myers@mentor.com ; Wed, 22 Jun 2016 16:28:03 -0700 Received: from digraph.polyomino.org.uk (137.202.0.76) by SVR-IES-FEM-01.mgc.mentorg.com (137.202.0.104) with Microsoft SMTP Server id 14.3.224.2; Thu, 23 Jun 2016 00:28:01 +0100 Received: from jsm28 (helo=localhost) by digraph.polyomino.org.uk with local-esmtp (Exim 4.86_2) (envelope-from ) id 1bFrYt-0002E1-R2; Wed, 22 Jun 2016 23:27:59 +0000 Date: Wed, 22 Jun 2016 23:27:59 +0000 From: Joseph Myers To: Bill Schmidt CC: GCC Patches , Segher Boessenkool , David Edelsohn Subject: Re: [PATCH, rs6000] Add minimum __float128 built-in support required for glibc In-Reply-To: <2BD1312F-1CB3-4B43-AC09-BFF01356FFA6@linux.vnet.ibm.com> Message-ID: References: <62B0D9C8-A6C4-4000-B409-0627F854F6DC@linux.vnet.ibm.com> <2BD1312F-1CB3-4B43-AC09-BFF01356FFA6@linux.vnet.ibm.com> User-Agent: Alpine 2.20 (DEB 67 2015-01-07) MIME-Version: 1.0 On Wed, 22 Jun 2016, Bill Schmidt wrote: > Hi Joseph, > > That's indeed preferable for the long term -- given how close we are to the > cutoff for 6.2, though, I'm worried about adding any new dependencies for > getting this upstream. I'd suggest that we go ahead with reviewing this > patch in the short term, and I'll be happy to work with you later on getting > the impedance matching right when they become arch-neutral. The architecture-independent built-in functions really aren't hard. See this patch, on top of my main _FloatN / _FloatNx patch. (Not written up or fully regression-tested, and I want to add more test coverage, but it seems to work.) To keep this patch minimal I didn't include updates to a few case statements only needed for optimization, e.g. in tree_call_nonnegative_warnv_p, but when those are changed you get optimizations automatically for these functions that would be harder to get with anything architecture-specific. Regarding your patch: (a) for GCC 6 (supposing my patch is used for trunk), it's missing documentation for the new functions (this patch has documentation for the architecture-independent functions); (b) for trunk, having an insn pattern infkf1 for a built-in function that loads a constant is not appropriate (other insn patterns to optimize the architecture-independent built-in functions may well be appropriate). Rather, if there is a particularly efficient way of generating code to load a certain constant, the back end should be set up to use that way whenever that constant occurs (more generally, whenever any constant to which that efficient way applies occurs) - including for example when it occurs from folding arithmetic, say (__float128) __builtin_inff (), not just from __builtin_inff128 (). diff --git a/gcc/builtin-types.def b/gcc/builtin-types.def index 7fab9f8..468313c4 100644 --- a/gcc/builtin-types.def +++ b/gcc/builtin-types.def @@ -76,6 +76,27 @@ 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_FLOAT16, (float16_type_node + ? float16_type_node + : error_mark_node)) +DEF_PRIMITIVE_TYPE (BT_FLOAT32, (float32_type_node + ? float32_type_node + : error_mark_node)) +DEF_PRIMITIVE_TYPE (BT_FLOAT64, (float64_type_node + ? float64_type_node + : error_mark_node)) +DEF_PRIMITIVE_TYPE (BT_FLOAT128, (float128_type_node + ? float128_type_node + : error_mark_node)) +DEF_PRIMITIVE_TYPE (BT_FLOAT32X, (float32x_type_node + ? float32x_type_node + : error_mark_node)) +DEF_PRIMITIVE_TYPE (BT_FLOAT64X, (float64x_type_node + ? float64x_type_node + : error_mark_node)) +DEF_PRIMITIVE_TYPE (BT_FLOAT128X, (float128x_type_node + ? float128x_type_node + : error_mark_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) @@ -146,6 +167,13 @@ 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_FLOAT16, BT_FLOAT16) +DEF_FUNCTION_TYPE_0 (BT_FN_FLOAT32, BT_FLOAT32) +DEF_FUNCTION_TYPE_0 (BT_FN_FLOAT64, BT_FLOAT64) +DEF_FUNCTION_TYPE_0 (BT_FN_FLOAT128, BT_FLOAT128) +DEF_FUNCTION_TYPE_0 (BT_FN_FLOAT32X, BT_FLOAT32X) +DEF_FUNCTION_TYPE_0 (BT_FN_FLOAT64X, BT_FLOAT64X) +DEF_FUNCTION_TYPE_0 (BT_FN_FLOAT128X, BT_FLOAT128X) DEF_FUNCTION_TYPE_0 (BT_FN_DFLOAT32, BT_DFLOAT32) DEF_FUNCTION_TYPE_0 (BT_FN_DFLOAT64, BT_DFLOAT64) DEF_FUNCTION_TYPE_0 (BT_FN_DFLOAT128, BT_DFLOAT128) @@ -157,6 +185,13 @@ 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_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) +DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT128_FLOAT128, BT_FLOAT128, BT_FLOAT128) +DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT32X_FLOAT32X, BT_FLOAT32X, BT_FLOAT32X) +DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT64X_FLOAT64X, BT_FLOAT64X, BT_FLOAT64X) +DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT128X_FLOAT128X, BT_FLOAT128X, BT_FLOAT128X) DEF_FUNCTION_TYPE_1 (BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, BT_COMPLEX_FLOAT, BT_COMPLEX_FLOAT) DEF_FUNCTION_TYPE_1 (BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, @@ -208,6 +243,13 @@ 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_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) +DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT128_CONST_STRING, BT_FLOAT128, BT_CONST_STRING) +DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT32X_CONST_STRING, BT_FLOAT32X, BT_CONST_STRING) +DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT64X_CONST_STRING, BT_FLOAT64X, BT_CONST_STRING) +DEF_FUNCTION_TYPE_1 (BT_FN_FLOAT128X_CONST_STRING, BT_FLOAT128X, BT_CONST_STRING) DEF_FUNCTION_TYPE_1 (BT_FN_DFLOAT32_CONST_STRING, BT_DFLOAT32, BT_CONST_STRING) DEF_FUNCTION_TYPE_1 (BT_FN_DFLOAT64_CONST_STRING, BT_DFLOAT64, BT_CONST_STRING) DEF_FUNCTION_TYPE_1 (BT_FN_DFLOAT128_CONST_STRING, @@ -271,6 +313,20 @@ DEF_FUNCTION_TYPE_2 (BT_FN_DOUBLE_DOUBLE_DOUBLE, BT_DOUBLE, BT_DOUBLE, BT_DOUBLE) DEF_FUNCTION_TYPE_2 (BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, BT_LONGDOUBLE, BT_LONGDOUBLE, BT_LONGDOUBLE) +DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT16_FLOAT16_FLOAT16, + BT_FLOAT16, BT_FLOAT16, BT_FLOAT16) +DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT32_FLOAT32_FLOAT32, + BT_FLOAT32, BT_FLOAT32, BT_FLOAT32) +DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT64_FLOAT64_FLOAT64, + BT_FLOAT64, BT_FLOAT64, BT_FLOAT64) +DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT128_FLOAT128_FLOAT128, + BT_FLOAT128, BT_FLOAT128, BT_FLOAT128) +DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT32X_FLOAT32X_FLOAT32X, + BT_FLOAT32X, BT_FLOAT32X, BT_FLOAT32X) +DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT64X_FLOAT64X_FLOAT64X, + BT_FLOAT64X, BT_FLOAT64X, BT_FLOAT64X) +DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT128X_FLOAT128X_FLOAT128X, + BT_FLOAT128X, BT_FLOAT128X, BT_FLOAT128X) DEF_FUNCTION_TYPE_2 (BT_FN_FLOAT_FLOAT_FLOATPTR, BT_FLOAT, BT_FLOAT, BT_FLOAT_PTR) DEF_FUNCTION_TYPE_2 (BT_FN_DOUBLE_DOUBLE_DOUBLEPTR, diff --git a/gcc/builtins.c b/gcc/builtins.c index 5d234a5..f8ec9cf 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -5761,6 +5761,7 @@ expand_builtin (tree exp, rtx target, rtx subtarget, machine_mode mode, switch (fcode) { CASE_FLT_FN (BUILT_IN_FABS): + CASE_FLT_FN_FLOATN_NX (BUILT_IN_FABS): case BUILT_IN_FABSD32: case BUILT_IN_FABSD64: case BUILT_IN_FABSD128: @@ -5770,6 +5771,7 @@ expand_builtin (tree exp, rtx target, rtx subtarget, machine_mode mode, break; CASE_FLT_FN (BUILT_IN_COPYSIGN): + CASE_FLT_FN_FLOATN_NX (BUILT_IN_COPYSIGN): target = expand_builtin_copysign (exp, target, subtarget); if (target) return target; @@ -8094,12 +8096,14 @@ fold_builtin_0 (location_t loc, tree fndecl) return fold_builtin_LINE (loc, type); CASE_FLT_FN (BUILT_IN_INF): + CASE_FLT_FN_FLOATN_NX (BUILT_IN_INF): case BUILT_IN_INFD32: case BUILT_IN_INFD64: case BUILT_IN_INFD128: return fold_builtin_inf (loc, type, true); CASE_FLT_FN (BUILT_IN_HUGE_VAL): + CASE_FLT_FN_FLOATN_NX (BUILT_IN_HUGE_VAL): return fold_builtin_inf (loc, type, false); case BUILT_IN_CLASSIFY_TYPE: @@ -8148,6 +8152,7 @@ fold_builtin_1 (location_t loc, tree fndecl, tree arg0) return fold_builtin_strlen (loc, type, arg0); CASE_FLT_FN (BUILT_IN_FABS): + CASE_FLT_FN_FLOATN_NX (BUILT_IN_FABS): case BUILT_IN_FABSD32: case BUILT_IN_FABSD64: case BUILT_IN_FABSD128: diff --git a/gcc/builtins.def b/gcc/builtins.def index 33a7626..814ca15 100644 --- a/gcc/builtins.def +++ b/gcc/builtins.def @@ -87,6 +87,19 @@ 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. */ +#undef DEF_GCC_FLOATN_NX_BUILTINS +#define DEF_GCC_FLOATN_NX_BUILTINS(ENUM, NAME, TYPE_MACRO, 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) \ + DEF_GCC_BUILTIN (ENUM ## F128, NAME "f128", TYPE_MACRO (FLOAT128), ATTRS) \ + DEF_GCC_BUILTIN (ENUM ## F32X, NAME "f32x", TYPE_MACRO (FLOAT32X), ATTRS) \ + DEF_GCC_BUILTIN (ENUM ## F64X, NAME "f64x", TYPE_MACRO (FLOAT64X), ATTRS) \ + DEF_GCC_BUILTIN (ENUM ## F128X, NAME "f128x", TYPE_MACRO (FLOAT128X), ATTRS) + /* A library builtin (like __builtin_strchr) is a builtin equivalent of an ANSI/ISO standard library function. In addition to the `__builtin' version, we will create an ordinary version (e.g, @@ -296,6 +309,9 @@ DEF_C99_C90RES_BUILTIN (BUILT_IN_CEILL, "ceill", BT_FN_LONGDOUBLE_LONGDOUBLE, AT DEF_C99_BUILTIN (BUILT_IN_COPYSIGN, "copysign", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_C99_BUILTIN (BUILT_IN_COPYSIGNF, "copysignf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_C99_BUILTIN (BUILT_IN_COPYSIGNL, "copysignl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +#define COPYSIGN_TYPE(F) BT_FN_##F##_##F##_##F +DEF_GCC_FLOATN_NX_BUILTINS (BUILT_IN_COPYSIGN, "copysign", COPYSIGN_TYPE, ATTR_CONST_NOTHROW_LEAF_LIST) +#undef COPYSIGN_TYPE DEF_LIB_BUILTIN (BUILT_IN_COS, "cos", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING) DEF_C99_C90RES_BUILTIN (BUILT_IN_COSF, "cosf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING) DEF_LIB_BUILTIN (BUILT_IN_COSH, "cosh", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) @@ -326,6 +342,9 @@ DEF_C99_BUILTIN (BUILT_IN_EXPM1L, "expm1l", BT_FN_LONGDOUBLE_LONGDOUBLE, DEF_LIB_BUILTIN (BUILT_IN_FABS, "fabs", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_C99_C90RES_BUILTIN (BUILT_IN_FABSF, "fabsf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_C99_C90RES_BUILTIN (BUILT_IN_FABSL, "fabsl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +#define FABS_TYPE(F) BT_FN_##F##_##F +DEF_GCC_FLOATN_NX_BUILTINS (BUILT_IN_FABS, "fabs", FABS_TYPE, ATTR_CONST_NOTHROW_LEAF_LIST) +#undef FABS_TYPE DEF_GCC_BUILTIN (BUILT_IN_FABSD32, "fabsd32", BT_FN_DFLOAT32_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_GCC_BUILTIN (BUILT_IN_FABSD64, "fabsd64", BT_FN_DFLOAT64_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_GCC_BUILTIN (BUILT_IN_FABSD128, "fabsd128", BT_FN_DFLOAT128_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST) @@ -359,6 +378,8 @@ DEF_EXT_LIB_BUILTIN (BUILT_IN_GAMMAL_R, "gammal_r", BT_FN_LONGDOUBLE_LONGDOUB DEF_GCC_BUILTIN (BUILT_IN_HUGE_VAL, "huge_val", BT_FN_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_GCC_BUILTIN (BUILT_IN_HUGE_VALF, "huge_valf", BT_FN_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_GCC_BUILTIN (BUILT_IN_HUGE_VALL, "huge_vall", BT_FN_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +#define INF_TYPE(F) BT_FN_##F +DEF_GCC_FLOATN_NX_BUILTINS (BUILT_IN_HUGE_VAL, "huge_val", INF_TYPE, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_C99_BUILTIN (BUILT_IN_HYPOT, "hypot", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) DEF_C99_BUILTIN (BUILT_IN_HYPOTF, "hypotf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) DEF_C99_BUILTIN (BUILT_IN_HYPOTL, "hypotl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) @@ -374,6 +395,8 @@ DEF_C99_BUILTIN (BUILT_IN_ILOGBL, "ilogbl", BT_FN_INT_LONGDOUBLE, ATTR_MA DEF_GCC_BUILTIN (BUILT_IN_INF, "inf", BT_FN_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_GCC_BUILTIN (BUILT_IN_INFF, "inff", BT_FN_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_GCC_BUILTIN (BUILT_IN_INFL, "infl", BT_FN_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_FLOATN_NX_BUILTINS (BUILT_IN_INF, "inf", INF_TYPE, ATTR_CONST_NOTHROW_LEAF_LIST) +#undef INF_TYPE DEF_GCC_BUILTIN (BUILT_IN_INFD32, "infd32", BT_FN_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_GCC_BUILTIN (BUILT_IN_INFD64, "infd64", BT_FN_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_GCC_BUILTIN (BUILT_IN_INFD128, "infd128", BT_FN_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST) @@ -446,12 +469,16 @@ DEF_C99_C90RES_BUILTIN (BUILT_IN_MODFL, "modfl", BT_FN_LONGDOUBLE_LONGDOUBLE_LON DEF_C99_BUILTIN (BUILT_IN_NAN, "nan", BT_FN_DOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) DEF_C99_BUILTIN (BUILT_IN_NANF, "nanf", BT_FN_FLOAT_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) DEF_C99_BUILTIN (BUILT_IN_NANL, "nanl", BT_FN_LONGDOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) +#define NAN_TYPE(F) BT_FN_##F##_CONST_STRING +DEF_GCC_FLOATN_NX_BUILTINS (BUILT_IN_NAN, "nan", NAN_TYPE, ATTR_CONST_NOTHROW_NONNULL) DEF_GCC_BUILTIN (BUILT_IN_NAND32, "nand32", BT_FN_DFLOAT32_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) DEF_GCC_BUILTIN (BUILT_IN_NAND64, "nand64", BT_FN_DFLOAT64_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) DEF_GCC_BUILTIN (BUILT_IN_NAND128, "nand128", BT_FN_DFLOAT128_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) DEF_GCC_BUILTIN (BUILT_IN_NANS, "nans", BT_FN_DOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) DEF_GCC_BUILTIN (BUILT_IN_NANSF, "nansf", BT_FN_FLOAT_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) 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_C99_BUILTIN (BUILT_IN_NEARBYINT, "nearbyint", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_C99_BUILTIN (BUILT_IN_NEARBYINTF, "nearbyintf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_C99_BUILTIN (BUILT_IN_NEARBYINTL, "nearbyintl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index c61ece9..0cd7b1e 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -10811,6 +10811,13 @@ that are recognized in any mode since ISO C90 reserves these names for the purpose to which ISO C99 puts them. All these functions have corresponding versions prefixed with @code{__builtin_}. +There are also built-in functions @code{__builtin_fabsf@var{n}}, +@code{__builtin_fabsf@var{n}x}, @code{__builtin_copysignf@var{n}} and +@code{__builtin_copysignf@var{n}x}, corresponding to the TS 18661-3 +functions @code{fabsf@var{n}}, @code{fabsf@var{n}x}, +@code{copysignf@var{n}} and @code{copysignf@var{n}x}, for supported +types @code{_Float@var{n}} and @code{_Float@var{n}x}. + There are also GNU extension functions @code{clog10}, @code{clog10f} and @code{clog10l} which names are reserved by ISO C99 for future use. All these functions have versions prefixed with @code{__builtin_}. @@ -11349,6 +11356,16 @@ Similar to @code{__builtin_huge_val}, except the return type is @code{long double}. @end deftypefn +@deftypefn {Built-in Function} _Float@var{n} __builtin_huge_valf@var{n} (void) +Similar to @code{__builtin_huge_val}, except the return type is +@code{_Float@var{n}}. +@end deftypefn + +@deftypefn {Built-in Function} _Float@var{n}x __builtin_huge_valf@var{n}x (void) +Similar to @code{__builtin_huge_val}, except the return type is +@code{_Float@var{n}x}. +@end deftypefn + @deftypefn {Built-in Function} int __builtin_fpclassify (int, int, int, int, int, ...) This built-in implements the C99 fpclassify functionality. The first five int arguments should be the target library's notion of the @@ -11387,6 +11404,16 @@ Similar to @code{__builtin_inf}, except the return type is @code{long double}. @end deftypefn +@deftypefn {Built-in Function} _Float@var{n} __builtin_inff@var{n} (void) +Similar to @code{__builtin_inf}, except the return +type is @code{_Float@var{n}}. +@end deftypefn + +@deftypefn {Built-in Function} _Float@var{n} __builtin_inff@var{n}x (void) +Similar to @code{__builtin_inf}, except the return +type is @code{_Float@var{n}x}. +@end deftypefn + @deftypefn {Built-in Function} int __builtin_isinf_sign (...) Similar to @code{isinf}, except the return value is -1 for an argument of @code{-Inf} and 1 for an argument of @code{+Inf}. @@ -11433,6 +11460,16 @@ Similar to @code{__builtin_nan}, except the return type is @code{float}. Similar to @code{__builtin_nan}, except the return type is @code{long double}. @end deftypefn +@deftypefn {Built-in Function} _Float@var{n} __builtin_nanf@var{n} (const char *str) +Similar to @code{__builtin_nan}, except the return type is +@code{_Float@var{n}}. +@end deftypefn + +@deftypefn {Built-in Function} _Float@var{n}x __builtin_nanf@var{n}x (const char *str) +Similar to @code{__builtin_nan}, except the return type is +@code{_Float@var{n}x}. +@end deftypefn + @deftypefn {Built-in Function} double __builtin_nans (const char *str) Similar to @code{__builtin_nan}, except the significand is forced to be a signaling NaN@. The @code{nans} function is proposed by @@ -11447,6 +11484,16 @@ Similar to @code{__builtin_nans}, except the return type is @code{float}. Similar to @code{__builtin_nans}, except the return type is @code{long double}. @end deftypefn +@deftypefn {Built-in Function} _Float@var{n} __builtin_nansf@var{n} (const char *str) +Similar to @code{__builtin_nans}, except the return type is +@code{_Float@var{n}}. +@end deftypefn + +@deftypefn {Built-in Function} _Float@var{n}x __builtin_nansf@var{n}x (const char *str) +Similar to @code{__builtin_nans}, except the return type is +@code{_Float@var{n}x}. +@end deftypefn + @deftypefn {Built-in Function} int __builtin_ffs (int x) Returns one plus the index of the least significant 1-bit of @var{x}, or if @var{x} is zero, returns zero. diff --git a/gcc/fold-const-call.c b/gcc/fold-const-call.c index 923a5d4..2bbc887 100644 --- a/gcc/fold-const-call.c +++ b/gcc/fold-const-call.c @@ -1131,12 +1131,14 @@ fold_const_call (combined_fn fn, tree type, tree arg) return NULL_TREE; CASE_CFN_NAN: + CASE_FLT_FN_FLOATN_NX (CFN_BUILT_IN_NAN): case CFN_BUILT_IN_NAND32: case CFN_BUILT_IN_NAND64: case CFN_BUILT_IN_NAND128: return fold_const_builtin_nan (type, arg, true); CASE_CFN_NANS: + CASE_FLT_FN_FLOATN_NX (CFN_BUILT_IN_NANS): return fold_const_builtin_nan (type, arg, false); default: diff --git a/gcc/testsuite/gcc.dg/torture/float128-builtin.c b/gcc/testsuite/gcc.dg/torture/float128-builtin.c new file mode 100644 index 0000000..2f4936f --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/float128-builtin.c @@ -0,0 +1,8 @@ +/* Test _Float128 built-in functions. */ +/* { dg-do run } */ +/* { dg-require-effective-target float128 } */ +/* { dg-options "" } */ + +#define WIDTH 128 +#define EXT 0 +#include "floatn-builtin.h" diff --git a/gcc/testsuite/gcc.dg/torture/float128x-builtin.c b/gcc/testsuite/gcc.dg/torture/float128x-builtin.c new file mode 100644 index 0000000..33ceeec --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/float128x-builtin.c @@ -0,0 +1,8 @@ +/* Test _Float128x built-in functions. */ +/* { dg-do run } */ +/* { dg-require-effective-target float128x } */ +/* { dg-options "" } */ + +#define WIDTH 128 +#define EXT 1 +#include "floatn-builtin.h" diff --git a/gcc/testsuite/gcc.dg/torture/float16-builtin.c b/gcc/testsuite/gcc.dg/torture/float16-builtin.c new file mode 100644 index 0000000..2a043fc --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/float16-builtin.c @@ -0,0 +1,8 @@ +/* Test _Float16 built-in functions. */ +/* { dg-do run } */ +/* { dg-require-effective-target float16 } */ +/* { dg-options "" } */ + +#define WIDTH 16 +#define EXT 0 +#include "floatn-builtin.h" diff --git a/gcc/testsuite/gcc.dg/torture/float32-builtin.c b/gcc/testsuite/gcc.dg/torture/float32-builtin.c new file mode 100644 index 0000000..25c7072 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/float32-builtin.c @@ -0,0 +1,8 @@ +/* Test _Float32 built-in functions. */ +/* { dg-do run } */ +/* { dg-require-effective-target float32 } */ +/* { dg-options "" } */ + +#define WIDTH 32 +#define EXT 0 +#include "floatn-builtin.h" diff --git a/gcc/testsuite/gcc.dg/torture/float32x-builtin.c b/gcc/testsuite/gcc.dg/torture/float32x-builtin.c new file mode 100644 index 0000000..63f23e5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/float32x-builtin.c @@ -0,0 +1,8 @@ +/* Test _Float32x built-in functions. */ +/* { dg-do run } */ +/* { dg-require-effective-target float32x } */ +/* { dg-options "" } */ + +#define WIDTH 32 +#define EXT 1 +#include "floatn-builtin.h" diff --git a/gcc/testsuite/gcc.dg/torture/float64-builtin.c b/gcc/testsuite/gcc.dg/torture/float64-builtin.c new file mode 100644 index 0000000..8e8c123 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/float64-builtin.c @@ -0,0 +1,8 @@ +/* Test _Float64 built-in functions. */ +/* { dg-do run } */ +/* { dg-require-effective-target float64 } */ +/* { dg-options "" } */ + +#define WIDTH 64 +#define EXT 0 +#include "floatn-builtin.h" diff --git a/gcc/testsuite/gcc.dg/torture/float64x-builtin.c b/gcc/testsuite/gcc.dg/torture/float64x-builtin.c new file mode 100644 index 0000000..4d91c4b --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/float64x-builtin.c @@ -0,0 +1,8 @@ +/* Test _Float64x built-in functions. */ +/* { dg-do run } */ +/* { dg-require-effective-target float64x } */ +/* { dg-options "" } */ + +#define WIDTH 64 +#define EXT 1 +#include "floatn-builtin.h" diff --git a/gcc/testsuite/gcc.dg/torture/floatn-builtin.h b/gcc/testsuite/gcc.dg/torture/floatn-builtin.h new file mode 100644 index 0000000..c562812 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/floatn-builtin.h @@ -0,0 +1,64 @@ +/* Tests for _FloatN / _FloatNx types: compile and execution tests for + built-in functions. Before including this file, define WIDTH as + the value N; define EXT to 1 for _FloatNx and 0 for _FloatN. */ + +#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) +#endif + +extern void exit (int); +extern void abort (void); + +extern TYPE test_type; +extern __typeof (FN (__builtin_inf) ()) test_type; +extern __typeof (FN (__builtin_huge_val) ()) test_type; +extern __typeof (FN (__builtin_nan) ("")) test_type; +extern __typeof (FN (__builtin_nans) ("")) test_type; +extern __typeof (FN (__builtin_fabs) (0)) test_type; +extern __typeof (FN (__builtin_copysign) (0, 0)) test_type; + +volatile TYPE inf_cst = FN (__builtin_inf) (); +volatile TYPE huge_val_cst = FN (__builtin_huge_val) (); +volatile TYPE nan_cst = FN (__builtin_nan) (""); +volatile TYPE nans_cst = FN (__builtin_nans) (""); +volatile TYPE neg0 = -CST (0.0), neg1 = -CST (1.0), one = 1.0; + +int +main (void) +{ + volatile TYPE 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 = FN (__builtin_fabs) (neg1); + if (r != CST (1.0)) + abort (); + r = FN (__builtin_copysign) (one, neg0); + if (r != neg1) + abort (); + r = FN (__builtin_copysign) (inf_cst, neg1); + if (r != -huge_val_cst) + abort (); + r = FN (__builtin_copysign) (-inf_cst, one); + if (r != huge_val_cst) + abort (); + exit (0); +} diff --git a/gcc/tree.h b/gcc/tree.h index acb8bf1..db6fbcf 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -234,6 +234,9 @@ as_internal_fn (combined_fn code) /* Helper macros for math builtins. */ #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 #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 @@ -3617,11 +3620,16 @@ tree_operand_check_code (const_tree __t, enum tree_code __code, int __i, #define FLOATN_NX_TYPE_NODE(IDX) global_trees[TI_FLOATN_NX_TYPE_FIRST + (IDX)] #define FLOATNX_TYPE_NODE(IDX) global_trees[TI_FLOATNX_TYPE_FIRST + (IDX)] -/* Names for individual types, where required by back ends - (architecture-independent code should always iterate over all such - types). */ +/* Names for individual types (code should normally iterate over all + such types; these are only for back-end use, or in contexts such as + *.def where iteration if not possible). */ +#define float16_type_node global_trees[TI_FLOAT16_TYPE] +#define float32_type_node global_trees[TI_FLOAT32_TYPE] +#define float64_type_node global_trees[TI_FLOAT64_TYPE] #define float128_type_node global_trees[TI_FLOAT128_TYPE] +#define float32x_type_node global_trees[TI_FLOAT32X_TYPE] #define float64x_type_node global_trees[TI_FLOAT64X_TYPE] +#define float128x_type_node global_trees[TI_FLOAT128X_TYPE] #define float_ptr_type_node global_trees[TI_FLOAT_PTR_TYPE] #define double_ptr_type_node global_trees[TI_DOUBLE_PTR_TYPE]