From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621168831; cv=none; d=zohomail.com; s=zohoarc; b=f5QmKOeDqcLxLrV90T8gFfkmyYHyw9iPOhf0JCY77lui3ozkWVyIL9EdnOl9nYz9a0402Hi0xLFSHI5UvnjUBf+aTJ7NQ3Rv58Jz8z3ipDp4lv+Fh0cOV0cLMc4pfdbwwooxkm2xVcvBS8bTzVts0isYGdJ7xIoqWrhqP5xpCkI= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621168831; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=Fn81QolisoGBee6Unux0EG9mqgMNVVRkx5P5b1nS6oI=; b=nF/Ia2HGehSlm5Slmr2OMpjiiYvIhBddaZI4WXPMpTSTyzwNul3oTX5XtF3+kg2c+L4sW3QwMI1lUKFGHXtqwPb1i9AKYq6CVPAauUng9FxSXTZTwcYg+UEGGhS3UhEpaDxmCS4mxgfMOBfWMFF9Qcj/w8NtCLokwN2EoEnT+Sg= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621168831736830.9085424248204; Sun, 16 May 2021 05:40:31 -0700 (PDT) Received: from localhost ([::1]:36358 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG4M-0007EK-NM for importer@patchew.org; Sun, 16 May 2021 08:40:30 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:42840) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFye-00079w-Pn for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:36 -0400 Received: from mail-qt1-x82a.google.com ([2607:f8b0:4864:20::82a]:34425) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyc-0007da-Mj for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:36 -0400 Received: by mail-qt1-x82a.google.com with SMTP id v4so3033998qtp.1 for ; Sun, 16 May 2021 05:34:34 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Fn81QolisoGBee6Unux0EG9mqgMNVVRkx5P5b1nS6oI=; b=QZ9nI0XHOe6nyyuHev0MOy1yF7amwTnAXleu8eQwyD7RJMrNHiClhuXWMXBO/WG0RE 9Mwsa0hBIgH/4IpHvSBCRtTmSr+kFSrYHhfsIr/GUm7j59T8EN8ISkfbMnyVnEwXcYmv YiQq4bmObLwv4QO4tljq/lLO8e4NQWyeF5ZEAHig85HiWfgjuPnl98geylf+rMAVa28s UKJlc+Zv+DR0joEjZmA67hHnglxM9u/O5ygSfIYKNSznLz9sKryWi1KqgPEwSGjiHuTM YfgVUC5Kl3FeRWrxv7ki5+M5Bb/kqvIbMOJWmM2QGjdYFpRQ5TMeY8dhcnKCgGkuci+W LzMA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Fn81QolisoGBee6Unux0EG9mqgMNVVRkx5P5b1nS6oI=; b=DmVzZLvMJj3c+rt98t79wUhRm09qfzAXlm1KnUAF0PTiEp+eqwAO+Zl4GgJIilJVGs /jbplp1QqdqpC0RraJY2APwkF3pWH8DVSZPhTkCbUIOsAhjsIIQiTJiRBh8PyklPxPDk VZmSHA01tn2m7u11vmGvot+0oZxEUSMW+UD8hF9HxG/XW/KfxzVbymSWhOsFO/V9RgPV zq4J1gfQdnU171Jwo/tAtMtCwjkb1affUG5UZlrt4IWDuLGuFpKDSUmEHhwot128ubOs PRbgOV0Fo2u9SSnd+UpJhtXzHdbJZXocksgspdKL0DKQG6jvVt4S2u/c+7hP7lwX4cgO RkTA== X-Gm-Message-State: AOAM530T01js/ZUieKLVLRzJCRn833AE9vsujWPUdEOiTZ/PPO8eVSng +6P1tS2cqm4sclrJ+Moa4xi98htiYmjHb0x3Z9M= X-Google-Smtp-Source: ABdhPJyvuUZRbShFW6l/VUovZeSTwp6z7QksF2hwg5jodLb8+v6OXneCWwKwG+4JzVani5qAYYQ6Kw== X-Received: by 2002:ac8:12c5:: with SMTP id b5mr52250331qtj.203.1621168473720; Sun, 16 May 2021 05:34:33 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 01/46] qemu/host-utils: Use __builtin_bitreverseN Date: Sun, 16 May 2021 07:33:46 -0500 Message-Id: <20210516123431.718318-2-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::82a; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x82a.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Clang has added some builtins for these operations; use them if available. Reviewed-by: Alex Benn=C3=A9e Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- include/qemu/host-utils.h | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/include/qemu/host-utils.h b/include/qemu/host-utils.h index cdca2991d8..f1e52851e0 100644 --- a/include/qemu/host-utils.h +++ b/include/qemu/host-utils.h @@ -272,6 +272,9 @@ static inline int ctpop64(uint64_t val) */ static inline uint8_t revbit8(uint8_t x) { +#if __has_builtin(__builtin_bitreverse8) + return __builtin_bitreverse8(x); +#else /* Assign the correct nibble position. */ x =3D ((x & 0xf0) >> 4) | ((x & 0x0f) << 4); @@ -281,6 +284,7 @@ static inline uint8_t revbit8(uint8_t x) | ((x & 0x22) << 1) | ((x & 0x11) << 3); return x; +#endif } =20 /** @@ -289,6 +293,9 @@ static inline uint8_t revbit8(uint8_t x) */ static inline uint16_t revbit16(uint16_t x) { +#if __has_builtin(__builtin_bitreverse16) + return __builtin_bitreverse16(x); +#else /* Assign the correct byte position. */ x =3D bswap16(x); /* Assign the correct nibble position. */ @@ -300,6 +307,7 @@ static inline uint16_t revbit16(uint16_t x) | ((x & 0x2222) << 1) | ((x & 0x1111) << 3); return x; +#endif } =20 /** @@ -308,6 +316,9 @@ static inline uint16_t revbit16(uint16_t x) */ static inline uint32_t revbit32(uint32_t x) { +#if __has_builtin(__builtin_bitreverse32) + return __builtin_bitreverse32(x); +#else /* Assign the correct byte position. */ x =3D bswap32(x); /* Assign the correct nibble position. */ @@ -319,6 +330,7 @@ static inline uint32_t revbit32(uint32_t x) | ((x & 0x22222222u) << 1) | ((x & 0x11111111u) << 3); return x; +#endif } =20 /** @@ -327,6 +339,9 @@ static inline uint32_t revbit32(uint32_t x) */ static inline uint64_t revbit64(uint64_t x) { +#if __has_builtin(__builtin_bitreverse64) + return __builtin_bitreverse64(x); +#else /* Assign the correct byte position. */ x =3D bswap64(x); /* Assign the correct nibble position. */ @@ -338,6 +353,7 @@ static inline uint64_t revbit64(uint64_t x) | ((x & 0x2222222222222222ull) << 1) | ((x & 0x1111111111111111ull) << 3); return x; +#endif } =20 /* Host type specific sizes of these routines. */ --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621168625; cv=none; d=zohomail.com; s=zohoarc; b=dLQv6vDwfld4RfsE8dfK8Am6P6PR5x/P13TrpfIN2ecMdvd+6LtAhN+Jp7msLWfk+BMbUOOW7HJ3+g83djXa8LMQ/768Xm5rptcM21PZRMzvqTq9/ab/iByCnFsTaZAGydEKroFWgXWZfqbMMHXMU/cIJKMJaoq2FyKEZe1xg5w= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621168625; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=OE2SstHOUvTaOB7/8Q/5yQQrmi158aC82gRKPD2FhoE=; b=J4MQRxgQZvj4X5R8vxSYKjejhbJQnC7Yu43ulIHYYj6k+KeJEG9pYqfzS2smCmn4Ms135JgeX1XwEPaZEFEt7v3dmk/VY0ShPjVRLGFtSomfj8RKfz0isRHb/NWDyZeHF7qUXk8jlNXzCD0tqwdIT+l4ATc9vX8yga2brZQYuys= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621168625051176.2707590975548; Sun, 16 May 2021 05:37:05 -0700 (PDT) Received: from localhost ([::1]:56222 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG12-0001ZQ-2f for importer@patchew.org; Sun, 16 May 2021 08:37:04 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:42864) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFyf-0007AE-TI for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:37 -0400 Received: from mail-qt1-x82e.google.com ([2607:f8b0:4864:20::82e]:33474) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyd-0007eE-Mb for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:37 -0400 Received: by mail-qt1-x82e.google.com with SMTP id 1so3064356qtb.0 for ; Sun, 16 May 2021 05:34:35 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:34 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=OE2SstHOUvTaOB7/8Q/5yQQrmi158aC82gRKPD2FhoE=; b=kPNiJRzhk+sovRDgHbL6uu63EJEDCdMIzQciMV06SxACz+0WGoNLpPUm2G8FHl9hin ywolksV6FujM1lUgxlJiP++HpTnsoFm5v3QCURmD4lY4yxi5B2fgzoA8wB79RpdmY8mT TqljV15UBIuC9nGnda414ehMgDzNW78HFE0D7os7zPEEKypdLKKT+YaO31/Racv1suGl f/H+DjXD0f+tBYhDgMkCRbOwvlpQMyZ9xe2IXqMRmJFU9Q3ANaJw9mVWkbwxKw61Oav6 D8a/G0rm6IUT3wa5h/wiG16DFayRzWICqNPFw8WmyjG/KMX7u7n2wPDVwcY50M4AwqXd UcTA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=OE2SstHOUvTaOB7/8Q/5yQQrmi158aC82gRKPD2FhoE=; b=Z5cV728pQ659YHJBeH+fWtN4iQVV8kpbfpsV6PSMv8DGPiFEEV9z+ZulqvPlUq/eXo MU1ReUY21knk0sEQbAS5sv75cI4ZenFZnWz3tckhRClPedEFCFALU7s54f0t1luKexZN AXTWWp0Pa9ENT9S9dl5rsKlP1DiL5W+zxaHWG6DbvC9uwQwORPaz4oTpldkEJ1wZyOnH 2C3jYrpUnVcplX6spTnC2f/sH1LALvd1cJ7FUZ03orQfH06Zz7jAcnmlL8ENaXF5TymG FyKvxBHZ/FjUGuMXq7y2Jnzk9JvYZk0KYa8mxvpYQKGkZcxMKtTEC/AgvxKNA67eM6bU yRIQ== X-Gm-Message-State: AOAM530JKWBfmvi8s+8t8sjmLQSOj6qp6OkrkZgtqcC1vxqLLIn9jVJQ TWFs56AAZ3FpNRZVh+jyPLvJtF1C44FpTtDCyWs= X-Google-Smtp-Source: ABdhPJzyAELMkBj4UWMKsx4nQ2G2VLdV8R0kOhoTGhrGL/kumm9+dR4rEq3kGaOy/QljDxiX1End2Q== X-Received: by 2002:ac8:5553:: with SMTP id o19mr5071609qtr.308.1621168474469; Sun, 16 May 2021 05:34:34 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 02/46] qemu/host-utils: Add wrappers for overflow builtins Date: Sun, 16 May 2021 07:33:47 -0500 Message-Id: <20210516123431.718318-3-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::82e; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x82e.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) These builtins came in with gcc 5 and clang 3.8, which are slightly newer than our supported minimum compiler versions. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- include/qemu/host-utils.h | 225 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 225 insertions(+) diff --git a/include/qemu/host-utils.h b/include/qemu/host-utils.h index f1e52851e0..cb95626c7d 100644 --- a/include/qemu/host-utils.h +++ b/include/qemu/host-utils.h @@ -356,6 +356,231 @@ static inline uint64_t revbit64(uint64_t x) #endif } =20 +/** + * sadd32_overflow - addition with overflow indication + * @x, @y: addends + * @ret: Output for sum + * + * Computes *@ret =3D @x + @y, and returns true if and only if that + * value has been truncated. + */ +static inline bool sadd32_overflow(int32_t x, int32_t y, int32_t *ret) +{ +#if __has_builtin(__builtin_add_overflow) || __GNUC__ >=3D 5 + return __builtin_add_overflow(x, y, ret); +#else + *ret =3D x + y; + return ((*ret ^ x) & ~(x ^ y)) < 0; +#endif +} + +/** + * sadd64_overflow - addition with overflow indication + * @x, @y: addends + * @ret: Output for sum + * + * Computes *@ret =3D @x + @y, and returns true if and only if that + * value has been truncated. + */ +static inline bool sadd64_overflow(int64_t x, int64_t y, int64_t *ret) +{ +#if __has_builtin(__builtin_add_overflow) || __GNUC__ >=3D 5 + return __builtin_add_overflow(x, y, ret); +#else + *ret =3D x + y; + return ((*ret ^ x) & ~(x ^ y)) < 0; +#endif +} + +/** + * uadd32_overflow - addition with overflow indication + * @x, @y: addends + * @ret: Output for sum + * + * Computes *@ret =3D @x + @y, and returns true if and only if that + * value has been truncated. + */ +static inline bool uadd32_overflow(uint32_t x, uint32_t y, uint32_t *ret) +{ +#if __has_builtin(__builtin_add_overflow) || __GNUC__ >=3D 5 + return __builtin_add_overflow(x, y, ret); +#else + *ret =3D x + y; + return *ret < x; +#endif +} + +/** + * uadd64_overflow - addition with overflow indication + * @x, @y: addends + * @ret: Output for sum + * + * Computes *@ret =3D @x + @y, and returns true if and only if that + * value has been truncated. + */ +static inline bool uadd64_overflow(uint64_t x, uint64_t y, uint64_t *ret) +{ +#if __has_builtin(__builtin_add_overflow) || __GNUC__ >=3D 5 + return __builtin_add_overflow(x, y, ret); +#else + *ret =3D x + y; + return *ret < x; +#endif +} + +/** + * ssub32_overflow - subtraction with overflow indication + * @x: Minuend + * @y: Subtrahend + * @ret: Output for difference + * + * Computes *@ret =3D @x - @y, and returns true if and only if that + * value has been truncated. + */ +static inline bool ssub32_overflow(int32_t x, int32_t y, int32_t *ret) +{ +#if __has_builtin(__builtin_sub_overflow) || __GNUC__ >=3D 5 + return __builtin_sub_overflow(x, y, ret); +#else + *ret =3D x - y; + return ((*ret ^ x) & (x ^ y)) < 0; +#endif +} + +/** + * ssub64_overflow - subtraction with overflow indication + * @x: Minuend + * @y: Subtrahend + * @ret: Output for sum + * + * Computes *@ret =3D @x - @y, and returns true if and only if that + * value has been truncated. + */ +static inline bool ssub64_overflow(int64_t x, int64_t y, int64_t *ret) +{ +#if __has_builtin(__builtin_sub_overflow) || __GNUC__ >=3D 5 + return __builtin_sub_overflow(x, y, ret); +#else + *ret =3D x - y; + return ((*ret ^ x) & (x ^ y)) < 0; +#endif +} + +/** + * usub32_overflow - subtraction with overflow indication + * @x: Minuend + * @y: Subtrahend + * @ret: Output for sum + * + * Computes *@ret =3D @x - @y, and returns true if and only if that + * value has been truncated. + */ +static inline bool usub32_overflow(uint32_t x, uint32_t y, uint32_t *ret) +{ +#if __has_builtin(__builtin_sub_overflow) || __GNUC__ >=3D 5 + return __builtin_sub_overflow(x, y, ret); +#else + *ret =3D x - y; + return x < y; +#endif +} + +/** + * usub64_overflow - subtraction with overflow indication + * @x: Minuend + * @y: Subtrahend + * @ret: Output for sum + * + * Computes *@ret =3D @x - @y, and returns true if and only if that + * value has been truncated. + */ +static inline bool usub64_overflow(uint64_t x, uint64_t y, uint64_t *ret) +{ +#if __has_builtin(__builtin_sub_overflow) || __GNUC__ >=3D 5 + return __builtin_sub_overflow(x, y, ret); +#else + *ret =3D x - y; + return x < y; +#endif +} + +/** + * smul32_overflow - multiplication with overflow indication + * @x, @y: Input multipliers + * @ret: Output for product + * + * Computes *@ret =3D @x * @y, and returns true if and only if that + * value has been truncated. + */ +static inline bool smul32_overflow(int32_t x, int32_t y, int32_t *ret) +{ +#if __has_builtin(__builtin_mul_overflow) || __GNUC__ >=3D 5 + return __builtin_mul_overflow(x, y, ret); +#else + int64_t z =3D (int64_t)x * y; + *ret =3D z; + return *ret !=3D z; +#endif +} + +/** + * smul64_overflow - multiplication with overflow indication + * @x, @y: Input multipliers + * @ret: Output for product + * + * Computes *@ret =3D @x * @y, and returns true if and only if that + * value has been truncated. + */ +static inline bool smul64_overflow(int64_t x, int64_t y, int64_t *ret) +{ +#if __has_builtin(__builtin_mul_overflow) || __GNUC__ >=3D 5 + return __builtin_mul_overflow(x, y, ret); +#else + uint64_t hi, lo; + muls64(&lo, &hi, x, y); + *ret =3D lo; + return hi !=3D ((int64_t)lo >> 63); +#endif +} + +/** + * umul32_overflow - multiplication with overflow indication + * @x, @y: Input multipliers + * @ret: Output for product + * + * Computes *@ret =3D @x * @y, and returns true if and only if that + * value has been truncated. + */ +static inline bool umul32_overflow(uint32_t x, uint32_t y, uint32_t *ret) +{ +#if __has_builtin(__builtin_mul_overflow) || __GNUC__ >=3D 5 + return __builtin_mul_overflow(x, y, ret); +#else + uint64_t z =3D (uint64_t)x * y; + *ret =3D z; + return z > UINT32_MAX; +#endif +} + +/** + * umul64_overflow - multiplication with overflow indication + * @x, @y: Input multipliers + * @ret: Output for product + * + * Computes *@ret =3D @x * @y, and returns true if and only if that + * value has been truncated. + */ +static inline bool umul64_overflow(uint64_t x, uint64_t y, uint64_t *ret) +{ +#if __has_builtin(__builtin_mul_overflow) || __GNUC__ >=3D 5 + return __builtin_mul_overflow(x, y, ret); +#else + uint64_t hi; + mulu64(ret, &hi, x, y); + return hi !=3D 0; +#endif +} + /* Host type specific sizes of these routines. */ =20 #if ULONG_MAX =3D=3D UINT32_MAX --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621168974; cv=none; d=zohomail.com; s=zohoarc; b=IkmdvS8R9b+M7VB3Z8iy69lEm8LMHw/eV9pJKSpVQuiDWpJu8LaE+EducXem5/gQZL8rjZuQSO5Vj/G+ASfnkrWzPTeu/hDP1/Pm7cyokyP++5lJq8A4PtY3iqb4ryx58+/T1pMJ8DenjInZiDfw67UElrSaXnlh3mhoLK/3H5M= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621168974; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=lkUZA1QUxVx6D7Ez3r9MoCYNO26DmbAtxbxbzUkDVlw=; b=XrXkeyXRgJHiWe4DtFyHh2jfmimHYFdLQY95pmWZib/Vnti5aECDaYQwJHNdm3jtABaEL3iAJeRtMKwzxfLjkCbZ9odoBuWJeLhALVGM1gpibZuHIKOl52PxDgg1vtweNsx5cnP0SNN/saSzo85MlQua06JVI2d1kjzwWB0LgzQ= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 16211689746871007.1781802854601; Sun, 16 May 2021 05:42:54 -0700 (PDT) Received: from localhost ([::1]:44796 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG6f-0004Vi-9p for importer@patchew.org; Sun, 16 May 2021 08:42:53 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:42876) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFyg-0007AV-9S for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:38 -0400 Received: from mail-qt1-x82b.google.com ([2607:f8b0:4864:20::82b]:46726) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFye-0007ek-7L for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:38 -0400 Received: by mail-qt1-x82b.google.com with SMTP id m13so2984626qtk.13 for ; Sun, 16 May 2021 05:34:35 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=lkUZA1QUxVx6D7Ez3r9MoCYNO26DmbAtxbxbzUkDVlw=; b=hGbSRJ4crDBrGo4NCYcjMQiD1/31bqIEEXSbIidbCwupwSKzlzOOhrkFRFkccAYvfs RCbns5KcpwCFYRekEQxJqsAU6NTZ8EartV33lRhigdVI6pqimsP7CgKXgkbZ7WEQKaJF 860vV1QkgVZD0KDqF9Pm8L/CGJc5ATTcp3xF4MV/9xUk8eFg31Y6OHO3PBiaHIKBYb3r 8ChkafloMVdp1pU0CG0tOs+/1dlBvYRFDSO1a3RtPHLVvM3/LpMr1CxWBSn/7X3sC2/5 euw6/e9usJajCdY63j+V8iPHPPDctSkOug2Vzq/Y51buc0yWRrmhbKc4rKucIjZqWnqA M7sQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=lkUZA1QUxVx6D7Ez3r9MoCYNO26DmbAtxbxbzUkDVlw=; b=uETi8TUu3U+pONe1saRdmbYn8qLpBxl7ZdunfXFqHaZEB9mJNU7I7IE3jKbJn5MLoa B2UqEnEGKl0QD8PUS/zMNod39CZbouMs9ppGuzRkqK0Vgi4yPYYXnXa2p+cT497ypDDh TbKyOePhjqLcjcx0novOR1XRIic/JxaIyNWSC+W5TYEg/gziiKvto/aggUxstdiaiLzK mLH8vfXHqodVxJBlJwrLd4EsvlTarN3lHH/76NH0Yo2bGV/5Ffm4ONipnU2MK8PM0L6O d2Hb17xPnb8cDafbWxBsvwnPkdPqw9oMt75hmnIyqg/Sv53UgnZ4C1UOQMA0G+zRZ4+r r8Tw== X-Gm-Message-State: AOAM531JPx3ziOjzAvsWYI9XGngF0SaT5JkzMkRqbJ5MixCiBHKHK4R9 EBF0NrECgKv5Phr8pEusuGyCWgackTfLTBtlnPU= X-Google-Smtp-Source: ABdhPJysmZO5q+IWy8ZGqNG3RZ0tWYNX4uwZRrOC62t41Ez6pSCv6vRV4wIiwXJBT9fHm2VFrxQUTA== X-Received: by 2002:ac8:450c:: with SMTP id q12mr9538723qtn.327.1621168475296; Sun, 16 May 2021 05:34:35 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 03/46] qemu/host-utils: Add wrappers for carry builtins Date: Sun, 16 May 2021 07:33:48 -0500 Message-Id: <20210516123431.718318-4-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::82b; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x82b.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) These builtins came in clang 3.8, but are not present in gcc through version 11. Even in clang the optimization is only ideal on x86_64, but never worse than the hand-coding that we currently do. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- include/qemu/host-utils.h | 50 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/include/qemu/host-utils.h b/include/qemu/host-utils.h index cb95626c7d..711b221704 100644 --- a/include/qemu/host-utils.h +++ b/include/qemu/host-utils.h @@ -26,6 +26,7 @@ #ifndef HOST_UTILS_H #define HOST_UTILS_H =20 +#include "qemu/compiler.h" #include "qemu/bswap.h" =20 #ifdef CONFIG_INT128 @@ -581,6 +582,55 @@ static inline bool umul64_overflow(uint64_t x, uint64_= t y, uint64_t *ret) #endif } =20 +/** + * uadd64_carry - addition with carry-in and carry-out + * @x, @y: addends + * @pcarry: in-out carry value + * + * Computes @x + @y + *@pcarry, placing the carry-out back + * into *@pcarry and returning the 64-bit sum. + */ +static inline uint64_t uadd64_carry(uint64_t x, uint64_t y, bool *pcarry) +{ +#if __has_builtin(__builtin_addcll) + unsigned long long c =3D *pcarry; + x =3D __builtin_addcll(x, y, c, &c); + *pcarry =3D c & 1; + return x; +#else + bool c =3D *pcarry; + /* This is clang's internal expansion of __builtin_addc. */ + c =3D uadd64_overflow(x, c, &x); + c |=3D uadd64_overflow(x, y, &x); + *pcarry =3D c; + return x; +#endif +} + +/** + * usub64_borrow - subtraction with borrow-in and borrow-out + * @x, @y: addends + * @pborrow: in-out borrow value + * + * Computes @x - @y - *@pborrow, placing the borrow-out back + * into *@pborrow and returning the 64-bit sum. + */ +static inline uint64_t usub64_borrow(uint64_t x, uint64_t y, bool *pborrow) +{ +#if __has_builtin(__builtin_subcll) + unsigned long long b =3D *pborrow; + x =3D __builtin_subcll(x, y, b, &b); + *pborrow =3D b & 1; + return x; +#else + bool b =3D *pborrow; + b =3D usub64_overflow(x, b, &x); + b |=3D usub64_overflow(x, y, &x); + *pborrow =3D b; + return x; +#endif +} + /* Host type specific sizes of these routines. */ =20 #if ULONG_MAX =3D=3D UINT32_MAX --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621168645; cv=none; d=zohomail.com; s=zohoarc; b=VR+egcf6Xbr65lPGDVgN1P+eP2zysiNqIHgYtUwBH8qZJB2LlBWh7pdY75vJ5NEMnwcC5c9q86CpQjyssYByzbPhb4uIcXIoPP2gN1s0dnx8qyoPRfmDOWdhhQTleo7RsZjTKouKYPNyqTTwzyvqT/fAV15UsTMVDDzWEjGcRg4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621168645; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=WCooW+37Z0FxZm2Vga9KGLb5BfCR58QdDfT18gmnbx0=; b=PhQytD+NZVw1XUMtk5UWuxHDeAqzIet0WWdnCF4X+dUq8oJm5/47uFIXV4CdbwVXn32dkM1S171RDYVhXnVqTv/LHG8zKIgRdoJ4VkdE1+NWwGJxwx3b75Q8PH6defsHwmfh4T9gNuBq5BzUemM/cBEnXTI37n72/V9JOTGYwK8= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621168645321892.8637253892641; Sun, 16 May 2021 05:37:25 -0700 (PDT) Received: from localhost ([::1]:56502 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG1J-0001kX-Om for importer@patchew.org; Sun, 16 May 2021 08:37:23 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:42894) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFyh-0007DP-Ul for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:39 -0400 Received: from mail-qt1-x82e.google.com ([2607:f8b0:4864:20::82e]:39929) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyf-0007hG-1b for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:39 -0400 Received: by mail-qt1-x82e.google.com with SMTP id f8so3012693qth.6 for ; Sun, 16 May 2021 05:34:36 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=WCooW+37Z0FxZm2Vga9KGLb5BfCR58QdDfT18gmnbx0=; b=ZeDISgmZHPvHyI1DWuDMQ6dhjakWxLPKfcGiem1eP6J8lJEiQUhi2zdW6oS49jpaoh rD4ZVb3x9zHlaH97Nd3rGjBIvfmIIvvEvFg1Gh63K1GN1QO70gym4x56EjYpgEt4LghK 94xCSqLz1ulbsvLDUf1JmXfZyEIKVGBjkyqTNl7ix7JpzzqUCp2eLgjIiA7hHpPYhVHX sWS/ax2/4JIlVBYDFOvhjgmMUXDngEqXT63xzX2DJarVAii/moLgmzNmYk3vd7W/SyL0 aEJhHSkCrlLqwe4O4dUzXhlhmA2CnphjywYVk66a6/xO/JRvUK2/kEuzMTGRj8zJi0vk 8a/w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=WCooW+37Z0FxZm2Vga9KGLb5BfCR58QdDfT18gmnbx0=; b=Kr79T1VMYJeZwjLpgeXmxHDrv/X2f2Mqa11o49Cn/vRYp48m39X7eRuCNp2RqyXbsu tCZo2MdMWarNB9IHgwaFYEWKuuJ45U1e8mQdLCrnhaVsp55JVF+OxSeAMUhPR+QKFoJa QUyDvN9S6FSVt5yWMGlrEka9piKS4nDAfk0bX/4LB7tO5KHZxBfRp3/jIqqWwztW/d0r PLfXJtK57amc1vYtGdSUuyHg7688dQtwPcKkqVqr36rpckbQoSLTUgU28rwkXsiGbF1i E5YbUuDwZYnce0u6WseEXYXE1FYvsKH24GEjcM/QaB8BbYavQ+GabrrLLMpIBAiDKLVi yJ/Q== X-Gm-Message-State: AOAM532TXdhIekadVVEPFkq+aSiZQXbyfqGh2qmWVY9mL/myfPWFpLZi wF9hMJnWRMUMuK/dvb18JEvznehmTEjMMRotK38= X-Google-Smtp-Source: ABdhPJw40qS2V77qSnmI5m39un9s4e5rIBdm2KRn9cMFm1JhoYFsBU6z0K/TDKrufpln1cengorigg== X-Received: by 2002:ac8:4750:: with SMTP id k16mr35381823qtp.13.1621168476251; Sun, 16 May 2021 05:34:36 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 04/46] accel/tcg: Use add/sub overflow routines in tcg-runtime-gvec.c Date: Sun, 16 May 2021 07:33:49 -0500 Message-Id: <20210516123431.718318-5-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::82e; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x82e.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= , =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Obvious uses of the new functions. Reviewed-by: Philippe Mathieu-Daud=C3=A9 Reviewed-by: Alex Benn=C3=A9e Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- accel/tcg/tcg-runtime-gvec.c | 36 ++++++++++++++++-------------------- 1 file changed, 16 insertions(+), 20 deletions(-) diff --git a/accel/tcg/tcg-runtime-gvec.c b/accel/tcg/tcg-runtime-gvec.c index 521da4a813..ac7d28c251 100644 --- a/accel/tcg/tcg-runtime-gvec.c +++ b/accel/tcg/tcg-runtime-gvec.c @@ -1073,9 +1073,8 @@ void HELPER(gvec_ssadd32)(void *d, void *a, void *b, = uint32_t desc) for (i =3D 0; i < oprsz; i +=3D sizeof(int32_t)) { int32_t ai =3D *(int32_t *)(a + i); int32_t bi =3D *(int32_t *)(b + i); - int32_t di =3D ai + bi; - if (((di ^ ai) &~ (ai ^ bi)) < 0) { - /* Signed overflow. */ + int32_t di; + if (sadd32_overflow(ai, bi, &di)) { di =3D (di < 0 ? INT32_MAX : INT32_MIN); } *(int32_t *)(d + i) =3D di; @@ -1091,9 +1090,8 @@ void HELPER(gvec_ssadd64)(void *d, void *a, void *b, = uint32_t desc) for (i =3D 0; i < oprsz; i +=3D sizeof(int64_t)) { int64_t ai =3D *(int64_t *)(a + i); int64_t bi =3D *(int64_t *)(b + i); - int64_t di =3D ai + bi; - if (((di ^ ai) &~ (ai ^ bi)) < 0) { - /* Signed overflow. */ + int64_t di; + if (sadd64_overflow(ai, bi, &di)) { di =3D (di < 0 ? INT64_MAX : INT64_MIN); } *(int64_t *)(d + i) =3D di; @@ -1143,9 +1141,8 @@ void HELPER(gvec_sssub32)(void *d, void *a, void *b, = uint32_t desc) for (i =3D 0; i < oprsz; i +=3D sizeof(int32_t)) { int32_t ai =3D *(int32_t *)(a + i); int32_t bi =3D *(int32_t *)(b + i); - int32_t di =3D ai - bi; - if (((di ^ ai) & (ai ^ bi)) < 0) { - /* Signed overflow. */ + int32_t di; + if (ssub32_overflow(ai, bi, &di)) { di =3D (di < 0 ? INT32_MAX : INT32_MIN); } *(int32_t *)(d + i) =3D di; @@ -1161,9 +1158,8 @@ void HELPER(gvec_sssub64)(void *d, void *a, void *b, = uint32_t desc) for (i =3D 0; i < oprsz; i +=3D sizeof(int64_t)) { int64_t ai =3D *(int64_t *)(a + i); int64_t bi =3D *(int64_t *)(b + i); - int64_t di =3D ai - bi; - if (((di ^ ai) & (ai ^ bi)) < 0) { - /* Signed overflow. */ + int64_t di; + if (ssub64_overflow(ai, bi, &di)) { di =3D (di < 0 ? INT64_MAX : INT64_MIN); } *(int64_t *)(d + i) =3D di; @@ -1209,8 +1205,8 @@ void HELPER(gvec_usadd32)(void *d, void *a, void *b, = uint32_t desc) for (i =3D 0; i < oprsz; i +=3D sizeof(uint32_t)) { uint32_t ai =3D *(uint32_t *)(a + i); uint32_t bi =3D *(uint32_t *)(b + i); - uint32_t di =3D ai + bi; - if (di < ai) { + uint32_t di; + if (uadd32_overflow(ai, bi, &di)) { di =3D UINT32_MAX; } *(uint32_t *)(d + i) =3D di; @@ -1226,8 +1222,8 @@ void HELPER(gvec_usadd64)(void *d, void *a, void *b, = uint32_t desc) for (i =3D 0; i < oprsz; i +=3D sizeof(uint64_t)) { uint64_t ai =3D *(uint64_t *)(a + i); uint64_t bi =3D *(uint64_t *)(b + i); - uint64_t di =3D ai + bi; - if (di < ai) { + uint64_t di; + if (uadd64_overflow(ai, bi, &di)) { di =3D UINT64_MAX; } *(uint64_t *)(d + i) =3D di; @@ -1273,8 +1269,8 @@ void HELPER(gvec_ussub32)(void *d, void *a, void *b, = uint32_t desc) for (i =3D 0; i < oprsz; i +=3D sizeof(uint32_t)) { uint32_t ai =3D *(uint32_t *)(a + i); uint32_t bi =3D *(uint32_t *)(b + i); - uint32_t di =3D ai - bi; - if (ai < bi) { + uint32_t di; + if (usub32_overflow(ai, bi, &di)) { di =3D 0; } *(uint32_t *)(d + i) =3D di; @@ -1290,8 +1286,8 @@ void HELPER(gvec_ussub64)(void *d, void *a, void *b, = uint32_t desc) for (i =3D 0; i < oprsz; i +=3D sizeof(uint64_t)) { uint64_t ai =3D *(uint64_t *)(a + i); uint64_t bi =3D *(uint64_t *)(b + i); - uint64_t di =3D ai - bi; - if (ai < bi) { + uint64_t di; + if (usub64_overflow(ai, bi, &di)) { di =3D 0; } *(uint64_t *)(d + i) =3D di; --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169148; cv=none; d=zohomail.com; s=zohoarc; b=UG3upe/sRhF4E3a7BQIvm2WxXtIx70NVKFetU8uPNp8BIF6FwMqLN2L7Kn1LPzgwzCP0n0mlI38w+24iwK6WoOzdqCJjNs1gh5YHOhg++Tnc7ECN5ERI3UOjtsvxsYBQ7Nw3U7pK1Hi91uFTM2TLM6YSVuvJAkHE66s3fN2HWCU= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169148; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=vInOL7n4fh0AFReF/5gQxfmHVQY38UqwnHgnHGBM/24=; b=Hs0v6yfgBcuOF2f8kV+lsTRLxZ2cqSK1iQkQ3SZpt9RAbihufALwYRRwutNlJxJGeNolQmsP0qgfugFPbY6//NuZo9b/M+fhuasOJm7YioaXDfDvxWY95MJOWJlvn0y3qTqnHVYPUByaS737zZZgCVfqVekYeIUPJKSeAH6Rr9o= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169148030142.53291813327337; Sun, 16 May 2021 05:45:48 -0700 (PDT) Received: from localhost ([::1]:53228 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG9S-0001i7-Uo for importer@patchew.org; Sun, 16 May 2021 08:45:46 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:42898) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFyi-0007E5-6f for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:40 -0400 Received: from mail-qt1-x82a.google.com ([2607:f8b0:4864:20::82a]:38492) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyg-0007hU-1F for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:39 -0400 Received: by mail-qt1-x82a.google.com with SMTP id h21so3018221qtu.5 for ; Sun, 16 May 2021 05:34:37 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=vInOL7n4fh0AFReF/5gQxfmHVQY38UqwnHgnHGBM/24=; b=LuHn+Zh/6j8uHB575uNaPMh3bB9898hjP5KEJtRJk7WK9pk3sYfWBSxFoDaxfyHeRA i03Sgct0IUDiJdqM3O6Qy4HfVCwNPjuk4MJLl7z4AE/CfvMX+KStChhWogO5DiMXepAy A6Ox/GCUng1paWtYfAX/RAwR1Cx1Ecga3rcHjDGWgz/21ip4558tRykOrpOLyjPqZDge xUSFSFoEuSH5ss28ybSvfpmTUkDk1Vd0U6aR/75tM+0q63LAuTDiamzIFmXWUougLZc2 8FoVLaidWtbusw3Fuf7IvBQFz6DBS7T7vpiUxxLnMBjUTIjIja7Ts6ZWdq0LOVEV4emV ghgA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=vInOL7n4fh0AFReF/5gQxfmHVQY38UqwnHgnHGBM/24=; b=RNmMnbPk7tgdv4zPsy+bX1qduhc/FQU9hRO2tKoYVn+S9hyzVPjSpR2eagnLmNw1E6 NWGZC6t4fHifwa85iXcrddak3gfJrXzRqZdJ8Zbgwq028Z3hQZOXA0stTwNOYHKqflB3 G66TT0YSDc/BHH3fWrimOvP3crcxcHaAC9IuLnhZVN8VJ6IlsvQ5+nDmn5o7+m3aue+a Z6Tclki7+q7lzWAhtYGLQ+Yb4oWJI/kxI8YV7SbU8t2joWEOHscEGvCxCUMFFza/XHik Lu9xOSVDMZ4hbMR/eGlnerkted7QCADTKd7Pdl/7Wr91Cz/xwNQFzTzUhwtHSsmyP12g DcMQ== X-Gm-Message-State: AOAM533FbOMceZsI9qiuLM5VwKaAlhlHBDaVnP/mpGyhyImIl0lrHIv9 a2A39IIrblylK5vxQxHfpB1svj0njDYdGpS9JmU= X-Google-Smtp-Source: ABdhPJzM8ZWhAU3EAawrhvUSOcJn6P1cgP4lgx0Wfuvk55oOUGfcj0jYWmMbvEL2hslxfYVewagaig== X-Received: by 2002:a05:622a:11cd:: with SMTP id n13mr24228803qtk.37.1621168477128; Sun, 16 May 2021 05:34:37 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 05/46] tests/fp: add quad support to the benchmark utility Date: Sun, 16 May 2021 07:33:50 -0500 Message-Id: <20210516123431.718318-6-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::82a; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x82a.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) From: Alex Benn=C3=A9e Currently this only support softfloat calculations because working out if the hardware supports 128 bit floats needs configure magic. The 3 op muladd operation is currently unimplemented so commented out for now. Reviewed-by: David Hildenbrand Signed-off-by: Alex Benn=C3=A9e Message-Id: <20201020163738.27700-8-alex.bennee@linaro.org> Signed-off-by: Richard Henderson --- tests/fp/fp-bench.c | 88 ++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 83 insertions(+), 5 deletions(-) diff --git a/tests/fp/fp-bench.c b/tests/fp/fp-bench.c index 4ba5e1d2d4..d319993280 100644 --- a/tests/fp/fp-bench.c +++ b/tests/fp/fp-bench.c @@ -14,6 +14,7 @@ #include #include #include "qemu/timer.h" +#include "qemu/int128.h" #include "fpu/softfloat.h" =20 /* amortize the computation of random inputs */ @@ -50,8 +51,10 @@ static const char * const op_names[] =3D { enum precision { PREC_SINGLE, PREC_DOUBLE, + PREC_QUAD, PREC_FLOAT32, PREC_FLOAT64, + PREC_FLOAT128, PREC_MAX_NR, }; =20 @@ -89,6 +92,7 @@ union fp { double d; float32 f32; float64 f64; + float128 f128; uint64_t u64; }; =20 @@ -113,6 +117,10 @@ struct op_desc { static uint64_t random_ops[MAX_OPERANDS] =3D { SEED_A, SEED_B, SEED_C, }; + +static float128 random_quad_ops[MAX_OPERANDS] =3D { + {SEED_A, SEED_B}, {SEED_B, SEED_C}, {SEED_C, SEED_A}, +}; static float_status soft_status; static enum precision precision; static enum op operation; @@ -141,25 +149,45 @@ static void update_random_ops(int n_ops, enum precisi= on prec) int i; =20 for (i =3D 0; i < n_ops; i++) { - uint64_t r =3D random_ops[i]; =20 switch (prec) { case PREC_SINGLE: case PREC_FLOAT32: + { + uint64_t r =3D random_ops[i]; do { r =3D xorshift64star(r); } while (!float32_is_normal(r)); + random_ops[i] =3D r; break; + } case PREC_DOUBLE: case PREC_FLOAT64: + { + uint64_t r =3D random_ops[i]; do { r =3D xorshift64star(r); } while (!float64_is_normal(r)); + random_ops[i] =3D r; break; + } + case PREC_QUAD: + case PREC_FLOAT128: + { + float128 r =3D random_quad_ops[i]; + uint64_t hi =3D r.high; + uint64_t lo =3D r.low; + do { + hi =3D xorshift64star(hi); + lo =3D xorshift64star(lo); + r =3D make_float128(hi, lo); + } while (!float128_is_normal(r)); + random_quad_ops[i] =3D r; + break; + } default: g_assert_not_reached(); } - random_ops[i] =3D r; } } =20 @@ -184,6 +212,13 @@ static void fill_random(union fp *ops, int n_ops, enum= precision prec, ops[i].f64 =3D float64_chs(ops[i].f64); } break; + case PREC_QUAD: + case PREC_FLOAT128: + ops[i].f128 =3D random_quad_ops[i]; + if (no_neg && float128_is_neg(ops[i].f128)) { + ops[i].f128 =3D float128_chs(ops[i].f128); + } + break; default: g_assert_not_reached(); } @@ -345,6 +380,41 @@ static void bench(enum precision prec, enum op op, int= n_ops, bool no_neg) } } break; + case PREC_FLOAT128: + fill_random(ops, n_ops, prec, no_neg); + t0 =3D get_clock(); + for (i =3D 0; i < OPS_PER_ITER; i++) { + float128 a =3D ops[0].f128; + float128 b =3D ops[1].f128; + /* float128 c =3D ops[2].f128; */ + + switch (op) { + case OP_ADD: + res.f128 =3D float128_add(a, b, &soft_status); + break; + case OP_SUB: + res.f128 =3D float128_sub(a, b, &soft_status); + break; + case OP_MUL: + res.f128 =3D float128_mul(a, b, &soft_status); + break; + case OP_DIV: + res.f128 =3D float128_div(a, b, &soft_status); + break; + /* case OP_FMA: */ + /* res.f128 =3D float128_muladd(a, b, c, 0, &soft_stat= us); */ + /* break; */ + case OP_SQRT: + res.f128 =3D float128_sqrt(a, &soft_status); + break; + case OP_CMP: + res.u64 =3D float128_compare_quiet(a, b, &soft_status); + break; + default: + g_assert_not_reached(); + } + } + break; default: g_assert_not_reached(); } @@ -369,7 +439,8 @@ static void bench(enum precision prec, enum op op, int = n_ops, bool no_neg) GEN_BENCH(bench_ ## opname ## _float, float, PREC_SINGLE, op, n_ops) \ GEN_BENCH(bench_ ## opname ## _double, double, PREC_DOUBLE, op, n_ops)= \ GEN_BENCH(bench_ ## opname ## _float32, float32, PREC_FLOAT32, op, n_o= ps) \ - GEN_BENCH(bench_ ## opname ## _float64, float64, PREC_FLOAT64, op, n_o= ps) + GEN_BENCH(bench_ ## opname ## _float64, float64, PREC_FLOAT64, op, n_o= ps) \ + GEN_BENCH(bench_ ## opname ## _float128, float128, PREC_FLOAT128, op, = n_ops) =20 GEN_BENCH_ALL_TYPES(add, OP_ADD, 2) GEN_BENCH_ALL_TYPES(sub, OP_SUB, 2) @@ -383,7 +454,8 @@ GEN_BENCH_ALL_TYPES(cmp, OP_CMP, 2) GEN_BENCH_NO_NEG(bench_ ## name ## _float, float, PREC_SINGLE, op, n) \ GEN_BENCH_NO_NEG(bench_ ## name ## _double, double, PREC_DOUBLE, op, n= ) \ GEN_BENCH_NO_NEG(bench_ ## name ## _float32, float32, PREC_FLOAT32, op= , n) \ - GEN_BENCH_NO_NEG(bench_ ## name ## _float64, float64, PREC_FLOAT64, op= , n) + GEN_BENCH_NO_NEG(bench_ ## name ## _float64, float64, PREC_FLOAT64, op= , n) \ + GEN_BENCH_NO_NEG(bench_ ## name ## _float128, float128, PREC_FLOAT128,= op, n) =20 GEN_BENCH_ALL_TYPES_NO_NEG(sqrt, OP_SQRT, 1) #undef GEN_BENCH_ALL_TYPES_NO_NEG @@ -397,6 +469,7 @@ GEN_BENCH_ALL_TYPES_NO_NEG(sqrt, OP_SQRT, 1) [PREC_DOUBLE] =3D bench_ ## opname ## _double, \ [PREC_FLOAT32] =3D bench_ ## opname ## _float32, \ [PREC_FLOAT64] =3D bench_ ## opname ## _float64, \ + [PREC_FLOAT128] =3D bench_ ## opname ## _float128, \ } =20 static const bench_func_t bench_funcs[OP_MAX_NR][PREC_MAX_NR] =3D { @@ -445,7 +518,7 @@ static void usage_complete(int argc, char *argv[]) fprintf(stderr, " -h =3D show this help message.\n"); fprintf(stderr, " -o =3D floating point operation (%s). Default: %s\n", op_list, op_names[0]); - fprintf(stderr, " -p =3D floating point precision (single, double). " + fprintf(stderr, " -p =3D floating point precision (single, double, qua= d[soft only]). " "Default: single\n"); fprintf(stderr, " -r =3D rounding mode (even, zero, down, up, tieaway)= . " "Default: even\n"); @@ -565,6 +638,8 @@ static void parse_args(int argc, char *argv[]) precision =3D PREC_SINGLE; } else if (!strcmp(optarg, "double")) { precision =3D PREC_DOUBLE; + } else if (!strcmp(optarg, "quad")) { + precision =3D PREC_QUAD; } else { fprintf(stderr, "Unsupported precision '%s'\n", optarg); exit(EXIT_FAILURE); @@ -608,6 +683,9 @@ static void parse_args(int argc, char *argv[]) case PREC_DOUBLE: precision =3D PREC_FLOAT64; break; + case PREC_QUAD: + precision =3D PREC_FLOAT128; + break; default: g_assert_not_reached(); } --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621168649; cv=none; d=zohomail.com; s=zohoarc; b=WVDse6Gcsd6ZGMKJSQTVJN1mFh+FD0cFJaTj8fLe/S8ZeQNS2FwVg9msWkUwWOUTL8fEdNExNNlPcSpMBlLPEqO1gyegZC9FBFAM8hxmio28e2DsM7Nea0TmYSRdPUrvWIPECg0CA1nDme/s+gs0q5Psd1beu4LWmKk0n1HM+Ak= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621168649; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=HnPXApZGOfezRUyUkfJd+r7Xafb2ezTr4qIfixFojDk=; b=chf5oRZ70ICKvDvLifivydrK7h7Y9IVNrqDvxJoFW8LSCkbWlG+cjcmJ5m7l+ELpd5HFL2RitneI69rGDwHpc6+BLQodFmSyTgGfaQq8TEATaOqAYnlkpTNY1DkgyX4FTyJkhlm0UoTMtZsdYEQnuOoVs3IC872LUamvhKkvrjU= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621168649754687.7315580309921; Sun, 16 May 2021 05:37:29 -0700 (PDT) Received: from localhost ([::1]:56710 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG1Q-0001sh-Mi for importer@patchew.org; Sun, 16 May 2021 08:37:28 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:42922) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFyj-0007I3-Hw for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:41 -0400 Received: from mail-qt1-x82f.google.com ([2607:f8b0:4864:20::82f]:34430) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyg-0007iY-Tc for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:41 -0400 Received: by mail-qt1-x82f.google.com with SMTP id v4so3034059qtp.1 for ; Sun, 16 May 2021 05:34:38 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.37 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=HnPXApZGOfezRUyUkfJd+r7Xafb2ezTr4qIfixFojDk=; b=KGIQMHFl1Ls6/DW/wzqlkx6X7QwtjzFRZQG8Q9ggVuOU2Hii3mvI2jjCfBaMmc0PYt Tf56mHfxRRMnXNsI9Qy11TaRuLhGE6vIkK4NkiE+gGOe4Xa/h2CPKKr7pxlYW3JYWkww Gf1a910JpnZMBWkVlD2nHryDhNJfzmRk2aWPGTOgGEDZdQHODOys89xhme+4DvbLT6dC hA/TB3yMqy1lqJGZ8dJrM3Ck8z8TLXrVwScGvbua1NL5RCfw6daiqoOw7Gl7gt7rOdwi qYcAu18l1BRiPDjnYBLb3D3QJCY056bl/RmV33yM+utnJQlNdaQqf9gKfQTk84NyT64G vZAA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=HnPXApZGOfezRUyUkfJd+r7Xafb2ezTr4qIfixFojDk=; b=MCmAzZgqIPmf0fBAdh5oCbZ72O935c/A8UZRkVDSVOPATmulHSHfX+/Y5CTLCag/+R QEtbWhZqDp82aPGfxrLdo3lr88jMMlzgHFdeJ6xJrGqZsxRcwWJ3rZpk9hgNe8d8LrDy kRVj2F0KB/CycjfgZYS18MfH5b6Ebhx6UbFYGLIERrKlPuz7Jlt+tYyX0ViW3c1jp+nq BmB736HHJRpyxicJAQZy3ZNLh6PB1AuDeb97d2uE2Tk1XTCmKxLDLcUCkuCGr/Ie0rVX KpsCc3mClt8XCnM5WDh5YeFW79w3nHqGuhm9GNbIDozAZzGd5PgI9jojIo+pgZtDKrrq E1mQ== X-Gm-Message-State: AOAM533ZTfFE0HNJtjEeIeFBZZa3tGg5AEMg9JhBbKBr2IiecKxI5RMA oHAvElVvE4665YS4D3Uhe8j7gtCzGQBtjrzmlxU= X-Google-Smtp-Source: ABdhPJwSTEDR68TZLTx3t3GFajB1byHn85Rdnh2eK1WuRWZy/KE342s+URZKdYngkf++H4aqN4n57w== X-Received: by 2002:a05:622a:1049:: with SMTP id f9mr51907806qte.140.1621168477868; Sun, 16 May 2021 05:34:37 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 06/46] softfloat: Move the binary point to the msb Date: Sun, 16 May 2021 07:33:51 -0500 Message-Id: <20210516123431.718318-7-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::82f; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x82f.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Rather than point the binary point at msb-1, put it at the msb. Use uadd64_overflow to detect when addition overflows instead of DECOMPOSED_OVERFLOW_BIT. This reduces the number of special cases within the code, such as shifting an int64_t either left or right during conversion. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 169 +++++++++++++++++++----------------------------- 1 file changed, 66 insertions(+), 103 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 67cfa0fd82..cd777743f1 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -503,9 +503,8 @@ typedef struct { bool sign; } FloatParts; =20 -#define DECOMPOSED_BINARY_POINT (64 - 2) +#define DECOMPOSED_BINARY_POINT 63 #define DECOMPOSED_IMPLICIT_BIT (1ull << DECOMPOSED_BINARY_POINT) -#define DECOMPOSED_OVERFLOW_BIT (DECOMPOSED_IMPLICIT_BIT << 1) =20 /* Structure holding all of the relevant parameters for a format. * exp_size: the size of the exponent field @@ -657,7 +656,7 @@ static FloatParts sf_canonicalize(FloatParts part, cons= t FloatFmt *parm, part.cls =3D float_class_zero; part.frac =3D 0; } else { - int shift =3D clz64(part.frac) - 1; + int shift =3D clz64(part.frac); part.cls =3D float_class_normal; part.exp =3D parm->frac_shift - parm->exp_bias - shift + 1; part.frac <<=3D shift; @@ -727,9 +726,8 @@ static FloatParts round_canonical(FloatParts p, float_s= tatus *s, if (likely(exp > 0)) { if (frac & round_mask) { flags |=3D float_flag_inexact; - frac +=3D inc; - if (frac & DECOMPOSED_OVERFLOW_BIT) { - frac >>=3D 1; + if (uadd64_overflow(frac, inc, &frac)) { + frac =3D (frac >> 1) | DECOMPOSED_IMPLICIT_BIT; exp++; } } @@ -758,9 +756,12 @@ static FloatParts round_canonical(FloatParts p, float_= status *s, p.cls =3D float_class_zero; goto do_zero; } else { - bool is_tiny =3D s->tininess_before_rounding - || (exp < 0) - || !((frac + inc) & DECOMPOSED_OVERFLOW_BIT); + bool is_tiny =3D s->tininess_before_rounding || (exp < 0); + + if (!is_tiny) { + uint64_t discard; + is_tiny =3D !uadd64_overflow(frac, inc, &discard); + } =20 shift64RightJamming(frac, 1 - exp, &frac); if (frac & round_mask) { @@ -985,7 +986,7 @@ static FloatParts addsub_floats(FloatParts a, FloatPart= s b, bool subtract, a.cls =3D float_class_zero; a.sign =3D s->float_rounding_mode =3D=3D float_round_down; } else { - int shift =3D clz64(a.frac) - 1; + int shift =3D clz64(a.frac); a.frac =3D a.frac << shift; a.exp =3D a.exp - shift; a.sign =3D a_sign; @@ -1022,9 +1023,10 @@ static FloatParts addsub_floats(FloatParts a, FloatP= arts b, bool subtract, shift64RightJamming(a.frac, b.exp - a.exp, &a.frac); a.exp =3D b.exp; } - a.frac +=3D b.frac; - if (a.frac & DECOMPOSED_OVERFLOW_BIT) { + + if (uadd64_overflow(a.frac, b.frac, &a.frac)) { shift64RightJamming(a.frac, 1, &a.frac); + a.frac |=3D DECOMPOSED_IMPLICIT_BIT; a.exp +=3D 1; } return a; @@ -1219,16 +1221,17 @@ static FloatParts mul_floats(FloatParts a, FloatPar= ts b, float_status *s) int exp =3D a.exp + b.exp; =20 mul64To128(a.frac, b.frac, &hi, &lo); - shift128RightJamming(hi, lo, DECOMPOSED_BINARY_POINT, &hi, &lo); - if (lo & DECOMPOSED_OVERFLOW_BIT) { - shift64RightJamming(lo, 1, &lo); + if (hi & DECOMPOSED_IMPLICIT_BIT) { exp +=3D 1; + } else { + hi <<=3D 1; } + hi |=3D (lo !=3D 0); =20 /* Re-use a */ a.exp =3D exp; a.sign =3D sign; - a.frac =3D lo; + a.frac =3D hi; return a; } /* handle all the NaN cases */ @@ -1411,56 +1414,41 @@ static FloatParts muladd_floats(FloatParts a, Float= Parts b, FloatParts c, =20 p_exp =3D a.exp + b.exp; =20 - /* Multiply of 2 62-bit numbers produces a (2*62) =3D=3D 124-bit - * result. - */ mul64To128(a.frac, b.frac, &hi, &lo); - /* binary point now at bit 124 */ =20 - /* check for overflow */ - if (hi & (1ULL << (DECOMPOSED_BINARY_POINT * 2 + 1 - 64))) { - shift128RightJamming(hi, lo, 1, &hi, &lo); + /* Renormalize to the msb. */ + if (hi & DECOMPOSED_IMPLICIT_BIT) { p_exp +=3D 1; + } else { + shortShift128Left(hi, lo, 1, &hi, &lo); } =20 /* + add/sub */ - if (c.cls =3D=3D float_class_zero) { - /* move binary point back to 62 */ - shift128RightJamming(hi, lo, DECOMPOSED_BINARY_POINT, &hi, &lo); - } else { + if (c.cls !=3D float_class_zero) { int exp_diff =3D p_exp - c.exp; if (p_sign =3D=3D c.sign) { /* Addition */ if (exp_diff <=3D 0) { - shift128RightJamming(hi, lo, - DECOMPOSED_BINARY_POINT - exp_diff, - &hi, &lo); - lo +=3D c.frac; + shift64RightJamming(hi, -exp_diff, &hi); p_exp =3D c.exp; + if (uadd64_overflow(hi, c.frac, &hi)) { + shift64RightJamming(hi, 1, &hi); + hi |=3D DECOMPOSED_IMPLICIT_BIT; + p_exp +=3D 1; + } } else { - uint64_t c_hi, c_lo; - /* shift c to the same binary point as the product (124) */ - c_hi =3D c.frac >> 2; - c_lo =3D 0; - shift128RightJamming(c_hi, c_lo, - exp_diff, - &c_hi, &c_lo); - add128(hi, lo, c_hi, c_lo, &hi, &lo); - /* move binary point back to 62 */ - shift128RightJamming(hi, lo, DECOMPOSED_BINARY_POINT, &hi,= &lo); + uint64_t c_hi, c_lo, over; + shift128RightJamming(c.frac, 0, exp_diff, &c_hi, &c_lo); + add192(0, hi, lo, 0, c_hi, c_lo, &over, &hi, &lo); + if (over) { + shift64RightJamming(hi, 1, &hi); + hi |=3D DECOMPOSED_IMPLICIT_BIT; + p_exp +=3D 1; + } } - - if (lo & DECOMPOSED_OVERFLOW_BIT) { - shift64RightJamming(lo, 1, &lo); - p_exp +=3D 1; - } - } else { /* Subtraction */ - uint64_t c_hi, c_lo; - /* make C binary point match product at bit 124 */ - c_hi =3D c.frac >> 2; - c_lo =3D 0; + uint64_t c_hi =3D c.frac, c_lo =3D 0; =20 if (exp_diff <=3D 0) { shift128RightJamming(hi, lo, -exp_diff, &hi, &lo); @@ -1495,20 +1483,15 @@ static FloatParts muladd_floats(FloatParts a, Float= Parts b, FloatParts c, /* Normalizing to a binary point of 124 is the correct adjust for the exponent. However since we're shifting, we might as well put the binary point back - at 62 where we really want it. Therefore shift as + at 63 where we really want it. Therefore shift as if we're leaving 1 bit at the top of the word, but adjust the exponent as if we're leaving 3 bits. */ - shift -=3D 1; - if (shift >=3D 64) { - lo =3D lo << (shift - 64); - } else { - hi =3D (hi << shift) | (lo >> (64 - shift)); - lo =3D hi | ((lo << shift) !=3D 0); - } - p_exp -=3D shift - 2; + shift128Left(hi, lo, shift, &hi, &lo); + p_exp -=3D shift; } } } + hi |=3D (lo !=3D 0); =20 if (flags & float_muladd_halve_result) { p_exp -=3D 1; @@ -1518,7 +1501,7 @@ static FloatParts muladd_floats(FloatParts a, FloatPa= rts b, FloatParts c, a.cls =3D float_class_normal; a.sign =3D p_sign ^ sign_flip; a.exp =3D p_exp; - a.frac =3D lo; + a.frac =3D hi; =20 return a; } @@ -1742,25 +1725,17 @@ static FloatParts div_floats(FloatParts a, FloatPar= ts b, float_status *s) * exponent to match. * * The udiv_qrnnd algorithm that we're using requires normalizatio= n, - * i.e. the msb of the denominator must be set. Since we know that - * DECOMPOSED_BINARY_POINT is msb-1, the inputs must be shifted le= ft - * by one (more), and the remainder must be shifted right by one. + * i.e. the msb of the denominator must be set, which is already t= rue. */ if (a.frac < b.frac) { exp -=3D 1; - shift128Left(0, a.frac, DECOMPOSED_BINARY_POINT + 2, &n1, &n0); - } else { shift128Left(0, a.frac, DECOMPOSED_BINARY_POINT + 1, &n1, &n0); + } else { + shift128Left(0, a.frac, DECOMPOSED_BINARY_POINT, &n1, &n0); } - q =3D udiv_qrnnd(&r, n1, n0, b.frac << 1); + q =3D udiv_qrnnd(&r, n1, n0, b.frac); =20 - /* - * Set lsb if there is a remainder, to set inexact. - * As mentioned above, to find the actual value of the remainder we - * would need to shift right, but (1) we are only concerned about - * non-zero-ness, and (2) the remainder will always be even because - * both inputs to the division primitive are even. - */ + /* Set lsb if there is a remainder, to set inexact. */ a.frac =3D q | (r !=3D 0); a.sign =3D sign; a.exp =3D exp; @@ -2135,12 +2110,12 @@ static FloatParts round_to_int(FloatParts a, FloatR= oundMode rmode, =20 if (a.frac & rnd_mask) { s->float_exception_flags |=3D float_flag_inexact; - a.frac +=3D inc; - a.frac &=3D ~rnd_mask; - if (a.frac & DECOMPOSED_OVERFLOW_BIT) { + if (uadd64_overflow(a.frac, inc, &a.frac)) { a.frac >>=3D 1; + a.frac |=3D DECOMPOSED_IMPLICIT_BIT; a.exp++; } + a.frac &=3D ~rnd_mask; } } break; @@ -2213,10 +2188,8 @@ static int64_t round_to_int_and_pack(FloatParts in, = FloatRoundMode rmode, case float_class_zero: return 0; case float_class_normal: - if (p.exp < DECOMPOSED_BINARY_POINT) { + if (p.exp <=3D DECOMPOSED_BINARY_POINT) { r =3D p.frac >> (DECOMPOSED_BINARY_POINT - p.exp); - } else if (p.exp - DECOMPOSED_BINARY_POINT < 2) { - r =3D p.frac << (p.exp - DECOMPOSED_BINARY_POINT); } else { r =3D UINT64_MAX; } @@ -2498,10 +2471,8 @@ static uint64_t round_to_uint_and_pack(FloatParts in= , FloatRoundMode rmode, return 0; } =20 - if (p.exp < DECOMPOSED_BINARY_POINT) { + if (p.exp <=3D DECOMPOSED_BINARY_POINT) { r =3D p.frac >> (DECOMPOSED_BINARY_POINT - p.exp); - } else if (p.exp - DECOMPOSED_BINARY_POINT < 2) { - r =3D p.frac << (p.exp - DECOMPOSED_BINARY_POINT); } else { s->float_exception_flags =3D orig_flags | float_flag_invalid; return max; @@ -2765,11 +2736,11 @@ static FloatParts int_to_float(int64_t a, int scale= , float_status *status) f =3D -f; r.sign =3D true; } - shift =3D clz64(f) - 1; + shift =3D clz64(f); scale =3D MIN(MAX(scale, -0x10000), 0x10000); =20 r.exp =3D DECOMPOSED_BINARY_POINT - shift + scale; - r.frac =3D (shift < 0 ? DECOMPOSED_IMPLICIT_BIT : f << shift); + r.frac =3D f << shift; } =20 return r; @@ -2920,21 +2891,16 @@ bfloat16 int16_to_bfloat16(int16_t a, float_status = *status) static FloatParts uint_to_float(uint64_t a, int scale, float_status *statu= s) { FloatParts r =3D { .sign =3D false }; + int shift; =20 if (a =3D=3D 0) { r.cls =3D float_class_zero; } else { scale =3D MIN(MAX(scale, -0x10000), 0x10000); + shift =3D clz64(a); r.cls =3D float_class_normal; - if ((int64_t)a < 0) { - r.exp =3D DECOMPOSED_BINARY_POINT + 1 + scale; - shift64RightJamming(a, 1, &a); - r.frac =3D a; - } else { - int shift =3D clz64(a) - 1; - r.exp =3D DECOMPOSED_BINARY_POINT - shift + scale; - r.frac =3D a << shift; - } + r.exp =3D DECOMPOSED_BINARY_POINT - shift + scale; + r.frac =3D a << shift; } =20 return r; @@ -3475,12 +3441,9 @@ static FloatParts sqrt_float(FloatParts a, float_sta= tus *s, const FloatFmt *p) /* We need two overflow bits at the top. Adding room for that is a * right shift. If the exponent is odd, we can discard the low bit * by multiplying the fraction by 2; that's a left shift. Combine - * those and we shift right if the exponent is even. + * those and we shift right by 1 if the exponent is odd, otherwise 2. */ - a_frac =3D a.frac; - if (!(a.exp & 1)) { - a_frac >>=3D 1; - } + a_frac =3D a.frac >> (2 - (a.exp & 1)); a.exp >>=3D 1; =20 /* Bit-by-bit computation of sqrt. */ @@ -3488,10 +3451,10 @@ static FloatParts sqrt_float(FloatParts a, float_st= atus *s, const FloatFmt *p) s_frac =3D 0; =20 /* Iterate from implicit bit down to the 3 extra bits to compute a - * properly rounded result. Remember we've inserted one more bit - * at the top, so these positions are one less. + * properly rounded result. Remember we've inserted two more bits + * at the top, so these positions are two less. */ - bit =3D DECOMPOSED_BINARY_POINT - 1; + bit =3D DECOMPOSED_BINARY_POINT - 2; last_bit =3D MAX(p->frac_shift - 4, 0); do { uint64_t q =3D 1ULL << bit; @@ -3507,7 +3470,7 @@ static FloatParts sqrt_float(FloatParts a, float_stat= us *s, const FloatFmt *p) /* Undo the right shift done above. If there is any remaining * fraction, the result is inexact. Set the sticky bit. */ - a.frac =3D (r_frac << 1) + (a_frac !=3D 0); + a.frac =3D (r_frac << 2) + (a_frac !=3D 0); =20 return a; } --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621168858; cv=none; d=zohomail.com; s=zohoarc; b=j4LoZevXGNkykxQANLFZ3AtiUjY+TsXEQHXBqiNHPrcdzG2Cx/bfI2UGHCNdni0llfPAMyPBI+gHYZVCDKI6lIPqst1M0MPKtngnq5rxXG5rzjmIBY5YubI0o4j6P8fQSoxuQKrU7Mg44xFKKV8N19F1KekNiydi1G7coVPRgZA= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621168858; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=ORTAesgjnoHt5n7pCAJGj1DNtFaoHQTutdablpI0FS8=; b=hn7vJDnCOEsRCXMghjA37UaC7llsX6PI+b0c6XbZp3tXNmF4/sN6D+EwvHCnTMEDzHTSefXCafPI22ZYMbvtQIczGgWp3XEVDA2V0wh6RYERTAFdRlpBm9UhuZdu9m6TRZsIpaxuMb9tsRe5V1pYBIrqymoTh/w6cKd0W8bbTrM= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621168858733862.3152579781092; Sun, 16 May 2021 05:40:58 -0700 (PDT) Received: from localhost ([::1]:37034 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG4n-0007ga-Km for importer@patchew.org; Sun, 16 May 2021 08:40:57 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:42952) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFym-0007Lt-7X for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:45 -0400 Received: from mail-qt1-x836.google.com ([2607:f8b0:4864:20::836]:36531) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyh-0007iz-Ks for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:43 -0400 Received: by mail-qt1-x836.google.com with SMTP id t7so3023936qtn.3 for ; Sun, 16 May 2021 05:34:39 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.38 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=ORTAesgjnoHt5n7pCAJGj1DNtFaoHQTutdablpI0FS8=; b=HzYv8jL0fvOf1NeM0bPe4BcdnGiF9hl9TShsQEm5a7uUmai26sk3M9XgQg1OOK62nq TjACSywMw0XYtr4iWnahQkPRle/+OIVfLHR+z9o+gR/p3z1GQ5A7BvuNlXS1PSGgQz1X NOI/Ei+Ed5FMYPgmYo/4OQ8qOqxPHB5Kk6o2FmGuqmn5n+WjBy/0nXe6uhEkRlqptfhB lQmYumCKQ2WyFRVWgqhy4OlqidqqQAcKqQ1aghXY1f0U4dy3RaTnGGFGWvB7yvemOYlQ A9n+bCZQNRehuDR1IJqlN8ljTr6ZyZE8ZvKrER0pUqf6kC15hLXqP1nZ9Vkc+WeP43TJ ve3Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=ORTAesgjnoHt5n7pCAJGj1DNtFaoHQTutdablpI0FS8=; b=RqzUkASCkU8VIET7ZYCiO+1fneWkJauHj2SjArZInZTOsP3wTF7nXcvn38yJTWdYxA U/NANeamUVFWEVOyM/cODr85h9OvSEJ1JW3qXwvKSLlcTMiAHKntUCPmwaF4xoCrL/Hp DWZ8vFDpw74+eudqndPI20rvpgYo/wp1mUftkXxK2PN0Y8RB/osQZeRWy6nOXHyEi98J cW5veP/C9YKZ9ED4sT9ttIl9+oI3Jzrq7nISapl7iQB0GJ29K4DDwFAW12LFD/IvB30v 09oGECdPj0WTvmxKM4bsU0ikW4M81WCqTrfrYeLXGbczM6K0QmvataEX3fbS37dJsbyA UfHQ== X-Gm-Message-State: AOAM5331qOXqdcYVWDSTR3ZVnpNO2DyygsUl8sm/94Pb6J3h/98qHbYl 4hc+ZNThq2K08V2uOewY6glvST/JZq6aB+wcRAM= X-Google-Smtp-Source: ABdhPJxm0OgoA9TTkTqHY61Qzs6fv3tkltxoyBIPfhJ5moGXmfCt5LrhiHZY4SGarGzB3u1g7EzQMQ== X-Received: by 2002:ac8:5855:: with SMTP id h21mr50480165qth.281.1621168478745; Sun, 16 May 2021 05:34:38 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 07/46] softfloat: Inline float_raise Date: Sun, 16 May 2021 07:33:52 -0500 Message-Id: <20210516123431.718318-8-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::836; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x836.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Reviewed-by: Philippe Mathieu-Daud=C3=A9 Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- include/fpu/softfloat.h | 5 ++++- fpu/softfloat-specialize.c.inc | 12 ------------ 2 files changed, 4 insertions(+), 13 deletions(-) diff --git a/include/fpu/softfloat.h b/include/fpu/softfloat.h index 78ad5ca738..019c2ec66d 100644 --- a/include/fpu/softfloat.h +++ b/include/fpu/softfloat.h @@ -100,7 +100,10 @@ typedef enum { | Routine to raise any or all of the software IEC/IEEE floating-point | exception flags. *-------------------------------------------------------------------------= ---*/ -void float_raise(uint8_t flags, float_status *status); +static inline void float_raise(uint8_t flags, float_status *status) +{ + status->float_exception_flags |=3D flags; +} =20 /*------------------------------------------------------------------------= ---- | If `a' is denormal and we are in flush-to-zero mode then set the diff --git a/fpu/softfloat-specialize.c.inc b/fpu/softfloat-specialize.c.inc index e19809c04b..96ed8c1a26 100644 --- a/fpu/softfloat-specialize.c.inc +++ b/fpu/softfloat-specialize.c.inc @@ -227,18 +227,6 @@ floatx80 floatx80_default_nan(float_status *status) const floatx80 floatx80_infinity =3D make_floatx80_init(floatx80_infinity_high, floatx80_infinity_low); =20 -/*------------------------------------------------------------------------= ---- -| Raises the exceptions specified by `flags'. Floating-point traps can be -| defined here if desired. It is currently not possible for such a trap -| to substitute a result value. If traps are not implemented, this routine -| should be simply `float_exception_flags |=3D flags;'. -*-------------------------------------------------------------------------= ---*/ - -void float_raise(uint8_t flags, float_status *status) -{ - status->float_exception_flags |=3D flags; -} - /*------------------------------------------------------------------------= ---- | Internal canonical NaN format. *-------------------------------------------------------------------------= ---*/ --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621168982; cv=none; d=zohomail.com; s=zohoarc; b=ciP4+jf9RdTWMqF/XiF4tGzIck0Yhr6X2/zuk7N4JuZdbkyYZsomwYBrw5BM0d6j0nEkp4nMV7EQeEzn1SpLWhbo0JjiWvNFhxTC88m0RJPaQlJbVDWSGFZPOKXZ4uJsRGodcGD8Zid6TE237kIHeUVyFfOLGZogVn/WovGtmHY= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621168982; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=h6yGPb1D0TPpeLoEn2DTqwUkL4N32JMarhisyJlcM+Q=; b=MDxIj46QCbVa0x6+v3nBhyiVqkFIF4U/UhoNI04JIh+sd7BQPzG+LiGR7XIHCOVevqZ7+v24eDeFZQupMbo7RHQb6pOnGn7ey6o3CuoEFHRIDH7kre4F5Ww6EpRqafdD80rbvN/60OTP4t/94SPf0XYd6VtUJwmme3ia9Ejh87E= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621168982564435.5930232460553; Sun, 16 May 2021 05:43:02 -0700 (PDT) Received: from localhost ([::1]:45554 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG6n-00051K-C3 for importer@patchew.org; Sun, 16 May 2021 08:43:01 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43006) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFyp-0007NV-Va for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:49 -0400 Received: from mail-qt1-x834.google.com ([2607:f8b0:4864:20::834]:33480) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyi-0007k1-IV for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:47 -0400 Received: by mail-qt1-x834.google.com with SMTP id 1so3064446qtb.0 for ; Sun, 16 May 2021 05:34:40 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.38 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:39 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=h6yGPb1D0TPpeLoEn2DTqwUkL4N32JMarhisyJlcM+Q=; b=v5cI4gmFAumKikxAiKXUjxUp5GopbP9qZSbWIVTVwPyMza77R1kc6kiUHyHveKU4DV LfvVn2XRPNdZ5uQ+CPuLYVGD6OlJxbjQPzir1apyl/qQZ2j/kkPU8PyDIqBKdtWvH7YH LOJZJQ0obtJj2jZLJmGRZH/mPJlndErdW1t39Nw/avd6c0/6kSKMCut03euern6fmVQX MEInajj80fOVYkRZy60uOnJn1ItAjeBKBnnyuD7LXRki/xlvUPbAf84T50TNUCJRWVtp nYI9/UQA4IeXuL+n2f46MsUuAwkhjzDFBEiPXb6OcXdAlS4XoQqa1zVCGqust/fxgHTI /jXg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=h6yGPb1D0TPpeLoEn2DTqwUkL4N32JMarhisyJlcM+Q=; b=GqYK45UBzPXFleF4XaGwGYLYp2yGay8jAotwv4rw13I+4R7N5K3CiKi+2MZH3b7hZ0 VrDkua4ibAzJ2VoF4Ekk86pLghqwos9XsULL/v1cCLQPUQBy/AXvd9try5G8qYonq9lo 076B4baMDbl7Y7Gtbdkdcodg9fBjL7AH4iWQEBPJYTxX0+ftlLsTLu8ri9CepOkZGuON UsCkb3N71eF0Fm4St8+pRXLDfwgKuD6YmRmoSX5Ez5z4F2F5eKuG/px4zMxgGgkP53qZ gZGu98ujaddgLdb1VgLegO3TlpM/zYFPu+n/cTQHmivwBKILnpC4nmvJB23XaHSLXu28 +XuA== X-Gm-Message-State: AOAM530sPMInQkEjTTAQm/Tu9WejqtDqVSIQCPZ7k1uT5mPP4umSDd14 RbSr4/xR8+KnmdqaGopSO8g1uuMdK42NkjXvDAo= X-Google-Smtp-Source: ABdhPJyCOcDNokH9UUo3UGfJtOMzEhXcy09mai1o/s5JJZpbGoDfZigTqwXLf3l62j2xXCbdlFlWxw== X-Received: by 2002:a05:622a:130a:: with SMTP id v10mr38156820qtk.113.1621168479591; Sun, 16 May 2021 05:34:39 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 08/46] softfloat: Use float_raise in more places Date: Sun, 16 May 2021 07:33:53 -0500 Message-Id: <20210516123431.718318-9-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::834; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x834.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) We have been somewhat inconsistent about when to use float_raise and when to or in the bit by hand. Reviewed-by: Philippe Mathieu-Daud=C3=A9 Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- fpu/softfloat.c | 87 +++++++++++++++++++++++++------------------------ 1 file changed, 44 insertions(+), 43 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index cd777743f1..93fe785809 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -132,7 +132,7 @@ this code that are retained. if (unlikely(soft_t ## _is_denormal(*a))) { \ *a =3D soft_t ## _set_sign(soft_t ## _zero, \ soft_t ## _is_neg(*a)); \ - s->float_exception_flags |=3D float_flag_input_denormal; \ + float_raise(float_flag_input_denormal, s); \ } \ } =20 @@ -360,7 +360,7 @@ float32_gen2(float32 xa, float32 xb, float_status *s, =20 ur.h =3D hard(ua.h, ub.h); if (unlikely(f32_is_inf(ur))) { - s->float_exception_flags |=3D float_flag_overflow; + float_raise(float_flag_overflow, s); } else if (unlikely(fabsf(ur.h) <=3D FLT_MIN) && post(ua, ub)) { goto soft; } @@ -391,7 +391,7 @@ float64_gen2(float64 xa, float64 xb, float_status *s, =20 ur.h =3D hard(ua.h, ub.h); if (unlikely(f64_is_inf(ur))) { - s->float_exception_flags |=3D float_flag_overflow; + float_raise(float_flag_overflow, s); } else if (unlikely(fabs(ur.h) <=3D DBL_MIN) && post(ua, ub)) { goto soft; } @@ -880,7 +880,7 @@ static FloatParts return_nan(FloatParts a, float_status= *s) { switch (a.cls) { case float_class_snan: - s->float_exception_flags |=3D float_flag_invalid; + float_raise(float_flag_invalid, s); a =3D parts_silence_nan(a, s); /* fall through */ case float_class_qnan: @@ -898,7 +898,7 @@ static FloatParts return_nan(FloatParts a, float_status= *s) static FloatParts pick_nan(FloatParts a, FloatParts b, float_status *s) { if (is_snan(a.cls) || is_snan(b.cls)) { - s->float_exception_flags |=3D float_flag_invalid; + float_raise(float_flag_invalid, s); } =20 if (s->default_nan_mode) { @@ -922,7 +922,7 @@ static FloatParts pick_nan_muladd(FloatParts a, FloatPa= rts b, FloatParts c, int which; =20 if (is_snan(a.cls) || is_snan(b.cls) || is_snan(c.cls)) { - s->float_exception_flags |=3D float_flag_invalid; + float_raise(float_flag_invalid, s); } =20 which =3D pickNaNMulAdd(a.cls, b.cls, c.cls, inf_zero, s); @@ -1241,7 +1241,7 @@ static FloatParts mul_floats(FloatParts a, FloatParts= b, float_status *s) /* Inf * Zero =3D=3D NaN */ if ((a.cls =3D=3D float_class_inf && b.cls =3D=3D float_class_zero) || (a.cls =3D=3D float_class_zero && b.cls =3D=3D float_class_inf)) { - s->float_exception_flags |=3D float_flag_invalid; + float_raise(float_flag_invalid, s); return parts_default_nan(s); } /* Multiply by 0 or Inf */ @@ -1356,6 +1356,7 @@ static FloatParts muladd_floats(FloatParts a, FloatPa= rts b, FloatParts c, } =20 if (inf_zero) { + float_raise(float_flag_invalid, s); s->float_exception_flags |=3D float_flag_invalid; return parts_default_nan(s); } @@ -1380,7 +1381,7 @@ static FloatParts muladd_floats(FloatParts a, FloatPa= rts b, FloatParts c, =20 if (c.cls =3D=3D float_class_inf) { if (p_class =3D=3D float_class_inf && p_sign !=3D c.sign) { - s->float_exception_flags |=3D float_flag_invalid; + float_raise(float_flag_invalid, s); return parts_default_nan(s); } else { a.cls =3D float_class_inf; @@ -1598,7 +1599,7 @@ float32_muladd(float32 xa, float32 xb, float32 xc, in= t flags, float_status *s) ur.h =3D fmaf(ua.h, ub.h, uc.h); =20 if (unlikely(f32_is_inf(ur))) { - s->float_exception_flags |=3D float_flag_overflow; + float_raise(float_flag_overflow, s); } else if (unlikely(fabsf(ur.h) <=3D FLT_MIN)) { ua =3D ua_orig; uc =3D uc_orig; @@ -1669,7 +1670,7 @@ float64_muladd(float64 xa, float64 xb, float64 xc, in= t flags, float_status *s) ur.h =3D fma(ua.h, ub.h, uc.h); =20 if (unlikely(f64_is_inf(ur))) { - s->float_exception_flags |=3D float_flag_overflow; + float_raise(float_flag_overflow, s); } else if (unlikely(fabs(ur.h) <=3D FLT_MIN)) { ua =3D ua_orig; uc =3D uc_orig; @@ -1749,7 +1750,7 @@ static FloatParts div_floats(FloatParts a, FloatParts= b, float_status *s) if (a.cls =3D=3D b.cls && (a.cls =3D=3D float_class_inf || a.cls =3D=3D float_class_zero)) { - s->float_exception_flags |=3D float_flag_invalid; + float_raise(float_flag_invalid, s); return parts_default_nan(s); } /* Inf / x or 0 / x */ @@ -1759,7 +1760,7 @@ static FloatParts div_floats(FloatParts a, FloatParts= b, float_status *s) } /* Div 0 =3D> Inf */ if (b.cls =3D=3D float_class_zero) { - s->float_exception_flags |=3D float_flag_divbyzero; + float_raise(float_flag_divbyzero, s); a.cls =3D float_class_inf; a.sign =3D sign; return a; @@ -1895,7 +1896,7 @@ static FloatParts float_to_float(FloatParts a, const = FloatFmt *dstf, /* There is no NaN in the destination format. Raise Invalid * and return a zero with the sign of the input NaN. */ - s->float_exception_flags |=3D float_flag_invalid; + float_raise(float_flag_invalid, s); a.cls =3D float_class_zero; a.frac =3D 0; a.exp =3D 0; @@ -1905,7 +1906,7 @@ static FloatParts float_to_float(FloatParts a, const = FloatFmt *dstf, /* There is no Inf in the destination format. Raise Invalid * and return the maximum normal with the correct sign. */ - s->float_exception_flags |=3D float_flag_invalid; + float_raise(float_flag_invalid, s); a.cls =3D float_class_normal; a.exp =3D dstf->exp_max; a.frac =3D ((1ull << dstf->frac_size) - 1) << dstf->frac_shift; @@ -1916,7 +1917,7 @@ static FloatParts float_to_float(FloatParts a, const = FloatFmt *dstf, } } else if (is_nan(a.cls)) { if (is_snan(a.cls)) { - s->float_exception_flags |=3D float_flag_invalid; + float_raise(float_flag_invalid, s); a =3D parts_silence_nan(a, s); } if (s->default_nan_mode) { @@ -2048,7 +2049,7 @@ static FloatParts round_to_int(FloatParts a, FloatRou= ndMode rmode, if (a.exp < 0) { bool one; /* all fractional */ - s->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, s); switch (rmode) { case float_round_nearest_even: one =3D a.exp =3D=3D -1 && a.frac > DECOMPOSED_IMPLICIT_BI= T; @@ -2109,7 +2110,7 @@ static FloatParts round_to_int(FloatParts a, FloatRou= ndMode rmode, } =20 if (a.frac & rnd_mask) { - s->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, s); if (uadd64_overflow(a.frac, inc, &a.frac)) { a.frac >>=3D 1; a.frac |=3D DECOMPOSED_IMPLICIT_BIT; @@ -3188,7 +3189,7 @@ static FloatRelation compare_floats(FloatParts a, Flo= atParts b, bool is_quiet, if (!is_quiet || a.cls =3D=3D float_class_snan || b.cls =3D=3D float_class_snan) { - s->float_exception_flags |=3D float_flag_invalid; + float_raise(float_flag_invalid, s); } return float_relation_unordered; } @@ -3429,7 +3430,7 @@ static FloatParts sqrt_float(FloatParts a, float_stat= us *s, const FloatFmt *p) return a; /* sqrt(+-0) =3D +-0 */ } if (a.sign) { - s->float_exception_flags |=3D float_flag_invalid; + float_raise(float_flag_invalid, s); return parts_default_nan(s); } if (a.cls =3D=3D float_class_inf) { @@ -3760,7 +3761,7 @@ static int32_t roundAndPackInt32(bool zSign, uint64_t= absZ, return zSign ? INT32_MIN : INT32_MAX; } if (roundBits) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } return z; =20 @@ -3822,7 +3823,7 @@ static int64_t roundAndPackInt64(bool zSign, uint64_t= absZ0, uint64_t absZ1, return zSign ? INT64_MIN : INT64_MAX; } if (absZ1) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } return z; =20 @@ -3883,7 +3884,7 @@ static int64_t roundAndPackUint64(bool zSign, uint64_= t absZ0, } =20 if (absZ1) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } return absZ0; } @@ -3994,7 +3995,7 @@ static float32 roundAndPackFloat32(bool zSign, int zE= xp, uint32_t zSig, } } if (roundBits) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } zSig =3D ( zSig + roundIncrement )>>7; if (!(roundBits ^ 0x40) && roundNearestEven) { @@ -4150,7 +4151,7 @@ static float64 roundAndPackFloat64(bool zSign, int zE= xp, uint64_t zSig, } } if (roundBits) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } zSig =3D ( zSig + roundIncrement )>>10; if (!(roundBits ^ 0x200) && roundNearestEven) { @@ -4284,7 +4285,7 @@ floatx80 roundAndPackFloatx80(int8_t roundingPrecisio= n, bool zSign, float_raise(float_flag_underflow, status); } if (roundBits) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } zSig0 +=3D roundIncrement; if ( (int64_t) zSig0 < 0 ) zExp =3D 1; @@ -4297,7 +4298,7 @@ floatx80 roundAndPackFloatx80(int8_t roundingPrecisio= n, bool zSign, } } if (roundBits) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } zSig0 +=3D roundIncrement; if ( zSig0 < roundIncrement ) { @@ -4360,7 +4361,7 @@ floatx80 roundAndPackFloatx80(int8_t roundingPrecisio= n, bool zSign, float_raise(float_flag_underflow, status); } if (zSig1) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } switch (roundingMode) { case float_round_nearest_even: @@ -4390,7 +4391,7 @@ floatx80 roundAndPackFloatx80(int8_t roundingPrecisio= n, bool zSign, } } if (zSig1) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } if ( increment ) { ++zSig0; @@ -4667,7 +4668,7 @@ static float128 roundAndPackFloat128(bool zSign, int3= 2_t zExp, } } if (zSig2) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } if ( increment ) { add128( zSig0, zSig1, 0, 1, &zSig0, &zSig1 ); @@ -5405,7 +5406,7 @@ int32_t floatx80_to_int32_round_to_zero(floatx80 a, f= loat_status *status) } else if ( aExp < 0x3FFF ) { if (aExp || aSig) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } return 0; } @@ -5420,7 +5421,7 @@ int32_t floatx80_to_int32_round_to_zero(floatx80 a, f= loat_status *status) return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF; } if ( ( aSig<float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } return z; =20 @@ -5504,13 +5505,13 @@ int64_t floatx80_to_int64_round_to_zero(floatx80 a,= float_status *status) } else if ( aExp < 0x3FFF ) { if (aExp | aSig) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } return 0; } z =3D aSig>>( - shiftCount ); if ( (uint64_t) ( aSig<<( shiftCount & 63 ) ) ) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } if ( aSign ) z =3D - z; return z; @@ -5661,7 +5662,7 @@ floatx80 floatx80_round_to_int(floatx80 a, float_stat= us *status) && ( (uint64_t) ( extractFloatx80Frac( a ) ) =3D=3D 0 ) ) { return a; } - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); aSign =3D extractFloatx80Sign( a ); switch (status->float_rounding_mode) { case float_round_nearest_even: @@ -5728,7 +5729,7 @@ floatx80 floatx80_round_to_int(floatx80 a, float_stat= us *status) z.low =3D UINT64_C(0x8000000000000000); } if (z.low !=3D a.low) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } return z; =20 @@ -6364,7 +6365,7 @@ int32_t float128_to_int32_round_to_zero(float128 a, f= loat_status *status) } else if ( aExp < 0x3FFF ) { if (aExp || aSig0) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } return 0; } @@ -6380,7 +6381,7 @@ int32_t float128_to_int32_round_to_zero(float128 a, f= loat_status *status) return aSign ? INT32_MIN : INT32_MAX; } if ( ( aSig0<float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } return z; =20 @@ -6458,7 +6459,7 @@ int64_t float128_to_int64_round_to_zero(float128 a, f= loat_status *status) if ( ( a.high =3D=3D UINT64_C(0xC03E000000000000) ) && ( aSig1 < UINT64_C(0x0002000000000000) ) ) { if (aSig1) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } } else { @@ -6471,20 +6472,20 @@ int64_t float128_to_int64_round_to_zero(float128 a,= float_status *status) } z =3D ( aSig0<>( ( - shiftCount ) & 63 ) ); if ( (uint64_t) ( aSig1<float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } } else { if ( aExp < 0x3FFF ) { if ( aExp | aSig0 | aSig1 ) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } return 0; } z =3D aSig0>>( - shiftCount ); if ( aSig1 || ( shiftCount && (uint64_t) ( aSig0<<( shiftCount & 63 ) ) = ) ) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } } if ( aSign ) z =3D - z; @@ -6793,7 +6794,7 @@ float128 float128_round_to_int(float128 a, float_stat= us *status) else { if ( aExp < 0x3FFF ) { if ( ( ( (uint64_t) ( a.high<<1 ) ) | a.low ) =3D=3D 0 ) retur= n a; - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); aSign =3D extractFloat128Sign( a ); switch (status->float_rounding_mode) { case float_round_nearest_even: @@ -6867,7 +6868,7 @@ float128 float128_round_to_int(float128 a, float_stat= us *status) z.high &=3D ~ roundBitsMask; } if ( ( z.low !=3D a.low ) || ( z.high !=3D a.high ) ) { - status->float_exception_flags |=3D float_flag_inexact; + float_raise(float_flag_inexact, status); } return z; =20 --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621168855; cv=none; d=zohomail.com; s=zohoarc; b=POmyDrDqadU+WbOGrLV9QjWUInbJfl3OFAfhTCs0Df90qZ2FyFkvxK0ogC0gY1mEXnj/GMvISN1FeaMIx2PUK0VPNZ+sN92y3On0OfcfI2nMtuY3VyAhTdnoQYML4f2fu/5lbGRW6Y2o28O06jkAcjHr92ekn1Tu9qO8Ofz+sHI= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621168855; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=ZKeNDHnMG1Vsy9FW47wdnzGiSOuMJBBVUnKRaVqfH0g=; b=SwzZNWJuf0OEj6YUyItVFmjlPxrMZ0L5689ntiwnvuMUC5zonDh0NNL+YtxnVCFLnuVgwUgmMYScRmKmW0d3unVZeCmePmyBSs4kvVdT/jmXOGkHBZW06Bg28qGdjDOkM9EtbcMgAiB5fbuPWHPMBJ0A5y1Yxso3a+PMsEwT8Tc= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 16211688557968.340443444746597; Sun, 16 May 2021 05:40:55 -0700 (PDT) Received: from localhost ([::1]:36748 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG4k-0007Tj-QD for importer@patchew.org; Sun, 16 May 2021 08:40:54 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:42982) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFyn-0007Mc-AO for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:45 -0400 Received: from mail-qt1-x834.google.com ([2607:f8b0:4864:20::834]:46735) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyj-0007kS-Ah for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:45 -0400 Received: by mail-qt1-x834.google.com with SMTP id m13so2984704qtk.13 for ; Sun, 16 May 2021 05:34:40 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=ZKeNDHnMG1Vsy9FW47wdnzGiSOuMJBBVUnKRaVqfH0g=; b=CucsNG3Iez8kGHjGeVZb0MiqE5kbpjEMOiG5Fl1ol1j2Wr3XnJu0GVmOv9oxg5rV29 OubqA4ea2cHjpM740jF2UUsy5sZ+mlu8UVMtW4BxbpYJe6MPM/jkELFvXqDorazg14i7 jg1HY8GWlvuGcmPGZ2AhrYzvBArkd3vMZMy2Yk0rxxHGNm+3tTuCOs2TsPpfULhKQVw9 pqOoZJGbS7jqHN593fj4cwCBO1gAZi3i1UT8rLaGOJUKLJTXaw50ej9sSvqFdoKTqFxw aCzfGVgPmmI8C9voM6QYk26+HZuxkxHxUwW7D546TSFpvtiqLm1wctrHmBZxk+kUtIiz 57OA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=ZKeNDHnMG1Vsy9FW47wdnzGiSOuMJBBVUnKRaVqfH0g=; b=X6i3r1rfnntjNmk6W7T66iirbMNxIdd5O82gWcEGUnMX1wPrPvjYWl4sSsZngQuLjb xt65EkUbZsNSvy44wlQ53GKDAAHZIac4V1ZNV30Fg9ttcjk+wZYqaEnAwrc8sLlz8jIz mljBxDlP4Hqd+p7jg6/bshTZcn0QEnaVbhONeTd4VsKS1xhuiNLBcKe6c+GSpuObhEKu PDgmIwywtTqgYn2LroeDm9g62PvWUc83m4RNFXHWDH4uI9R7ZEsOD4tVpNnfTM08XnXb ATvOovZoxzVDH+Oi0Dig8Gx0dGzLN36zNB97niPcbtubcIZjOnEKBcuy5GNVMsqxF/Rj Ul/A== X-Gm-Message-State: AOAM5309L9P/L3iE2YWHTr78yh0V7iXS0uXyreGjXvMSqJjFViKfQ0f2 2cj9nDUmpPMY77kfQjEwFUHu5VVLnV7XCsWn3lQ= X-Google-Smtp-Source: ABdhPJyz8L/DQ1ezESf+P4qGaop9LZdfC39XFM1cUrQBKn1o8dnmB8FbCEDalE5ipKrzf/mk9jmLvw== X-Received: by 2002:ac8:1192:: with SMTP id d18mr51191488qtj.253.1621168480540; Sun, 16 May 2021 05:34:40 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 09/46] softfloat: Tidy a * b + inf return Date: Sun, 16 May 2021 07:33:54 -0500 Message-Id: <20210516123431.718318-10-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::834; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x834.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= , =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) No reason to set values in 'a', when we already have float_class_inf in 'c', and can flip that sign. Reviewed-by: Philippe Mathieu-Daud=C3=A9 Reviewed-by: Alex Benn=C3=A9e Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- fpu/softfloat.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 93fe785809..ee4b5073b6 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -1384,9 +1384,8 @@ static FloatParts muladd_floats(FloatParts a, FloatPa= rts b, FloatParts c, float_raise(float_flag_invalid, s); return parts_default_nan(s); } else { - a.cls =3D float_class_inf; - a.sign =3D c.sign ^ sign_flip; - return a; + c.sign ^=3D sign_flip; + return c; } } =20 --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169156; cv=none; d=zohomail.com; s=zohoarc; b=nWNKeuyGztzYuk2Tp0H+uoNhWqTSwCFSBuK3crXtLruLHJYza0Z7pfIuJElyw1QxO6ViaDtlnUsJg/kSjYjDyZs8P5+yM6JAqPbH1St3Q/42qHongufXNbqi2jVvnUW+oAP5QaTyR9OZv2yXAubhSVyI1y1pvQzqRUXLcPsLHIo= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169156; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=J2jECUv0KB/VRaKbNWjXBjsVAbH6ZqCf4a3f43XZat8=; b=dwX3ZLYw+ckTiUbogjuk5UszRchNoVzg5dKOsyMgfk9h3VFC3B05XNDYcTfn1QjRZjFqxAJjWrt8wIlqOj8bMkoLKcmgD3/+l0tQ25lvyg2Ep9cxPsEmbW+QxDoUF4CgZKvhCU+lzB2+6ip/3IfrVb0MHVpqyoJ4dzBgNIp5bO8= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169156435663.2466470654068; Sun, 16 May 2021 05:45:56 -0700 (PDT) Received: from localhost ([::1]:53950 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG9a-0002BI-DN for importer@patchew.org; Sun, 16 May 2021 08:45:54 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43070) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFz0-0007Pz-9d for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:58 -0400 Received: from mail-qk1-x72d.google.com ([2607:f8b0:4864:20::72d]:37607) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyl-0007kz-Ts for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:54 -0400 Received: by mail-qk1-x72d.google.com with SMTP id i67so3308675qkc.4 for ; Sun, 16 May 2021 05:34:42 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=J2jECUv0KB/VRaKbNWjXBjsVAbH6ZqCf4a3f43XZat8=; b=jwCh6rrfJbb1xV5SIS6Sij5OrpTm/g5qdLmso/I/C2kE/DEX7VAEfGHBmORiVbYhUh 5pfiOltwC5sQrQifPv2zejAIhUfETlDYBT3b8OWA+yeJ9SkeEz57KBGr4UVM6A1CWA6N zWZQ1r7UUTQ1kPwFfXnvK6eFlta3opfWVmw2fW+OOloLwl7XN2PA06isxycxH/JsaqxF R5Wo+X20b08hubWE/RG8y886IR/bLEJawu7oXXb7k8qnbhI2h3jbBz0khexP3BRupGIn +NzRSssbCLktewDw1nUCey9bgfqtikz9kD9baI7OuJsPtjgj1WltfOBXJr6jke8FG1Jr RSwg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=J2jECUv0KB/VRaKbNWjXBjsVAbH6ZqCf4a3f43XZat8=; b=VGsvnC2yLw2Qt60LcOgDlSEgnRZX8O5iJz4rWYdOjVvrUneW5Pi9y58Bh3qqKJ9o4V pky03ypAov1WqN54r1kByVZJ81Fxy9WHhV4ySR8gcX3gCFog7+y/VtDJlXzFSfWvSvRW KeyNBAevug/NPJdCxACxfzkf/NugPmbUVK2SaCuafI1KLCKLvfZ0wAbRoCuELYcF1ZZC gYX1BkLWTbxlt+4VWVMLn6A91Lwho827E1zYnaH2vsJrnvFEe/9oYFaSvLJYbGR2IkpO VZ5KZvAZa4M+djEq0yM+ImcNNOWGP7j0Pniasl10231/DAibMWwduvTNJFYMcRFtbavd 4zqw== X-Gm-Message-State: AOAM531pgBHhZT9YT4c5OcgagApqZlIZ4MjwJVGtj6ZzMoJxp7PTe8L7 c0WXy5hE7p/dj7kRPjx7AsUkQJcSRQJMpqjDyzc= X-Google-Smtp-Source: ABdhPJyWrxdR4n2RnESG15IEI+esRIZ/7THg3LCuXZhtCCkdaAkL4IEEPclTvhyKSjXNbFlFqW8Ltg== X-Received: by 2002:a37:7306:: with SMTP id o6mr16495344qkc.38.1621168481391; Sun, 16 May 2021 05:34:41 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 10/46] softfloat: Add float_cmask and constants Date: Sun, 16 May 2021 07:33:55 -0500 Message-Id: <20210516123431.718318-11-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::72d; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x72d.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=unavailable autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Testing more than one class at a time is better done with masks. This reduces the static branch count. Reviewed-by: Alex Benn=C3=A9e Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- fpu/softfloat.c | 30 +++++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index ee4b5073b6..64edb23793 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -469,6 +469,20 @@ typedef enum __attribute__ ((__packed__)) { float_class_snan, } FloatClass; =20 +#define float_cmask(bit) (1u << (bit)) + +enum { + float_cmask_zero =3D float_cmask(float_class_zero), + float_cmask_normal =3D float_cmask(float_class_normal), + float_cmask_inf =3D float_cmask(float_class_inf), + float_cmask_qnan =3D float_cmask(float_class_qnan), + float_cmask_snan =3D float_cmask(float_class_snan), + + float_cmask_infzero =3D float_cmask_zero | float_cmask_inf, + float_cmask_anynan =3D float_cmask_qnan | float_cmask_snan, +}; + + /* Simple helpers for checking if, or what kind of, NaN we have */ static inline __attribute__((unused)) bool is_nan(FloatClass c) { @@ -1338,26 +1352,28 @@ bfloat16 QEMU_FLATTEN bfloat16_mul(bfloat16 a, bflo= at16 b, float_status *status) static FloatParts muladd_floats(FloatParts a, FloatParts b, FloatParts c, int flags, float_status *s) { - bool inf_zero =3D ((1 << a.cls) | (1 << b.cls)) =3D=3D - ((1 << float_class_inf) | (1 << float_class_zero)); - bool p_sign; + bool inf_zero, p_sign; bool sign_flip =3D flags & float_muladd_negate_result; FloatClass p_class; uint64_t hi, lo; int p_exp; + int ab_mask, abc_mask; + + ab_mask =3D float_cmask(a.cls) | float_cmask(b.cls); + abc_mask =3D float_cmask(c.cls) | ab_mask; + inf_zero =3D ab_mask =3D=3D float_cmask_infzero; =20 /* It is implementation-defined whether the cases of (0,inf,qnan) * and (inf,0,qnan) raise InvalidOperation or not (and what QNaN * they return if they do), so we have to hand this information * off to the target-specific pick-a-NaN routine. */ - if (is_nan(a.cls) || is_nan(b.cls) || is_nan(c.cls)) { + if (unlikely(abc_mask & float_cmask_anynan)) { return pick_nan_muladd(a, b, c, inf_zero, s); } =20 if (inf_zero) { float_raise(float_flag_invalid, s); - s->float_exception_flags |=3D float_flag_invalid; return parts_default_nan(s); } =20 @@ -1371,9 +1387,9 @@ static FloatParts muladd_floats(FloatParts a, FloatPa= rts b, FloatParts c, p_sign ^=3D 1; } =20 - if (a.cls =3D=3D float_class_inf || b.cls =3D=3D float_class_inf) { + if (ab_mask & float_cmask_inf) { p_class =3D float_class_inf; - } else if (a.cls =3D=3D float_class_zero || b.cls =3D=3D float_class_z= ero) { + } else if (ab_mask & float_cmask_zero) { p_class =3D float_class_zero; } else { p_class =3D float_class_normal; --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621168977; cv=none; d=zohomail.com; s=zohoarc; b=hb5MW6lORCJT1cK3hEWATu+iSLC+CtFc3S7+CN7j7gP5THwzbF1enEo6k/up0w4XKUfnCF6XR+/I44TBWzqA7LU6DJP4r+W35EPXzSv2/USTmt2aIuxje0J1bNgI/S8HjqCoPmWBmrKZU65JqhzMLuxvS3dgHCC8mzb5Aor2Ddk= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621168977; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=AF+ruYCNDH4UlWvIHqw6UVSO6vQwfwahqfCGjxjM9+Q=; b=SHlhBVw1AbceZPFBOqzIUTixiBqu7kiRTxx2lt+lljqfo+V631V8azt76cJJ3JrFMrmjlScr34cY23j3Pplp6tS32ilPsf4MVG4MHydDYHxsBORiXT/AXSpqXfXdAvBL17QH5ovG3ZPjspznGoAT/e9gPjkazKfEEDAiLeJ51n0= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621168977417886.8328776753132; Sun, 16 May 2021 05:42:57 -0700 (PDT) Received: from localhost ([::1]:45164 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG6i-0004lL-BJ for importer@patchew.org; Sun, 16 May 2021 08:42:56 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43090) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFz1-0007QR-LX for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:00 -0400 Received: from mail-qk1-x733.google.com ([2607:f8b0:4864:20::733]:44628) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyl-0007lO-VK for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:57 -0400 Received: by mail-qk1-x733.google.com with SMTP id a2so3284527qkh.11 for ; Sun, 16 May 2021 05:34:42 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=AF+ruYCNDH4UlWvIHqw6UVSO6vQwfwahqfCGjxjM9+Q=; b=z0jkEucPVfSO0sZKQVX5pZhn5pW0xMqsZprNhtPFV3IQiq/DfCoSjONp9G2aPbjY6G P09WcrlCzvG+fPsAlXazBXxr14gZSe1YeuzFLJXFyyOrA1WTqiSjdllhUHlvgRJBUaWU Mvjcg9BrIUfMKfQXB6TUPloy+0gBmdysBsyEN7Hktdc6fTChQSQGkSH4uHQoWZ4y01Ww NIOgxvXbqYm/mZRxbW5rV84C04e5eo2KAdyL3qpFRPS6wA36/MN7b1owBoJGQkt8yP4O 5ma/t7n43DaY/aTvBAoHce7gRXZ0Kik2WezEBrXIk1rv52TRfi4wDObtR2Aj5dVSyEiG koFA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=AF+ruYCNDH4UlWvIHqw6UVSO6vQwfwahqfCGjxjM9+Q=; b=Meupz0/v4UUHIEZrsMt8wJsO+M4VFYgqmodSrpj253RwP/vdHPrJK183g0tLJelV/v nXiQxCO27cNh5XdTTaJedX059c4CCPqWqXKgkJFXz65DUbsvCPNQzdLGsdWEqBDLesL8 vTKs/FZc3mbrYa13WDCa+uXHIVul7G4Y0QFlREOM1gN67w4/XFeX5JIDtgcF5FH4izJs BGkvt/gEEErpQVgHHxxK5smuANsDrnIzk9h468LGn6UgXW7uIBNpDieuLdktYAeSohVv UpW+EzPs3qNIL6st7b6DtG4J57CTCKPllbOIHk7ir0xAM64ugYlvY0wwYQQDloQ0iCVM dJfg== X-Gm-Message-State: AOAM532VI4g30fJwiEuxwCQEnheDkUK/d0aSRDkBy8l/n6R1pu9QLnlq lmOoK6rbvK1IAGG7iE/LGp8iPnwtg3tGWmoTeyE= X-Google-Smtp-Source: ABdhPJyOLmZSxUg7YbyYbvPjkRkqNEoaMeze5gx/WeHiSbyr5MwlOkLu0xIR3B+YuH1kUobJu08AzQ== X-Received: by 2002:a37:a3d7:: with SMTP id m206mr51286755qke.343.1621168482306; Sun, 16 May 2021 05:34:42 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 11/46] softfloat: Use return_nan in float_to_float Date: Sun, 16 May 2021 07:33:56 -0500 Message-Id: <20210516123431.718318-12-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::733; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x733.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=unavailable autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Reviewed-by: Alex Benn=C3=A9e Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- fpu/softfloat.c | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 64edb23793..b694e38522 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -1931,13 +1931,7 @@ static FloatParts float_to_float(FloatParts a, const= FloatFmt *dstf, break; } } else if (is_nan(a.cls)) { - if (is_snan(a.cls)) { - float_raise(float_flag_invalid, s); - a =3D parts_silence_nan(a, s); - } - if (s->default_nan_mode) { - return parts_default_nan(s); - } + return return_nan(a, s); } return a; } --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169349; cv=none; d=zohomail.com; s=zohoarc; b=QeAaWyz9NjtR7tVnVCL1zLBQVAEG21MvnuwVFgdlQOVqJ36VRaT5pBY3kEAPI7zl+kGXfVbsrTIlsaYlRrXevmQy+Wf95LmHD5bvS7h/+4ecKNG/kPEtXqJ3lDVEnfVr4RuK5Ec3B673czIKtvL3ALNn+NmN5rY6zAnovZ7kTJM= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169349; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=fk8y2yS7knqViGJ3bJXKmDCpU5b8/c3S/Dv6Z84fdLg=; b=ZdnBrbi92xR0+f0qSKcQ+Hx/uhixMOD6NeuIsoRIORvSaMIJpi6/Z7SVDWG7A/dI4ysR8Mx7GwLk2OUGk7NSSQ+R67tIuqUwOLv41aKlh0w3E1E7RMpz5rKSJJItyTevONUw0KiGXoLAVVVuugy7yAj66hC4q05CoQKVSIWR6RE= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169349957609.2396089966587; Sun, 16 May 2021 05:49:09 -0700 (PDT) Received: from localhost ([::1]:33492 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGCi-0007dV-F7 for importer@patchew.org; Sun, 16 May 2021 08:49:08 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43044) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFyw-0007PS-K3 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:56 -0400 Received: from mail-qk1-x72f.google.com ([2607:f8b0:4864:20::72f]:37609) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyl-0007lj-V5 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:50 -0400 Received: by mail-qk1-x72f.google.com with SMTP id i67so3308705qkc.4 for ; Sun, 16 May 2021 05:34:43 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=fk8y2yS7knqViGJ3bJXKmDCpU5b8/c3S/Dv6Z84fdLg=; b=KPt/sMI/b+t6yzUc0Z6fAgmnLdgLSLH2WQP4OLyEu+8yW2KDU7BBFVnO9cSVLqJDhp XlQMvFaf7j9Rx/2YRDsZgOTccIJK7WHsDMOTQ5SAw4ZZmzhbvT9uZNhPHFQQiN0JUtzM u6TNXORYi1Krs/RRQffIZmqKQy738g4dlxt/baz3B7mR/JVHU/y+uP9VkPlTwzD/8MRh At9nN3/Ymh99h3QX9dOtHBmPQdsmQYV6JhfPTytEWkaFF2TT6INL3PH4ZWVigaORAh/0 z4QIR7PfY380uMCujPewl2nGwaGP9aRuottl/TGGD+TfbHufDWWDVTkpem938KzwAuDl lcGg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=fk8y2yS7knqViGJ3bJXKmDCpU5b8/c3S/Dv6Z84fdLg=; b=lAJ8ckdZF0pwciO0ZOJC1bhw4Z52ObZtIFIuo4q04Af6OAKF0TbWyW8w6hwpnH+iyu fvYFxnTzUmun61bLObcXDAuQZ70YNRs6dxKFVAXbsNp7hfB6NMNj2Cqtx7mS26vQav/Q 07hS3U6XvdlvY9KDTCvypbWpkviRhCVZHKHZ+H5sL9gNFLFpPG1OTrRIHVoFA+/+a9EL xxgT2E89EiXEvfflX2F9BiPs4nHWGflhWz+Aw4myKwhYrVAL4oVx/X0T8Psq54fcLYmd sWnuaURxvvh7FDib7F6QlDCcEeef+2zMC7OlTUlW4OyBXoTXq6sMsGt7iDM5YE+AqTyr UcnQ== X-Gm-Message-State: AOAM533Ouv8Rky+3ZASTSbIN5uT2XJb/xrM0TOTFTIuNYH60UIxYPICX fih6EqdQkIdvllGnLeHxy/LXlQ5k1f0zYMeb5E8= X-Google-Smtp-Source: ABdhPJzQpN7nTxTCjm+7pFocExzbio9L5ITjPdiEY03Dq99QO9dSJ5NQERPNWEgxpMhZ1kkYkP2JZQ== X-Received: by 2002:a37:a0c9:: with SMTP id j192mr39305170qke.19.1621168483096; Sun, 16 May 2021 05:34:43 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 12/46] softfloat: fix return_nan vs default_nan_mode Date: Sun, 16 May 2021 07:33:57 -0500 Message-Id: <20210516123431.718318-13-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::72f; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x72f.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Do not call parts_silence_nan when default_nan_mode is in effect. This will avoid an assert in a later patch. Reviewed-by: Alex Benn=C3=A9e Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- fpu/softfloat.c | 19 +++++++------------ 1 file changed, 7 insertions(+), 12 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index b694e38522..6589f00b23 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -892,21 +892,16 @@ static float64 float64_round_pack_canonical(FloatPart= s p, float_status *s) =20 static FloatParts return_nan(FloatParts a, float_status *s) { - switch (a.cls) { - case float_class_snan: + g_assert(is_nan(a.cls)); + if (is_snan(a.cls)) { float_raise(float_flag_invalid, s); - a =3D parts_silence_nan(a, s); - /* fall through */ - case float_class_qnan: - if (s->default_nan_mode) { - return parts_default_nan(s); + if (!s->default_nan_mode) { + return parts_silence_nan(a, s); } - break; - - default: - g_assert_not_reached(); + } else if (!s->default_nan_mode) { + return a; } - return a; + return parts_default_nan(s); } =20 static FloatParts pick_nan(FloatParts a, FloatParts b, float_status *s) --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169585; cv=none; d=zohomail.com; s=zohoarc; b=S7/KT4NnH7iOs3GZmUiJj437CEQfmDAO1VmVBJ8FEdRqdevwBtHDEnwe03zUDmJKfHtR2T491etUFWjz87lq6tnDlAispZZxShAykifb+Sw+C8jxSkGqYXD5Kgt01A09B+wQW2VF2O4aI+JPg+htLmUfYaYLxvyHwr04LWPH4Dw= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169585; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=h+0x8Nk29/SnfgdnKuRZIh8yPkErRHPxcHfxg3QL/Gg=; b=dj+36+6nku6TPg2BDWi/0ANd83M0vEdvK+HV+LLvK7+ksH3v3ARU2hBy3nk04gTj3coGiEFTWS0HWTQphaBi/uCtTJX22t2ReK0jHzGbgC5GWLq5NYYmL7gK3xiD4KYnpFiCS5N4MIg1JzxbUi2txFkGrIvNBfeJH8YmYcWyCig= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169585596327.8525961828525; Sun, 16 May 2021 05:53:05 -0700 (PDT) Received: from localhost ([::1]:41988 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGGW-0005A9-8g for importer@patchew.org; Sun, 16 May 2021 08:53:04 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43142) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFz2-0007Qf-K9 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:03 -0400 Received: from mail-qk1-x731.google.com ([2607:f8b0:4864:20::731]:34439) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFym-0007lr-WB for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:59 -0400 Received: by mail-qk1-x731.google.com with SMTP id v8so3337092qkv.1 for ; Sun, 16 May 2021 05:34:44 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:43 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=h+0x8Nk29/SnfgdnKuRZIh8yPkErRHPxcHfxg3QL/Gg=; b=LPA5YcKgUCh9zKjzuuyyWY6g3BKz9NwEm4lR8lNfqCzbzkFzACdu9yN9Ckx3UhadrJ 2T8oRVbfqPwz8ytg1+Fvsq0WdTWJDb78gydq1S0bMT9CDDFIeksKZxF6s0dw/WtopgqX Oxsz+VDvzcW/VzT0LYPoTrLCwBEwPQXS1dwLnjLDGt2+cXsLMFQfXdwIYrrpnzrj0qDc CzhQbfXG2i8WMNjFyVAZ3wcKgHUCQKPZxrHi2u4SQ4BS0oB6oMGeKxNv3HkbmXGA60b6 xSujSmBiaBeJjURf+S0YsyvEi0vjC2vfAEh+IIuT/qpWA2IR/wAqX286CO9j9AqUth7L hJng== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=h+0x8Nk29/SnfgdnKuRZIh8yPkErRHPxcHfxg3QL/Gg=; b=obIvsJtF5xlIWiPkPZT2bZXqfCV6BypUX+8lTBSItN0YJizDpDYOXb1g1dSKEzC5QA WfJbJdfWqHvYrf879AzWBbJM+k1IiiehrfxN5zlVx4BYvGeABs3+vmtkowCxMKiv6BM5 OntLqBnHFKPer5YHX6HQsx9qgDBjFd68Xxr5QAfHAxdhUwfIi74vb7PIGGjwuNalT/C/ QgrYIgkOHpGA1X20xhCmJkImD7gwOQwdfDVYmzePchi8ROjGibJ9VU4pWWwLueXXuQrm djBmEpxe8Lca3NLzxqBQmgMCDUTVe0hDhpkOPZ4l+ZmfdLAzAlijnGaMP+LK9qK+kxBf 2JAw== X-Gm-Message-State: AOAM532nq+pFFsbJDGkuyK/hAdUxOZhk6vuWneVOY0H0R924A1BRq4fs bYNpIdcUeW0CDQg7LIJe2LFmw5jyBAnZXnK3t6I= X-Google-Smtp-Source: ABdhPJylEd+zFPEI65Hoijdt+Ws7cRp/unlSDH2UZgGDD6bBrjMNU4IQZJAb7cwfp1nwNTbwDV9Ihw== X-Received: by 2002:a37:e10b:: with SMTP id c11mr51712383qkm.152.1621168483854; Sun, 16 May 2021 05:34:43 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 13/46] target/mips: Set set_default_nan_mode with set_snan_bit_is_one Date: Sun, 16 May 2021 07:33:58 -0500 Message-Id: <20210516123431.718318-14-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::731; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x731.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) This behavior is currently hard-coded in parts_silence_nan, but setting this bit properly will allow this to be cleaned up. Reviewed-by: Alex Benn=C3=A9e Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- target/mips/fpu_helper.h | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/target/mips/fpu_helper.h b/target/mips/fpu_helper.h index 1c2d6d35a7..ad1116e8c1 100644 --- a/target/mips/fpu_helper.h +++ b/target/mips/fpu_helper.h @@ -27,8 +27,14 @@ static inline void restore_flush_mode(CPUMIPSState *env) =20 static inline void restore_snan_bit_mode(CPUMIPSState *env) { - set_snan_bit_is_one((env->active_fpu.fcr31 & (1 << FCR31_NAN2008)) =3D= =3D 0, - &env->active_fpu.fp_status); + bool nan2008 =3D env->active_fpu.fcr31 & (1 << FCR31_NAN2008); + + /* + * With nan2008, SNaNs are silenced in the usual way. + * Before that, SNaNs are not silenced; default nans are produced. + */ + set_snan_bit_is_one(!nan2008, &env->active_fpu.fp_status); + set_default_nan_mode(!nan2008, &env->active_fpu.fp_status); } =20 static inline void restore_fp_status(CPUMIPSState *env) --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169363; cv=none; d=zohomail.com; s=zohoarc; b=lFPjfCqMlsd8nb0pvTA019x+x1SG35N/IJIYPb31dSzZ3J+mTTedTEEjkIDrcWLdrYf6WSDJYdz1cuoFAt9hCG+JMD0JsXsr6dLWzNK3QVyP8EIGXNo0YqaztnJmqIpxdhepIqFy70/Qb+RZVDGRERFDkuQUvk7CP67MgGhfWcE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169363; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=qvtL26lQB5H4Yj/m9dMuiJ0Pgz43KUosPXD7aZnzb8Q=; b=V/UdY1oAwIwMUEW0eMoHPiLL1X7bMhsB3XKntoRVaoPeqqk1e/vUkxXzyPwnDF/JOQA0OMIYf4U6V38X4kmdHNviZ/VW9FvZ3EzLalDNmkCqv9NAsfUa8WFL23pMWdzZ2cTOk1vYx7LzQfOWI0Ikw4IwUzQCP0LR2fXKJbKM9iQ= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169363795768.9629325849469; Sun, 16 May 2021 05:49:23 -0700 (PDT) Received: from localhost ([::1]:34156 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGCw-00087u-Io for importer@patchew.org; Sun, 16 May 2021 08:49:22 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43086) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFz1-0007QQ-L6 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:00 -0400 Received: from mail-qk1-x72e.google.com ([2607:f8b0:4864:20::72e]:39751) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyn-0007m1-RT for qemu-devel@nongnu.org; Sun, 16 May 2021 08:34:58 -0400 Received: by mail-qk1-x72e.google.com with SMTP id k127so3306122qkc.6 for ; Sun, 16 May 2021 05:34:45 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=qvtL26lQB5H4Yj/m9dMuiJ0Pgz43KUosPXD7aZnzb8Q=; b=yqZMmentklELMI4XI5PBS46S380dHIIH0ogJd194nWQn3Yrm6/8jBV95zRQKvuWNDR oz+aeRqVTjMXMequiCGLYVmWvOtcSOlsJxd6kNb6DIvueIk+2axMhTdzO1UiBqfGiAGa PHX2AIDfGteHY0Z6Y1EObvICkWkgv4H+HBErmvaIwYF1xwLOQd789UeMHCiYgYaKoYB4 26Gxmly6/EyFpa8rPNI6RbHbXR9SkQlXyfXR7tbGgE0budY/bY7FGI+FlW0a3nqTWMCf r+z+gH0vwtRxBkJdgr/J1iMnbaBo5vwoM2KWHILN/R8SMoH/EdtJ0qbSvPyZbCqfN1Ak /7XQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=qvtL26lQB5H4Yj/m9dMuiJ0Pgz43KUosPXD7aZnzb8Q=; b=pqx8wVI53D/JiQmEPlK6AieHgNP1zP50O6eSiFkleAE1qFO0929sR1C7IeliY0/vML drdxXCEERJ9tkm14m9wSIAXarD4pmHmniiFaPPepj0KqDmtn87HUDz5gaPH8P4tPYMQ1 BBDJ0f7rHEn7+R5zO/c+2jNTLkqZeKN/uQO79/mtWymkq7WpigvPhL7PXY8OYnMQgXoh 3kwgu+Gzs4iDRB4JOEi73iSiBX69fkNtefZz98mM5JkeKvQ+PCIe2ExElwBfs8Eidm4+ UsZ6j6XSKI31FlicGN9ZWNPYxDdOh9hQ4s+4A23FrppnsIWKH5Et1cRhWTUoCJ9njBYP Vv5A== X-Gm-Message-State: AOAM533RUixt9jsPE+Huar0uCqTbUmAyFepef9DhDJGqF6psn5uQMWUR HLqwMHa3SIzc4BvKkUuaF3ypunmRJdgX3+Pejos= X-Google-Smtp-Source: ABdhPJxW3PkKiWyBXBxG6cWyQYqG/m9QX3ubL3D5NTwhkk/RQMtAQZbqMaG+evZsTo/JK8WcyTgNjw== X-Received: by 2002:a37:5ca:: with SMTP id 193mr51326402qkf.356.1621168484648; Sun, 16 May 2021 05:34:44 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 14/46] softfloat: Do not produce a default_nan from parts_silence_nan Date: Sun, 16 May 2021 07:33:59 -0500 Message-Id: <20210516123431.718318-15-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::72e; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x72e.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=unavailable autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Require default_nan_mode to be set instead. Reviewed-by: Alex Benn=C3=A9e Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- fpu/softfloat-specialize.c.inc | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/fpu/softfloat-specialize.c.inc b/fpu/softfloat-specialize.c.inc index 96ed8c1a26..05cb2ee940 100644 --- a/fpu/softfloat-specialize.c.inc +++ b/fpu/softfloat-specialize.c.inc @@ -179,16 +179,15 @@ static FloatParts parts_default_nan(float_status *sta= tus) static FloatParts parts_silence_nan(FloatParts a, float_status *status) { g_assert(!no_signaling_nans(status)); -#if defined(TARGET_HPPA) - a.frac &=3D ~(1ULL << (DECOMPOSED_BINARY_POINT - 1)); - a.frac |=3D 1ULL << (DECOMPOSED_BINARY_POINT - 2); -#else + g_assert(!status->default_nan_mode); + + /* The only snan_bit_is_one target without default_nan_mode is HPPA. */ if (snan_bit_is_one(status)) { - return parts_default_nan(status); + a.frac &=3D ~(1ULL << (DECOMPOSED_BINARY_POINT - 1)); + a.frac |=3D 1ULL << (DECOMPOSED_BINARY_POINT - 2); } else { a.frac |=3D 1ULL << (DECOMPOSED_BINARY_POINT - 1); } -#endif a.cls =3D float_class_qnan; return a; } --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169157; cv=none; d=zohomail.com; s=zohoarc; b=OgLftl6o1sP4Zr47++KKtefn/7A3zI98Eiqr3abV2Brtl/fNvx63vtSXRGk+9eZSTjH7yu9tZG3ydInuMytPDXHlgMf00jKXak5vINzRSIOhcBnctixri4BzYYLSsBVt+CDyICoxCy5HkL0lqXNVbTYSRZtLSMBUv+9/jZPnHbg= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169157; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=V0es/wDFZUURqqgFenpijBwZxOvb4b3Yd6l1jCzQvFc=; b=Wl5qBvi6juZHB8DNiI7bAQt+0zTzRzmbE59/AqJT2Qk1hfn8GKVPNrDGED+HSPzk/2w5PJRnUdxCbcqFWO6Tx4N/ek4VJm1QvbqBWgEynQHzLdX2HtBgi6TT1q9e73/P37FPMSC/+j3BXg3iGoGv3D2L1Oc8H2t1KqQ9jAPb75s= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169157797104.42328867523338; Sun, 16 May 2021 05:45:57 -0700 (PDT) Received: from localhost ([::1]:53884 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG9b-00028k-Ds for importer@patchew.org; Sun, 16 May 2021 08:45:55 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43198) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFz7-0007Sy-L2 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:05 -0400 Received: from mail-qk1-x730.google.com ([2607:f8b0:4864:20::730]:39753) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyp-0007mJ-Nz for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:05 -0400 Received: by mail-qk1-x730.google.com with SMTP id k127so3306147qkc.6 for ; Sun, 16 May 2021 05:34:46 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=V0es/wDFZUURqqgFenpijBwZxOvb4b3Yd6l1jCzQvFc=; b=LX22CzMNe8c7jgp4Yh5wwAtMg3wRyqmKLaPgYTCQ6MtvFC+PxgpJrWbAKSKBE/b1gv eTS5Fm7PzVkKc7Sd1NgpOZlqYI2u3evyr9XG8kCcApmttDJIt0AkeMxDpZeIInYRaRzP 4Gbc+S4z0XuhBBa8lF0xdpVHoOcAFe/kdb3Rr0g2oZUJywc7lu0sW+V3mcVSTxnCJtV4 RZ3EoErr+sNmqHZLpCWvGRRgtundoz+cpFIyMnSnqbgG3LKU/AtoOZw0Z0sTLeHh8y2J V5fPyAHte334DeCfdbskoUWzmYCAUcp2xJcAR/zxdkPN6jwXZjMXrV7sypTrFoF7sTL1 DuFg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=V0es/wDFZUURqqgFenpijBwZxOvb4b3Yd6l1jCzQvFc=; b=Yb2UktEsl+SsLQpvu1VaY6713PoTEvnBqe9oTThr4Mu3s4zauRUsFpU4J+wrGobqSK SEG/zmsARhngosmWE+ptnJ2LKPCnNOTMymxXC948ygn43NNwzZs8VFOZx+xbZNzLDwwq Gk8wtH6J55GOGCwricWvbrCbukoOpOtXIViWcnOsoTxlHEuAzDgZ8LP1Egqobfl/OF7+ vkr9FshbV/T1aF9xXGaGgEJ01T+7psakL4bJJLsVcULNeXH6dd1JSrKVNsAa5BAog8I2 3HuCoRFwtm9T+A1xUQCtgKxYyub7N6ZvfxDWQJYvgzbKyzf4AWHHqVaGtQ7yY2eiXFPY utVQ== X-Gm-Message-State: AOAM531VEjAPGSc2f+JoPcHbAvuUmHdlGhs/+unDvcClIVsewFrseFil lv3/gnDlWLC8DlIx8mniZ8a19ugOooKiSVfVARc= X-Google-Smtp-Source: ABdhPJwBbqK7qvGJwUXvDZ79RUJ5uCaNz5En0pHAsiHSshSDpJShsUJPz64kHSnyBP/M+YHZWO8hnQ== X-Received: by 2002:a05:620a:cf6:: with SMTP id c22mr52057266qkj.123.1621168485693; Sun, 16 May 2021 05:34:45 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 15/46] softfloat: Rename FloatParts to FloatParts64 Date: Sun, 16 May 2021 07:34:00 -0500 Message-Id: <20210516123431.718318-16-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::730; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x730.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Reviewed-by: Philippe Mathieu-Daud=C3=A9 Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- fpu/softfloat.c | 362 ++++++++++++++++----------------- fpu/softfloat-specialize.c.inc | 6 +- 2 files changed, 184 insertions(+), 184 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 6589f00b23..27b51659c9 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -515,7 +515,7 @@ typedef struct { int32_t exp; FloatClass cls; bool sign; -} FloatParts; +} FloatParts64; =20 #define DECOMPOSED_BINARY_POINT 63 #define DECOMPOSED_IMPLICIT_BIT (1ull << DECOMPOSED_BINARY_POINT) @@ -580,11 +580,11 @@ static const FloatFmt float64_params =3D { }; =20 /* Unpack a float to parts, but do not canonicalize. */ -static inline FloatParts unpack_raw(FloatFmt fmt, uint64_t raw) +static inline FloatParts64 unpack_raw(FloatFmt fmt, uint64_t raw) { const int sign_pos =3D fmt.frac_size + fmt.exp_size; =20 - return (FloatParts) { + return (FloatParts64) { .cls =3D float_class_unclassified, .sign =3D extract64(raw, sign_pos, 1), .exp =3D extract64(raw, fmt.frac_size, fmt.exp_size), @@ -592,50 +592,50 @@ static inline FloatParts unpack_raw(FloatFmt fmt, uin= t64_t raw) }; } =20 -static inline FloatParts float16_unpack_raw(float16 f) +static inline FloatParts64 float16_unpack_raw(float16 f) { return unpack_raw(float16_params, f); } =20 -static inline FloatParts bfloat16_unpack_raw(bfloat16 f) +static inline FloatParts64 bfloat16_unpack_raw(bfloat16 f) { return unpack_raw(bfloat16_params, f); } =20 -static inline FloatParts float32_unpack_raw(float32 f) +static inline FloatParts64 float32_unpack_raw(float32 f) { return unpack_raw(float32_params, f); } =20 -static inline FloatParts float64_unpack_raw(float64 f) +static inline FloatParts64 float64_unpack_raw(float64 f) { return unpack_raw(float64_params, f); } =20 /* Pack a float from parts, but do not canonicalize. */ -static inline uint64_t pack_raw(FloatFmt fmt, FloatParts p) +static inline uint64_t pack_raw(FloatFmt fmt, FloatParts64 p) { const int sign_pos =3D fmt.frac_size + fmt.exp_size; uint64_t ret =3D deposit64(p.frac, fmt.frac_size, fmt.exp_size, p.exp); return deposit64(ret, sign_pos, 1, p.sign); } =20 -static inline float16 float16_pack_raw(FloatParts p) +static inline float16 float16_pack_raw(FloatParts64 p) { return make_float16(pack_raw(float16_params, p)); } =20 -static inline bfloat16 bfloat16_pack_raw(FloatParts p) +static inline bfloat16 bfloat16_pack_raw(FloatParts64 p) { return pack_raw(bfloat16_params, p); } =20 -static inline float32 float32_pack_raw(FloatParts p) +static inline float32 float32_pack_raw(FloatParts64 p) { return make_float32(pack_raw(float32_params, p)); } =20 -static inline float64 float64_pack_raw(FloatParts p) +static inline float64 float64_pack_raw(FloatParts64 p) { return make_float64(pack_raw(float64_params, p)); } @@ -651,7 +651,7 @@ static inline float64 float64_pack_raw(FloatParts p) #include "softfloat-specialize.c.inc" =20 /* Canonicalize EXP and FRAC, setting CLS. */ -static FloatParts sf_canonicalize(FloatParts part, const FloatFmt *parm, +static FloatParts64 sf_canonicalize(FloatParts64 part, const FloatFmt *par= m, float_status *status) { if (part.exp =3D=3D parm->exp_max && !parm->arm_althp) { @@ -689,7 +689,7 @@ static FloatParts sf_canonicalize(FloatParts part, cons= t FloatFmt *parm, * by EXP_BIAS and must be bounded by [EXP_MAX-1, 0]. */ =20 -static FloatParts round_canonical(FloatParts p, float_status *s, +static FloatParts64 round_canonical(FloatParts64 p, float_status *s, const FloatFmt *parm) { const uint64_t frac_lsb =3D parm->frac_lsb; @@ -838,59 +838,59 @@ static FloatParts round_canonical(FloatParts p, float= _status *s, } =20 /* Explicit FloatFmt version */ -static FloatParts float16a_unpack_canonical(float16 f, float_status *s, +static FloatParts64 float16a_unpack_canonical(float16 f, float_status *s, const FloatFmt *params) { return sf_canonicalize(float16_unpack_raw(f), params, s); } =20 -static FloatParts float16_unpack_canonical(float16 f, float_status *s) +static FloatParts64 float16_unpack_canonical(float16 f, float_status *s) { return float16a_unpack_canonical(f, s, &float16_params); } =20 -static FloatParts bfloat16_unpack_canonical(bfloat16 f, float_status *s) +static FloatParts64 bfloat16_unpack_canonical(bfloat16 f, float_status *s) { return sf_canonicalize(bfloat16_unpack_raw(f), &bfloat16_params, s); } =20 -static float16 float16a_round_pack_canonical(FloatParts p, float_status *s, +static float16 float16a_round_pack_canonical(FloatParts64 p, float_status = *s, const FloatFmt *params) { return float16_pack_raw(round_canonical(p, s, params)); } =20 -static float16 float16_round_pack_canonical(FloatParts p, float_status *s) +static float16 float16_round_pack_canonical(FloatParts64 p, float_status *= s) { return float16a_round_pack_canonical(p, s, &float16_params); } =20 -static bfloat16 bfloat16_round_pack_canonical(FloatParts p, float_status *= s) +static bfloat16 bfloat16_round_pack_canonical(FloatParts64 p, float_status= *s) { return bfloat16_pack_raw(round_canonical(p, s, &bfloat16_params)); } =20 -static FloatParts float32_unpack_canonical(float32 f, float_status *s) +static FloatParts64 float32_unpack_canonical(float32 f, float_status *s) { return sf_canonicalize(float32_unpack_raw(f), &float32_params, s); } =20 -static float32 float32_round_pack_canonical(FloatParts p, float_status *s) +static float32 float32_round_pack_canonical(FloatParts64 p, float_status *= s) { return float32_pack_raw(round_canonical(p, s, &float32_params)); } =20 -static FloatParts float64_unpack_canonical(float64 f, float_status *s) +static FloatParts64 float64_unpack_canonical(float64 f, float_status *s) { return sf_canonicalize(float64_unpack_raw(f), &float64_params, s); } =20 -static float64 float64_round_pack_canonical(FloatParts p, float_status *s) +static float64 float64_round_pack_canonical(FloatParts64 p, float_status *= s) { return float64_pack_raw(round_canonical(p, s, &float64_params)); } =20 -static FloatParts return_nan(FloatParts a, float_status *s) +static FloatParts64 return_nan(FloatParts64 a, float_status *s) { g_assert(is_nan(a.cls)); if (is_snan(a.cls)) { @@ -904,7 +904,7 @@ static FloatParts return_nan(FloatParts a, float_status= *s) return parts_default_nan(s); } =20 -static FloatParts pick_nan(FloatParts a, FloatParts b, float_status *s) +static FloatParts64 pick_nan(FloatParts64 a, FloatParts64 b, float_status = *s) { if (is_snan(a.cls) || is_snan(b.cls)) { float_raise(float_flag_invalid, s); @@ -925,7 +925,7 @@ static FloatParts pick_nan(FloatParts a, FloatParts b, = float_status *s) return a; } =20 -static FloatParts pick_nan_muladd(FloatParts a, FloatParts b, FloatParts c, +static FloatParts64 pick_nan_muladd(FloatParts64 a, FloatParts64 b, FloatP= arts64 c, bool inf_zero, float_status *s) { int which; @@ -971,7 +971,7 @@ static FloatParts pick_nan_muladd(FloatParts a, FloatPa= rts b, FloatParts c, * Arithmetic. */ =20 -static FloatParts addsub_floats(FloatParts a, FloatParts b, bool subtract, +static FloatParts64 addsub_floats(FloatParts64 a, FloatParts64 b, bool sub= tract, float_status *s) { bool a_sign =3D a.sign; @@ -1062,18 +1062,18 @@ static FloatParts addsub_floats(FloatParts a, Float= Parts b, bool subtract, =20 float16 QEMU_FLATTEN float16_add(float16 a, float16 b, float_status *statu= s) { - FloatParts pa =3D float16_unpack_canonical(a, status); - FloatParts pb =3D float16_unpack_canonical(b, status); - FloatParts pr =3D addsub_floats(pa, pb, false, status); + FloatParts64 pa =3D float16_unpack_canonical(a, status); + FloatParts64 pb =3D float16_unpack_canonical(b, status); + FloatParts64 pr =3D addsub_floats(pa, pb, false, status); =20 return float16_round_pack_canonical(pr, status); } =20 float16 QEMU_FLATTEN float16_sub(float16 a, float16 b, float_status *statu= s) { - FloatParts pa =3D float16_unpack_canonical(a, status); - FloatParts pb =3D float16_unpack_canonical(b, status); - FloatParts pr =3D addsub_floats(pa, pb, true, status); + FloatParts64 pa =3D float16_unpack_canonical(a, status); + FloatParts64 pb =3D float16_unpack_canonical(b, status); + FloatParts64 pr =3D addsub_floats(pa, pb, true, status); =20 return float16_round_pack_canonical(pr, status); } @@ -1081,9 +1081,9 @@ float16 QEMU_FLATTEN float16_sub(float16 a, float16 b= , float_status *status) static float32 QEMU_SOFTFLOAT_ATTR soft_f32_addsub(float32 a, float32 b, bool subtract, float_status *status) { - FloatParts pa =3D float32_unpack_canonical(a, status); - FloatParts pb =3D float32_unpack_canonical(b, status); - FloatParts pr =3D addsub_floats(pa, pb, subtract, status); + FloatParts64 pa =3D float32_unpack_canonical(a, status); + FloatParts64 pb =3D float32_unpack_canonical(b, status); + FloatParts64 pr =3D addsub_floats(pa, pb, subtract, status); =20 return float32_round_pack_canonical(pr, status); } @@ -1101,9 +1101,9 @@ static inline float32 soft_f32_sub(float32 a, float32= b, float_status *status) static float64 QEMU_SOFTFLOAT_ATTR soft_f64_addsub(float64 a, float64 b, bool subtract, float_status *status) { - FloatParts pa =3D float64_unpack_canonical(a, status); - FloatParts pb =3D float64_unpack_canonical(b, status); - FloatParts pr =3D addsub_floats(pa, pb, subtract, status); + FloatParts64 pa =3D float64_unpack_canonical(a, status); + FloatParts64 pb =3D float64_unpack_canonical(b, status); + FloatParts64 pr =3D addsub_floats(pa, pb, subtract, status); =20 return float64_round_pack_canonical(pr, status); } @@ -1199,18 +1199,18 @@ float64_sub(float64 a, float64 b, float_status *s) */ bfloat16 QEMU_FLATTEN bfloat16_add(bfloat16 a, bfloat16 b, float_status *s= tatus) { - FloatParts pa =3D bfloat16_unpack_canonical(a, status); - FloatParts pb =3D bfloat16_unpack_canonical(b, status); - FloatParts pr =3D addsub_floats(pa, pb, false, status); + FloatParts64 pa =3D bfloat16_unpack_canonical(a, status); + FloatParts64 pb =3D bfloat16_unpack_canonical(b, status); + FloatParts64 pr =3D addsub_floats(pa, pb, false, status); =20 return bfloat16_round_pack_canonical(pr, status); } =20 bfloat16 QEMU_FLATTEN bfloat16_sub(bfloat16 a, bfloat16 b, float_status *s= tatus) { - FloatParts pa =3D bfloat16_unpack_canonical(a, status); - FloatParts pb =3D bfloat16_unpack_canonical(b, status); - FloatParts pr =3D addsub_floats(pa, pb, true, status); + FloatParts64 pa =3D bfloat16_unpack_canonical(a, status); + FloatParts64 pb =3D bfloat16_unpack_canonical(b, status); + FloatParts64 pr =3D addsub_floats(pa, pb, true, status); =20 return bfloat16_round_pack_canonical(pr, status); } @@ -1221,7 +1221,7 @@ bfloat16 QEMU_FLATTEN bfloat16_sub(bfloat16 a, bfloat= 16 b, float_status *status) * for Binary Floating-Point Arithmetic. */ =20 -static FloatParts mul_floats(FloatParts a, FloatParts b, float_status *s) +static FloatParts64 mul_floats(FloatParts64 a, FloatParts64 b, float_statu= s *s) { bool sign =3D a.sign ^ b.sign; =20 @@ -1267,9 +1267,9 @@ static FloatParts mul_floats(FloatParts a, FloatParts= b, float_status *s) =20 float16 QEMU_FLATTEN float16_mul(float16 a, float16 b, float_status *statu= s) { - FloatParts pa =3D float16_unpack_canonical(a, status); - FloatParts pb =3D float16_unpack_canonical(b, status); - FloatParts pr =3D mul_floats(pa, pb, status); + FloatParts64 pa =3D float16_unpack_canonical(a, status); + FloatParts64 pb =3D float16_unpack_canonical(b, status); + FloatParts64 pr =3D mul_floats(pa, pb, status); =20 return float16_round_pack_canonical(pr, status); } @@ -1277,9 +1277,9 @@ float16 QEMU_FLATTEN float16_mul(float16 a, float16 b= , float_status *status) static float32 QEMU_SOFTFLOAT_ATTR soft_f32_mul(float32 a, float32 b, float_status *status) { - FloatParts pa =3D float32_unpack_canonical(a, status); - FloatParts pb =3D float32_unpack_canonical(b, status); - FloatParts pr =3D mul_floats(pa, pb, status); + FloatParts64 pa =3D float32_unpack_canonical(a, status); + FloatParts64 pb =3D float32_unpack_canonical(b, status); + FloatParts64 pr =3D mul_floats(pa, pb, status); =20 return float32_round_pack_canonical(pr, status); } @@ -1287,9 +1287,9 @@ soft_f32_mul(float32 a, float32 b, float_status *stat= us) static float64 QEMU_SOFTFLOAT_ATTR soft_f64_mul(float64 a, float64 b, float_status *status) { - FloatParts pa =3D float64_unpack_canonical(a, status); - FloatParts pb =3D float64_unpack_canonical(b, status); - FloatParts pr =3D mul_floats(pa, pb, status); + FloatParts64 pa =3D float64_unpack_canonical(a, status); + FloatParts64 pb =3D float64_unpack_canonical(b, status); + FloatParts64 pr =3D mul_floats(pa, pb, status); =20 return float64_round_pack_canonical(pr, status); } @@ -1325,9 +1325,9 @@ float64_mul(float64 a, float64 b, float_status *s) =20 bfloat16 QEMU_FLATTEN bfloat16_mul(bfloat16 a, bfloat16 b, float_status *s= tatus) { - FloatParts pa =3D bfloat16_unpack_canonical(a, status); - FloatParts pb =3D bfloat16_unpack_canonical(b, status); - FloatParts pr =3D mul_floats(pa, pb, status); + FloatParts64 pa =3D bfloat16_unpack_canonical(a, status); + FloatParts64 pb =3D bfloat16_unpack_canonical(b, status); + FloatParts64 pr =3D mul_floats(pa, pb, status); =20 return bfloat16_round_pack_canonical(pr, status); } @@ -1344,7 +1344,7 @@ bfloat16 QEMU_FLATTEN bfloat16_mul(bfloat16 a, bfloat= 16 b, float_status *status) * NaNs.) */ =20 -static FloatParts muladd_floats(FloatParts a, FloatParts b, FloatParts c, +static FloatParts64 muladd_floats(FloatParts64 a, FloatParts64 b, FloatPar= ts64 c, int flags, float_status *s) { bool inf_zero, p_sign; @@ -1520,10 +1520,10 @@ static FloatParts muladd_floats(FloatParts a, Float= Parts b, FloatParts c, float16 QEMU_FLATTEN float16_muladd(float16 a, float16 b, float16 c, int flags, float_status *s= tatus) { - FloatParts pa =3D float16_unpack_canonical(a, status); - FloatParts pb =3D float16_unpack_canonical(b, status); - FloatParts pc =3D float16_unpack_canonical(c, status); - FloatParts pr =3D muladd_floats(pa, pb, pc, flags, status); + FloatParts64 pa =3D float16_unpack_canonical(a, status); + FloatParts64 pb =3D float16_unpack_canonical(b, status); + FloatParts64 pc =3D float16_unpack_canonical(c, status); + FloatParts64 pr =3D muladd_floats(pa, pb, pc, flags, status); =20 return float16_round_pack_canonical(pr, status); } @@ -1532,10 +1532,10 @@ static float32 QEMU_SOFTFLOAT_ATTR soft_f32_muladd(float32 a, float32 b, float32 c, int flags, float_status *status) { - FloatParts pa =3D float32_unpack_canonical(a, status); - FloatParts pb =3D float32_unpack_canonical(b, status); - FloatParts pc =3D float32_unpack_canonical(c, status); - FloatParts pr =3D muladd_floats(pa, pb, pc, flags, status); + FloatParts64 pa =3D float32_unpack_canonical(a, status); + FloatParts64 pb =3D float32_unpack_canonical(b, status); + FloatParts64 pc =3D float32_unpack_canonical(c, status); + FloatParts64 pr =3D muladd_floats(pa, pb, pc, flags, status); =20 return float32_round_pack_canonical(pr, status); } @@ -1544,10 +1544,10 @@ static float64 QEMU_SOFTFLOAT_ATTR soft_f64_muladd(float64 a, float64 b, float64 c, int flags, float_status *status) { - FloatParts pa =3D float64_unpack_canonical(a, status); - FloatParts pb =3D float64_unpack_canonical(b, status); - FloatParts pc =3D float64_unpack_canonical(c, status); - FloatParts pr =3D muladd_floats(pa, pb, pc, flags, status); + FloatParts64 pa =3D float64_unpack_canonical(a, status); + FloatParts64 pb =3D float64_unpack_canonical(b, status); + FloatParts64 pc =3D float64_unpack_canonical(c, status); + FloatParts64 pr =3D muladd_floats(pa, pb, pc, flags, status); =20 return float64_round_pack_canonical(pr, status); } @@ -1705,10 +1705,10 @@ float64_muladd(float64 xa, float64 xb, float64 xc, = int flags, float_status *s) bfloat16 QEMU_FLATTEN bfloat16_muladd(bfloat16 a, bfloat16 b, bfloat16 c, int flags, float_status *status) { - FloatParts pa =3D bfloat16_unpack_canonical(a, status); - FloatParts pb =3D bfloat16_unpack_canonical(b, status); - FloatParts pc =3D bfloat16_unpack_canonical(c, status); - FloatParts pr =3D muladd_floats(pa, pb, pc, flags, status); + FloatParts64 pa =3D bfloat16_unpack_canonical(a, status); + FloatParts64 pb =3D bfloat16_unpack_canonical(b, status); + FloatParts64 pc =3D bfloat16_unpack_canonical(c, status); + FloatParts64 pr =3D muladd_floats(pa, pb, pc, flags, status); =20 return bfloat16_round_pack_canonical(pr, status); } @@ -1719,7 +1719,7 @@ bfloat16 QEMU_FLATTEN bfloat16_muladd(bfloat16 a, bfl= oat16 b, bfloat16 c, * the IEC/IEEE Standard for Binary Floating-Point Arithmetic. */ =20 -static FloatParts div_floats(FloatParts a, FloatParts b, float_status *s) +static FloatParts64 div_floats(FloatParts64 a, FloatParts64 b, float_statu= s *s) { bool sign =3D a.sign ^ b.sign; =20 @@ -1786,9 +1786,9 @@ static FloatParts div_floats(FloatParts a, FloatParts= b, float_status *s) =20 float16 float16_div(float16 a, float16 b, float_status *status) { - FloatParts pa =3D float16_unpack_canonical(a, status); - FloatParts pb =3D float16_unpack_canonical(b, status); - FloatParts pr =3D div_floats(pa, pb, status); + FloatParts64 pa =3D float16_unpack_canonical(a, status); + FloatParts64 pb =3D float16_unpack_canonical(b, status); + FloatParts64 pr =3D div_floats(pa, pb, status); =20 return float16_round_pack_canonical(pr, status); } @@ -1796,9 +1796,9 @@ float16 float16_div(float16 a, float16 b, float_statu= s *status) static float32 QEMU_SOFTFLOAT_ATTR soft_f32_div(float32 a, float32 b, float_status *status) { - FloatParts pa =3D float32_unpack_canonical(a, status); - FloatParts pb =3D float32_unpack_canonical(b, status); - FloatParts pr =3D div_floats(pa, pb, status); + FloatParts64 pa =3D float32_unpack_canonical(a, status); + FloatParts64 pb =3D float32_unpack_canonical(b, status); + FloatParts64 pr =3D div_floats(pa, pb, status); =20 return float32_round_pack_canonical(pr, status); } @@ -1806,9 +1806,9 @@ soft_f32_div(float32 a, float32 b, float_status *stat= us) static float64 QEMU_SOFTFLOAT_ATTR soft_f64_div(float64 a, float64 b, float_status *status) { - FloatParts pa =3D float64_unpack_canonical(a, status); - FloatParts pb =3D float64_unpack_canonical(b, status); - FloatParts pr =3D div_floats(pa, pb, status); + FloatParts64 pa =3D float64_unpack_canonical(a, status); + FloatParts64 pb =3D float64_unpack_canonical(b, status); + FloatParts64 pr =3D div_floats(pa, pb, status); =20 return float64_round_pack_canonical(pr, status); } @@ -1878,9 +1878,9 @@ float64_div(float64 a, float64 b, float_status *s) =20 bfloat16 bfloat16_div(bfloat16 a, bfloat16 b, float_status *status) { - FloatParts pa =3D bfloat16_unpack_canonical(a, status); - FloatParts pb =3D bfloat16_unpack_canonical(b, status); - FloatParts pr =3D div_floats(pa, pb, status); + FloatParts64 pa =3D bfloat16_unpack_canonical(a, status); + FloatParts64 pb =3D bfloat16_unpack_canonical(b, status); + FloatParts64 pr =3D div_floats(pa, pb, status); =20 return bfloat16_round_pack_canonical(pr, status); } @@ -1896,7 +1896,7 @@ bfloat16 bfloat16_div(bfloat16 a, bfloat16 b, float_s= tatus *status) * invalid exceptions and handling the conversion on NaNs. */ =20 -static FloatParts float_to_float(FloatParts a, const FloatFmt *dstf, +static FloatParts64 float_to_float(FloatParts64 a, const FloatFmt *dstf, float_status *s) { if (dstf->arm_althp) { @@ -1934,32 +1934,32 @@ static FloatParts float_to_float(FloatParts a, cons= t FloatFmt *dstf, float32 float16_to_float32(float16 a, bool ieee, float_status *s) { const FloatFmt *fmt16 =3D ieee ? &float16_params : &float16_params_ahp; - FloatParts p =3D float16a_unpack_canonical(a, s, fmt16); - FloatParts pr =3D float_to_float(p, &float32_params, s); + FloatParts64 p =3D float16a_unpack_canonical(a, s, fmt16); + FloatParts64 pr =3D float_to_float(p, &float32_params, s); return float32_round_pack_canonical(pr, s); } =20 float64 float16_to_float64(float16 a, bool ieee, float_status *s) { const FloatFmt *fmt16 =3D ieee ? &float16_params : &float16_params_ahp; - FloatParts p =3D float16a_unpack_canonical(a, s, fmt16); - FloatParts pr =3D float_to_float(p, &float64_params, s); + FloatParts64 p =3D float16a_unpack_canonical(a, s, fmt16); + FloatParts64 pr =3D float_to_float(p, &float64_params, s); return float64_round_pack_canonical(pr, s); } =20 float16 float32_to_float16(float32 a, bool ieee, float_status *s) { const FloatFmt *fmt16 =3D ieee ? &float16_params : &float16_params_ahp; - FloatParts p =3D float32_unpack_canonical(a, s); - FloatParts pr =3D float_to_float(p, fmt16, s); + FloatParts64 p =3D float32_unpack_canonical(a, s); + FloatParts64 pr =3D float_to_float(p, fmt16, s); return float16a_round_pack_canonical(pr, s, fmt16); } =20 static float64 QEMU_SOFTFLOAT_ATTR soft_float32_to_float64(float32 a, float_status *s) { - FloatParts p =3D float32_unpack_canonical(a, s); - FloatParts pr =3D float_to_float(p, &float64_params, s); + FloatParts64 p =3D float32_unpack_canonical(a, s); + FloatParts64 pr =3D float_to_float(p, &float64_params, s); return float64_round_pack_canonical(pr, s); } =20 @@ -1982,43 +1982,43 @@ float64 float32_to_float64(float32 a, float_status = *s) float16 float64_to_float16(float64 a, bool ieee, float_status *s) { const FloatFmt *fmt16 =3D ieee ? &float16_params : &float16_params_ahp; - FloatParts p =3D float64_unpack_canonical(a, s); - FloatParts pr =3D float_to_float(p, fmt16, s); + FloatParts64 p =3D float64_unpack_canonical(a, s); + FloatParts64 pr =3D float_to_float(p, fmt16, s); return float16a_round_pack_canonical(pr, s, fmt16); } =20 float32 float64_to_float32(float64 a, float_status *s) { - FloatParts p =3D float64_unpack_canonical(a, s); - FloatParts pr =3D float_to_float(p, &float32_params, s); + FloatParts64 p =3D float64_unpack_canonical(a, s); + FloatParts64 pr =3D float_to_float(p, &float32_params, s); return float32_round_pack_canonical(pr, s); } =20 float32 bfloat16_to_float32(bfloat16 a, float_status *s) { - FloatParts p =3D bfloat16_unpack_canonical(a, s); - FloatParts pr =3D float_to_float(p, &float32_params, s); + FloatParts64 p =3D bfloat16_unpack_canonical(a, s); + FloatParts64 pr =3D float_to_float(p, &float32_params, s); return float32_round_pack_canonical(pr, s); } =20 float64 bfloat16_to_float64(bfloat16 a, float_status *s) { - FloatParts p =3D bfloat16_unpack_canonical(a, s); - FloatParts pr =3D float_to_float(p, &float64_params, s); + FloatParts64 p =3D bfloat16_unpack_canonical(a, s); + FloatParts64 pr =3D float_to_float(p, &float64_params, s); return float64_round_pack_canonical(pr, s); } =20 bfloat16 float32_to_bfloat16(float32 a, float_status *s) { - FloatParts p =3D float32_unpack_canonical(a, s); - FloatParts pr =3D float_to_float(p, &bfloat16_params, s); + FloatParts64 p =3D float32_unpack_canonical(a, s); + FloatParts64 pr =3D float_to_float(p, &bfloat16_params, s); return bfloat16_round_pack_canonical(pr, s); } =20 bfloat16 float64_to_bfloat16(float64 a, float_status *s) { - FloatParts p =3D float64_unpack_canonical(a, s); - FloatParts pr =3D float_to_float(p, &bfloat16_params, s); + FloatParts64 p =3D float64_unpack_canonical(a, s); + FloatParts64 pr =3D float_to_float(p, &bfloat16_params, s); return bfloat16_round_pack_canonical(pr, s); } =20 @@ -2029,7 +2029,7 @@ bfloat16 float64_to_bfloat16(float64 a, float_status = *s) * Arithmetic. */ =20 -static FloatParts round_to_int(FloatParts a, FloatRoundMode rmode, +static FloatParts64 round_to_int(FloatParts64 a, FloatRoundMode rmode, int scale, float_status *s) { switch (a.cls) { @@ -2132,22 +2132,22 @@ static FloatParts round_to_int(FloatParts a, FloatR= oundMode rmode, =20 float16 float16_round_to_int(float16 a, float_status *s) { - FloatParts pa =3D float16_unpack_canonical(a, s); - FloatParts pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); + FloatParts64 pa =3D float16_unpack_canonical(a, s); + FloatParts64 pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); return float16_round_pack_canonical(pr, s); } =20 float32 float32_round_to_int(float32 a, float_status *s) { - FloatParts pa =3D float32_unpack_canonical(a, s); - FloatParts pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); + FloatParts64 pa =3D float32_unpack_canonical(a, s); + FloatParts64 pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); return float32_round_pack_canonical(pr, s); } =20 float64 float64_round_to_int(float64 a, float_status *s) { - FloatParts pa =3D float64_unpack_canonical(a, s); - FloatParts pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); + FloatParts64 pa =3D float64_unpack_canonical(a, s); + FloatParts64 pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); return float64_round_pack_canonical(pr, s); } =20 @@ -2158,8 +2158,8 @@ float64 float64_round_to_int(float64 a, float_status = *s) =20 bfloat16 bfloat16_round_to_int(bfloat16 a, float_status *s) { - FloatParts pa =3D bfloat16_unpack_canonical(a, s); - FloatParts pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); + FloatParts64 pa =3D bfloat16_unpack_canonical(a, s); + FloatParts64 pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); return bfloat16_round_pack_canonical(pr, s); } =20 @@ -2174,13 +2174,13 @@ bfloat16 bfloat16_round_to_int(bfloat16 a, float_st= atus *s) * is returned. */ =20 -static int64_t round_to_int_and_pack(FloatParts in, FloatRoundMode rmode, +static int64_t round_to_int_and_pack(FloatParts64 in, FloatRoundMode rmode, int scale, int64_t min, int64_t max, float_status *s) { uint64_t r; int orig_flags =3D get_float_exception_flags(s); - FloatParts p =3D round_to_int(in, rmode, scale, s); + FloatParts64 p =3D round_to_int(in, rmode, scale, s); =20 switch (p.cls) { case float_class_snan: @@ -2452,12 +2452,12 @@ int64_t bfloat16_to_int64_round_to_zero(bfloat16 a,= float_status *s) * flag. */ =20 -static uint64_t round_to_uint_and_pack(FloatParts in, FloatRoundMode rmode, +static uint64_t round_to_uint_and_pack(FloatParts64 in, FloatRoundMode rmo= de, int scale, uint64_t max, float_status *s) { int orig_flags =3D get_float_exception_flags(s); - FloatParts p =3D round_to_int(in, rmode, scale, s); + FloatParts64 p =3D round_to_int(in, rmode, scale, s); uint64_t r; =20 switch (p.cls) { @@ -2726,9 +2726,9 @@ uint64_t bfloat16_to_uint64_round_to_zero(bfloat16 a,= float_status *s) * to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. */ =20 -static FloatParts int_to_float(int64_t a, int scale, float_status *status) +static FloatParts64 int_to_float(int64_t a, int scale, float_status *statu= s) { - FloatParts r =3D { .sign =3D false }; + FloatParts64 r =3D { .sign =3D false }; =20 if (a =3D=3D 0) { r.cls =3D float_class_zero; @@ -2753,7 +2753,7 @@ static FloatParts int_to_float(int64_t a, int scale, = float_status *status) =20 float16 int64_to_float16_scalbn(int64_t a, int scale, float_status *status) { - FloatParts pa =3D int_to_float(a, scale, status); + FloatParts64 pa =3D int_to_float(a, scale, status); return float16_round_pack_canonical(pa, status); } =20 @@ -2789,7 +2789,7 @@ float16 int8_to_float16(int8_t a, float_status *statu= s) =20 float32 int64_to_float32_scalbn(int64_t a, int scale, float_status *status) { - FloatParts pa =3D int_to_float(a, scale, status); + FloatParts64 pa =3D int_to_float(a, scale, status); return float32_round_pack_canonical(pa, status); } =20 @@ -2820,7 +2820,7 @@ float32 int16_to_float32(int16_t a, float_status *sta= tus) =20 float64 int64_to_float64_scalbn(int64_t a, int scale, float_status *status) { - FloatParts pa =3D int_to_float(a, scale, status); + FloatParts64 pa =3D int_to_float(a, scale, status); return float64_round_pack_canonical(pa, status); } =20 @@ -2856,7 +2856,7 @@ float64 int16_to_float64(int16_t a, float_status *sta= tus) =20 bfloat16 int64_to_bfloat16_scalbn(int64_t a, int scale, float_status *stat= us) { - FloatParts pa =3D int_to_float(a, scale, status); + FloatParts64 pa =3D int_to_float(a, scale, status); return bfloat16_round_pack_canonical(pa, status); } =20 @@ -2893,9 +2893,9 @@ bfloat16 int16_to_bfloat16(int16_t a, float_status *s= tatus) * IEC/IEEE Standard for Binary Floating-Point Arithmetic. */ =20 -static FloatParts uint_to_float(uint64_t a, int scale, float_status *statu= s) +static FloatParts64 uint_to_float(uint64_t a, int scale, float_status *sta= tus) { - FloatParts r =3D { .sign =3D false }; + FloatParts64 r =3D { .sign =3D false }; int shift; =20 if (a =3D=3D 0) { @@ -2913,7 +2913,7 @@ static FloatParts uint_to_float(uint64_t a, int scale= , float_status *status) =20 float16 uint64_to_float16_scalbn(uint64_t a, int scale, float_status *stat= us) { - FloatParts pa =3D uint_to_float(a, scale, status); + FloatParts64 pa =3D uint_to_float(a, scale, status); return float16_round_pack_canonical(pa, status); } =20 @@ -2949,7 +2949,7 @@ float16 uint8_to_float16(uint8_t a, float_status *sta= tus) =20 float32 uint64_to_float32_scalbn(uint64_t a, int scale, float_status *stat= us) { - FloatParts pa =3D uint_to_float(a, scale, status); + FloatParts64 pa =3D uint_to_float(a, scale, status); return float32_round_pack_canonical(pa, status); } =20 @@ -2980,7 +2980,7 @@ float32 uint16_to_float32(uint16_t a, float_status *s= tatus) =20 float64 uint64_to_float64_scalbn(uint64_t a, int scale, float_status *stat= us) { - FloatParts pa =3D uint_to_float(a, scale, status); + FloatParts64 pa =3D uint_to_float(a, scale, status); return float64_round_pack_canonical(pa, status); } =20 @@ -3016,7 +3016,7 @@ float64 uint16_to_float64(uint16_t a, float_status *s= tatus) =20 bfloat16 uint64_to_bfloat16_scalbn(uint64_t a, int scale, float_status *st= atus) { - FloatParts pa =3D uint_to_float(a, scale, status); + FloatParts64 pa =3D uint_to_float(a, scale, status); return bfloat16_round_pack_canonical(pa, status); } =20 @@ -3061,7 +3061,7 @@ bfloat16 uint16_to_bfloat16(uint16_t a, float_status = *status) * minnummag() and maxnummag() functions correspond to minNumMag() * and minNumMag() from the IEEE-754 2008. */ -static FloatParts minmax_floats(FloatParts a, FloatParts b, bool ismin, +static FloatParts64 minmax_floats(FloatParts64 a, FloatParts64 b, bool ism= in, bool ieee, bool ismag, float_status *s) { if (unlikely(is_nan(a.cls) || is_nan(b.cls))) { @@ -3136,9 +3136,9 @@ static FloatParts minmax_floats(FloatParts a, FloatPa= rts b, bool ismin, float ## sz float ## sz ## _ ## name(float ## sz a, float ## sz b, \ float_status *s) \ { \ - FloatParts pa =3D float ## sz ## _unpack_canonical(a, s); \ - FloatParts pb =3D float ## sz ## _unpack_canonical(b, s); \ - FloatParts pr =3D minmax_floats(pa, pb, ismin, isiee, ismag, s); \ + FloatParts64 pa =3D float ## sz ## _unpack_canonical(a, s); = \ + FloatParts64 pb =3D float ## sz ## _unpack_canonical(b, s); = \ + FloatParts64 pr =3D minmax_floats(pa, pb, ismin, isiee, ismag, s); = \ \ return float ## sz ## _round_pack_canonical(pr, s); \ } @@ -3169,9 +3169,9 @@ MINMAX(64, maxnummag, false, true, true) #define BF16_MINMAX(name, ismin, isiee, ismag) \ bfloat16 bfloat16_ ## name(bfloat16 a, bfloat16 b, float_status *s) \ { \ - FloatParts pa =3D bfloat16_unpack_canonical(a, s); \ - FloatParts pb =3D bfloat16_unpack_canonical(b, s); \ - FloatParts pr =3D minmax_floats(pa, pb, ismin, isiee, ismag, s); \ + FloatParts64 pa =3D bfloat16_unpack_canonical(a, s); = \ + FloatParts64 pb =3D bfloat16_unpack_canonical(b, s); = \ + FloatParts64 pr =3D minmax_floats(pa, pb, ismin, isiee, ismag, s); = \ \ return bfloat16_round_pack_canonical(pr, s); \ } @@ -3186,7 +3186,7 @@ BF16_MINMAX(maxnummag, false, true, true) #undef BF16_MINMAX =20 /* Floating point compare */ -static FloatRelation compare_floats(FloatParts a, FloatParts b, bool is_qu= iet, +static FloatRelation compare_floats(FloatParts64 a, FloatParts64 b, bool i= s_quiet, float_status *s) { if (is_nan(a.cls) || is_nan(b.cls)) { @@ -3247,8 +3247,8 @@ static FloatRelation compare_floats(FloatParts a, Flo= atParts b, bool is_quiet, static int attr \ name(float ## sz a, float ## sz b, bool is_quiet, float_status *s) \ { \ - FloatParts pa =3D float ## sz ## _unpack_canonical(a, s); \ - FloatParts pb =3D float ## sz ## _unpack_canonical(b, s); \ + FloatParts64 pa =3D float ## sz ## _unpack_canonical(a, s); = \ + FloatParts64 pb =3D float ## sz ## _unpack_canonical(b, s); = \ return compare_floats(pa, pb, is_quiet, s); \ } =20 @@ -3349,8 +3349,8 @@ FloatRelation float64_compare_quiet(float64 a, float6= 4 b, float_status *s) static FloatRelation QEMU_FLATTEN soft_bf16_compare(bfloat16 a, bfloat16 b, bool is_quiet, float_status *s) { - FloatParts pa =3D bfloat16_unpack_canonical(a, s); - FloatParts pb =3D bfloat16_unpack_canonical(b, s); + FloatParts64 pa =3D bfloat16_unpack_canonical(a, s); + FloatParts64 pb =3D bfloat16_unpack_canonical(b, s); return compare_floats(pa, pb, is_quiet, s); } =20 @@ -3365,16 +3365,16 @@ FloatRelation bfloat16_compare_quiet(bfloat16 a, bf= loat16 b, float_status *s) } =20 /* Multiply A by 2 raised to the power N. */ -static FloatParts scalbn_decomposed(FloatParts a, int n, float_status *s) +static FloatParts64 scalbn_decomposed(FloatParts64 a, int n, float_status = *s) { if (unlikely(is_nan(a.cls))) { return return_nan(a, s); } if (a.cls =3D=3D float_class_normal) { - /* The largest float type (even though not supported by FloatParts) + /* The largest float type (even though not supported by FloatParts= 64) * is float128, which has a 15 bit exponent. Bounding N to 16 bits * still allows rounding to infinity, without allowing overflow - * within the int32_t that backs FloatParts.exp. + * within the int32_t that backs FloatParts64.exp. */ n =3D MIN(MAX(n, -0x10000), 0x10000); a.exp +=3D n; @@ -3384,29 +3384,29 @@ static FloatParts scalbn_decomposed(FloatParts a, i= nt n, float_status *s) =20 float16 float16_scalbn(float16 a, int n, float_status *status) { - FloatParts pa =3D float16_unpack_canonical(a, status); - FloatParts pr =3D scalbn_decomposed(pa, n, status); + FloatParts64 pa =3D float16_unpack_canonical(a, status); + FloatParts64 pr =3D scalbn_decomposed(pa, n, status); return float16_round_pack_canonical(pr, status); } =20 float32 float32_scalbn(float32 a, int n, float_status *status) { - FloatParts pa =3D float32_unpack_canonical(a, status); - FloatParts pr =3D scalbn_decomposed(pa, n, status); + FloatParts64 pa =3D float32_unpack_canonical(a, status); + FloatParts64 pr =3D scalbn_decomposed(pa, n, status); return float32_round_pack_canonical(pr, status); } =20 float64 float64_scalbn(float64 a, int n, float_status *status) { - FloatParts pa =3D float64_unpack_canonical(a, status); - FloatParts pr =3D scalbn_decomposed(pa, n, status); + FloatParts64 pa =3D float64_unpack_canonical(a, status); + FloatParts64 pr =3D scalbn_decomposed(pa, n, status); return float64_round_pack_canonical(pr, status); } =20 bfloat16 bfloat16_scalbn(bfloat16 a, int n, float_status *status) { - FloatParts pa =3D bfloat16_unpack_canonical(a, status); - FloatParts pr =3D scalbn_decomposed(pa, n, status); + FloatParts64 pa =3D bfloat16_unpack_canonical(a, status); + FloatParts64 pr =3D scalbn_decomposed(pa, n, status); return bfloat16_round_pack_canonical(pr, status); } =20 @@ -3422,7 +3422,7 @@ bfloat16 bfloat16_scalbn(bfloat16 a, int n, float_sta= tus *status) * especially for 64 bit floats. */ =20 -static FloatParts sqrt_float(FloatParts a, float_status *s, const FloatFmt= *p) +static FloatParts64 sqrt_float(FloatParts64 a, float_status *s, const Floa= tFmt *p) { uint64_t a_frac, r_frac, s_frac; int bit, last_bit; @@ -3482,24 +3482,24 @@ static FloatParts sqrt_float(FloatParts a, float_st= atus *s, const FloatFmt *p) =20 float16 QEMU_FLATTEN float16_sqrt(float16 a, float_status *status) { - FloatParts pa =3D float16_unpack_canonical(a, status); - FloatParts pr =3D sqrt_float(pa, status, &float16_params); + FloatParts64 pa =3D float16_unpack_canonical(a, status); + FloatParts64 pr =3D sqrt_float(pa, status, &float16_params); return float16_round_pack_canonical(pr, status); } =20 static float32 QEMU_SOFTFLOAT_ATTR soft_f32_sqrt(float32 a, float_status *status) { - FloatParts pa =3D float32_unpack_canonical(a, status); - FloatParts pr =3D sqrt_float(pa, status, &float32_params); + FloatParts64 pa =3D float32_unpack_canonical(a, status); + FloatParts64 pr =3D sqrt_float(pa, status, &float32_params); return float32_round_pack_canonical(pr, status); } =20 static float64 QEMU_SOFTFLOAT_ATTR soft_f64_sqrt(float64 a, float_status *status) { - FloatParts pa =3D float64_unpack_canonical(a, status); - FloatParts pr =3D sqrt_float(pa, status, &float64_params); + FloatParts64 pa =3D float64_unpack_canonical(a, status); + FloatParts64 pr =3D sqrt_float(pa, status, &float64_params); return float64_round_pack_canonical(pr, status); } =20 @@ -3559,8 +3559,8 @@ float64 QEMU_FLATTEN float64_sqrt(float64 xa, float_s= tatus *s) =20 bfloat16 QEMU_FLATTEN bfloat16_sqrt(bfloat16 a, float_status *status) { - FloatParts pa =3D bfloat16_unpack_canonical(a, status); - FloatParts pr =3D sqrt_float(pa, status, &bfloat16_params); + FloatParts64 pa =3D bfloat16_unpack_canonical(a, status); + FloatParts64 pr =3D sqrt_float(pa, status, &bfloat16_params); return bfloat16_round_pack_canonical(pr, status); } =20 @@ -3570,28 +3570,28 @@ bfloat16 QEMU_FLATTEN bfloat16_sqrt(bfloat16 a, flo= at_status *status) =20 float16 float16_default_nan(float_status *status) { - FloatParts p =3D parts_default_nan(status); + FloatParts64 p =3D parts_default_nan(status); p.frac >>=3D float16_params.frac_shift; return float16_pack_raw(p); } =20 float32 float32_default_nan(float_status *status) { - FloatParts p =3D parts_default_nan(status); + FloatParts64 p =3D parts_default_nan(status); p.frac >>=3D float32_params.frac_shift; return float32_pack_raw(p); } =20 float64 float64_default_nan(float_status *status) { - FloatParts p =3D parts_default_nan(status); + FloatParts64 p =3D parts_default_nan(status); p.frac >>=3D float64_params.frac_shift; return float64_pack_raw(p); } =20 float128 float128_default_nan(float_status *status) { - FloatParts p =3D parts_default_nan(status); + FloatParts64 p =3D parts_default_nan(status); float128 r; =20 /* Extrapolate from the choices made by parts_default_nan to fill @@ -3608,7 +3608,7 @@ float128 float128_default_nan(float_status *status) =20 bfloat16 bfloat16_default_nan(float_status *status) { - FloatParts p =3D parts_default_nan(status); + FloatParts64 p =3D parts_default_nan(status); p.frac >>=3D bfloat16_params.frac_shift; return bfloat16_pack_raw(p); } @@ -3619,7 +3619,7 @@ bfloat16 bfloat16_default_nan(float_status *status) =20 float16 float16_silence_nan(float16 a, float_status *status) { - FloatParts p =3D float16_unpack_raw(a); + FloatParts64 p =3D float16_unpack_raw(a); p.frac <<=3D float16_params.frac_shift; p =3D parts_silence_nan(p, status); p.frac >>=3D float16_params.frac_shift; @@ -3628,7 +3628,7 @@ float16 float16_silence_nan(float16 a, float_status *= status) =20 float32 float32_silence_nan(float32 a, float_status *status) { - FloatParts p =3D float32_unpack_raw(a); + FloatParts64 p =3D float32_unpack_raw(a); p.frac <<=3D float32_params.frac_shift; p =3D parts_silence_nan(p, status); p.frac >>=3D float32_params.frac_shift; @@ -3637,7 +3637,7 @@ float32 float32_silence_nan(float32 a, float_status *= status) =20 float64 float64_silence_nan(float64 a, float_status *status) { - FloatParts p =3D float64_unpack_raw(a); + FloatParts64 p =3D float64_unpack_raw(a); p.frac <<=3D float64_params.frac_shift; p =3D parts_silence_nan(p, status); p.frac >>=3D float64_params.frac_shift; @@ -3646,7 +3646,7 @@ float64 float64_silence_nan(float64 a, float_status *= status) =20 bfloat16 bfloat16_silence_nan(bfloat16 a, float_status *status) { - FloatParts p =3D bfloat16_unpack_raw(a); + FloatParts64 p =3D bfloat16_unpack_raw(a); p.frac <<=3D bfloat16_params.frac_shift; p =3D parts_silence_nan(p, status); p.frac >>=3D bfloat16_params.frac_shift; @@ -3658,7 +3658,7 @@ bfloat16 bfloat16_silence_nan(bfloat16 a, float_statu= s *status) | input-denormal exception and return zero. Otherwise just return the valu= e. *-------------------------------------------------------------------------= ---*/ =20 -static bool parts_squash_denormal(FloatParts p, float_status *status) +static bool parts_squash_denormal(FloatParts64 p, float_status *status) { if (p.exp =3D=3D 0 && p.frac !=3D 0) { float_raise(float_flag_input_denormal, status); @@ -3671,7 +3671,7 @@ static bool parts_squash_denormal(FloatParts p, float= _status *status) float16 float16_squash_input_denormal(float16 a, float_status *status) { if (status->flush_inputs_to_zero) { - FloatParts p =3D float16_unpack_raw(a); + FloatParts64 p =3D float16_unpack_raw(a); if (parts_squash_denormal(p, status)) { return float16_set_sign(float16_zero, p.sign); } @@ -3682,7 +3682,7 @@ float16 float16_squash_input_denormal(float16 a, floa= t_status *status) float32 float32_squash_input_denormal(float32 a, float_status *status) { if (status->flush_inputs_to_zero) { - FloatParts p =3D float32_unpack_raw(a); + FloatParts64 p =3D float32_unpack_raw(a); if (parts_squash_denormal(p, status)) { return float32_set_sign(float32_zero, p.sign); } @@ -3693,7 +3693,7 @@ float32 float32_squash_input_denormal(float32 a, floa= t_status *status) float64 float64_squash_input_denormal(float64 a, float_status *status) { if (status->flush_inputs_to_zero) { - FloatParts p =3D float64_unpack_raw(a); + FloatParts64 p =3D float64_unpack_raw(a); if (parts_squash_denormal(p, status)) { return float64_set_sign(float64_zero, p.sign); } @@ -3704,7 +3704,7 @@ float64 float64_squash_input_denormal(float64 a, floa= t_status *status) bfloat16 bfloat16_squash_input_denormal(bfloat16 a, float_status *status) { if (status->flush_inputs_to_zero) { - FloatParts p =3D bfloat16_unpack_raw(a); + FloatParts64 p =3D bfloat16_unpack_raw(a); if (parts_squash_denormal(p, status)) { return bfloat16_set_sign(bfloat16_zero, p.sign); } diff --git a/fpu/softfloat-specialize.c.inc b/fpu/softfloat-specialize.c.inc index 05cb2ee940..bb928b0b9f 100644 --- a/fpu/softfloat-specialize.c.inc +++ b/fpu/softfloat-specialize.c.inc @@ -129,7 +129,7 @@ static bool parts_is_snan_frac(uint64_t frac, float_sta= tus *status) | The pattern for a default generated deconstructed floating-point NaN. *-------------------------------------------------------------------------= ---*/ =20 -static FloatParts parts_default_nan(float_status *status) +static FloatParts64 parts_default_nan(float_status *status) { bool sign =3D 0; uint64_t frac; @@ -163,7 +163,7 @@ static FloatParts parts_default_nan(float_status *statu= s) } #endif =20 - return (FloatParts) { + return (FloatParts64) { .cls =3D float_class_qnan, .sign =3D sign, .exp =3D INT_MAX, @@ -176,7 +176,7 @@ static FloatParts parts_default_nan(float_status *statu= s) | floating-point parts. *-------------------------------------------------------------------------= ---*/ =20 -static FloatParts parts_silence_nan(FloatParts a, float_status *status) +static FloatParts64 parts_silence_nan(FloatParts64 a, float_status *status) { g_assert(!no_signaling_nans(status)); g_assert(!status->default_nan_mode); --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169366; cv=none; d=zohomail.com; s=zohoarc; b=WmJEsj9/YnRBHyFOvz2sRrmHtNQqfnHts4WHboqWyAILJTJ7CV9PByYeB/dA7Z5P0MlMjLJ5QrjPA8aEWVzUZl2lIB466sXSjgShywgvsxbHSgclYIEwfXbG29iXTUXLaDM2LUu4D6c3ff0jVLfZFDznQe9LBTL92DO0v7+tdzQ= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169366; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=Ox0xEuSw27UkSWdR6GqHPFeB67qrzPm+Gy+AAkd2bwg=; b=U8uuqmVWv7FJSZ7zmy2V7kyfSKxzV0fV4NfQoAM/hvam5GTSolOmEPz77ulPWdeHYA13WS3TYI2BwkXptZES6xcMJWyW69wgsiGh7h3U/8xx4BbA3A6/HZco584y/goHWBxV8XKmY8eebt/eWVEWPCIeqmv/VaV6OllKF8U9ZSo= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169366673606.546726776203; Sun, 16 May 2021 05:49:26 -0700 (PDT) Received: from localhost ([::1]:34398 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGCz-0008Iq-99 for importer@patchew.org; Sun, 16 May 2021 08:49:25 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43208) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFz8-0007V8-BV for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:06 -0400 Received: from mail-qk1-x72a.google.com ([2607:f8b0:4864:20::72a]:44620) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyp-0007mN-O1 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:06 -0400 Received: by mail-qk1-x72a.google.com with SMTP id a2so3284599qkh.11 for ; Sun, 16 May 2021 05:34:47 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Ox0xEuSw27UkSWdR6GqHPFeB67qrzPm+Gy+AAkd2bwg=; b=xEOZir6y03yEKESVlN4eCYHotoCmXNZmoA6+ixH0s7vjvf6mZUe1zMcGxQ31GXnfbH bwFmGOUyz8TjnU9fh6hDh5F/1/30owZAgEF9KhWC9NoInslvcsmEJ2zIYc30TPXrhhkJ egPel322GVdAlnfgf57YYbIgUHJkwJemYibTJZkX0+CrMOPFCcl/Y3gyEZzjUt1uxih3 JYn084uopxBt0We922T18myyl+VuiwAACN1HFZNf6XkRVORYtuJnOQdE1gmREgLPKZf9 b2EGYJ17sZnwRlEEgLsRFexkHg3+Wv7ACiT2/qPl9Uv/v9z6e4iSNaPTON6v/7h3pY44 y/1w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Ox0xEuSw27UkSWdR6GqHPFeB67qrzPm+Gy+AAkd2bwg=; b=rqH/evXn/8tOAs/tgihz0l90PLuOFfxEQTXTWA5Ml7cyOclFRn62yV9AUZK3x7w1BN JwL/cXD89SphOVbOiGOQjBHuhLhPnTDwOMS8fnEKbaFhAeBADbO6Z0rndH7hM/FR5eH2 yV113lSvFelDAyQnWZAKgttJCZBcDyprlpgCViQ9lpQVy9htloucrfRoc0DYx+4k7WQa GkhsRZwYD1u2eCVSMffiialwF7uZFubX7wR1qyrOUnQcVLhI5vak71fyWCsqSXexJJ32 ZyW0OU28Ly9EoeTqs4wmj6Ntn6VZHqMBfuqQ3n0a+SUL6rDnXpmVz8WX5zl2UvZ8vA8D s7HQ== X-Gm-Message-State: AOAM533YQiS9qhAvoMATGem1sxiSMNERf/+MoGrMNGFaZR+LA2pKQFuY uuUUqyRVSsz3Xiz3Mbuc034s6hUPPvDhvipJv+E= X-Google-Smtp-Source: ABdhPJxa8KVTt/Dsnj9reXd8Yxsh84rYR273waQL/20y0GVNvKUCSFOVCdku+e179Yvu1aZjTdkPXQ== X-Received: by 2002:a05:620a:1223:: with SMTP id v3mr51814430qkj.470.1621168486547; Sun, 16 May 2021 05:34:46 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 16/46] softfloat: Move type-specific pack/unpack routines Date: Sun, 16 May 2021 07:34:01 -0500 Message-Id: <20210516123431.718318-17-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::72a; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x72a.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) In preparation from moving sf_canonicalize. Reviewed-by: Philippe Mathieu-Daud=C3=A9 Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- fpu/softfloat.c | 109 +++++++++++++++++++++++++----------------------- 1 file changed, 56 insertions(+), 53 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 27b51659c9..398a068b58 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -837,59 +837,6 @@ static FloatParts64 round_canonical(FloatParts64 p, fl= oat_status *s, return p; } =20 -/* Explicit FloatFmt version */ -static FloatParts64 float16a_unpack_canonical(float16 f, float_status *s, - const FloatFmt *params) -{ - return sf_canonicalize(float16_unpack_raw(f), params, s); -} - -static FloatParts64 float16_unpack_canonical(float16 f, float_status *s) -{ - return float16a_unpack_canonical(f, s, &float16_params); -} - -static FloatParts64 bfloat16_unpack_canonical(bfloat16 f, float_status *s) -{ - return sf_canonicalize(bfloat16_unpack_raw(f), &bfloat16_params, s); -} - -static float16 float16a_round_pack_canonical(FloatParts64 p, float_status = *s, - const FloatFmt *params) -{ - return float16_pack_raw(round_canonical(p, s, params)); -} - -static float16 float16_round_pack_canonical(FloatParts64 p, float_status *= s) -{ - return float16a_round_pack_canonical(p, s, &float16_params); -} - -static bfloat16 bfloat16_round_pack_canonical(FloatParts64 p, float_status= *s) -{ - return bfloat16_pack_raw(round_canonical(p, s, &bfloat16_params)); -} - -static FloatParts64 float32_unpack_canonical(float32 f, float_status *s) -{ - return sf_canonicalize(float32_unpack_raw(f), &float32_params, s); -} - -static float32 float32_round_pack_canonical(FloatParts64 p, float_status *= s) -{ - return float32_pack_raw(round_canonical(p, s, &float32_params)); -} - -static FloatParts64 float64_unpack_canonical(float64 f, float_status *s) -{ - return sf_canonicalize(float64_unpack_raw(f), &float64_params, s); -} - -static float64 float64_round_pack_canonical(FloatParts64 p, float_status *= s) -{ - return float64_pack_raw(round_canonical(p, s, &float64_params)); -} - static FloatParts64 return_nan(FloatParts64 a, float_status *s) { g_assert(is_nan(a.cls)); @@ -964,6 +911,62 @@ static FloatParts64 pick_nan_muladd(FloatParts64 a, Fl= oatParts64 b, FloatParts64 return a; } =20 +/* + * Pack/unpack routines with a specific FloatFmt. + */ + +static FloatParts64 float16a_unpack_canonical(float16 f, float_status *s, + const FloatFmt *params) +{ + return sf_canonicalize(float16_unpack_raw(f), params, s); +} + +static FloatParts64 float16_unpack_canonical(float16 f, float_status *s) +{ + return float16a_unpack_canonical(f, s, &float16_params); +} + +static FloatParts64 bfloat16_unpack_canonical(bfloat16 f, float_status *s) +{ + return sf_canonicalize(bfloat16_unpack_raw(f), &bfloat16_params, s); +} + +static float16 float16a_round_pack_canonical(FloatParts64 p, float_status = *s, + const FloatFmt *params) +{ + return float16_pack_raw(round_canonical(p, s, params)); +} + +static float16 float16_round_pack_canonical(FloatParts64 p, float_status *= s) +{ + return float16a_round_pack_canonical(p, s, &float16_params); +} + +static bfloat16 bfloat16_round_pack_canonical(FloatParts64 p, float_status= *s) +{ + return bfloat16_pack_raw(round_canonical(p, s, &bfloat16_params)); +} + +static FloatParts64 float32_unpack_canonical(float32 f, float_status *s) +{ + return sf_canonicalize(float32_unpack_raw(f), &float32_params, s); +} + +static float32 float32_round_pack_canonical(FloatParts64 p, float_status *= s) +{ + return float32_pack_raw(round_canonical(p, s, &float32_params)); +} + +static FloatParts64 float64_unpack_canonical(float64 f, float_status *s) +{ + return sf_canonicalize(float64_unpack_raw(f), &float64_params, s); +} + +static float64 float64_round_pack_canonical(FloatParts64 p, float_status *= s) +{ + return float64_pack_raw(round_canonical(p, s, &float64_params)); +} + /* * Returns the result of adding or subtracting the values of the * floating-point values `a' and `b'. The operation is performed --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170117; cv=none; d=zohomail.com; s=zohoarc; b=Q6DjvrMsJzIjbD+AJfNeM+WVA3aw3OoW7gi9eijSEM22rztpbn/72Kw0pgg0MtRvQ4ryEteKpiAUR8Fi77sSG4NPUVfMGeDpQtHqhHJujKtXWETJfxWkv1ZDzoaA9JVa6p2g84JCP2LM2T4JmPMXTpnh9qFvwmwnNDh9E8n6LUM= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170117; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=qwLatIcg1M2jQdAtiotIU2QCLhsJTV7Ha800ap1A6gk=; b=MyunAdiI6jKR6M4O9NgvOIeZqKmenIxPASrBZH1qQ9qJiKyKTenz1lkFghLPLo++zTvlgqSgX7ol1AN5G7ap74y43S3xO69DwstPL5daqcRc+72PAvBCe7Ej6ivfs6GS3WygfkuCKA0zYAJNOzNNLaYqCZBZGKvR4xQIzT7+5lw= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170117419339.5350032496724; Sun, 16 May 2021 06:01:57 -0700 (PDT) Received: from localhost ([::1]:39146 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGP6-0005MG-7g for importer@patchew.org; Sun, 16 May 2021 09:01:56 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43234) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFz9-0007Zl-K8 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:07 -0400 Received: from mail-qt1-x82c.google.com ([2607:f8b0:4864:20::82c]:40954) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFys-0007mT-2l for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:07 -0400 Received: by mail-qt1-x82c.google.com with SMTP id j19so3002381qtp.7 for ; Sun, 16 May 2021 05:34:47 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=qwLatIcg1M2jQdAtiotIU2QCLhsJTV7Ha800ap1A6gk=; b=NgZ/dI/m8zMI9E6VE/v9zUmBGWGadTA4jQESYKVMbMTDWk/oaZa2vrBCLwTuna7D4g gVhtie1/jQyRZ+9Qbq/ucJBlmTdix7A2XjHuVSVTBfdZcu8qQDyTHr8HUt2ctkwE5Naz ITmLoAMnXwzsRzYd8PaNCZ0F7ecyHbvwntcpMusIcfIrRSPYSfvW7CTcjCn9UC3Ihcuy /G3U/wO/DwuYuLa0g+bjIJ5ckyYpZJ32aBtFDBb0T1saYqM53PkXNDRPnncPjuWC8jlh VkS0sH2qoD6R3Rn93lCmzE0MOiDwwAbrpGthNbyAXNKwffM5xmVaa7ov73QE7JBLiamP ktHw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=qwLatIcg1M2jQdAtiotIU2QCLhsJTV7Ha800ap1A6gk=; b=C5U5WnQMogBZXGJ6CCChH9+rU9bPswYNy+bridJSsYFWSaF7CkRcdrBkAL1LzdwGOL iRR/dglswdDs7uf8T62LM0hMnJC35V0vj/qENoaL+fMLYgU+Jz+1nmj+3uxdyVRJmJUI eWw9svJDdhti4UnupVygXE2u3X2+tqRu9F0iXkuCqNDqlxg2g/xB1QfBr2SQGDRh24NB byh0m9XYf6L2h8qeCUjnLvbfOEIADSuWA8pedvvgNZwpZWA4G12MYoVkg38fnQ5bfldo MOenqZo0/gCPi3NvSEjSoyIfYNHZVoDkfP6SdSMv+zkD/dNVrLzGIArM1bULPRt5EG1S 2GnQ== X-Gm-Message-State: AOAM532r91WUhQivvM91B+wP+DNTF0NijsTqU8hembpYcWRH44TgNi3T VMjBTabVFH2p0vMJLRA8mO/Q1MwTth2MmZ1FDx0= X-Google-Smtp-Source: ABdhPJzWULCbaEFvK9rzcBWcQjw5KSgvU+UUIAs6kdaGIRcxTs1qJapjkRCmh3ro8Lgod8tvdtpagg== X-Received: by 2002:ac8:5854:: with SMTP id h20mr51899218qth.87.1621168487287; Sun, 16 May 2021 05:34:47 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 17/46] softfloat: Use pointers with parts_default_nan Date: Sun, 16 May 2021 07:34:02 -0500 Message-Id: <20210516123431.718318-18-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::82c; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x82c.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Content-Type: text/plain; charset="utf-8" At the same time, rename to parts64_default_nan and add a macro for parts_default_nan. This will be flushed out once 128-bit support is added. Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- fpu/softfloat.c | 47 +++++++++++++++++++++++----------- fpu/softfloat-specialize.c.inc | 4 +-- 2 files changed, 34 insertions(+), 17 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 398a068b58..c7f95961cf 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -650,6 +650,8 @@ static inline float64 float64_pack_raw(FloatParts64 p) *-------------------------------------------------------------------------= ---*/ #include "softfloat-specialize.c.inc" =20 +#define parts_default_nan parts64_default_nan + /* Canonicalize EXP and FRAC, setting CLS. */ static FloatParts64 sf_canonicalize(FloatParts64 part, const FloatFmt *par= m, float_status *status) @@ -848,7 +850,8 @@ static FloatParts64 return_nan(FloatParts64 a, float_st= atus *s) } else if (!s->default_nan_mode) { return a; } - return parts_default_nan(s); + parts_default_nan(&a, s); + return a; } =20 static FloatParts64 pick_nan(FloatParts64 a, FloatParts64 b, float_status = *s) @@ -858,7 +861,7 @@ static FloatParts64 pick_nan(FloatParts64 a, FloatParts= 64 b, float_status *s) } =20 if (s->default_nan_mode) { - return parts_default_nan(s); + parts_default_nan(&a, s); } else { if (pickNaN(a.cls, b.cls, a.frac > b.frac || @@ -900,7 +903,8 @@ static FloatParts64 pick_nan_muladd(FloatParts64 a, Flo= atParts64 b, FloatParts64 a =3D c; break; case 3: - return parts_default_nan(s); + parts_default_nan(&a, s); + break; default: g_assert_not_reached(); } @@ -1011,7 +1015,7 @@ static FloatParts64 addsub_floats(FloatParts64 a, Flo= atParts64 b, bool subtract, if (a.cls =3D=3D float_class_inf) { if (b.cls =3D=3D float_class_inf) { float_raise(float_flag_invalid, s); - return parts_default_nan(s); + parts_default_nan(&a, s); } return a; } @@ -1254,7 +1258,8 @@ static FloatParts64 mul_floats(FloatParts64 a, FloatP= arts64 b, float_status *s) if ((a.cls =3D=3D float_class_inf && b.cls =3D=3D float_class_zero) || (a.cls =3D=3D float_class_zero && b.cls =3D=3D float_class_inf)) { float_raise(float_flag_invalid, s); - return parts_default_nan(s); + parts_default_nan(&a, s); + return a; } /* Multiply by 0 or Inf */ if (a.cls =3D=3D float_class_inf || a.cls =3D=3D float_class_zero) { @@ -1372,7 +1377,8 @@ static FloatParts64 muladd_floats(FloatParts64 a, Flo= atParts64 b, FloatParts64 c =20 if (inf_zero) { float_raise(float_flag_invalid, s); - return parts_default_nan(s); + parts_default_nan(&a, s); + return a; } =20 if (flags & float_muladd_negate_c) { @@ -1396,11 +1402,11 @@ static FloatParts64 muladd_floats(FloatParts64 a, F= loatParts64 b, FloatParts64 c if (c.cls =3D=3D float_class_inf) { if (p_class =3D=3D float_class_inf && p_sign !=3D c.sign) { float_raise(float_flag_invalid, s); - return parts_default_nan(s); + parts_default_nan(&c, s); } else { c.sign ^=3D sign_flip; - return c; } + return c; } =20 if (p_class =3D=3D float_class_inf) { @@ -1764,7 +1770,8 @@ static FloatParts64 div_floats(FloatParts64 a, FloatP= arts64 b, float_status *s) && (a.cls =3D=3D float_class_inf || a.cls =3D=3D float_class_zero)) { float_raise(float_flag_invalid, s); - return parts_default_nan(s); + parts_default_nan(&a, s); + return a; } /* Inf / x or 0 / x */ if (a.cls =3D=3D float_class_inf || a.cls =3D=3D float_class_zero) { @@ -3438,7 +3445,8 @@ static FloatParts64 sqrt_float(FloatParts64 a, float_= status *s, const FloatFmt * } if (a.sign) { float_raise(float_flag_invalid, s); - return parts_default_nan(s); + parts_default_nan(&a, s); + return a; } if (a.cls =3D=3D float_class_inf) { return a; /* sqrt(+inf) =3D +inf */ @@ -3573,30 +3581,37 @@ bfloat16 QEMU_FLATTEN bfloat16_sqrt(bfloat16 a, flo= at_status *status) =20 float16 float16_default_nan(float_status *status) { - FloatParts64 p =3D parts_default_nan(status); + FloatParts64 p; + + parts_default_nan(&p, status); p.frac >>=3D float16_params.frac_shift; return float16_pack_raw(p); } =20 float32 float32_default_nan(float_status *status) { - FloatParts64 p =3D parts_default_nan(status); + FloatParts64 p; + + parts_default_nan(&p, status); p.frac >>=3D float32_params.frac_shift; return float32_pack_raw(p); } =20 float64 float64_default_nan(float_status *status) { - FloatParts64 p =3D parts_default_nan(status); + FloatParts64 p; + + parts_default_nan(&p, status); p.frac >>=3D float64_params.frac_shift; return float64_pack_raw(p); } =20 float128 float128_default_nan(float_status *status) { - FloatParts64 p =3D parts_default_nan(status); + FloatParts64 p; float128 r; =20 + parts_default_nan(&p, status); /* Extrapolate from the choices made by parts_default_nan to fill * in the quad-floating format. If the low bit is set, assume we * want to set all non-snan bits. @@ -3611,7 +3626,9 @@ float128 float128_default_nan(float_status *status) =20 bfloat16 bfloat16_default_nan(float_status *status) { - FloatParts64 p =3D parts_default_nan(status); + FloatParts64 p; + + parts_default_nan(&p, status); p.frac >>=3D bfloat16_params.frac_shift; return bfloat16_pack_raw(p); } diff --git a/fpu/softfloat-specialize.c.inc b/fpu/softfloat-specialize.c.inc index bb928b0b9f..47c3652d63 100644 --- a/fpu/softfloat-specialize.c.inc +++ b/fpu/softfloat-specialize.c.inc @@ -129,7 +129,7 @@ static bool parts_is_snan_frac(uint64_t frac, float_sta= tus *status) | The pattern for a default generated deconstructed floating-point NaN. *-------------------------------------------------------------------------= ---*/ =20 -static FloatParts64 parts_default_nan(float_status *status) +static void parts64_default_nan(FloatParts64 *p, float_status *status) { bool sign =3D 0; uint64_t frac; @@ -163,7 +163,7 @@ static FloatParts64 parts_default_nan(float_status *sta= tus) } #endif =20 - return (FloatParts64) { + *p =3D (FloatParts64) { .cls =3D float_class_qnan, .sign =3D sign, .exp =3D INT_MAX, --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169613; cv=none; d=zohomail.com; s=zohoarc; b=FcVpP6q5sUZ2RlaetzWa0QsqT+EHp+nSAg9t1s75sIlx54OtEU3lpR1QK5Cf/Gt+f6wWfGiyUj3mOylSLd2cDeuNi+ecC9CCh+eKiJIAhDt9CqjpxAccZl0PaNQJTQWY+26ky+MFHy6fui3u+yGzO5qEzJIC736gFWpO/i9a4+A= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169613; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=Ni3IITrUvu6KOgaXHOkggF2jGpEbkqCHdxNG/RCcdrM=; b=UPnwg4iJbU6Ktge4S78uY13ApN1PVDVxOjAneCUV6CX8evW3xd5nmyeToXpAFoUKfD56BqNSgTJdycti1maod6NrYxP3ZRPK2pKIL7v3Q2Pue4ZHYAM46Z2qW3jy/EgfO6ZKQphTkO+cy2tz2ShpROcrqFqnGobIFtAOZCWpS24= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169613993952.6635846900398; Sun, 16 May 2021 05:53:33 -0700 (PDT) Received: from localhost ([::1]:42762 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGGy-0005gD-VN for importer@patchew.org; Sun, 16 May 2021 08:53:32 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43176) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFz4-0007RY-Ks for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:03 -0400 Received: from mail-qk1-x72c.google.com ([2607:f8b0:4864:20::72c]:37607) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFys-0007md-3W for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:02 -0400 Received: by mail-qk1-x72c.google.com with SMTP id i67so3308791qkc.4 for ; Sun, 16 May 2021 05:34:48 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Ni3IITrUvu6KOgaXHOkggF2jGpEbkqCHdxNG/RCcdrM=; b=hdUoRcf7f4CQa6H0ztH7P4gUsIcYZv7vSTbNK92r79BO3I7Goe8z7LyvT0u7lZ4ylN GgEdBTOxJEQ6IBgi90wAHZrl2X0xzJ32LJkEm5zpzMPuLdR/gGROIOAqaQdgBWwc2+Ac 4mtoEHKT47WSnONA5KmXqElvqZrFeM4UE1yv25cQNUhEeckWw6V5fzan8axQrpt1Uxmy r8N8hrubx80Y2ABr/P083m/WoL6J3kyaNiJ5g7mDvIH3HZ17Mt/YXgBvnUKJMbGocUv0 h/AzyUgzSeKMyOXnsdUHP7VTEMzxuFFCckOVEjcOnPcgOJDurTEANQhtyppPPeQ2hUyJ vsEg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Ni3IITrUvu6KOgaXHOkggF2jGpEbkqCHdxNG/RCcdrM=; b=qaP9eyaWDGDsDZ4GqmpLEVZMvn2qBUPa8nORiTGIGCAKLq5Feq6plhjhRddQpQfGVW /Ebj/1Mma1l7/6jqUFOMJCDP0DbYRcpBtNEGeNP89umJh9BUd/o16aYQZZmlWIYBGJtO UeBnFNsaj+4wFCAYLCyzCQG5ugBGAxlOeCJwTp1vaTyUwX2qzCAL9aSc5S0PQoiJ6ezp VfACF4G/7vRbbn3XdF3OTbyE5vXyewD7ql7PfVAFjzTtEWUmKUqd5muMZsNHLBtDGV7y wya/I2TeR+8buCl6MRQh+Quj1SVIsjSlOJ1jVSgwTrHLCDP8fZyGfGopQ5GcmQOCvDiO FTzQ== X-Gm-Message-State: AOAM530CTOBiPNXEZseQwzU0gzlkmFwG8dJKsbYbRw4Wue2nohi8JsVF jVbLA6js5Ohe7B1LBlIbtyEJlpNvt8jDXjHMSZg= X-Google-Smtp-Source: ABdhPJzZ5R3aZ0cZ+4hW833j156w98/3V6iM6fArenKFlu9sPzTDbQYIvpONfOTquKME78xkD5L4pQ== X-Received: by 2002:a37:6257:: with SMTP id w84mr53266861qkb.158.1621168488095; Sun, 16 May 2021 05:34:48 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 18/46] softfloat: Use pointers with unpack_raw Date: Sun, 16 May 2021 07:34:03 -0500 Message-Id: <20210516123431.718318-19-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::72c; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x72c.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= , =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) At the same time, rename to unpack_raw64. Reviewed-by: Alex Benn=C3=A9e Reviewed-by: Philippe Mathieu-Daud=C3=A9 Signed-off-by: Richard Henderson --- fpu/softfloat.c | 29 +++++++++++++++++++---------- 1 file changed, 19 insertions(+), 10 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index c7f95961cf..5ff9368012 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -580,36 +580,45 @@ static const FloatFmt float64_params =3D { }; =20 /* Unpack a float to parts, but do not canonicalize. */ -static inline FloatParts64 unpack_raw(FloatFmt fmt, uint64_t raw) +static void unpack_raw64(FloatParts64 *r, const FloatFmt *fmt, uint64_t ra= w) { - const int sign_pos =3D fmt.frac_size + fmt.exp_size; + const int f_size =3D fmt->frac_size; + const int e_size =3D fmt->exp_size; =20 - return (FloatParts64) { + *r =3D (FloatParts64) { .cls =3D float_class_unclassified, - .sign =3D extract64(raw, sign_pos, 1), - .exp =3D extract64(raw, fmt.frac_size, fmt.exp_size), - .frac =3D extract64(raw, 0, fmt.frac_size), + .sign =3D extract64(raw, f_size + e_size, 1), + .exp =3D extract64(raw, f_size, e_size), + .frac =3D extract64(raw, 0, f_size) }; } =20 static inline FloatParts64 float16_unpack_raw(float16 f) { - return unpack_raw(float16_params, f); + FloatParts64 p; + unpack_raw64(&p, &float16_params, f); + return p; } =20 static inline FloatParts64 bfloat16_unpack_raw(bfloat16 f) { - return unpack_raw(bfloat16_params, f); + FloatParts64 p; + unpack_raw64(&p, &bfloat16_params, f); + return p; } =20 static inline FloatParts64 float32_unpack_raw(float32 f) { - return unpack_raw(float32_params, f); + FloatParts64 p; + unpack_raw64(&p, &float32_params, f); + return p; } =20 static inline FloatParts64 float64_unpack_raw(float64 f) { - return unpack_raw(float64_params, f); + FloatParts64 p; + unpack_raw64(&p, &float64_params, f); + return p; } =20 /* Pack a float from parts, but do not canonicalize. */ --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169738; cv=none; d=zohomail.com; s=zohoarc; b=MjVEqB1tOEFMcVF+spbmcebx7/gSQxSb+dG/2QZVmJgt1Mi8igbZG4XoQDi1Znb4H4Z9y9GuvYVnEZ9bVjzFD7DoeWW8sx3Bng0n94BLkIQ7EhxjllqilD7Vs9uth/oAbZW/w2cTS8tpkorf9mzz9KY30oageNyzAzNUJuk4uhQ= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169738; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=mZI8v3AkQn3mKHHMFm846fTGkxDZ4HvUvOZFuGx9ZbQ=; b=kKB+sNMrFNbCWepJN/QFqsF2rRen74L3E/usTdRy9feEugzCOAReX0zCnM4bNfBACHgkiO0MLmiQHN3XeH/MMwgNBqSeYDBaz5v2fan4goyJ2Zqqdx0pcIeqYMgWKJZmSRiYmgjmvmoODeQrFL6G4egvLAr4jrtYTa8P0ADw8KE= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169738227608.9763357792115; Sun, 16 May 2021 05:55:38 -0700 (PDT) Received: from localhost ([::1]:50440 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGIz-0002KZ-5p for importer@patchew.org; Sun, 16 May 2021 08:55:37 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43212) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFz8-0007Vr-Io for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:06 -0400 Received: from mail-qv1-xf29.google.com ([2607:f8b0:4864:20::f29]:45983) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyt-0007mi-P6 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:06 -0400 Received: by mail-qv1-xf29.google.com with SMTP id h7so1208502qvs.12 for ; Sun, 16 May 2021 05:34:49 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=mZI8v3AkQn3mKHHMFm846fTGkxDZ4HvUvOZFuGx9ZbQ=; b=ykceMs4Eo3aBXyrFHRD5zgLEibFM2JA5igxrPFwRpsb8jltrrCOjGdDqi83RR2UBNP stVOye0pztF51r5C9IWR7EElRLxPklOX29TBhX6WHNAazj2wwP7IervDjoBj6LxrLBmh /jgpwnzVP/KVNefVpYHT0/V5P9WnKqGXaGDllwrPa215+WZ7b2lbWpzyyJnY5bUCGUFL yfaYggY9K8fTru6XDrFljHY6vphZSYEn9fyZlmFVLD/goEihkac1WaHMvQ7fm/5NCEIM taozN0CFQIM+0S2VkBUdAYdbhLG+mBmnurothrfyj48c6Jy6SF4M6YptsHsVXarzLcAw td/Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=mZI8v3AkQn3mKHHMFm846fTGkxDZ4HvUvOZFuGx9ZbQ=; b=T49oyI5Qlx463iFmKJGfGcFBBp4vSNYBpbKqCsdlJ+SJFUpYhlB8vshXLtnvEftqFy D8bT/Xafc06y6D4pW0ZxH2xPhvUiwKcbz8znmhyA1MvN7DETGdD9TIDW8qramsqJHpuj BvmMyCkz/EvFRgWm9RkJrwex3MK8EmPsmX7nc/D0iZ+T8CkRrXtkZ2E41zXKRuoy0KFw eMDmzFhGqyGg0HBvp8/KoQdfHVw6BxeezrG29S/UU6fCOphgyLb6AVPGR7PliC35AcZC NF6GGTCpREzUDThLXLO2iekQ7mJtVP4EJyI7fkRHHfQvojIBpR66Er5mYkykrM6oz+sn S5Xw== X-Gm-Message-State: AOAM532n6OWKPJsTabNT9iNN6RTTT8jGzY/vDV9w13ft7UatpJI2WdVI JSLSsIGuExB98C+cXJQx6R8KNOG0ZqI0VZJTJcM= X-Google-Smtp-Source: ABdhPJyXqjX36Bf/ojr297TIsJDb5LJ/vuqDTv2uwJm/5Mue8euiYhdTqN7gZ8hfEgKaEtCbQyDA0A== X-Received: by 2002:a0c:ef45:: with SMTP id t5mr4670674qvs.26.1621168488824; Sun, 16 May 2021 05:34:48 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 19/46] softfloat: Use pointers with ftype_unpack_raw Date: Sun, 16 May 2021 07:34:04 -0500 Message-Id: <20210516123431.718318-20-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::f29; envelope-from=richard.henderson@linaro.org; helo=mail-qv1-xf29.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 76 +++++++++++++++++++++++++++++++------------------ 1 file changed, 48 insertions(+), 28 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 5ff9368012..5a736a46cf 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -593,32 +593,24 @@ static void unpack_raw64(FloatParts64 *r, const Float= Fmt *fmt, uint64_t raw) }; } =20 -static inline FloatParts64 float16_unpack_raw(float16 f) +static inline void float16_unpack_raw(FloatParts64 *p, float16 f) { - FloatParts64 p; - unpack_raw64(&p, &float16_params, f); - return p; + unpack_raw64(p, &float16_params, f); } =20 -static inline FloatParts64 bfloat16_unpack_raw(bfloat16 f) +static inline void bfloat16_unpack_raw(FloatParts64 *p, bfloat16 f) { - FloatParts64 p; - unpack_raw64(&p, &bfloat16_params, f); - return p; + unpack_raw64(p, &bfloat16_params, f); } =20 -static inline FloatParts64 float32_unpack_raw(float32 f) +static inline void float32_unpack_raw(FloatParts64 *p, float32 f) { - FloatParts64 p; - unpack_raw64(&p, &float32_params, f); - return p; + unpack_raw64(p, &float32_params, f); } =20 -static inline FloatParts64 float64_unpack_raw(float64 f) +static inline void float64_unpack_raw(FloatParts64 *p, float64 f) { - FloatParts64 p; - unpack_raw64(&p, &float64_params, f); - return p; + unpack_raw64(p, &float64_params, f); } =20 /* Pack a float from parts, but do not canonicalize. */ @@ -931,7 +923,10 @@ static FloatParts64 pick_nan_muladd(FloatParts64 a, Fl= oatParts64 b, FloatParts64 static FloatParts64 float16a_unpack_canonical(float16 f, float_status *s, const FloatFmt *params) { - return sf_canonicalize(float16_unpack_raw(f), params, s); + FloatParts64 p; + + float16_unpack_raw(&p, f); + return sf_canonicalize(p, params, s); } =20 static FloatParts64 float16_unpack_canonical(float16 f, float_status *s) @@ -941,7 +936,10 @@ static FloatParts64 float16_unpack_canonical(float16 f= , float_status *s) =20 static FloatParts64 bfloat16_unpack_canonical(bfloat16 f, float_status *s) { - return sf_canonicalize(bfloat16_unpack_raw(f), &bfloat16_params, s); + FloatParts64 p; + + bfloat16_unpack_raw(&p, f); + return sf_canonicalize(p, &bfloat16_params, s); } =20 static float16 float16a_round_pack_canonical(FloatParts64 p, float_status = *s, @@ -962,7 +960,10 @@ static bfloat16 bfloat16_round_pack_canonical(FloatPar= ts64 p, float_status *s) =20 static FloatParts64 float32_unpack_canonical(float32 f, float_status *s) { - return sf_canonicalize(float32_unpack_raw(f), &float32_params, s); + FloatParts64 p; + + float32_unpack_raw(&p, f); + return sf_canonicalize(p, &float32_params, s); } =20 static float32 float32_round_pack_canonical(FloatParts64 p, float_status *= s) @@ -972,7 +973,10 @@ static float32 float32_round_pack_canonical(FloatParts= 64 p, float_status *s) =20 static FloatParts64 float64_unpack_canonical(float64 f, float_status *s) { - return sf_canonicalize(float64_unpack_raw(f), &float64_params, s); + FloatParts64 p; + + float64_unpack_raw(&p, f); + return sf_canonicalize(p, &float64_params, s); } =20 static float64 float64_round_pack_canonical(FloatParts64 p, float_status *= s) @@ -3648,7 +3652,9 @@ bfloat16 bfloat16_default_nan(float_status *status) =20 float16 float16_silence_nan(float16 a, float_status *status) { - FloatParts64 p =3D float16_unpack_raw(a); + FloatParts64 p; + + float16_unpack_raw(&p, a); p.frac <<=3D float16_params.frac_shift; p =3D parts_silence_nan(p, status); p.frac >>=3D float16_params.frac_shift; @@ -3657,7 +3663,9 @@ float16 float16_silence_nan(float16 a, float_status *= status) =20 float32 float32_silence_nan(float32 a, float_status *status) { - FloatParts64 p =3D float32_unpack_raw(a); + FloatParts64 p; + + float32_unpack_raw(&p, a); p.frac <<=3D float32_params.frac_shift; p =3D parts_silence_nan(p, status); p.frac >>=3D float32_params.frac_shift; @@ -3666,7 +3674,9 @@ float32 float32_silence_nan(float32 a, float_status *= status) =20 float64 float64_silence_nan(float64 a, float_status *status) { - FloatParts64 p =3D float64_unpack_raw(a); + FloatParts64 p; + + float64_unpack_raw(&p, a); p.frac <<=3D float64_params.frac_shift; p =3D parts_silence_nan(p, status); p.frac >>=3D float64_params.frac_shift; @@ -3675,7 +3685,9 @@ float64 float64_silence_nan(float64 a, float_status *= status) =20 bfloat16 bfloat16_silence_nan(bfloat16 a, float_status *status) { - FloatParts64 p =3D bfloat16_unpack_raw(a); + FloatParts64 p; + + bfloat16_unpack_raw(&p, a); p.frac <<=3D bfloat16_params.frac_shift; p =3D parts_silence_nan(p, status); p.frac >>=3D bfloat16_params.frac_shift; @@ -3700,7 +3712,9 @@ static bool parts_squash_denormal(FloatParts64 p, flo= at_status *status) float16 float16_squash_input_denormal(float16 a, float_status *status) { if (status->flush_inputs_to_zero) { - FloatParts64 p =3D float16_unpack_raw(a); + FloatParts64 p; + + float16_unpack_raw(&p, a); if (parts_squash_denormal(p, status)) { return float16_set_sign(float16_zero, p.sign); } @@ -3711,7 +3725,9 @@ float16 float16_squash_input_denormal(float16 a, floa= t_status *status) float32 float32_squash_input_denormal(float32 a, float_status *status) { if (status->flush_inputs_to_zero) { - FloatParts64 p =3D float32_unpack_raw(a); + FloatParts64 p; + + float32_unpack_raw(&p, a); if (parts_squash_denormal(p, status)) { return float32_set_sign(float32_zero, p.sign); } @@ -3722,7 +3738,9 @@ float32 float32_squash_input_denormal(float32 a, floa= t_status *status) float64 float64_squash_input_denormal(float64 a, float_status *status) { if (status->flush_inputs_to_zero) { - FloatParts64 p =3D float64_unpack_raw(a); + FloatParts64 p; + + float64_unpack_raw(&p, a); if (parts_squash_denormal(p, status)) { return float64_set_sign(float64_zero, p.sign); } @@ -3733,7 +3751,9 @@ float64 float64_squash_input_denormal(float64 a, floa= t_status *status) bfloat16 bfloat16_squash_input_denormal(bfloat16 a, float_status *status) { if (status->flush_inputs_to_zero) { - FloatParts64 p =3D bfloat16_unpack_raw(a); + FloatParts64 p; + + bfloat16_unpack_raw(&p, a); if (parts_squash_denormal(p, status)) { return bfloat16_set_sign(bfloat16_zero, p.sign); } --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169945; cv=none; d=zohomail.com; s=zohoarc; b=Fb4UkNLI147D6Z3SlTlwllKZ5jikqNPvLtU5TKRZibZmZ1T9XmiccYnk3x6YRaIP/jwODGV8Nwx9M/PWkS97CpyC2x+3iZvrwwjeaTNlYJFJ5DKTbb14WVtC0MuzizOeVrJhvFTnW5ffETNqsXKDOVMeeDK6NZZ4622ahWBbB8E= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169945; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=SSsnZ91q8QYxYfIeEERPVDuhgJY0Ge1EGClwWnWfqNg=; b=Vp+dIR3chfXbblq+h9QH6SieqMEqmc71eJ2G+j015C2a8A76sL6AAf8mOsbF/NufQYaBaw/6wNb+F85O1Ys1ZX/Y4GH4K8CFSDBI5k6YoBCgXL01McJWfyy6sz1XN91W2+92HjAgzUC5Y3XXz6t/jarcb0Ki2Svh0L3AI+8txC8= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169945500509.49710301884704; Sun, 16 May 2021 05:59:05 -0700 (PDT) Received: from localhost ([::1]:58900 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGMK-00083q-7r for importer@patchew.org; Sun, 16 May 2021 08:59:04 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43216) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFz8-0007WG-Jz for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:06 -0400 Received: from mail-qt1-x82d.google.com ([2607:f8b0:4864:20::82d]:46729) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyu-0007mm-6u for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:06 -0400 Received: by mail-qt1-x82d.google.com with SMTP id m13so2984845qtk.13 for ; Sun, 16 May 2021 05:34:50 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=SSsnZ91q8QYxYfIeEERPVDuhgJY0Ge1EGClwWnWfqNg=; b=aEjx55rvfM2q0aWQEtXILk1yqJmsfESPdxI47NnXiXmAWZzOtt4I5xiyBGDLfobLyr r9DEY3zdDtJ8Hy5WfTzxQlsCx0QgfdeAkt7DYqMouz/ixlbkRE4ldxOS4brDW1+/rxhH 9qxU5UV/sG+d7MrHPNzL0Q9UtJac8i3azF1BUbjREswFEHLDCiSGIdkMVhoIa+cyaDu9 /qBymHTP9BRHZQVZKQ8ftmhxIrxRo5RqBo2yNSW/qshZ7j6jZWcYqTiYA4Xw4VBBu4ms /XAcqS/EsDIe/b0FZ3A7cn6gPT24dYQI47eoSC57HqDmEi//hmt9Ka83un1KqFl4X37q EKYA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=SSsnZ91q8QYxYfIeEERPVDuhgJY0Ge1EGClwWnWfqNg=; b=BbMBP4TR6lJqdYmRhr1czT0Dlg2utCGBx97RayY/V1KYeZZSHy/VPEdNiKD/rDwZQ9 OZL9iiXGSyE/Z1fzFGPAWr2z9YO48ggBywpJCL2IYRrKVGahD9UHvcLoue6Fu2AHwn7Z HM923DF1g8CQTyU3zRY3UZUE/kaEdGOHbbmkuvAGquD1uEMgxU8mb4Q1L7kgf+66b7xB 5uxwqyYwzrJhcSski4jKvwX322Q7+aeCvdysH4HG3XiWSvw211jf0Y1ci7DAPis7A80m ioS2cLsNChYH1GnB3BffH/zCi9GqWnbLcrb2Y6d5YIYJXwxG9+xAoQliiyTKYe0TLKUr NFBA== X-Gm-Message-State: AOAM531vsS4kIz1go67gERcoUOzH/m2SSb26k7O6YvLYZ37xfUUNkIhR 5V73OWItlrVo54pb6QTgnZjpaUWKJAGtEuM/n7g= X-Google-Smtp-Source: ABdhPJwnYrXFSiI24U8GMI4nRLgshs8o/RrN9+yqyNc9KKYJ/y3eHeXyuokjMGSYG9sXoaffKBGmMw== X-Received: by 2002:a05:622a:1044:: with SMTP id f4mr36340056qte.181.1621168489511; Sun, 16 May 2021 05:34:49 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 20/46] softfloat: Use pointers with pack_raw Date: Sun, 16 May 2021 07:34:05 -0500 Message-Id: <20210516123431.718318-21-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::82d; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x82d.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) At the same time, rename to pack_raw64. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 5a736a46cf..b59b777bca 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -614,31 +614,36 @@ static inline void float64_unpack_raw(FloatParts64 *p= , float64 f) } =20 /* Pack a float from parts, but do not canonicalize. */ -static inline uint64_t pack_raw(FloatFmt fmt, FloatParts64 p) +static uint64_t pack_raw64(const FloatParts64 *p, const FloatFmt *fmt) { - const int sign_pos =3D fmt.frac_size + fmt.exp_size; - uint64_t ret =3D deposit64(p.frac, fmt.frac_size, fmt.exp_size, p.exp); - return deposit64(ret, sign_pos, 1, p.sign); + const int f_size =3D fmt->frac_size; + const int e_size =3D fmt->exp_size; + uint64_t ret; + + ret =3D (uint64_t)p->sign << (f_size + e_size); + ret =3D deposit64(ret, f_size, e_size, p->exp); + ret =3D deposit64(ret, 0, f_size, p->frac); + return ret; } =20 static inline float16 float16_pack_raw(FloatParts64 p) { - return make_float16(pack_raw(float16_params, p)); + return make_float16(pack_raw64(&p, &float16_params)); } =20 static inline bfloat16 bfloat16_pack_raw(FloatParts64 p) { - return pack_raw(bfloat16_params, p); + return pack_raw64(&p, &bfloat16_params); } =20 static inline float32 float32_pack_raw(FloatParts64 p) { - return make_float32(pack_raw(float32_params, p)); + return make_float32(pack_raw64(&p, &float32_params)); } =20 static inline float64 float64_pack_raw(FloatParts64 p) { - return make_float64(pack_raw(float64_params, p)); + return make_float64(pack_raw64(&p, &float64_params)); } =20 /*------------------------------------------------------------------------= ---- --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170294; cv=none; d=zohomail.com; s=zohoarc; b=XtdGsUx773CswdZNlPyr0ETF2x7ByS0IT8dNuma0Ypv6q1f7wAhF+2NUW8BVdHIghv6Btpt8MObyR5BGsDUQb4kTTQc/BVd9obCkhopO1Cor3zuhftRvhS8dbHwemUdi3Sc1aELQcxeyYgMtz8eADjZ/3mi30AhJrz36RUTTK/g= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170294; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=VuTZsp4nWzxSgrnRWmG8340twmRTJJl7O53UuGDFiDA=; b=a3Lf6hczLkBBFHTCyVfJ2puGiSyYJ/dJNXgNSUfhek5yutvsw9zgvvcWzWlhIwfdgptiyztvIiSR6Mvuz5yKrmDZOlQH4AD7LFdVpznpQM1MMr8U1RYTKjHczFjW6gZJ898dS3tsJevNgu434B1lbTbqeXXooE7uBVRljRxhBcM= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170294071571.8111267658368; Sun, 16 May 2021 06:04:54 -0700 (PDT) Received: from localhost ([::1]:47452 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGRx-0002XD-1t for importer@patchew.org; Sun, 16 May 2021 09:04:53 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43290) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzC-0007ex-Iu for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:13 -0400 Received: from mail-qk1-x72b.google.com ([2607:f8b0:4864:20::72b]:43922) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyv-0007mt-Lm for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:10 -0400 Received: by mail-qk1-x72b.google.com with SMTP id a22so3278810qkl.10 for ; Sun, 16 May 2021 05:34:50 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=VuTZsp4nWzxSgrnRWmG8340twmRTJJl7O53UuGDFiDA=; b=zB3jc6Sj6guevuaKEsPhcYRfz5CW9LTic7Tk3ZtdhwPmO2iSvrVlc9K5EXL4VzrMHs fFdDRUGUxua/JiyEoFK8ZX1b1ptBfOdgBV25vtKmieH+0VnIiMq8LEutRGi1aFGtVcpE HK+FOKr5/8bo9BZhabg72wrL39t+u3b22/zRLG/MHO56JSuksozOywLn7ISuWBiLugn5 /z01Ro0CWVIt49Jg7YcPfdZc9u22kt/tyh/Xcoj9lMryNHotXdvV5MGBKSAuNYpDbvqM Q7i2SgNMhp7t0lrZhPFXyswwFGb7h60RY3nA2BJx0HFXL8895d7EDqQtcqEh/MC7J10X bLWA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=VuTZsp4nWzxSgrnRWmG8340twmRTJJl7O53UuGDFiDA=; b=CqHMcgfYdaJbsxk8UYTRoY7C3vfmnWgPlxQ3vMjfdgTyBy5+rEt9d1vjx4KLGFgqwa jdIh2tkQmAtVDNysaAcOp11i9PETwsmcluFXEAXYx0AcdNxQGzKIX4giegn2Nzbny9YZ 2Wr6Uh7GFTdWe/jSd2+98AttzCJLXpuKPy6y090NE6yHFD3uEu7sMpmw0jz3IWsEf5eT MWvxxPX03tVw1mO1JhmltYaS+fEGnXezTi4lzzVQeR/FGl0WVFMGietI2HGvnzQuvlM6 A3NQ/fU6b/rYt4iEcmd/6QMfqN2osWZKNPNL40YCcdfe54jroN9usL6gnxEn7D0oEHeq gyKg== X-Gm-Message-State: AOAM532c6jvSondlMJuOu+JicBrNTgJYpC7p9JbCslbG8SBwvFvwFo50 Nz5Ou4yCJUNEd2YW6HB3ftoB23s9Gr/hrp0OuQo= X-Google-Smtp-Source: ABdhPJzuRlVuYBtGyc4FP49+6EtxpLS/6DHgGVxXwNYv3bL12EKckVKI8ZzKlJBRY3ZjSYZC33DggQ== X-Received: by 2002:a05:620a:24cf:: with SMTP id m15mr50525402qkn.435.1621168490352; Sun, 16 May 2021 05:34:50 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 21/46] softfloat: Use pointers with ftype_pack_raw Date: Sun, 16 May 2021 07:34:06 -0500 Message-Id: <20210516123431.718318-22-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::72b; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x72b.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 44 ++++++++++++++++++++++++-------------------- 1 file changed, 24 insertions(+), 20 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index b59b777bca..e02cbafaf9 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -626,24 +626,24 @@ static uint64_t pack_raw64(const FloatParts64 *p, con= st FloatFmt *fmt) return ret; } =20 -static inline float16 float16_pack_raw(FloatParts64 p) +static inline float16 float16_pack_raw(const FloatParts64 *p) { - return make_float16(pack_raw64(&p, &float16_params)); + return make_float16(pack_raw64(p, &float16_params)); } =20 -static inline bfloat16 bfloat16_pack_raw(FloatParts64 p) +static inline bfloat16 bfloat16_pack_raw(const FloatParts64 *p) { - return pack_raw64(&p, &bfloat16_params); + return pack_raw64(p, &bfloat16_params); } =20 -static inline float32 float32_pack_raw(FloatParts64 p) +static inline float32 float32_pack_raw(const FloatParts64 *p) { - return make_float32(pack_raw64(&p, &float32_params)); + return make_float32(pack_raw64(p, &float32_params)); } =20 -static inline float64 float64_pack_raw(FloatParts64 p) +static inline float64 float64_pack_raw(const FloatParts64 *p) { - return make_float64(pack_raw64(&p, &float64_params)); + return make_float64(pack_raw64(p, &float64_params)); } =20 /*------------------------------------------------------------------------= ---- @@ -950,7 +950,8 @@ static FloatParts64 bfloat16_unpack_canonical(bfloat16 = f, float_status *s) static float16 float16a_round_pack_canonical(FloatParts64 p, float_status = *s, const FloatFmt *params) { - return float16_pack_raw(round_canonical(p, s, params)); + p =3D round_canonical(p, s, params); + return float16_pack_raw(&p); } =20 static float16 float16_round_pack_canonical(FloatParts64 p, float_status *= s) @@ -960,7 +961,8 @@ static float16 float16_round_pack_canonical(FloatParts6= 4 p, float_status *s) =20 static bfloat16 bfloat16_round_pack_canonical(FloatParts64 p, float_status= *s) { - return bfloat16_pack_raw(round_canonical(p, s, &bfloat16_params)); + p =3D round_canonical(p, s, &bfloat16_params); + return bfloat16_pack_raw(&p); } =20 static FloatParts64 float32_unpack_canonical(float32 f, float_status *s) @@ -973,7 +975,8 @@ static FloatParts64 float32_unpack_canonical(float32 f,= float_status *s) =20 static float32 float32_round_pack_canonical(FloatParts64 p, float_status *= s) { - return float32_pack_raw(round_canonical(p, s, &float32_params)); + p =3D round_canonical(p, s, &float32_params); + return float32_pack_raw(&p); } =20 static FloatParts64 float64_unpack_canonical(float64 f, float_status *s) @@ -986,7 +989,8 @@ static FloatParts64 float64_unpack_canonical(float64 f,= float_status *s) =20 static float64 float64_round_pack_canonical(FloatParts64 p, float_status *= s) { - return float64_pack_raw(round_canonical(p, s, &float64_params)); + p =3D round_canonical(p, s, &float64_params); + return float64_pack_raw(&p); } =20 /* @@ -3603,7 +3607,7 @@ float16 float16_default_nan(float_status *status) =20 parts_default_nan(&p, status); p.frac >>=3D float16_params.frac_shift; - return float16_pack_raw(p); + return float16_pack_raw(&p); } =20 float32 float32_default_nan(float_status *status) @@ -3612,7 +3616,7 @@ float32 float32_default_nan(float_status *status) =20 parts_default_nan(&p, status); p.frac >>=3D float32_params.frac_shift; - return float32_pack_raw(p); + return float32_pack_raw(&p); } =20 float64 float64_default_nan(float_status *status) @@ -3621,7 +3625,7 @@ float64 float64_default_nan(float_status *status) =20 parts_default_nan(&p, status); p.frac >>=3D float64_params.frac_shift; - return float64_pack_raw(p); + return float64_pack_raw(&p); } =20 float128 float128_default_nan(float_status *status) @@ -3648,7 +3652,7 @@ bfloat16 bfloat16_default_nan(float_status *status) =20 parts_default_nan(&p, status); p.frac >>=3D bfloat16_params.frac_shift; - return bfloat16_pack_raw(p); + return bfloat16_pack_raw(&p); } =20 /*------------------------------------------------------------------------= ---- @@ -3663,7 +3667,7 @@ float16 float16_silence_nan(float16 a, float_status *= status) p.frac <<=3D float16_params.frac_shift; p =3D parts_silence_nan(p, status); p.frac >>=3D float16_params.frac_shift; - return float16_pack_raw(p); + return float16_pack_raw(&p); } =20 float32 float32_silence_nan(float32 a, float_status *status) @@ -3674,7 +3678,7 @@ float32 float32_silence_nan(float32 a, float_status *= status) p.frac <<=3D float32_params.frac_shift; p =3D parts_silence_nan(p, status); p.frac >>=3D float32_params.frac_shift; - return float32_pack_raw(p); + return float32_pack_raw(&p); } =20 float64 float64_silence_nan(float64 a, float_status *status) @@ -3685,7 +3689,7 @@ float64 float64_silence_nan(float64 a, float_status *= status) p.frac <<=3D float64_params.frac_shift; p =3D parts_silence_nan(p, status); p.frac >>=3D float64_params.frac_shift; - return float64_pack_raw(p); + return float64_pack_raw(&p); } =20 bfloat16 bfloat16_silence_nan(bfloat16 a, float_status *status) @@ -3696,7 +3700,7 @@ bfloat16 bfloat16_silence_nan(bfloat16 a, float_statu= s *status) p.frac <<=3D bfloat16_params.frac_shift; p =3D parts_silence_nan(p, status); p.frac >>=3D bfloat16_params.frac_shift; - return bfloat16_pack_raw(p); + return bfloat16_pack_raw(&p); } =20 /*------------------------------------------------------------------------= ---- --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621168857; cv=none; d=zohomail.com; s=zohoarc; b=B757cI1NM3SgLWnwyDly81M3nBRPVHctC+c+XDySDv/yV5nFL/8lpXcVXumLW2gWV5j1QLTOOSc99EXdBXZAG+ZJEknF7/X1YGjHcV2ibKT/mGBnVgdairg/xoQb0czNVZvY8Sjb11tpRYmAV625hlA3ekurrhOx1SMlRRdLIZE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621168857; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=V7hUeiPFQkvahBGT2smLwtNp0TEukAyH7yxlNzzFq8Y=; b=TJcNHO9vfIEU3ubLgUEJW/ZnkIvViHlAT0JPKRl2osQgm66ISd2PmRbxNsRHOTnas2LjjAXhg0Palq2OszrksCFtmOfm/P6HsS25sdJcvRSDiF44GIUqMs/Jw8ityQOXah/+l4E5eWe4ZkyC20lk8Ty6aA2iqdYH6aHpXhMm7fo= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621168857047793.5204852177262; Sun, 16 May 2021 05:40:57 -0700 (PDT) Received: from localhost ([::1]:36768 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG4l-0007UZ-QI for importer@patchew.org; Sun, 16 May 2021 08:40:55 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43316) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzJ-0007g4-95 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:20 -0400 Received: from mail-qt1-x82e.google.com ([2607:f8b0:4864:20::82e]:33475) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz1-0007n2-EX for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:14 -0400 Received: by mail-qt1-x82e.google.com with SMTP id 1so3064623qtb.0 for ; Sun, 16 May 2021 05:34:51 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=V7hUeiPFQkvahBGT2smLwtNp0TEukAyH7yxlNzzFq8Y=; b=eB4qI7rEqFRrg8yeDCDC9MvYv4SHyXTwph6d93YseFPSOg+AASEK223ZDvLyKKpsx+ IWSwuenWxzvPfEnZO0qPIW2sj9GhhwCyoZFNmo/9+cw6UAc4Lvr2/FAouDU41KeZ5ATH y5WI2oKGujYxmTA0w+CsU2hZjeZBvX/RZZkdUzV7faxsO4CjTvMIky0UVOtHTFVKeCBB MeB6r2/Fo1uWDU9hMXoB3EjAg0VSxZ84xDfeMQOkb+76xH5rAc9/zgo13Bmp1XlkhbUN klevz7TyohKh2xNedJZyrVMMu7Aeo1s5S6dukGQ9GMDhaJZRwypQTRa36+8t0h3sd9UM RkYw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=V7hUeiPFQkvahBGT2smLwtNp0TEukAyH7yxlNzzFq8Y=; b=Fmi2GNDSx56Pn6a0DQJHeP2Jb4i51DU859topxzmD1QARWyMXgmKK5GGz1sUlPGr47 97UKyHF4CgzrYz6VJRJOASR47j8wDnkSFBTsV7atIO/bk8Ddtfa/EWYsHeDPGzTDO7IY AA2LTR+PgCcpQw1OCn5S9/Rj1v0vIseP/Ec3nC2ypA2zl1bUuDZjMX8UmI8bRCiSKqUa URtvHmnplo6iQPGGxkp+Q6dSHOsqUmUDLknJs1qjFjg1GKP0HM/bUgoNRgxbH4T5O0ZZ 6VZeJBy8s2Ww8js2DOea7b/F6nLaFBwI6KLyBlO/bWU+xJMcT4Tgbbwf628SN/ayxwzN g1EQ== X-Gm-Message-State: AOAM530xkzcAklukRONyQW3qsHPlw4ed9IUfotIoC16i82mGifrO6RkG UZcokkq8Rigeg6uBoGzjOC5ULO2GgyvKYvobViI= X-Google-Smtp-Source: ABdhPJygcrDOUHpQZX8Ue2RNx0jWAP4OJor50COg1j7X62Herh4oS2mfiqL+vrTtvWXTozdVHl2QeQ== X-Received: by 2002:ac8:1183:: with SMTP id d3mr52099132qtj.390.1621168491290; Sun, 16 May 2021 05:34:51 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 22/46] softfloat: Use pointers with ftype_unpack_canonical Date: Sun, 16 May 2021 07:34:07 -0500 Message-Id: <20210516123431.718318-23-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::82e; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x82e.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 509 ++++++++++++++++++++++++++++++------------------ 1 file changed, 320 insertions(+), 189 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index e02cbafaf9..e53d4a138f 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -925,26 +925,24 @@ static FloatParts64 pick_nan_muladd(FloatParts64 a, F= loatParts64 b, FloatParts64 * Pack/unpack routines with a specific FloatFmt. */ =20 -static FloatParts64 float16a_unpack_canonical(float16 f, float_status *s, - const FloatFmt *params) +static void float16a_unpack_canonical(FloatParts64 *p, float16 f, + float_status *s, const FloatFmt *par= ams) { - FloatParts64 p; - - float16_unpack_raw(&p, f); - return sf_canonicalize(p, params, s); + float16_unpack_raw(p, f); + *p =3D sf_canonicalize(*p, params, s); } =20 -static FloatParts64 float16_unpack_canonical(float16 f, float_status *s) +static void float16_unpack_canonical(FloatParts64 *p, float16 f, + float_status *s) { - return float16a_unpack_canonical(f, s, &float16_params); + float16a_unpack_canonical(p, f, s, &float16_params); } =20 -static FloatParts64 bfloat16_unpack_canonical(bfloat16 f, float_status *s) +static void bfloat16_unpack_canonical(FloatParts64 *p, bfloat16 f, + float_status *s) { - FloatParts64 p; - - bfloat16_unpack_raw(&p, f); - return sf_canonicalize(p, &bfloat16_params, s); + bfloat16_unpack_raw(p, f); + *p =3D sf_canonicalize(*p, &bfloat16_params, s); } =20 static float16 float16a_round_pack_canonical(FloatParts64 p, float_status = *s, @@ -965,12 +963,11 @@ static bfloat16 bfloat16_round_pack_canonical(FloatPa= rts64 p, float_status *s) return bfloat16_pack_raw(&p); } =20 -static FloatParts64 float32_unpack_canonical(float32 f, float_status *s) +static void float32_unpack_canonical(FloatParts64 *p, float32 f, + float_status *s) { - FloatParts64 p; - - float32_unpack_raw(&p, f); - return sf_canonicalize(p, &float32_params, s); + float32_unpack_raw(p, f); + *p =3D sf_canonicalize(*p, &float32_params, s); } =20 static float32 float32_round_pack_canonical(FloatParts64 p, float_status *= s) @@ -979,12 +976,11 @@ static float32 float32_round_pack_canonical(FloatPart= s64 p, float_status *s) return float32_pack_raw(&p); } =20 -static FloatParts64 float64_unpack_canonical(float64 f, float_status *s) +static void float64_unpack_canonical(FloatParts64 *p, float64 f, + float_status *s) { - FloatParts64 p; - - float64_unpack_raw(&p, f); - return sf_canonicalize(p, &float64_params, s); + float64_unpack_raw(p, f); + *p =3D sf_canonicalize(*p, &float64_params, s); } =20 static float64 float64_round_pack_canonical(FloatParts64 p, float_status *= s) @@ -1091,18 +1087,22 @@ static FloatParts64 addsub_floats(FloatParts64 a, F= loatParts64 b, bool subtract, =20 float16 QEMU_FLATTEN float16_add(float16 a, float16 b, float_status *statu= s) { - FloatParts64 pa =3D float16_unpack_canonical(a, status); - FloatParts64 pb =3D float16_unpack_canonical(b, status); - FloatParts64 pr =3D addsub_floats(pa, pb, false, status); + FloatParts64 pa, pb, pr; + + float16_unpack_canonical(&pa, a, status); + float16_unpack_canonical(&pb, b, status); + pr =3D addsub_floats(pa, pb, false, status); =20 return float16_round_pack_canonical(pr, status); } =20 float16 QEMU_FLATTEN float16_sub(float16 a, float16 b, float_status *statu= s) { - FloatParts64 pa =3D float16_unpack_canonical(a, status); - FloatParts64 pb =3D float16_unpack_canonical(b, status); - FloatParts64 pr =3D addsub_floats(pa, pb, true, status); + FloatParts64 pa, pb, pr; + + float16_unpack_canonical(&pa, a, status); + float16_unpack_canonical(&pb, b, status); + pr =3D addsub_floats(pa, pb, true, status); =20 return float16_round_pack_canonical(pr, status); } @@ -1110,9 +1110,11 @@ float16 QEMU_FLATTEN float16_sub(float16 a, float16 = b, float_status *status) static float32 QEMU_SOFTFLOAT_ATTR soft_f32_addsub(float32 a, float32 b, bool subtract, float_status *status) { - FloatParts64 pa =3D float32_unpack_canonical(a, status); - FloatParts64 pb =3D float32_unpack_canonical(b, status); - FloatParts64 pr =3D addsub_floats(pa, pb, subtract, status); + FloatParts64 pa, pb, pr; + + float32_unpack_canonical(&pa, a, status); + float32_unpack_canonical(&pb, b, status); + pr =3D addsub_floats(pa, pb, subtract, status); =20 return float32_round_pack_canonical(pr, status); } @@ -1130,9 +1132,11 @@ static inline float32 soft_f32_sub(float32 a, float3= 2 b, float_status *status) static float64 QEMU_SOFTFLOAT_ATTR soft_f64_addsub(float64 a, float64 b, bool subtract, float_status *status) { - FloatParts64 pa =3D float64_unpack_canonical(a, status); - FloatParts64 pb =3D float64_unpack_canonical(b, status); - FloatParts64 pr =3D addsub_floats(pa, pb, subtract, status); + FloatParts64 pa, pb, pr; + + float64_unpack_canonical(&pa, a, status); + float64_unpack_canonical(&pb, b, status); + pr =3D addsub_floats(pa, pb, subtract, status); =20 return float64_round_pack_canonical(pr, status); } @@ -1228,18 +1232,22 @@ float64_sub(float64 a, float64 b, float_status *s) */ bfloat16 QEMU_FLATTEN bfloat16_add(bfloat16 a, bfloat16 b, float_status *s= tatus) { - FloatParts64 pa =3D bfloat16_unpack_canonical(a, status); - FloatParts64 pb =3D bfloat16_unpack_canonical(b, status); - FloatParts64 pr =3D addsub_floats(pa, pb, false, status); + FloatParts64 pa, pb, pr; + + bfloat16_unpack_canonical(&pa, a, status); + bfloat16_unpack_canonical(&pb, b, status); + pr =3D addsub_floats(pa, pb, false, status); =20 return bfloat16_round_pack_canonical(pr, status); } =20 bfloat16 QEMU_FLATTEN bfloat16_sub(bfloat16 a, bfloat16 b, float_status *s= tatus) { - FloatParts64 pa =3D bfloat16_unpack_canonical(a, status); - FloatParts64 pb =3D bfloat16_unpack_canonical(b, status); - FloatParts64 pr =3D addsub_floats(pa, pb, true, status); + FloatParts64 pa, pb, pr; + + bfloat16_unpack_canonical(&pa, a, status); + bfloat16_unpack_canonical(&pb, b, status); + pr =3D addsub_floats(pa, pb, true, status); =20 return bfloat16_round_pack_canonical(pr, status); } @@ -1297,9 +1305,11 @@ static FloatParts64 mul_floats(FloatParts64 a, Float= Parts64 b, float_status *s) =20 float16 QEMU_FLATTEN float16_mul(float16 a, float16 b, float_status *statu= s) { - FloatParts64 pa =3D float16_unpack_canonical(a, status); - FloatParts64 pb =3D float16_unpack_canonical(b, status); - FloatParts64 pr =3D mul_floats(pa, pb, status); + FloatParts64 pa, pb, pr; + + float16_unpack_canonical(&pa, a, status); + float16_unpack_canonical(&pb, b, status); + pr =3D mul_floats(pa, pb, status); =20 return float16_round_pack_canonical(pr, status); } @@ -1307,9 +1317,11 @@ float16 QEMU_FLATTEN float16_mul(float16 a, float16 = b, float_status *status) static float32 QEMU_SOFTFLOAT_ATTR soft_f32_mul(float32 a, float32 b, float_status *status) { - FloatParts64 pa =3D float32_unpack_canonical(a, status); - FloatParts64 pb =3D float32_unpack_canonical(b, status); - FloatParts64 pr =3D mul_floats(pa, pb, status); + FloatParts64 pa, pb, pr; + + float32_unpack_canonical(&pa, a, status); + float32_unpack_canonical(&pb, b, status); + pr =3D mul_floats(pa, pb, status); =20 return float32_round_pack_canonical(pr, status); } @@ -1317,9 +1329,11 @@ soft_f32_mul(float32 a, float32 b, float_status *sta= tus) static float64 QEMU_SOFTFLOAT_ATTR soft_f64_mul(float64 a, float64 b, float_status *status) { - FloatParts64 pa =3D float64_unpack_canonical(a, status); - FloatParts64 pb =3D float64_unpack_canonical(b, status); - FloatParts64 pr =3D mul_floats(pa, pb, status); + FloatParts64 pa, pb, pr; + + float64_unpack_canonical(&pa, a, status); + float64_unpack_canonical(&pb, b, status); + pr =3D mul_floats(pa, pb, status); =20 return float64_round_pack_canonical(pr, status); } @@ -1355,9 +1369,11 @@ float64_mul(float64 a, float64 b, float_status *s) =20 bfloat16 QEMU_FLATTEN bfloat16_mul(bfloat16 a, bfloat16 b, float_status *s= tatus) { - FloatParts64 pa =3D bfloat16_unpack_canonical(a, status); - FloatParts64 pb =3D bfloat16_unpack_canonical(b, status); - FloatParts64 pr =3D mul_floats(pa, pb, status); + FloatParts64 pa, pb, pr; + + bfloat16_unpack_canonical(&pa, a, status); + bfloat16_unpack_canonical(&pb, b, status); + pr =3D mul_floats(pa, pb, status); =20 return bfloat16_round_pack_canonical(pr, status); } @@ -1551,10 +1567,12 @@ static FloatParts64 muladd_floats(FloatParts64 a, F= loatParts64 b, FloatParts64 c float16 QEMU_FLATTEN float16_muladd(float16 a, float16 b, float16 c, int flags, float_status *s= tatus) { - FloatParts64 pa =3D float16_unpack_canonical(a, status); - FloatParts64 pb =3D float16_unpack_canonical(b, status); - FloatParts64 pc =3D float16_unpack_canonical(c, status); - FloatParts64 pr =3D muladd_floats(pa, pb, pc, flags, status); + FloatParts64 pa, pb, pc, pr; + + float16_unpack_canonical(&pa, a, status); + float16_unpack_canonical(&pb, b, status); + float16_unpack_canonical(&pc, c, status); + pr =3D muladd_floats(pa, pb, pc, flags, status); =20 return float16_round_pack_canonical(pr, status); } @@ -1563,10 +1581,12 @@ static float32 QEMU_SOFTFLOAT_ATTR soft_f32_muladd(float32 a, float32 b, float32 c, int flags, float_status *status) { - FloatParts64 pa =3D float32_unpack_canonical(a, status); - FloatParts64 pb =3D float32_unpack_canonical(b, status); - FloatParts64 pc =3D float32_unpack_canonical(c, status); - FloatParts64 pr =3D muladd_floats(pa, pb, pc, flags, status); + FloatParts64 pa, pb, pc, pr; + + float32_unpack_canonical(&pa, a, status); + float32_unpack_canonical(&pb, b, status); + float32_unpack_canonical(&pc, c, status); + pr =3D muladd_floats(pa, pb, pc, flags, status); =20 return float32_round_pack_canonical(pr, status); } @@ -1575,10 +1595,12 @@ static float64 QEMU_SOFTFLOAT_ATTR soft_f64_muladd(float64 a, float64 b, float64 c, int flags, float_status *status) { - FloatParts64 pa =3D float64_unpack_canonical(a, status); - FloatParts64 pb =3D float64_unpack_canonical(b, status); - FloatParts64 pc =3D float64_unpack_canonical(c, status); - FloatParts64 pr =3D muladd_floats(pa, pb, pc, flags, status); + FloatParts64 pa, pb, pc, pr; + + float64_unpack_canonical(&pa, a, status); + float64_unpack_canonical(&pb, b, status); + float64_unpack_canonical(&pc, c, status); + pr =3D muladd_floats(pa, pb, pc, flags, status); =20 return float64_round_pack_canonical(pr, status); } @@ -1736,10 +1758,12 @@ float64_muladd(float64 xa, float64 xb, float64 xc, = int flags, float_status *s) bfloat16 QEMU_FLATTEN bfloat16_muladd(bfloat16 a, bfloat16 b, bfloat16 c, int flags, float_status *status) { - FloatParts64 pa =3D bfloat16_unpack_canonical(a, status); - FloatParts64 pb =3D bfloat16_unpack_canonical(b, status); - FloatParts64 pc =3D bfloat16_unpack_canonical(c, status); - FloatParts64 pr =3D muladd_floats(pa, pb, pc, flags, status); + FloatParts64 pa, pb, pc, pr; + + bfloat16_unpack_canonical(&pa, a, status); + bfloat16_unpack_canonical(&pb, b, status); + bfloat16_unpack_canonical(&pc, c, status); + pr =3D muladd_floats(pa, pb, pc, flags, status); =20 return bfloat16_round_pack_canonical(pr, status); } @@ -1818,9 +1842,11 @@ static FloatParts64 div_floats(FloatParts64 a, Float= Parts64 b, float_status *s) =20 float16 float16_div(float16 a, float16 b, float_status *status) { - FloatParts64 pa =3D float16_unpack_canonical(a, status); - FloatParts64 pb =3D float16_unpack_canonical(b, status); - FloatParts64 pr =3D div_floats(pa, pb, status); + FloatParts64 pa, pb, pr; + + float16_unpack_canonical(&pa, a, status); + float16_unpack_canonical(&pb, b, status); + pr =3D div_floats(pa, pb, status); =20 return float16_round_pack_canonical(pr, status); } @@ -1828,9 +1854,11 @@ float16 float16_div(float16 a, float16 b, float_stat= us *status) static float32 QEMU_SOFTFLOAT_ATTR soft_f32_div(float32 a, float32 b, float_status *status) { - FloatParts64 pa =3D float32_unpack_canonical(a, status); - FloatParts64 pb =3D float32_unpack_canonical(b, status); - FloatParts64 pr =3D div_floats(pa, pb, status); + FloatParts64 pa, pb, pr; + + float32_unpack_canonical(&pa, a, status); + float32_unpack_canonical(&pb, b, status); + pr =3D div_floats(pa, pb, status); =20 return float32_round_pack_canonical(pr, status); } @@ -1838,9 +1866,11 @@ soft_f32_div(float32 a, float32 b, float_status *sta= tus) static float64 QEMU_SOFTFLOAT_ATTR soft_f64_div(float64 a, float64 b, float_status *status) { - FloatParts64 pa =3D float64_unpack_canonical(a, status); - FloatParts64 pb =3D float64_unpack_canonical(b, status); - FloatParts64 pr =3D div_floats(pa, pb, status); + FloatParts64 pa, pb, pr; + + float64_unpack_canonical(&pa, a, status); + float64_unpack_canonical(&pb, b, status); + pr =3D div_floats(pa, pb, status); =20 return float64_round_pack_canonical(pr, status); } @@ -1910,9 +1940,11 @@ float64_div(float64 a, float64 b, float_status *s) =20 bfloat16 bfloat16_div(bfloat16 a, bfloat16 b, float_status *status) { - FloatParts64 pa =3D bfloat16_unpack_canonical(a, status); - FloatParts64 pb =3D bfloat16_unpack_canonical(b, status); - FloatParts64 pr =3D div_floats(pa, pb, status); + FloatParts64 pa, pb, pr; + + bfloat16_unpack_canonical(&pa, a, status); + bfloat16_unpack_canonical(&pb, b, status); + pr =3D div_floats(pa, pb, status); =20 return bfloat16_round_pack_canonical(pr, status); } @@ -1966,32 +1998,40 @@ static FloatParts64 float_to_float(FloatParts64 a, = const FloatFmt *dstf, float32 float16_to_float32(float16 a, bool ieee, float_status *s) { const FloatFmt *fmt16 =3D ieee ? &float16_params : &float16_params_ahp; - FloatParts64 p =3D float16a_unpack_canonical(a, s, fmt16); - FloatParts64 pr =3D float_to_float(p, &float32_params, s); + FloatParts64 pa, pr; + + float16a_unpack_canonical(&pa, a, s, fmt16); + pr =3D float_to_float(pa, &float32_params, s); return float32_round_pack_canonical(pr, s); } =20 float64 float16_to_float64(float16 a, bool ieee, float_status *s) { const FloatFmt *fmt16 =3D ieee ? &float16_params : &float16_params_ahp; - FloatParts64 p =3D float16a_unpack_canonical(a, s, fmt16); - FloatParts64 pr =3D float_to_float(p, &float64_params, s); + FloatParts64 pa, pr; + + float16a_unpack_canonical(&pa, a, s, fmt16); + pr =3D float_to_float(pa, &float64_params, s); return float64_round_pack_canonical(pr, s); } =20 float16 float32_to_float16(float32 a, bool ieee, float_status *s) { const FloatFmt *fmt16 =3D ieee ? &float16_params : &float16_params_ahp; - FloatParts64 p =3D float32_unpack_canonical(a, s); - FloatParts64 pr =3D float_to_float(p, fmt16, s); + FloatParts64 pa, pr; + + float32_unpack_canonical(&pa, a, s); + pr =3D float_to_float(pa, fmt16, s); return float16a_round_pack_canonical(pr, s, fmt16); } =20 static float64 QEMU_SOFTFLOAT_ATTR soft_float32_to_float64(float32 a, float_status *s) { - FloatParts64 p =3D float32_unpack_canonical(a, s); - FloatParts64 pr =3D float_to_float(p, &float64_params, s); + FloatParts64 pa, pr; + + float32_unpack_canonical(&pa, a, s); + pr =3D float_to_float(pa, &float64_params, s); return float64_round_pack_canonical(pr, s); } =20 @@ -2014,43 +2054,55 @@ float64 float32_to_float64(float32 a, float_status = *s) float16 float64_to_float16(float64 a, bool ieee, float_status *s) { const FloatFmt *fmt16 =3D ieee ? &float16_params : &float16_params_ahp; - FloatParts64 p =3D float64_unpack_canonical(a, s); - FloatParts64 pr =3D float_to_float(p, fmt16, s); + FloatParts64 pa, pr; + + float64_unpack_canonical(&pa, a, s); + pr =3D float_to_float(pa, fmt16, s); return float16a_round_pack_canonical(pr, s, fmt16); } =20 float32 float64_to_float32(float64 a, float_status *s) { - FloatParts64 p =3D float64_unpack_canonical(a, s); - FloatParts64 pr =3D float_to_float(p, &float32_params, s); + FloatParts64 pa, pr; + + float64_unpack_canonical(&pa, a, s); + pr =3D float_to_float(pa, &float32_params, s); return float32_round_pack_canonical(pr, s); } =20 float32 bfloat16_to_float32(bfloat16 a, float_status *s) { - FloatParts64 p =3D bfloat16_unpack_canonical(a, s); - FloatParts64 pr =3D float_to_float(p, &float32_params, s); + FloatParts64 pa, pr; + + bfloat16_unpack_canonical(&pa, a, s); + pr =3D float_to_float(pa, &float32_params, s); return float32_round_pack_canonical(pr, s); } =20 float64 bfloat16_to_float64(bfloat16 a, float_status *s) { - FloatParts64 p =3D bfloat16_unpack_canonical(a, s); - FloatParts64 pr =3D float_to_float(p, &float64_params, s); + FloatParts64 pa, pr; + + bfloat16_unpack_canonical(&pa, a, s); + pr =3D float_to_float(pa, &float64_params, s); return float64_round_pack_canonical(pr, s); } =20 bfloat16 float32_to_bfloat16(float32 a, float_status *s) { - FloatParts64 p =3D float32_unpack_canonical(a, s); - FloatParts64 pr =3D float_to_float(p, &bfloat16_params, s); + FloatParts64 pa, pr; + + float32_unpack_canonical(&pa, a, s); + pr =3D float_to_float(pa, &bfloat16_params, s); return bfloat16_round_pack_canonical(pr, s); } =20 bfloat16 float64_to_bfloat16(float64 a, float_status *s) { - FloatParts64 p =3D float64_unpack_canonical(a, s); - FloatParts64 pr =3D float_to_float(p, &bfloat16_params, s); + FloatParts64 pa, pr; + + float64_unpack_canonical(&pa, a, s); + pr =3D float_to_float(pa, &bfloat16_params, s); return bfloat16_round_pack_canonical(pr, s); } =20 @@ -2164,22 +2216,28 @@ static FloatParts64 round_to_int(FloatParts64 a, Fl= oatRoundMode rmode, =20 float16 float16_round_to_int(float16 a, float_status *s) { - FloatParts64 pa =3D float16_unpack_canonical(a, s); - FloatParts64 pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); + FloatParts64 pa, pr; + + float16_unpack_canonical(&pa, a, s); + pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); return float16_round_pack_canonical(pr, s); } =20 float32 float32_round_to_int(float32 a, float_status *s) { - FloatParts64 pa =3D float32_unpack_canonical(a, s); - FloatParts64 pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); + FloatParts64 pa, pr; + + float32_unpack_canonical(&pa, a, s); + pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); return float32_round_pack_canonical(pr, s); } =20 float64 float64_round_to_int(float64 a, float_status *s) { - FloatParts64 pa =3D float64_unpack_canonical(a, s); - FloatParts64 pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); + FloatParts64 pa, pr; + + float64_unpack_canonical(&pa, a, s); + pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); return float64_round_pack_canonical(pr, s); } =20 @@ -2190,8 +2248,10 @@ float64 float64_round_to_int(float64 a, float_status= *s) =20 bfloat16 bfloat16_round_to_int(bfloat16 a, float_status *s) { - FloatParts64 pa =3D bfloat16_unpack_canonical(a, s); - FloatParts64 pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); + FloatParts64 pa, pr; + + bfloat16_unpack_canonical(&pa, a, s); + pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); return bfloat16_round_pack_canonical(pr, s); } =20 @@ -2253,71 +2313,91 @@ static int64_t round_to_int_and_pack(FloatParts64 i= n, FloatRoundMode rmode, int8_t float16_to_int8_scalbn(float16 a, FloatRoundMode rmode, int scale, float_status *s) { - return round_to_int_and_pack(float16_unpack_canonical(a, s), - rmode, scale, INT8_MIN, INT8_MAX, s); + FloatParts64 p; + + float16_unpack_canonical(&p, a, s); + return round_to_int_and_pack(p, rmode, scale, INT8_MIN, INT8_MAX, s); } =20 int16_t float16_to_int16_scalbn(float16 a, FloatRoundMode rmode, int scale, float_status *s) { - return round_to_int_and_pack(float16_unpack_canonical(a, s), - rmode, scale, INT16_MIN, INT16_MAX, s); + FloatParts64 p; + + float16_unpack_canonical(&p, a, s); + return round_to_int_and_pack(p, rmode, scale, INT16_MIN, INT16_MAX, s); } =20 int32_t float16_to_int32_scalbn(float16 a, FloatRoundMode rmode, int scale, float_status *s) { - return round_to_int_and_pack(float16_unpack_canonical(a, s), - rmode, scale, INT32_MIN, INT32_MAX, s); + FloatParts64 p; + + float16_unpack_canonical(&p, a, s); + return round_to_int_and_pack(p, rmode, scale, INT32_MIN, INT32_MAX, s); } =20 int64_t float16_to_int64_scalbn(float16 a, FloatRoundMode rmode, int scale, float_status *s) { - return round_to_int_and_pack(float16_unpack_canonical(a, s), - rmode, scale, INT64_MIN, INT64_MAX, s); + FloatParts64 p; + + float16_unpack_canonical(&p, a, s); + return round_to_int_and_pack(p, rmode, scale, INT64_MIN, INT64_MAX, s); } =20 int16_t float32_to_int16_scalbn(float32 a, FloatRoundMode rmode, int scale, float_status *s) { - return round_to_int_and_pack(float32_unpack_canonical(a, s), - rmode, scale, INT16_MIN, INT16_MAX, s); + FloatParts64 p; + + float32_unpack_canonical(&p, a, s); + return round_to_int_and_pack(p, rmode, scale, INT16_MIN, INT16_MAX, s); } =20 int32_t float32_to_int32_scalbn(float32 a, FloatRoundMode rmode, int scale, float_status *s) { - return round_to_int_and_pack(float32_unpack_canonical(a, s), - rmode, scale, INT32_MIN, INT32_MAX, s); + FloatParts64 p; + + float32_unpack_canonical(&p, a, s); + return round_to_int_and_pack(p, rmode, scale, INT32_MIN, INT32_MAX, s); } =20 int64_t float32_to_int64_scalbn(float32 a, FloatRoundMode rmode, int scale, float_status *s) { - return round_to_int_and_pack(float32_unpack_canonical(a, s), - rmode, scale, INT64_MIN, INT64_MAX, s); + FloatParts64 p; + + float32_unpack_canonical(&p, a, s); + return round_to_int_and_pack(p, rmode, scale, INT64_MIN, INT64_MAX, s); } =20 int16_t float64_to_int16_scalbn(float64 a, FloatRoundMode rmode, int scale, float_status *s) { - return round_to_int_and_pack(float64_unpack_canonical(a, s), - rmode, scale, INT16_MIN, INT16_MAX, s); + FloatParts64 p; + + float64_unpack_canonical(&p, a, s); + return round_to_int_and_pack(p, rmode, scale, INT16_MIN, INT16_MAX, s); } =20 int32_t float64_to_int32_scalbn(float64 a, FloatRoundMode rmode, int scale, float_status *s) { - return round_to_int_and_pack(float64_unpack_canonical(a, s), - rmode, scale, INT32_MIN, INT32_MAX, s); + FloatParts64 p; + + float64_unpack_canonical(&p, a, s); + return round_to_int_and_pack(p, rmode, scale, INT32_MIN, INT32_MAX, s); } =20 int64_t float64_to_int64_scalbn(float64 a, FloatRoundMode rmode, int scale, float_status *s) { - return round_to_int_and_pack(float64_unpack_canonical(a, s), - rmode, scale, INT64_MIN, INT64_MAX, s); + FloatParts64 p; + + float64_unpack_canonical(&p, a, s); + return round_to_int_and_pack(p, rmode, scale, INT64_MIN, INT64_MAX, s); } =20 int8_t float16_to_int8(float16 a, float_status *s) @@ -2423,22 +2503,28 @@ int64_t float64_to_int64_round_to_zero(float64 a, f= loat_status *s) int16_t bfloat16_to_int16_scalbn(bfloat16 a, FloatRoundMode rmode, int sca= le, float_status *s) { - return round_to_int_and_pack(bfloat16_unpack_canonical(a, s), - rmode, scale, INT16_MIN, INT16_MAX, s); + FloatParts64 p; + + bfloat16_unpack_canonical(&p, a, s); + return round_to_int_and_pack(p, rmode, scale, INT16_MIN, INT16_MAX, s); } =20 int32_t bfloat16_to_int32_scalbn(bfloat16 a, FloatRoundMode rmode, int sca= le, float_status *s) { - return round_to_int_and_pack(bfloat16_unpack_canonical(a, s), - rmode, scale, INT32_MIN, INT32_MAX, s); + FloatParts64 p; + + bfloat16_unpack_canonical(&p, a, s); + return round_to_int_and_pack(p, rmode, scale, INT32_MIN, INT32_MAX, s); } =20 int64_t bfloat16_to_int64_scalbn(bfloat16 a, FloatRoundMode rmode, int sca= le, float_status *s) { - return round_to_int_and_pack(bfloat16_unpack_canonical(a, s), - rmode, scale, INT64_MIN, INT64_MAX, s); + FloatParts64 p; + + bfloat16_unpack_canonical(&p, a, s); + return round_to_int_and_pack(p, rmode, scale, INT64_MIN, INT64_MAX, s); } =20 int16_t bfloat16_to_int16(bfloat16 a, float_status *s) @@ -2532,71 +2618,91 @@ static uint64_t round_to_uint_and_pack(FloatParts64= in, FloatRoundMode rmode, uint8_t float16_to_uint8_scalbn(float16 a, FloatRoundMode rmode, int scale, float_status *s) { - return round_to_uint_and_pack(float16_unpack_canonical(a, s), - rmode, scale, UINT8_MAX, s); + FloatParts64 p; + + float16_unpack_canonical(&p, a, s); + return round_to_uint_and_pack(p, rmode, scale, UINT8_MAX, s); } =20 uint16_t float16_to_uint16_scalbn(float16 a, FloatRoundMode rmode, int sca= le, float_status *s) { - return round_to_uint_and_pack(float16_unpack_canonical(a, s), - rmode, scale, UINT16_MAX, s); + FloatParts64 p; + + float16_unpack_canonical(&p, a, s); + return round_to_uint_and_pack(p, rmode, scale, UINT16_MAX, s); } =20 uint32_t float16_to_uint32_scalbn(float16 a, FloatRoundMode rmode, int sca= le, float_status *s) { - return round_to_uint_and_pack(float16_unpack_canonical(a, s), - rmode, scale, UINT32_MAX, s); + FloatParts64 p; + + float16_unpack_canonical(&p, a, s); + return round_to_uint_and_pack(p, rmode, scale, UINT32_MAX, s); } =20 uint64_t float16_to_uint64_scalbn(float16 a, FloatRoundMode rmode, int sca= le, float_status *s) { - return round_to_uint_and_pack(float16_unpack_canonical(a, s), - rmode, scale, UINT64_MAX, s); + FloatParts64 p; + + float16_unpack_canonical(&p, a, s); + return round_to_uint_and_pack(p, rmode, scale, UINT64_MAX, s); } =20 uint16_t float32_to_uint16_scalbn(float32 a, FloatRoundMode rmode, int sca= le, float_status *s) { - return round_to_uint_and_pack(float32_unpack_canonical(a, s), - rmode, scale, UINT16_MAX, s); + FloatParts64 p; + + float32_unpack_canonical(&p, a, s); + return round_to_uint_and_pack(p, rmode, scale, UINT16_MAX, s); } =20 uint32_t float32_to_uint32_scalbn(float32 a, FloatRoundMode rmode, int sca= le, float_status *s) { - return round_to_uint_and_pack(float32_unpack_canonical(a, s), - rmode, scale, UINT32_MAX, s); + FloatParts64 p; + + float32_unpack_canonical(&p, a, s); + return round_to_uint_and_pack(p, rmode, scale, UINT32_MAX, s); } =20 uint64_t float32_to_uint64_scalbn(float32 a, FloatRoundMode rmode, int sca= le, float_status *s) { - return round_to_uint_and_pack(float32_unpack_canonical(a, s), - rmode, scale, UINT64_MAX, s); + FloatParts64 p; + + float32_unpack_canonical(&p, a, s); + return round_to_uint_and_pack(p, rmode, scale, UINT64_MAX, s); } =20 uint16_t float64_to_uint16_scalbn(float64 a, FloatRoundMode rmode, int sca= le, float_status *s) { - return round_to_uint_and_pack(float64_unpack_canonical(a, s), - rmode, scale, UINT16_MAX, s); + FloatParts64 p; + + float64_unpack_canonical(&p, a, s); + return round_to_uint_and_pack(p, rmode, scale, UINT16_MAX, s); } =20 uint32_t float64_to_uint32_scalbn(float64 a, FloatRoundMode rmode, int sca= le, float_status *s) { - return round_to_uint_and_pack(float64_unpack_canonical(a, s), - rmode, scale, UINT32_MAX, s); + FloatParts64 p; + + float64_unpack_canonical(&p, a, s); + return round_to_uint_and_pack(p, rmode, scale, UINT32_MAX, s); } =20 uint64_t float64_to_uint64_scalbn(float64 a, FloatRoundMode rmode, int sca= le, float_status *s) { - return round_to_uint_and_pack(float64_unpack_canonical(a, s), - rmode, scale, UINT64_MAX, s); + FloatParts64 p; + + float64_unpack_canonical(&p, a, s); + return round_to_uint_and_pack(p, rmode, scale, UINT64_MAX, s); } =20 uint8_t float16_to_uint8(float16 a, float_status *s) @@ -2702,22 +2808,28 @@ uint64_t float64_to_uint64_round_to_zero(float64 a,= float_status *s) uint16_t bfloat16_to_uint16_scalbn(bfloat16 a, FloatRoundMode rmode, int scale, float_status *s) { - return round_to_uint_and_pack(bfloat16_unpack_canonical(a, s), - rmode, scale, UINT16_MAX, s); + FloatParts64 p; + + bfloat16_unpack_canonical(&p, a, s); + return round_to_uint_and_pack(p, rmode, scale, UINT16_MAX, s); } =20 uint32_t bfloat16_to_uint32_scalbn(bfloat16 a, FloatRoundMode rmode, int scale, float_status *s) { - return round_to_uint_and_pack(bfloat16_unpack_canonical(a, s), - rmode, scale, UINT32_MAX, s); + FloatParts64 p; + + bfloat16_unpack_canonical(&p, a, s); + return round_to_uint_and_pack(p, rmode, scale, UINT32_MAX, s); } =20 uint64_t bfloat16_to_uint64_scalbn(bfloat16 a, FloatRoundMode rmode, int scale, float_status *s) { - return round_to_uint_and_pack(bfloat16_unpack_canonical(a, s), - rmode, scale, UINT64_MAX, s); + FloatParts64 p; + + bfloat16_unpack_canonical(&p, a, s); + return round_to_uint_and_pack(p, rmode, scale, UINT64_MAX, s); } =20 uint16_t bfloat16_to_uint16(bfloat16 a, float_status *s) @@ -3168,10 +3280,10 @@ static FloatParts64 minmax_floats(FloatParts64 a, F= loatParts64 b, bool ismin, float ## sz float ## sz ## _ ## name(float ## sz a, float ## sz b, \ float_status *s) \ { \ - FloatParts64 pa =3D float ## sz ## _unpack_canonical(a, s); = \ - FloatParts64 pb =3D float ## sz ## _unpack_canonical(b, s); = \ - FloatParts64 pr =3D minmax_floats(pa, pb, ismin, isiee, ismag, s); = \ - \ + FloatParts64 pa, pb, pr; \ + float ## sz ## _unpack_canonical(&pa, a, s); \ + float ## sz ## _unpack_canonical(&pb, b, s); \ + pr =3D minmax_floats(pa, pb, ismin, isiee, ismag, s); \ return float ## sz ## _round_pack_canonical(pr, s); \ } =20 @@ -3201,10 +3313,10 @@ MINMAX(64, maxnummag, false, true, true) #define BF16_MINMAX(name, ismin, isiee, ismag) \ bfloat16 bfloat16_ ## name(bfloat16 a, bfloat16 b, float_status *s) \ { \ - FloatParts64 pa =3D bfloat16_unpack_canonical(a, s); = \ - FloatParts64 pb =3D bfloat16_unpack_canonical(b, s); = \ - FloatParts64 pr =3D minmax_floats(pa, pb, ismin, isiee, ismag, s); = \ - \ + FloatParts64 pa, pb, pr; \ + bfloat16_unpack_canonical(&pa, a, s); \ + bfloat16_unpack_canonical(&pb, b, s); \ + pr =3D minmax_floats(pa, pb, ismin, isiee, ismag, s); \ return bfloat16_round_pack_canonical(pr, s); \ } =20 @@ -3279,8 +3391,9 @@ static FloatRelation compare_floats(FloatParts64 a, F= loatParts64 b, bool is_quie static int attr \ name(float ## sz a, float ## sz b, bool is_quiet, float_status *s) \ { \ - FloatParts64 pa =3D float ## sz ## _unpack_canonical(a, s); = \ - FloatParts64 pb =3D float ## sz ## _unpack_canonical(b, s); = \ + FloatParts64 pa, pb; \ + float ## sz ## _unpack_canonical(&pa, a, s); \ + float ## sz ## _unpack_canonical(&pb, b, s); \ return compare_floats(pa, pb, is_quiet, s); \ } =20 @@ -3381,8 +3494,10 @@ FloatRelation float64_compare_quiet(float64 a, float= 64 b, float_status *s) static FloatRelation QEMU_FLATTEN soft_bf16_compare(bfloat16 a, bfloat16 b, bool is_quiet, float_status *s) { - FloatParts64 pa =3D bfloat16_unpack_canonical(a, s); - FloatParts64 pb =3D bfloat16_unpack_canonical(b, s); + FloatParts64 pa, pb; + + bfloat16_unpack_canonical(&pa, a, s); + bfloat16_unpack_canonical(&pb, b, s); return compare_floats(pa, pb, is_quiet, s); } =20 @@ -3416,29 +3531,37 @@ static FloatParts64 scalbn_decomposed(FloatParts64 = a, int n, float_status *s) =20 float16 float16_scalbn(float16 a, int n, float_status *status) { - FloatParts64 pa =3D float16_unpack_canonical(a, status); - FloatParts64 pr =3D scalbn_decomposed(pa, n, status); + FloatParts64 pa, pr; + + float16_unpack_canonical(&pa, a, status); + pr =3D scalbn_decomposed(pa, n, status); return float16_round_pack_canonical(pr, status); } =20 float32 float32_scalbn(float32 a, int n, float_status *status) { - FloatParts64 pa =3D float32_unpack_canonical(a, status); - FloatParts64 pr =3D scalbn_decomposed(pa, n, status); + FloatParts64 pa, pr; + + float32_unpack_canonical(&pa, a, status); + pr =3D scalbn_decomposed(pa, n, status); return float32_round_pack_canonical(pr, status); } =20 float64 float64_scalbn(float64 a, int n, float_status *status) { - FloatParts64 pa =3D float64_unpack_canonical(a, status); - FloatParts64 pr =3D scalbn_decomposed(pa, n, status); + FloatParts64 pa, pr; + + float64_unpack_canonical(&pa, a, status); + pr =3D scalbn_decomposed(pa, n, status); return float64_round_pack_canonical(pr, status); } =20 bfloat16 bfloat16_scalbn(bfloat16 a, int n, float_status *status) { - FloatParts64 pa =3D bfloat16_unpack_canonical(a, status); - FloatParts64 pr =3D scalbn_decomposed(pa, n, status); + FloatParts64 pa, pr; + + bfloat16_unpack_canonical(&pa, a, status); + pr =3D scalbn_decomposed(pa, n, status); return bfloat16_round_pack_canonical(pr, status); } =20 @@ -3515,24 +3638,30 @@ static FloatParts64 sqrt_float(FloatParts64 a, floa= t_status *s, const FloatFmt * =20 float16 QEMU_FLATTEN float16_sqrt(float16 a, float_status *status) { - FloatParts64 pa =3D float16_unpack_canonical(a, status); - FloatParts64 pr =3D sqrt_float(pa, status, &float16_params); + FloatParts64 pa, pr; + + float16_unpack_canonical(&pa, a, status); + pr =3D sqrt_float(pa, status, &float16_params); return float16_round_pack_canonical(pr, status); } =20 static float32 QEMU_SOFTFLOAT_ATTR soft_f32_sqrt(float32 a, float_status *status) { - FloatParts64 pa =3D float32_unpack_canonical(a, status); - FloatParts64 pr =3D sqrt_float(pa, status, &float32_params); + FloatParts64 pa, pr; + + float32_unpack_canonical(&pa, a, status); + pr =3D sqrt_float(pa, status, &float32_params); return float32_round_pack_canonical(pr, status); } =20 static float64 QEMU_SOFTFLOAT_ATTR soft_f64_sqrt(float64 a, float_status *status) { - FloatParts64 pa =3D float64_unpack_canonical(a, status); - FloatParts64 pr =3D sqrt_float(pa, status, &float64_params); + FloatParts64 pa, pr; + + float64_unpack_canonical(&pa, a, status); + pr =3D sqrt_float(pa, status, &float64_params); return float64_round_pack_canonical(pr, status); } =20 @@ -3592,8 +3721,10 @@ float64 QEMU_FLATTEN float64_sqrt(float64 xa, float_= status *s) =20 bfloat16 QEMU_FLATTEN bfloat16_sqrt(bfloat16 a, float_status *status) { - FloatParts64 pa =3D bfloat16_unpack_canonical(a, status); - FloatParts64 pr =3D sqrt_float(pa, status, &bfloat16_params); + FloatParts64 pa, pr; + + bfloat16_unpack_canonical(&pa, a, status); + pr =3D sqrt_float(pa, status, &bfloat16_params); return bfloat16_round_pack_canonical(pr, status); } =20 --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169852; cv=none; d=zohomail.com; s=zohoarc; b=VMj+nVljOnGSX1euZVEvm3vDqUYjvAyjMF4uKeM9yCH+v+KhFnI8EoAYcqxeBD4GgEs3GSYlE63Fm4S2PznOk3Xo2vEwwAtgdtnMuV9/JlnQVUeUILF8cly6w+U5dvtUbVyqfJwohksqE+9w+Fi6NXyZRe0mp+i79BUcQx8X4nc= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169852; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=62fRAyXZmBgNMhTV3+Af7/n95yoP7HpSCS2EVP0taEU=; b=Kt87kCyH/sE5iU+7DQ5T9Kjx0WhvkiLo5+6csUqpkdDGs1fdRg3rcClbGq8eQVqY62i+n3qkXB/YNN3icO/NXacdPSaN4dMnpS1yRLKc84c4cpElr3yjtrKmcUKRbVQio8NVx4sy0pTb7yZdvH6K7AmNxSoFtJgzY4tz9FAGty8= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169852073109.19307298067156; Sun, 16 May 2021 05:57:32 -0700 (PDT) Received: from localhost ([::1]:54394 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGKo-00053b-Qr for importer@patchew.org; Sun, 16 May 2021 08:57:30 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43266) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzB-0007ci-75 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:09 -0400 Received: from mail-qk1-x736.google.com ([2607:f8b0:4864:20::736]:35402) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFyw-0007nA-EK for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:08 -0400 Received: by mail-qk1-x736.google.com with SMTP id x8so3333368qkl.2 for ; Sun, 16 May 2021 05:34:52 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=62fRAyXZmBgNMhTV3+Af7/n95yoP7HpSCS2EVP0taEU=; b=qMtrvaL/b7+doiqMmUWiOHJ5VQBK2111zPBUThPu/yOKk3yZ6dlvpWECGUQ2pD2/ci wVoKJuNJmKjGlw7633rFOCEGtRdfkyhxfUzTrtMQ9Q5n7LYjr9shYM0nrfZZn1DOX6Xv B6/2oiA7Jf+8smQ7gBEilSKgKJcEc3b9KCw2vz7aB0DfBXvv7XLr1j6GO6SkWT1QUkuK Lkm9AMIeC1H1bRwwcZq2En7gXhJ0bT+LgWuRp5FxB7Km6yPlUZU6ScXTH7Mn5neePjXw RGzrzEqsyaUPrJmTMb7DbJ2m40KclPlbaPlUylFzjbwn42+r7srcoJ8sOjyMIYwNDUEJ +HTQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=62fRAyXZmBgNMhTV3+Af7/n95yoP7HpSCS2EVP0taEU=; b=lgzKYk1o41mcwbmhLACHx7WIs/C0jSDo/sC52C8DBLs/9w/g8L6RMsRjq/K6wXUL8f BFCe9iuD5z4A1yzb5v8SaBFmzqWBWI3W5RpS8DzoWyo5BhDFU7MWm5pe2VOhQatXML2/ NKrlV70ZxKF4+sADp9SQxHpyYOa/BQ/JsvI3f4+Ok3SVOCi872gw4iXxzbNO9Le47Yk5 gS6TofFQl5Iq419pKJF7iG9J6gVqN4Vv5t21qOr/yzoSuUrdSgKHBIvdWZLY9+Y6WCZK aVMToF7IdvUFGHjPDhXWVzNGSZkYSbkKScNVrCDMuZjHJQDsbdgEHCkjgY1aqiwwC/jq HWpw== X-Gm-Message-State: AOAM530iymV2J3aDAtxTClUrI9lV0yC4IfwZmy1akn4oZXcARYXYDKhW lGHNsgQTGvutgisqM9k6X9gSkzRFmw2yRYGFOsw= X-Google-Smtp-Source: ABdhPJyzq9p04e9cMK/0wUhfqIQGfElbRO5NHx5sDBSvuvhhgstbIVs8dr707c+AGIIYA+Xhr2kKmg== X-Received: by 2002:a37:444d:: with SMTP id r74mr10167346qka.291.1621168492119; Sun, 16 May 2021 05:34:52 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 23/46] softfloat: Use pointers with ftype_round_pack_canonical Date: Sun, 16 May 2021 07:34:08 -0500 Message-Id: <20210516123431.718318-24-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::736; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x736.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 131 +++++++++++++++++++++++++----------------------- 1 file changed, 68 insertions(+), 63 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index e53d4a138f..b0cbd5941c 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -945,22 +945,25 @@ static void bfloat16_unpack_canonical(FloatParts64 *p= , bfloat16 f, *p =3D sf_canonicalize(*p, &bfloat16_params, s); } =20 -static float16 float16a_round_pack_canonical(FloatParts64 p, float_status = *s, +static float16 float16a_round_pack_canonical(FloatParts64 *p, + float_status *s, const FloatFmt *params) { - p =3D round_canonical(p, s, params); - return float16_pack_raw(&p); + *p =3D round_canonical(*p, s, params); + return float16_pack_raw(p); } =20 -static float16 float16_round_pack_canonical(FloatParts64 p, float_status *= s) +static float16 float16_round_pack_canonical(FloatParts64 *p, + float_status *s) { return float16a_round_pack_canonical(p, s, &float16_params); } =20 -static bfloat16 bfloat16_round_pack_canonical(FloatParts64 p, float_status= *s) +static bfloat16 bfloat16_round_pack_canonical(FloatParts64 *p, + float_status *s) { - p =3D round_canonical(p, s, &bfloat16_params); - return bfloat16_pack_raw(&p); + *p =3D round_canonical(*p, s, &bfloat16_params); + return bfloat16_pack_raw(p); } =20 static void float32_unpack_canonical(FloatParts64 *p, float32 f, @@ -970,10 +973,11 @@ static void float32_unpack_canonical(FloatParts64 *p,= float32 f, *p =3D sf_canonicalize(*p, &float32_params, s); } =20 -static float32 float32_round_pack_canonical(FloatParts64 p, float_status *= s) +static float32 float32_round_pack_canonical(FloatParts64 *p, + float_status *s) { - p =3D round_canonical(p, s, &float32_params); - return float32_pack_raw(&p); + *p =3D round_canonical(*p, s, &float32_params); + return float32_pack_raw(p); } =20 static void float64_unpack_canonical(FloatParts64 *p, float64 f, @@ -983,10 +987,11 @@ static void float64_unpack_canonical(FloatParts64 *p,= float64 f, *p =3D sf_canonicalize(*p, &float64_params, s); } =20 -static float64 float64_round_pack_canonical(FloatParts64 p, float_status *= s) +static float64 float64_round_pack_canonical(FloatParts64 *p, + float_status *s) { - p =3D round_canonical(p, s, &float64_params); - return float64_pack_raw(&p); + *p =3D round_canonical(*p, s, &float64_params); + return float64_pack_raw(p); } =20 /* @@ -1093,7 +1098,7 @@ float16 QEMU_FLATTEN float16_add(float16 a, float16 b= , float_status *status) float16_unpack_canonical(&pb, b, status); pr =3D addsub_floats(pa, pb, false, status); =20 - return float16_round_pack_canonical(pr, status); + return float16_round_pack_canonical(&pr, status); } =20 float16 QEMU_FLATTEN float16_sub(float16 a, float16 b, float_status *statu= s) @@ -1104,7 +1109,7 @@ float16 QEMU_FLATTEN float16_sub(float16 a, float16 b= , float_status *status) float16_unpack_canonical(&pb, b, status); pr =3D addsub_floats(pa, pb, true, status); =20 - return float16_round_pack_canonical(pr, status); + return float16_round_pack_canonical(&pr, status); } =20 static float32 QEMU_SOFTFLOAT_ATTR @@ -1116,7 +1121,7 @@ soft_f32_addsub(float32 a, float32 b, bool subtract, = float_status *status) float32_unpack_canonical(&pb, b, status); pr =3D addsub_floats(pa, pb, subtract, status); =20 - return float32_round_pack_canonical(pr, status); + return float32_round_pack_canonical(&pr, status); } =20 static inline float32 soft_f32_add(float32 a, float32 b, float_status *sta= tus) @@ -1138,7 +1143,7 @@ soft_f64_addsub(float64 a, float64 b, bool subtract, = float_status *status) float64_unpack_canonical(&pb, b, status); pr =3D addsub_floats(pa, pb, subtract, status); =20 - return float64_round_pack_canonical(pr, status); + return float64_round_pack_canonical(&pr, status); } =20 static inline float64 soft_f64_add(float64 a, float64 b, float_status *sta= tus) @@ -1238,7 +1243,7 @@ bfloat16 QEMU_FLATTEN bfloat16_add(bfloat16 a, bfloat= 16 b, float_status *status) bfloat16_unpack_canonical(&pb, b, status); pr =3D addsub_floats(pa, pb, false, status); =20 - return bfloat16_round_pack_canonical(pr, status); + return bfloat16_round_pack_canonical(&pr, status); } =20 bfloat16 QEMU_FLATTEN bfloat16_sub(bfloat16 a, bfloat16 b, float_status *s= tatus) @@ -1249,7 +1254,7 @@ bfloat16 QEMU_FLATTEN bfloat16_sub(bfloat16 a, bfloat= 16 b, float_status *status) bfloat16_unpack_canonical(&pb, b, status); pr =3D addsub_floats(pa, pb, true, status); =20 - return bfloat16_round_pack_canonical(pr, status); + return bfloat16_round_pack_canonical(&pr, status); } =20 /* @@ -1311,7 +1316,7 @@ float16 QEMU_FLATTEN float16_mul(float16 a, float16 b= , float_status *status) float16_unpack_canonical(&pb, b, status); pr =3D mul_floats(pa, pb, status); =20 - return float16_round_pack_canonical(pr, status); + return float16_round_pack_canonical(&pr, status); } =20 static float32 QEMU_SOFTFLOAT_ATTR @@ -1323,7 +1328,7 @@ soft_f32_mul(float32 a, float32 b, float_status *stat= us) float32_unpack_canonical(&pb, b, status); pr =3D mul_floats(pa, pb, status); =20 - return float32_round_pack_canonical(pr, status); + return float32_round_pack_canonical(&pr, status); } =20 static float64 QEMU_SOFTFLOAT_ATTR @@ -1335,7 +1340,7 @@ soft_f64_mul(float64 a, float64 b, float_status *stat= us) float64_unpack_canonical(&pb, b, status); pr =3D mul_floats(pa, pb, status); =20 - return float64_round_pack_canonical(pr, status); + return float64_round_pack_canonical(&pr, status); } =20 static float hard_f32_mul(float a, float b) @@ -1375,7 +1380,7 @@ bfloat16 QEMU_FLATTEN bfloat16_mul(bfloat16 a, bfloat= 16 b, float_status *status) bfloat16_unpack_canonical(&pb, b, status); pr =3D mul_floats(pa, pb, status); =20 - return bfloat16_round_pack_canonical(pr, status); + return bfloat16_round_pack_canonical(&pr, status); } =20 /* @@ -1574,7 +1579,7 @@ float16 QEMU_FLATTEN float16_muladd(float16 a, float1= 6 b, float16 c, float16_unpack_canonical(&pc, c, status); pr =3D muladd_floats(pa, pb, pc, flags, status); =20 - return float16_round_pack_canonical(pr, status); + return float16_round_pack_canonical(&pr, status); } =20 static float32 QEMU_SOFTFLOAT_ATTR @@ -1588,7 +1593,7 @@ soft_f32_muladd(float32 a, float32 b, float32 c, int = flags, float32_unpack_canonical(&pc, c, status); pr =3D muladd_floats(pa, pb, pc, flags, status); =20 - return float32_round_pack_canonical(pr, status); + return float32_round_pack_canonical(&pr, status); } =20 static float64 QEMU_SOFTFLOAT_ATTR @@ -1602,7 +1607,7 @@ soft_f64_muladd(float64 a, float64 b, float64 c, int = flags, float64_unpack_canonical(&pc, c, status); pr =3D muladd_floats(pa, pb, pc, flags, status); =20 - return float64_round_pack_canonical(pr, status); + return float64_round_pack_canonical(&pr, status); } =20 static bool force_soft_fma; @@ -1765,7 +1770,7 @@ bfloat16 QEMU_FLATTEN bfloat16_muladd(bfloat16 a, bfl= oat16 b, bfloat16 c, bfloat16_unpack_canonical(&pc, c, status); pr =3D muladd_floats(pa, pb, pc, flags, status); =20 - return bfloat16_round_pack_canonical(pr, status); + return bfloat16_round_pack_canonical(&pr, status); } =20 /* @@ -1848,7 +1853,7 @@ float16 float16_div(float16 a, float16 b, float_statu= s *status) float16_unpack_canonical(&pb, b, status); pr =3D div_floats(pa, pb, status); =20 - return float16_round_pack_canonical(pr, status); + return float16_round_pack_canonical(&pr, status); } =20 static float32 QEMU_SOFTFLOAT_ATTR @@ -1860,7 +1865,7 @@ soft_f32_div(float32 a, float32 b, float_status *stat= us) float32_unpack_canonical(&pb, b, status); pr =3D div_floats(pa, pb, status); =20 - return float32_round_pack_canonical(pr, status); + return float32_round_pack_canonical(&pr, status); } =20 static float64 QEMU_SOFTFLOAT_ATTR @@ -1872,7 +1877,7 @@ soft_f64_div(float64 a, float64 b, float_status *stat= us) float64_unpack_canonical(&pb, b, status); pr =3D div_floats(pa, pb, status); =20 - return float64_round_pack_canonical(pr, status); + return float64_round_pack_canonical(&pr, status); } =20 static float hard_f32_div(float a, float b) @@ -1946,7 +1951,7 @@ bfloat16 bfloat16_div(bfloat16 a, bfloat16 b, float_s= tatus *status) bfloat16_unpack_canonical(&pb, b, status); pr =3D div_floats(pa, pb, status); =20 - return bfloat16_round_pack_canonical(pr, status); + return bfloat16_round_pack_canonical(&pr, status); } =20 /* @@ -2002,7 +2007,7 @@ float32 float16_to_float32(float16 a, bool ieee, floa= t_status *s) =20 float16a_unpack_canonical(&pa, a, s, fmt16); pr =3D float_to_float(pa, &float32_params, s); - return float32_round_pack_canonical(pr, s); + return float32_round_pack_canonical(&pr, s); } =20 float64 float16_to_float64(float16 a, bool ieee, float_status *s) @@ -2012,7 +2017,7 @@ float64 float16_to_float64(float16 a, bool ieee, floa= t_status *s) =20 float16a_unpack_canonical(&pa, a, s, fmt16); pr =3D float_to_float(pa, &float64_params, s); - return float64_round_pack_canonical(pr, s); + return float64_round_pack_canonical(&pr, s); } =20 float16 float32_to_float16(float32 a, bool ieee, float_status *s) @@ -2022,7 +2027,7 @@ float16 float32_to_float16(float32 a, bool ieee, floa= t_status *s) =20 float32_unpack_canonical(&pa, a, s); pr =3D float_to_float(pa, fmt16, s); - return float16a_round_pack_canonical(pr, s, fmt16); + return float16a_round_pack_canonical(&pr, s, fmt16); } =20 static float64 QEMU_SOFTFLOAT_ATTR @@ -2032,7 +2037,7 @@ soft_float32_to_float64(float32 a, float_status *s) =20 float32_unpack_canonical(&pa, a, s); pr =3D float_to_float(pa, &float64_params, s); - return float64_round_pack_canonical(pr, s); + return float64_round_pack_canonical(&pr, s); } =20 float64 float32_to_float64(float32 a, float_status *s) @@ -2058,7 +2063,7 @@ float16 float64_to_float16(float64 a, bool ieee, floa= t_status *s) =20 float64_unpack_canonical(&pa, a, s); pr =3D float_to_float(pa, fmt16, s); - return float16a_round_pack_canonical(pr, s, fmt16); + return float16a_round_pack_canonical(&pr, s, fmt16); } =20 float32 float64_to_float32(float64 a, float_status *s) @@ -2067,7 +2072,7 @@ float32 float64_to_float32(float64 a, float_status *s) =20 float64_unpack_canonical(&pa, a, s); pr =3D float_to_float(pa, &float32_params, s); - return float32_round_pack_canonical(pr, s); + return float32_round_pack_canonical(&pr, s); } =20 float32 bfloat16_to_float32(bfloat16 a, float_status *s) @@ -2076,7 +2081,7 @@ float32 bfloat16_to_float32(bfloat16 a, float_status = *s) =20 bfloat16_unpack_canonical(&pa, a, s); pr =3D float_to_float(pa, &float32_params, s); - return float32_round_pack_canonical(pr, s); + return float32_round_pack_canonical(&pr, s); } =20 float64 bfloat16_to_float64(bfloat16 a, float_status *s) @@ -2085,7 +2090,7 @@ float64 bfloat16_to_float64(bfloat16 a, float_status = *s) =20 bfloat16_unpack_canonical(&pa, a, s); pr =3D float_to_float(pa, &float64_params, s); - return float64_round_pack_canonical(pr, s); + return float64_round_pack_canonical(&pr, s); } =20 bfloat16 float32_to_bfloat16(float32 a, float_status *s) @@ -2094,7 +2099,7 @@ bfloat16 float32_to_bfloat16(float32 a, float_status = *s) =20 float32_unpack_canonical(&pa, a, s); pr =3D float_to_float(pa, &bfloat16_params, s); - return bfloat16_round_pack_canonical(pr, s); + return bfloat16_round_pack_canonical(&pr, s); } =20 bfloat16 float64_to_bfloat16(float64 a, float_status *s) @@ -2103,7 +2108,7 @@ bfloat16 float64_to_bfloat16(float64 a, float_status = *s) =20 float64_unpack_canonical(&pa, a, s); pr =3D float_to_float(pa, &bfloat16_params, s); - return bfloat16_round_pack_canonical(pr, s); + return bfloat16_round_pack_canonical(&pr, s); } =20 /* @@ -2220,7 +2225,7 @@ float16 float16_round_to_int(float16 a, float_status = *s) =20 float16_unpack_canonical(&pa, a, s); pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); - return float16_round_pack_canonical(pr, s); + return float16_round_pack_canonical(&pr, s); } =20 float32 float32_round_to_int(float32 a, float_status *s) @@ -2229,7 +2234,7 @@ float32 float32_round_to_int(float32 a, float_status = *s) =20 float32_unpack_canonical(&pa, a, s); pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); - return float32_round_pack_canonical(pr, s); + return float32_round_pack_canonical(&pr, s); } =20 float64 float64_round_to_int(float64 a, float_status *s) @@ -2238,7 +2243,7 @@ float64 float64_round_to_int(float64 a, float_status = *s) =20 float64_unpack_canonical(&pa, a, s); pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); - return float64_round_pack_canonical(pr, s); + return float64_round_pack_canonical(&pr, s); } =20 /* @@ -2252,7 +2257,7 @@ bfloat16 bfloat16_round_to_int(bfloat16 a, float_stat= us *s) =20 bfloat16_unpack_canonical(&pa, a, s); pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); - return bfloat16_round_pack_canonical(pr, s); + return bfloat16_round_pack_canonical(&pr, s); } =20 /* @@ -2898,7 +2903,7 @@ static FloatParts64 int_to_float(int64_t a, int scale= , float_status *status) float16 int64_to_float16_scalbn(int64_t a, int scale, float_status *status) { FloatParts64 pa =3D int_to_float(a, scale, status); - return float16_round_pack_canonical(pa, status); + return float16_round_pack_canonical(&pa, status); } =20 float16 int32_to_float16_scalbn(int32_t a, int scale, float_status *status) @@ -2934,7 +2939,7 @@ float16 int8_to_float16(int8_t a, float_status *statu= s) float32 int64_to_float32_scalbn(int64_t a, int scale, float_status *status) { FloatParts64 pa =3D int_to_float(a, scale, status); - return float32_round_pack_canonical(pa, status); + return float32_round_pack_canonical(&pa, status); } =20 float32 int32_to_float32_scalbn(int32_t a, int scale, float_status *status) @@ -2965,7 +2970,7 @@ float32 int16_to_float32(int16_t a, float_status *sta= tus) float64 int64_to_float64_scalbn(int64_t a, int scale, float_status *status) { FloatParts64 pa =3D int_to_float(a, scale, status); - return float64_round_pack_canonical(pa, status); + return float64_round_pack_canonical(&pa, status); } =20 float64 int32_to_float64_scalbn(int32_t a, int scale, float_status *status) @@ -3001,7 +3006,7 @@ float64 int16_to_float64(int16_t a, float_status *sta= tus) bfloat16 int64_to_bfloat16_scalbn(int64_t a, int scale, float_status *stat= us) { FloatParts64 pa =3D int_to_float(a, scale, status); - return bfloat16_round_pack_canonical(pa, status); + return bfloat16_round_pack_canonical(&pa, status); } =20 bfloat16 int32_to_bfloat16_scalbn(int32_t a, int scale, float_status *stat= us) @@ -3058,7 +3063,7 @@ static FloatParts64 uint_to_float(uint64_t a, int sca= le, float_status *status) float16 uint64_to_float16_scalbn(uint64_t a, int scale, float_status *stat= us) { FloatParts64 pa =3D uint_to_float(a, scale, status); - return float16_round_pack_canonical(pa, status); + return float16_round_pack_canonical(&pa, status); } =20 float16 uint32_to_float16_scalbn(uint32_t a, int scale, float_status *stat= us) @@ -3094,7 +3099,7 @@ float16 uint8_to_float16(uint8_t a, float_status *sta= tus) float32 uint64_to_float32_scalbn(uint64_t a, int scale, float_status *stat= us) { FloatParts64 pa =3D uint_to_float(a, scale, status); - return float32_round_pack_canonical(pa, status); + return float32_round_pack_canonical(&pa, status); } =20 float32 uint32_to_float32_scalbn(uint32_t a, int scale, float_status *stat= us) @@ -3125,7 +3130,7 @@ float32 uint16_to_float32(uint16_t a, float_status *s= tatus) float64 uint64_to_float64_scalbn(uint64_t a, int scale, float_status *stat= us) { FloatParts64 pa =3D uint_to_float(a, scale, status); - return float64_round_pack_canonical(pa, status); + return float64_round_pack_canonical(&pa, status); } =20 float64 uint32_to_float64_scalbn(uint32_t a, int scale, float_status *stat= us) @@ -3161,7 +3166,7 @@ float64 uint16_to_float64(uint16_t a, float_status *s= tatus) bfloat16 uint64_to_bfloat16_scalbn(uint64_t a, int scale, float_status *st= atus) { FloatParts64 pa =3D uint_to_float(a, scale, status); - return bfloat16_round_pack_canonical(pa, status); + return bfloat16_round_pack_canonical(&pa, status); } =20 bfloat16 uint32_to_bfloat16_scalbn(uint32_t a, int scale, float_status *st= atus) @@ -3284,7 +3289,7 @@ float ## sz float ## sz ## _ ## name(float ## sz a, f= loat ## sz b, \ float ## sz ## _unpack_canonical(&pa, a, s); \ float ## sz ## _unpack_canonical(&pb, b, s); \ pr =3D minmax_floats(pa, pb, ismin, isiee, ismag, s); \ - return float ## sz ## _round_pack_canonical(pr, s); \ + return float ## sz ## _round_pack_canonical(&pr, s); \ } =20 MINMAX(16, min, true, false, false) @@ -3317,7 +3322,7 @@ bfloat16 bfloat16_ ## name(bfloat16 a, bfloat16 b, fl= oat_status *s) \ bfloat16_unpack_canonical(&pa, a, s); \ bfloat16_unpack_canonical(&pb, b, s); \ pr =3D minmax_floats(pa, pb, ismin, isiee, ismag, s); \ - return bfloat16_round_pack_canonical(pr, s); \ + return bfloat16_round_pack_canonical(&pr, s); \ } =20 BF16_MINMAX(min, true, false, false) @@ -3535,7 +3540,7 @@ float16 float16_scalbn(float16 a, int n, float_status= *status) =20 float16_unpack_canonical(&pa, a, status); pr =3D scalbn_decomposed(pa, n, status); - return float16_round_pack_canonical(pr, status); + return float16_round_pack_canonical(&pr, status); } =20 float32 float32_scalbn(float32 a, int n, float_status *status) @@ -3544,7 +3549,7 @@ float32 float32_scalbn(float32 a, int n, float_status= *status) =20 float32_unpack_canonical(&pa, a, status); pr =3D scalbn_decomposed(pa, n, status); - return float32_round_pack_canonical(pr, status); + return float32_round_pack_canonical(&pr, status); } =20 float64 float64_scalbn(float64 a, int n, float_status *status) @@ -3553,7 +3558,7 @@ float64 float64_scalbn(float64 a, int n, float_status= *status) =20 float64_unpack_canonical(&pa, a, status); pr =3D scalbn_decomposed(pa, n, status); - return float64_round_pack_canonical(pr, status); + return float64_round_pack_canonical(&pr, status); } =20 bfloat16 bfloat16_scalbn(bfloat16 a, int n, float_status *status) @@ -3562,7 +3567,7 @@ bfloat16 bfloat16_scalbn(bfloat16 a, int n, float_sta= tus *status) =20 bfloat16_unpack_canonical(&pa, a, status); pr =3D scalbn_decomposed(pa, n, status); - return bfloat16_round_pack_canonical(pr, status); + return bfloat16_round_pack_canonical(&pr, status); } =20 /* @@ -3642,7 +3647,7 @@ float16 QEMU_FLATTEN float16_sqrt(float16 a, float_st= atus *status) =20 float16_unpack_canonical(&pa, a, status); pr =3D sqrt_float(pa, status, &float16_params); - return float16_round_pack_canonical(pr, status); + return float16_round_pack_canonical(&pr, status); } =20 static float32 QEMU_SOFTFLOAT_ATTR @@ -3652,7 +3657,7 @@ soft_f32_sqrt(float32 a, float_status *status) =20 float32_unpack_canonical(&pa, a, status); pr =3D sqrt_float(pa, status, &float32_params); - return float32_round_pack_canonical(pr, status); + return float32_round_pack_canonical(&pr, status); } =20 static float64 QEMU_SOFTFLOAT_ATTR @@ -3662,7 +3667,7 @@ soft_f64_sqrt(float64 a, float_status *status) =20 float64_unpack_canonical(&pa, a, status); pr =3D sqrt_float(pa, status, &float64_params); - return float64_round_pack_canonical(pr, status); + return float64_round_pack_canonical(&pr, status); } =20 float32 QEMU_FLATTEN float32_sqrt(float32 xa, float_status *s) @@ -3725,7 +3730,7 @@ bfloat16 QEMU_FLATTEN bfloat16_sqrt(bfloat16 a, float= _status *status) =20 bfloat16_unpack_canonical(&pa, a, status); pr =3D sqrt_float(pa, status, &bfloat16_params); - return bfloat16_round_pack_canonical(pr, status); + return bfloat16_round_pack_canonical(&pr, status); } =20 /*------------------------------------------------------------------------= ---- --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170418; cv=none; d=zohomail.com; s=zohoarc; b=QpEedSJ7U9/UfO1SGOvJTN4rD8VyNnVp1A2S295YihPv7IJnyTVNGOVc7NkkHJy1S/SOtRDDruvbLTiS30ZRSVqpm4Ty9qZbn4e+47TDr6+hdEp1npQgW9t2GW4SXJFETdH+niSlCrTgcFHPTkdkXWFkHHUXaLel74FQjPBnLhs= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170418; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=uD8kmoDvMjgobthd5uZZXJmvbO539JQ1A2VRyt45llE=; b=jJqwaWYQTdulT107G7+Rct+tOuLXpojOokf0KMiVN/zsKUKUKiPrTz5Ojey5G9yzz/rHrh/O3sPhV6N127gF0MappOUBJg2Fu8M3TUiI/r+HR8/DlvJ+SheLq9aUa9vGPlhKzWe/2F/kY+2Hyyg8LZ9ZKggyZ+PpGYnQFRPOuUQ= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170418237613.7699892596099; Sun, 16 May 2021 06:06:58 -0700 (PDT) Received: from localhost ([::1]:55664 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGTx-000878-5s for importer@patchew.org; Sun, 16 May 2021 09:06:57 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43342) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzQ-0007he-RY for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:26 -0400 Received: from mail-qt1-x836.google.com ([2607:f8b0:4864:20::836]:38504) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz2-0007nl-9A for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:17 -0400 Received: by mail-qt1-x836.google.com with SMTP id h21so3018447qtu.5 for ; Sun, 16 May 2021 05:34:53 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=uD8kmoDvMjgobthd5uZZXJmvbO539JQ1A2VRyt45llE=; b=fLolXtvE+vr/GXEKIrkewEMB6H9XPK/CklMuzcM5OkYQAqzWMoPs5AHa4RNyKWHpNe uOEbin93lr40KpGjjr68gUmL0YfccNZIOW9YZulUiSdZwlnAahLCu7h3uUfYgVBFBV7y 3uYAlVmTynE1psVjjVh9Fm2Q5B7xPSWf3KWu0j9sU5GyVIjmfOk2uljWNUGJKXSoKRIm lhBmRyWqpgOMSJAAHTG9vhk9gTWeczfW8ViM1il7S+C8nCbsCO4lk+NkUadNw6IeuZH3 /y2VniMdxhN9o3Pf5M1MwlfA07M8EPsjaV8N/AC9ZGZ/Eh8FNe5590XLVLYy62JdSO2J IA7w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=uD8kmoDvMjgobthd5uZZXJmvbO539JQ1A2VRyt45llE=; b=L02ZrUUdTlR+zKIIWLBAu7QQmG61uWTHBkSts4whuPtH/vqE9Rarv3+JNaqw0o1lfd OM/OCcDnjeyA0DZyIMpSKWjA5tpU1vbxBchKLf5W3pqnJGY4ZLSz3eE2Ow+ymhzNWesO 0pQo5QTs8wtxks3WgUqy2FfpG6O1a9cn4yuIzg5oNlvWlAoKmBLUgSmAPhzWYSikzDKE Hix9GNBl/PYf0eX0oLNKM3Dz4hu5eMFFOBRKWGi8JTWVThsrPvWLpZBnjmyZYEdVMMDn bJnlps7IBF+p36er0uWiH6DnwVGkABzxA4x+zd3boQukdbrY+nvFEpUhs3qvX/gBdvgj PqCw== X-Gm-Message-State: AOAM532G+4ufYnMjEz0O99HC73JZYzXdMRd9q/8ZYQYZB7cokxDN4Rkf sQeByMua7smTOhMr0tVKKJa5CftI73X6fnRCihg= X-Google-Smtp-Source: ABdhPJwdGoOmbeWg6FU+0BtGPgKYA2RpC8ChRj+M/w350pB2gyn354CIgR27OiiXBlTKHrbx0dO6DA== X-Received: by 2002:ac8:5550:: with SMTP id o16mr51695608qtr.7.1621168492909; Sun, 16 May 2021 05:34:52 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 24/46] softfloat: Use pointers with parts_silence_nan Date: Sun, 16 May 2021 07:34:09 -0500 Message-Id: <20210516123431.718318-25-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::836; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x836.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) At the same time, rename to parts64_silence_nan, split out parts_silence_nan_frac, and define a macro for parts_silence_nan. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 16 +++++++++------- fpu/softfloat-specialize.c.inc | 17 +++++++++++------ 2 files changed, 20 insertions(+), 13 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index b0cbd5941c..2123453d40 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -657,6 +657,7 @@ static inline float64 float64_pack_raw(const FloatParts= 64 *p) #include "softfloat-specialize.c.inc" =20 #define parts_default_nan parts64_default_nan +#define parts_silence_nan parts64_silence_nan =20 /* Canonicalize EXP and FRAC, setting CLS. */ static FloatParts64 sf_canonicalize(FloatParts64 part, const FloatFmt *par= m, @@ -851,7 +852,8 @@ static FloatParts64 return_nan(FloatParts64 a, float_st= atus *s) if (is_snan(a.cls)) { float_raise(float_flag_invalid, s); if (!s->default_nan_mode) { - return parts_silence_nan(a, s); + parts_silence_nan(&a, s); + return a; } } else if (!s->default_nan_mode) { return a; @@ -875,7 +877,7 @@ static FloatParts64 pick_nan(FloatParts64 a, FloatParts= 64 b, float_status *s) a =3D b; } if (is_snan(a.cls)) { - return parts_silence_nan(a, s); + parts_silence_nan(&a, s); } } return a; @@ -916,7 +918,7 @@ static FloatParts64 pick_nan_muladd(FloatParts64 a, Flo= atParts64 b, FloatParts64 } =20 if (is_snan(a.cls)) { - return parts_silence_nan(a, s); + parts_silence_nan(&a, s); } return a; } @@ -3801,7 +3803,7 @@ float16 float16_silence_nan(float16 a, float_status *= status) =20 float16_unpack_raw(&p, a); p.frac <<=3D float16_params.frac_shift; - p =3D parts_silence_nan(p, status); + parts_silence_nan(&p, status); p.frac >>=3D float16_params.frac_shift; return float16_pack_raw(&p); } @@ -3812,7 +3814,7 @@ float32 float32_silence_nan(float32 a, float_status *= status) =20 float32_unpack_raw(&p, a); p.frac <<=3D float32_params.frac_shift; - p =3D parts_silence_nan(p, status); + parts_silence_nan(&p, status); p.frac >>=3D float32_params.frac_shift; return float32_pack_raw(&p); } @@ -3823,7 +3825,7 @@ float64 float64_silence_nan(float64 a, float_status *= status) =20 float64_unpack_raw(&p, a); p.frac <<=3D float64_params.frac_shift; - p =3D parts_silence_nan(p, status); + parts_silence_nan(&p, status); p.frac >>=3D float64_params.frac_shift; return float64_pack_raw(&p); } @@ -3834,7 +3836,7 @@ bfloat16 bfloat16_silence_nan(bfloat16 a, float_statu= s *status) =20 bfloat16_unpack_raw(&p, a); p.frac <<=3D bfloat16_params.frac_shift; - p =3D parts_silence_nan(p, status); + parts_silence_nan(&p, status); p.frac >>=3D bfloat16_params.frac_shift; return bfloat16_pack_raw(&p); } diff --git a/fpu/softfloat-specialize.c.inc b/fpu/softfloat-specialize.c.inc index 47c3652d63..4038955379 100644 --- a/fpu/softfloat-specialize.c.inc +++ b/fpu/softfloat-specialize.c.inc @@ -176,20 +176,25 @@ static void parts64_default_nan(FloatParts64 *p, floa= t_status *status) | floating-point parts. *-------------------------------------------------------------------------= ---*/ =20 -static FloatParts64 parts_silence_nan(FloatParts64 a, float_status *status) +static uint64_t parts_silence_nan_frac(uint64_t frac, float_status *status) { g_assert(!no_signaling_nans(status)); g_assert(!status->default_nan_mode); =20 /* The only snan_bit_is_one target without default_nan_mode is HPPA. */ if (snan_bit_is_one(status)) { - a.frac &=3D ~(1ULL << (DECOMPOSED_BINARY_POINT - 1)); - a.frac |=3D 1ULL << (DECOMPOSED_BINARY_POINT - 2); + frac &=3D ~(1ULL << (DECOMPOSED_BINARY_POINT - 1)); + frac |=3D 1ULL << (DECOMPOSED_BINARY_POINT - 2); } else { - a.frac |=3D 1ULL << (DECOMPOSED_BINARY_POINT - 1); + frac |=3D 1ULL << (DECOMPOSED_BINARY_POINT - 1); } - a.cls =3D float_class_qnan; - return a; + return frac; +} + +static void parts64_silence_nan(FloatParts64 *p, float_status *status) +{ + p->frac =3D parts_silence_nan_frac(p->frac, status); + p->cls =3D float_class_qnan; } =20 /*------------------------------------------------------------------------= ---- --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621168980; cv=none; d=zohomail.com; s=zohoarc; b=i5sjDuw5peCT9phlbXg6Si20IhiaFaIUqHqRUde3wcqw2j5ToS+YTtaiE4aZV/Q/rxLSp1Qa/0JfibNUOflcrjrEr6Qmk3++L+qLescJlh3TiYEBwlJN+6ssqhiS+nwbTtQhsa9kcPWg1y1YSzPnjF/on+rYwTnF2j7e5ykptQM= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621168980; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=WtVnyNXfkFjXiL/rrreOZ74P1ptL2lcGNEOLA4QHWTg=; b=bPgoKJWFnyAQshTdUEHTAB+5OXXzR+6OguMJzKNcEJTwE32u0itPS/AEEFWtyha46HwT62rWNVv2AKLkHf2V+GMjn25i3uFTBiiylJlRqcCyc0PdNwDCsxF7j0ufXJjZjnW66yg+9Q1nJeE7N5ElVFARd1aWWE2YtfWuMteYjBI= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621168980910189.40034086946036; Sun, 16 May 2021 05:43:00 -0700 (PDT) Received: from localhost ([::1]:45528 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG6l-00050S-Qx for importer@patchew.org; Sun, 16 May 2021 08:42:59 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43344) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzQ-0007hf-SD for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:29 -0400 Received: from mail-qk1-x72a.google.com ([2607:f8b0:4864:20::72a]:41852) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz1-0007np-Er for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:20 -0400 Received: by mail-qk1-x72a.google.com with SMTP id l129so3299053qke.8 for ; Sun, 16 May 2021 05:34:54 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.53 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=WtVnyNXfkFjXiL/rrreOZ74P1ptL2lcGNEOLA4QHWTg=; b=wCT2pHv9FB0oj7kMK0bLL4dntBFUoPoRMFxTwjAruDmGtmOqONqOJ/mGA4+lVBZE7N 3/TQiBQhSgJBvVjAXaigHgD5bDv6f0YzaVwtGzBY4WKJWp9oejGfQo1OXevqI3qoXrrm emxKX7U6RGVjRN02H4qmt0BpMuVWV1AhIr08gheDTWU7Rd/qJg8CvNyVHc2FjKa4pu3e tcOjO/n3gWkbTKowHJZ3CsZZFLLd+3OZj6tOh3L6BWEZetr3326skB1oqhKDRt1t/TZK c5YXf+o9Xf6A55URrgxMjbSSf/m8a25baaYLQRS1ARaNk+o+9Yzq5EwRIHMUk+UDKOAi q1Lw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=WtVnyNXfkFjXiL/rrreOZ74P1ptL2lcGNEOLA4QHWTg=; b=BK758dkJxZY/EQ20c4QoDo3bdfjOEzH5Msxw3KIn88dDn3ce60rqdym8ovPvHSB7K7 9d33K3pSslTmU63IgNoEkr+vtfC/2j1n10mrmCwM81FPFbibSUuP2+Nrr60JHt0kcsLu PaxrEOtmrB0WgipFTHhQ6/3JNwCPqG922tiUUiLqvFynnUHy+2Cwp6CV3W1ncVvYoW6C xR6g3ga+8bZHwuaUzWpTrZTVsTgD8WoDGF74OiM2XzMwowRoEDwxPSp2V838wM9B42gI W7ljvkGUBoNNPSQz0bHa7byCk++i/zSwSJDdY0EmnqGZfuqynAImWB4zz0viMdR+mEv+ sE1A== X-Gm-Message-State: AOAM532bHix1VRybibIaR6ZywB2wfNWIQnyf7tykkKAxVtFjw01LEWil jfxH4KFyw2JzV2WD6WNih15Vok5t7anutFIfEoE= X-Google-Smtp-Source: ABdhPJwb43TxZz8X5FZ10gB6HCf5Lo8Ax2GCjzOzMdFfefp9EZswP8I1aSrziXKpdQDenxC734p4Ng== X-Received: by 2002:a05:620a:167a:: with SMTP id d26mr20707395qko.293.1621168493708; Sun, 16 May 2021 05:34:53 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 25/46] softfloat: Rearrange FloatParts64 Date: Sun, 16 May 2021 07:34:10 -0500 Message-Id: <20210516123431.718318-26-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::72a; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x72a.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=unavailable autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Shuffle the fraction to the end, otherwise sort by size. Add frac_hi and frac_lo members to alias frac. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 2123453d40..ee609540aa 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -511,10 +511,20 @@ static inline __attribute__((unused)) bool is_qnan(Fl= oatClass c) */ =20 typedef struct { - uint64_t frac; - int32_t exp; FloatClass cls; bool sign; + int32_t exp; + union { + /* Routines that know the structure may reference the singular nam= e. */ + uint64_t frac; + /* + * Routines expanded with multiple structures reference "hi" and "= lo" + * depending on the operation. In FloatParts64, "hi" and "lo" are + * both the same word and aliased here. + */ + uint64_t frac_hi; + uint64_t frac_lo; + }; } FloatParts64; =20 #define DECOMPOSED_BINARY_POINT 63 --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170075; cv=none; d=zohomail.com; s=zohoarc; b=b/vwhHWVd0O8RsLW/qRmERlsvncS1lRuyC9jqj2kZVTJ9LAfT+pfG/TMerTWKfz7CVppOUZWuyMkETR2Gutud3bddqVf+qd5oih8B41Ly9/ezS3g/bpPFweeZyN6zZV7jVxfghwgO+TOQCL9vUWXKXP+3o7MTqcXQxXU8ZsnAQU= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170075; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=wol0hIlUZMDB7Lxhd/OO6iyKqSE57dtkR8dBi3DQOxs=; b=E/JvMkjyXPzF3ZxvaLFFZjADkrAlX/1y/WZZmoFDhx4A9DEWbTsuJQtSsYb1jFJ5vvqkNyS81ExuQ3vnk417wDNHhB4z6JCg6PB9F0Pp9vwSiuTzMNgIWM11BaVP2RPNvYnaYnoK9kIcfTqF0NtM7TlvNK0m6FJpZGb7REtKUg0= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170075827878.7935198579535; Sun, 16 May 2021 06:01:15 -0700 (PDT) Received: from localhost ([::1]:37888 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGOQ-0004OK-JV for importer@patchew.org; Sun, 16 May 2021 09:01:14 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43346) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzQ-0007hg-Se for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:29 -0400 Received: from mail-qt1-x831.google.com ([2607:f8b0:4864:20::831]:36527) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz1-0007nz-Eo for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:20 -0400 Received: by mail-qt1-x831.google.com with SMTP id t7so3024174qtn.3 for ; Sun, 16 May 2021 05:34:55 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.53 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=wol0hIlUZMDB7Lxhd/OO6iyKqSE57dtkR8dBi3DQOxs=; b=nmQSaScX4wqOhCdaIMXUa4I7PD/kxZS5aTIi/TR+Anzu/VrZ81ANJwvyyvRw3TbkQi xEUtxTgSSDIuegCDQtm0xZwnC/pj6kxIbckFkJS+05c9ezOPf8AESNm/bFhJ2FCLnzaQ 2bQcXmpoeC1agSKbq9PPeAabkj+RQpR+Cei8hi3xFsD2Ni01duBDJL20AhjAyivRqB8+ JuLRCYRp/afer/3hGD9Z2CXxGSdYzjlQxjRXOy0FowQjr3ZbfbEW574qEtb+r+5+HwNi Cg+Q9ZmvYNYDv+kuVN9I7sy/MTXYXioJr0LH/C6qVEKk8DG+aP2RdlkIYCkoYX5dOYoK cMNw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=wol0hIlUZMDB7Lxhd/OO6iyKqSE57dtkR8dBi3DQOxs=; b=eIJZkH6ddkM7uoXHh+gY02VWuyeSg//0DmlRlxuWOoV6IcR2/aHz7mbLvr1wAnaU7c 9U6W02KLRhHSEu6XyHIIGke8UqHa79bAtzMZE8Z+JudicrvFTNKVdTHaWs+0/wNX5D4g xQO6bp3F3FpuGUF4VfY/61fdIUnBhu7IQeX/fVUst4XzrAFS58g2Bp01dWSMerPFjeyR ShPz53dCbrsorYtrwJWD2p48LdJSjS7i7aJqS8Yhhic1drjL6yDdrdF5T5UI0+gyWQ3R WOsu2yW5qhJ9cuvZMnqly2lOV8I/KtuvL3KT1Pu+nrzRGjvEuk4oWTyjg0pM4saKLmcz rDvw== X-Gm-Message-State: AOAM532e3dWr78PGbDGNBamo1ODMubS5XVIC5jt5k8/T0EHDTaELabn6 KbNLJATQD7QCgTh2PR32ON367ioP83/B0CnEpik= X-Google-Smtp-Source: ABdhPJzGmvtL9UPdnLRtsBTOYc9UTLxIWU+8sscDjWAtfVypW5Z0mfC0vI8RRWkhBmLrBs7nJ7wQHQ== X-Received: by 2002:ac8:7c4b:: with SMTP id o11mr25766242qtv.336.1621168494468; Sun, 16 May 2021 05:34:54 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 26/46] softfloat: Convert float128_silence_nan to parts Date: Sun, 16 May 2021 07:34:11 -0500 Message-Id: <20210516123431.718318-27-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::831; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x831.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=unavailable autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) This is the minimal change that also introduces float128_params, float128_unpack_raw, and float128_pack_raw without running into unused symbol Werrors. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 96 +++++++++++++++++++++++++++++----- fpu/softfloat-specialize.c.inc | 25 +++------ 2 files changed, 89 insertions(+), 32 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index ee609540aa..f8f4ef51e8 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -500,14 +500,12 @@ static inline __attribute__((unused)) bool is_qnan(Fl= oatClass c) } =20 /* - * Structure holding all of the decomposed parts of a float. The - * exponent is unbiased and the fraction is normalized. All - * calculations are done with a 64 bit fraction and then rounded as - * appropriate for the final format. + * Structure holding all of the decomposed parts of a float. + * The exponent is unbiased and the fraction is normalized. * - * Thanks to the packed FloatClass a decent compiler should be able to - * fit the whole structure into registers and avoid using the stack - * for parameter passing. + * The fraction words are stored in big-endian word ordering, + * so that truncation from a larger format to a smaller format + * can be done simply by ignoring subsequent elements. */ =20 typedef struct { @@ -527,6 +525,15 @@ typedef struct { }; } FloatParts64; =20 +typedef struct { + FloatClass cls; + bool sign; + int32_t exp; + uint64_t frac_hi; + uint64_t frac_lo; +} FloatParts128; + +/* These apply to the most significant word of each FloatPartsN. */ #define DECOMPOSED_BINARY_POINT 63 #define DECOMPOSED_IMPLICIT_BIT (1ull << DECOMPOSED_BINARY_POINT) =20 @@ -562,11 +569,11 @@ typedef struct { .exp_bias =3D ((1 << E) - 1) >> 1, \ .exp_max =3D (1 << E) - 1, \ .frac_size =3D F, \ - .frac_shift =3D DECOMPOSED_BINARY_POINT - F, \ - .frac_lsb =3D 1ull << (DECOMPOSED_BINARY_POINT - F), \ - .frac_lsbm1 =3D 1ull << ((DECOMPOSED_BINARY_POINT - F) - 1), \ - .round_mask =3D (1ull << (DECOMPOSED_BINARY_POINT - F)) - 1, \ - .roundeven_mask =3D (2ull << (DECOMPOSED_BINARY_POINT - F)) - 1 + .frac_shift =3D (-F - 1) & 63, \ + .frac_lsb =3D 1ull << ((-F - 1) & 63), \ + .frac_lsbm1 =3D 1ull << ((-F - 2) & 63), \ + .round_mask =3D (1ull << ((-F - 1) & 63)) - 1, \ + .roundeven_mask =3D (2ull << ((-F - 1) & 63)) - 1 =20 static const FloatFmt float16_params =3D { FLOAT_PARAMS(5, 10) @@ -589,6 +596,10 @@ static const FloatFmt float64_params =3D { FLOAT_PARAMS(11, 52) }; =20 +static const FloatFmt float128_params =3D { + FLOAT_PARAMS(15, 112) +}; + /* Unpack a float to parts, but do not canonicalize. */ static void unpack_raw64(FloatParts64 *r, const FloatFmt *fmt, uint64_t ra= w) { @@ -623,6 +634,20 @@ static inline void float64_unpack_raw(FloatParts64 *p,= float64 f) unpack_raw64(p, &float64_params, f); } =20 +static void float128_unpack_raw(FloatParts128 *p, float128 f) +{ + const int f_size =3D float128_params.frac_size - 64; + const int e_size =3D float128_params.exp_size; + + *p =3D (FloatParts128) { + .cls =3D float_class_unclassified, + .sign =3D extract64(f.high, f_size + e_size, 1), + .exp =3D extract64(f.high, f_size, e_size), + .frac_hi =3D extract64(f.high, 0, f_size), + .frac_lo =3D f.low, + }; +} + /* Pack a float from parts, but do not canonicalize. */ static uint64_t pack_raw64(const FloatParts64 *p, const FloatFmt *fmt) { @@ -656,6 +681,18 @@ static inline float64 float64_pack_raw(const FloatPart= s64 *p) return make_float64(pack_raw64(p, &float64_params)); } =20 +static float128 float128_pack_raw(const FloatParts128 *p) +{ + const int f_size =3D float128_params.frac_size - 64; + const int e_size =3D float128_params.exp_size; + uint64_t hi; + + hi =3D (uint64_t)p->sign << (f_size + e_size); + hi =3D deposit64(hi, f_size, e_size, p->exp); + hi =3D deposit64(hi, 0, f_size, p->frac_hi); + return make_float128(hi, p->frac_lo); +} + /*------------------------------------------------------------------------= ---- | Functions and definitions to determine: (1) whether tininess for underf= low | is detected before or after rounding by default, (2) what (if anything) @@ -666,8 +703,30 @@ static inline float64 float64_pack_raw(const FloatPart= s64 *p) *-------------------------------------------------------------------------= ---*/ #include "softfloat-specialize.c.inc" =20 +#define PARTS_GENERIC_64_128(NAME, P) \ + QEMU_GENERIC(P, (FloatParts128 *, parts128_##NAME), parts64_##NAME) + #define parts_default_nan parts64_default_nan -#define parts_silence_nan parts64_silence_nan +#define parts_silence_nan(P, S) PARTS_GENERIC_64_128(silence_nan, P)(P,= S) + + +/* + * Helper functions for softfloat-parts.c.inc, per-size operations. + */ + +static void frac128_shl(FloatParts128 *a, int c) +{ + shift128Left(a->frac_hi, a->frac_lo, c, &a->frac_hi, &a->frac_lo); +} + +#define frac_shl(A, C) frac128_shl(A, C) + +static void frac128_shr(FloatParts128 *a, int c) +{ + shift128Right(a->frac_hi, a->frac_lo, c, &a->frac_hi, &a->frac_lo); +} + +#define frac_shr(A, C) frac128_shr(A, C) =20 /* Canonicalize EXP and FRAC, setting CLS. */ static FloatParts64 sf_canonicalize(FloatParts64 part, const FloatFmt *par= m, @@ -3851,6 +3910,17 @@ bfloat16 bfloat16_silence_nan(bfloat16 a, float_stat= us *status) return bfloat16_pack_raw(&p); } =20 +float128 float128_silence_nan(float128 a, float_status *status) +{ + FloatParts128 p; + + float128_unpack_raw(&p, a); + frac_shl(&p, float128_params.frac_shift); + parts_silence_nan(&p, status); + frac_shr(&p, float128_params.frac_shift); + return float128_pack_raw(&p); +} + /*------------------------------------------------------------------------= ---- | If `a' is denormal and we are in flush-to-zero mode then set the | input-denormal exception and return zero. Otherwise just return the valu= e. diff --git a/fpu/softfloat-specialize.c.inc b/fpu/softfloat-specialize.c.inc index 4038955379..5b85b843c2 100644 --- a/fpu/softfloat-specialize.c.inc +++ b/fpu/softfloat-specialize.c.inc @@ -197,6 +197,12 @@ static void parts64_silence_nan(FloatParts64 *p, float= _status *status) p->cls =3D float_class_qnan; } =20 +static void parts128_silence_nan(FloatParts128 *p, float_status *status) +{ + p->frac_hi =3D parts_silence_nan_frac(p->frac_hi, status); + p->cls =3D float_class_qnan; +} + /*------------------------------------------------------------------------= ---- | The pattern for a default generated extended double-precision NaN. *-------------------------------------------------------------------------= ---*/ @@ -1062,25 +1068,6 @@ bool float128_is_signaling_nan(float128 a, float_sta= tus *status) } } =20 -/*------------------------------------------------------------------------= ---- -| Returns a quiet NaN from a signalling NaN for the quadruple-precision -| floating point value `a'. -*-------------------------------------------------------------------------= ---*/ - -float128 float128_silence_nan(float128 a, float_status *status) -{ - if (no_signaling_nans(status)) { - g_assert_not_reached(); - } else { - if (snan_bit_is_one(status)) { - return float128_default_nan(status); - } else { - a.high |=3D UINT64_C(0x0000800000000000); - return a; - } - } -} - /*------------------------------------------------------------------------= ---- | Returns the result of converting the quadruple-precision floating-point = NaN | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169792; cv=none; d=zohomail.com; s=zohoarc; b=Z2LxghVdDA6qPpFdiJci5xQulgRVElnQMk9EmuuPsG+Uf4cXfniPqFam3HAzrSyFcyUaPUsKK3J9hKNVWFSbJzoyuNHnJP/NgiRE2o29M/Jun6hLZcDAmiEW8KwOgHDW4fWYKfxOMG8sIcuz9nEu7FkVy/FzcwzrBzHGPfCqBqQ= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169792; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=2MqvZurasxzpgYGu9FWNV4B+meV5FVHuhb0YtHOgOVE=; b=WICIyCWW+Wv5RSjUF+n15Mmlo4xOFSk3gcqFOe3T5c4CCcEoIB9tXQwji7OSfIZdJ1hj94H0SwqEzaqe+DA1LI6RfzBteuUvz6zhE12+DPPLBCvLiTvCQ34jI/1YFr8npCHcWKcYt5HUrLYLhIrL8IxG6YK6UVtqWDpW5s5ZdFA= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169792039808.0045523840646; Sun, 16 May 2021 05:56:32 -0700 (PDT) Received: from localhost ([::1]:51554 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGJq-00033w-U3 for importer@patchew.org; Sun, 16 May 2021 08:56:30 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43368) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzW-0007ig-Hu for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:30 -0400 Received: from mail-qt1-x82e.google.com ([2607:f8b0:4864:20::82e]:44691) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz1-0007ob-Em for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:24 -0400 Received: by mail-qt1-x82e.google.com with SMTP id y12so2987501qtx.11 for ; Sun, 16 May 2021 05:34:55 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=2MqvZurasxzpgYGu9FWNV4B+meV5FVHuhb0YtHOgOVE=; b=LqysAjKbIoO561yWMLKO33058BU8DJWwP75hlPtt/S/7iClnpEXt8VTvYTBv/6t2os DfFRU3pbZD3gS3O+9TSqxx0wQVgl45aeYF+FUBqBh1DStyNfgLjg/1fHX/Y/HkxNE27Y 6vNg16RQnqTJKkur7trisP+4a7/O5rYCz5oSZdxYus3BUac5aukElwEeAXFrY1tI1sfT zqs9u1IKIevQcpL/JLnBSNrRx1EhoGLv0JY+CWAdfVcy015YSluB+VQ/zrc7QA9MU+ut PZ/U4buUDe56IIM02AII123A1l6HGGcCZGothhAxmKpU2fDJaUER2XT3MoAiN0veVBmL N5xw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=2MqvZurasxzpgYGu9FWNV4B+meV5FVHuhb0YtHOgOVE=; b=Hq7wOpqpOfa+rsHGaAMgpRceJknKaf8kSTf1J7KSBiz/T66ZShKZz9X0eK+uheI5lN k9At6W+XP3HpB4RjVqFwHrxLvO15DoarSFi9onZhPF/ENl8ERs/4LET+CkqhA+TLTpRI Qm4kvbMH4STJMtMRagod7TLk0hPc2tIWLv2pQmuzIuVcjtOVTa+F/IGRm7h/QpFE5nk4 hNdJYdJjJ3OmdHfhQ7bHcnJwnRxr6uLXucmOlmgnJFIoT8Bt7ygEbcxf/ZqObceoTo4x T9KIm7wSkO24lhlssQ1LCRpcB7FuHkjfaO8tvF1WtBE+buICOi08scdKOa1Q+hoaz0HM Jw9w== X-Gm-Message-State: AOAM530rmDmpMtxH2SMqinCISpJVX2fthbO28RvMeTV6zol6aEwg8jFh o2pTN7x859wuEPef8HUPBgqragxdnAMc9ZpCj3A= X-Google-Smtp-Source: ABdhPJwUw8Hd6O+0hL9HwOlQrFG2z9jklZKISL6OIK2TwUHRLapHtD+jkySAXeqTy5ts1/NGOWWtiA== X-Received: by 2002:ac8:12c5:: with SMTP id b5mr52251432qtj.203.1621168495195; Sun, 16 May 2021 05:34:55 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 27/46] softfloat: Convert float128_default_nan to parts Date: Sun, 16 May 2021 07:34:12 -0500 Message-Id: <20210516123431.718318-28-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::82e; envelope-from=richard.henderson@linaro.org; helo=mail-qt1-x82e.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 17 ++++------------- fpu/softfloat-specialize.c.inc | 19 +++++++++++++++++++ 2 files changed, 23 insertions(+), 13 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index f8f4ef51e8..08fd812ea0 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -706,7 +706,7 @@ static float128 float128_pack_raw(const FloatParts128 *= p) #define PARTS_GENERIC_64_128(NAME, P) \ QEMU_GENERIC(P, (FloatParts128 *, parts128_##NAME), parts64_##NAME) =20 -#define parts_default_nan parts64_default_nan +#define parts_default_nan(P, S) PARTS_GENERIC_64_128(default_nan, P)(P,= S) #define parts_silence_nan(P, S) PARTS_GENERIC_64_128(silence_nan, P)(P,= S) =20 =20 @@ -3837,20 +3837,11 @@ float64 float64_default_nan(float_status *status) =20 float128 float128_default_nan(float_status *status) { - FloatParts64 p; - float128 r; + FloatParts128 p; =20 parts_default_nan(&p, status); - /* Extrapolate from the choices made by parts_default_nan to fill - * in the quad-floating format. If the low bit is set, assume we - * want to set all non-snan bits. - */ - r.low =3D -(p.frac & 1); - r.high =3D p.frac >> (DECOMPOSED_BINARY_POINT - 48); - r.high |=3D UINT64_C(0x7FFF000000000000); - r.high |=3D (uint64_t)p.sign << 63; - - return r; + frac_shr(&p, float128_params.frac_shift); + return float128_pack_raw(&p); } =20 bfloat16 bfloat16_default_nan(float_status *status) diff --git a/fpu/softfloat-specialize.c.inc b/fpu/softfloat-specialize.c.inc index 5b85b843c2..c895733e79 100644 --- a/fpu/softfloat-specialize.c.inc +++ b/fpu/softfloat-specialize.c.inc @@ -171,6 +171,25 @@ static void parts64_default_nan(FloatParts64 *p, float= _status *status) }; } =20 +static void parts128_default_nan(FloatParts128 *p, float_status *status) +{ + /* + * Extrapolate from the choices made by parts64_default_nan to fill + * in the quad-floating format. If the low bit is set, assume we + * want to set all non-snan bits. + */ + FloatParts64 p64; + parts64_default_nan(&p64, status); + + *p =3D (FloatParts128) { + .cls =3D float_class_qnan, + .sign =3D p64.sign, + .exp =3D INT_MAX, + .frac_hi =3D p64.frac, + .frac_lo =3D -(p64.frac & 1) + }; +} + /*------------------------------------------------------------------------= ---- | Returns a quiet NaN from a signalling NaN for the deconstructed | floating-point parts. --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170518; cv=none; d=zohomail.com; s=zohoarc; b=Hyo9aEN2JsbQ4+qdaBvAXXMZNtpw9sd0Hy9r+dvXxXu7KpmUWWhx7KIUjAfGMlQQ4Czaxx+SWSYkoox9KvioXvV9PtEF+IrVoIdAd8po28YCkFHIbc9P65gpnDFeUTOO2fDXxEZFzQrJZ25g5qaBipgc/TdgbYKldQfnracqAIY= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170518; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=higXGsISKjfG3yJhtMKpkIr13//TTmgs1GnUua1I9hQ=; b=HLdS12htqWrj+PI7cs3qQI6xbKF8wWVyyy7EkAWnmphknxgq76hRKCC6EPpn0LvryV5FRPneOJ+Mr4tLA1g72KFvzRGzPkRvQZattdtiVta0MqmVgpbEctDk2FGdZcM7mGNqe4uqGW0XTV12BEkExrF4d/xTOeeQwRl+v+BDfoE= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170518198928.101020192302; Sun, 16 May 2021 06:08:38 -0700 (PDT) Received: from localhost ([::1]:34174 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGVZ-000483-8M for importer@patchew.org; Sun, 16 May 2021 09:08:37 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43372) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzW-0007jA-Nq for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:30 -0400 Received: from mail-qk1-x735.google.com ([2607:f8b0:4864:20::735]:43932) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz2-0007of-Ch for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:30 -0400 Received: by mail-qk1-x735.google.com with SMTP id a22so3278957qkl.10 for ; Sun, 16 May 2021 05:34:56 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=higXGsISKjfG3yJhtMKpkIr13//TTmgs1GnUua1I9hQ=; b=he/Zlmrw7OWrgJ+2o97ljFy/BTPc7CDvFDDN97Ci3ceaXVxVaYIwCnKfEwsXQThBDN 7haFuvRsBLmVld3qvjkUcW7MEAvcSjHo3u6zPeBGtiEDP+QVI9qhwttv3ZzfuriMkQzk Jyo2lCASoVMlv+mSWjJsIS0UCLdPqPOVzOvTd5RK5JDyAbY6TlQ3AvkPttm4YvSaorWv dVdjuzmPuPmVz1wJB6M6eVX3y1GjFXvGX0WzWNQ9iXftvKP5us2DywD3Bb+UJIOlFUN1 bnlMZIjpC2N8buixtrYX8Zf4SU3CGp95ia9IAbigk+RWvF8YuLd6qPnAzVjVapoX9qGa o0Uw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=higXGsISKjfG3yJhtMKpkIr13//TTmgs1GnUua1I9hQ=; b=IGZfGNYV6JjyQK/nIPpdyFfAXANuw99/Yb7LZdmmAXMie/vWVfLxCUERUVHVVpbNaw tf/kLnIu7kf/0UUQzzSgyKFcoFgNGHK7OM/un9X4XRawr0WbcAOEhWHAusG/VN3s+E9I vwGwobC9REuwyiK19AAd5SHJuYLPDA9Ah2Tazp9HDKINOs8yVS8lLkb7qX43nx1jJvRv k4RTzKGoVHl3Ly+FeQTAYDRFlbuCSm92DbNCyOPGIJlzkboSo6CWx2l0hKtEZX47M6wE TmjlRO3ANKNbb7/MZH/VQJeVjn/vCyLm+XTFHnFC0w7G7qEIugf2be7zENIule+fDaNe Kb1Q== X-Gm-Message-State: AOAM533E8diEp3QaqksTQY4W1dn4/3ywZShT0k9fGwdiWQt1b5Vxj9Ht n/rBURhBc7+7T/tAT27uMu99U6jGTr8+1oU2FiE= X-Google-Smtp-Source: ABdhPJyEno3HDtP1mWBLWkQVW4OercLbq+vcAcQVW2LkWEJJUXNjCuosOA5KEOSW9CD7IyOAv1vOcA== X-Received: by 2002:a05:620a:945:: with SMTP id w5mr48465037qkw.68.1621168495979; Sun, 16 May 2021 05:34:55 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 28/46] softfloat: Move return_nan to softfloat-parts.c.inc Date: Sun, 16 May 2021 07:34:13 -0500 Message-Id: <20210516123431.718318-29-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::735; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x735.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Content-Type: text/plain; charset="utf-8" At the same time, convert to pointers, rename to return_nan$N and define a macro for return_nan using QEMU_GENERIC. Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- fpu/softfloat.c | 45 ++++++++++++++++++++++----------------- fpu/softfloat-parts.c.inc | 37 ++++++++++++++++++++++++++++++++ 2 files changed, 62 insertions(+), 20 deletions(-) create mode 100644 fpu/softfloat-parts.c.inc diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 08fd812ea0..bdc3125e5c 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -709,6 +709,10 @@ static float128 float128_pack_raw(const FloatParts128 = *p) #define parts_default_nan(P, S) PARTS_GENERIC_64_128(default_nan, P)(P,= S) #define parts_silence_nan(P, S) PARTS_GENERIC_64_128(silence_nan, P)(P,= S) =20 +static void parts64_return_nan(FloatParts64 *a, float_status *s); +static void parts128_return_nan(FloatParts128 *a, float_status *s); + +#define parts_return_nan(P, S) PARTS_GENERIC_64_128(return_nan, P)(P, = S) =20 /* * Helper functions for softfloat-parts.c.inc, per-size operations. @@ -915,22 +919,6 @@ static FloatParts64 round_canonical(FloatParts64 p, fl= oat_status *s, return p; } =20 -static FloatParts64 return_nan(FloatParts64 a, float_status *s) -{ - g_assert(is_nan(a.cls)); - if (is_snan(a.cls)) { - float_raise(float_flag_invalid, s); - if (!s->default_nan_mode) { - parts_silence_nan(&a, s); - return a; - } - } else if (!s->default_nan_mode) { - return a; - } - parts_default_nan(&a, s); - return a; -} - static FloatParts64 pick_nan(FloatParts64 a, FloatParts64 b, float_status = *s) { if (is_snan(a.cls) || is_snan(b.cls)) { @@ -992,6 +980,21 @@ static FloatParts64 pick_nan_muladd(FloatParts64 a, Fl= oatParts64 b, FloatParts64 return a; } =20 +#define partsN(NAME) parts64_##NAME +#define FloatPartsN FloatParts64 + +#include "softfloat-parts.c.inc" + +#undef partsN +#undef FloatPartsN +#define partsN(NAME) parts128_##NAME +#define FloatPartsN FloatParts128 + +#include "softfloat-parts.c.inc" + +#undef partsN +#undef FloatPartsN + /* * Pack/unpack routines with a specific FloatFmt. */ @@ -2066,7 +2069,7 @@ static FloatParts64 float_to_float(FloatParts64 a, co= nst FloatFmt *dstf, break; } } else if (is_nan(a.cls)) { - return return_nan(a, s); + parts_return_nan(&a, s); } return a; } @@ -2195,7 +2198,8 @@ static FloatParts64 round_to_int(FloatParts64 a, Floa= tRoundMode rmode, switch (a.cls) { case float_class_qnan: case float_class_snan: - return return_nan(a, s); + parts_return_nan(&a, s); + break; =20 case float_class_zero: case float_class_inf: @@ -3591,7 +3595,7 @@ FloatRelation bfloat16_compare_quiet(bfloat16 a, bflo= at16 b, float_status *s) static FloatParts64 scalbn_decomposed(FloatParts64 a, int n, float_status = *s) { if (unlikely(is_nan(a.cls))) { - return return_nan(a, s); + parts_return_nan(&a, s); } if (a.cls =3D=3D float_class_normal) { /* The largest float type (even though not supported by FloatParts= 64) @@ -3659,7 +3663,8 @@ static FloatParts64 sqrt_float(FloatParts64 a, float_= status *s, const FloatFmt * int bit, last_bit; =20 if (is_nan(a.cls)) { - return return_nan(a, s); + parts_return_nan(&a, s); + return a; } if (a.cls =3D=3D float_class_zero) { return a; /* sqrt(+-0) =3D +-0 */ diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc new file mode 100644 index 0000000000..2a3075d6fe --- /dev/null +++ b/fpu/softfloat-parts.c.inc @@ -0,0 +1,37 @@ +/* + * QEMU float support + * + * The code in this source file is derived from release 2a of the SoftFloat + * IEC/IEEE Floating-point Arithmetic Package. Those parts of the code (and + * some later contributions) are provided under that license, as detailed = below. + * It has subsequently been modified by contributors to the QEMU Project, + * so some portions are provided under: + * the SoftFloat-2a license + * the BSD license + * GPL-v2-or-later + * + * Any future contributions to this file after December 1st 2014 will be + * taken to be licensed under the Softfloat-2a license unless specifically + * indicated otherwise. + */ + +static void partsN(return_nan)(FloatPartsN *a, float_status *s) +{ + switch (a->cls) { + case float_class_snan: + float_raise(float_flag_invalid, s); + if (s->default_nan_mode) { + parts_default_nan(a, s); + } else { + parts_silence_nan(a, s); + } + break; + case float_class_qnan: + if (s->default_nan_mode) { + parts_default_nan(a, s); + } + break; + default: + g_assert_not_reached(); + } +} --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170241; cv=none; d=zohomail.com; s=zohoarc; b=cDX8ZCXialirH/f/qUDZq80y7+c1YsrG63tAhm15ewpQCUS5sFv2ewLff1ClMSO7OgBGIGpHHxb6BhFdV5nbepMaZH9Cyv5U5aHmyPwlinC0srmzrfYA8hDnCeQMZ/i4ChIbQWIBnSkhUQ+SrbBx2fxVXqQsPL/6Y39IW9ZBEz4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170241; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=9VdzNFszTdcD2ktO3zGU/bD6+PDA34XFo6jM/oZ00K8=; b=Xz8nE76pxG+xfl5XKb4Ea07rhxJMcTdoXc26MLfn/JozZRN1G/GtKVAAgSFkgy2H9W8E9xP5vf73QVthiFsmTupAoGvjQdI4jOYSg/vTjGBRG4XDfOCyF5K09ze52snK27VSv3ZDeupEruYKIP8jF2A+1s3sgXea0ZnAQOCWpak= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170241971984.4628701765871; Sun, 16 May 2021 06:04:01 -0700 (PDT) Received: from localhost ([::1]:46350 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGR6-0001mN-T6 for importer@patchew.org; Sun, 16 May 2021 09:04:00 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43370) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzW-0007iu-L5 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:30 -0400 Received: from mail-qk1-x72c.google.com ([2607:f8b0:4864:20::72c]:36454) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz1-0007oj-FI for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:24 -0400 Received: by mail-qk1-x72c.google.com with SMTP id c20so3321916qkm.3 for ; Sun, 16 May 2021 05:34:57 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=9VdzNFszTdcD2ktO3zGU/bD6+PDA34XFo6jM/oZ00K8=; b=ses4bz4QEGorYBkf7xNApBGMq5JwYnoh2YIlOi8T6BtfGJU7i5N0gs7Voq2pr64urk sl8BNnSRHzUJICDqQ84hDCTvUq6QioSHBswtITl3J+PQL943KTTzFQ9KyjTq6uSYcal+ 7aK0Pn0E+vrknImXCJpGFtgaHyhrArye4QmcQ7P1QOcV3P+CzMBkgjnpR79tctS2a/Ma g2CQKzsCSLQcd/GbyMQ4PAL2YhTf07fsqLCD7g+AWpqL1nNjRUGvAoDImU7j33KE+51o xIWIWTp/BEtQzZpi3gxD9itHCa174KUnSZ9JjbldrSoacZDMXG0LvSVD35wV8EHLMJbw bCyg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=9VdzNFszTdcD2ktO3zGU/bD6+PDA34XFo6jM/oZ00K8=; b=lJZ5uXFF6ldC6zSqJgiCoQFZ0OeYX1CcHi/fRqLbc9DNH/Hu1dC2zuVoOEuOyepfxv BnJqfPYCp6pTEoE5t8QzheD4DDTiVBLXRN5upMOGfDMcOjDqoKegqbz3nCjo+uw8TRwH L6XjyMwyKal3ScX6AN0f/dBLrMy89C0AnJMeWzp5jd36WfhEdm1reUTMSzGQTjDzEVJq 4cLqoyfMc9gj7lM5gY6mhS8f5Yi6d0n5h6t0p7pfQTRRxk51vW1TY1XL9RRqK+a3wX16 qhubXKUZmfYW1mUozvha6EnxeIe9sHT3ueRtKsjyRPuPsmeYu64XSUiqVIT/ULPeKkKK Qd1Q== X-Gm-Message-State: AOAM530+LIY8SMoWLo9A+7GFQ6XrK4eJu6QKXtWuO+6gbKJ2r/Kok4sn arwjkoHnGqUKf6zSqZ4o2m5zEIFh6yeoBQw0UhY= X-Google-Smtp-Source: ABdhPJy3JUsjAhN7qCXr3sdxVU0rUPXgAmIliP3+86n+tA68mNhog3ySnNoJdLuNkFYp4TAZy4Yfag== X-Received: by 2002:a37:94e:: with SMTP id 75mr52421068qkj.128.1621168496697; Sun, 16 May 2021 05:34:56 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 29/46] softfloat: Move pick_nan to softfloat-parts.c.inc Date: Sun, 16 May 2021 07:34:14 -0500 Message-Id: <20210516123431.718318-30-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::72c; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x72c.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=unavailable autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Content-Type: text/plain; charset="utf-8" At the same time, convert to pointers, rename to parts$N_pick_nan and define a macro for parts_pick_nan using QEMU_GENERIC. Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- fpu/softfloat.c | 62 ++++++++++++++++++++++----------------- fpu/softfloat-parts.c.inc | 25 ++++++++++++++++ 2 files changed, 60 insertions(+), 27 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index bdc3125e5c..019b34d378 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -714,10 +714,39 @@ static void parts128_return_nan(FloatParts128 *a, flo= at_status *s); =20 #define parts_return_nan(P, S) PARTS_GENERIC_64_128(return_nan, P)(P, = S) =20 +static FloatParts64 *parts64_pick_nan(FloatParts64 *a, FloatParts64 *b, + float_status *s); +static FloatParts128 *parts128_pick_nan(FloatParts128 *a, FloatParts128 *b, + float_status *s); + +#define parts_pick_nan(A, B, S) PARTS_GENERIC_64_128(pick_nan, A)(A, B,= S) + /* * Helper functions for softfloat-parts.c.inc, per-size operations. */ =20 +#define FRAC_GENERIC_64_128(NAME, P) \ + QEMU_GENERIC(P, (FloatParts128 *, frac128_##NAME), frac64_##NAME) + +static int frac64_cmp(FloatParts64 *a, FloatParts64 *b) +{ + return a->frac =3D=3D b->frac ? 0 : a->frac < b->frac ? -1 : 1; +} + +static int frac128_cmp(FloatParts128 *a, FloatParts128 *b) +{ + uint64_t ta =3D a->frac_hi, tb =3D b->frac_hi; + if (ta =3D=3D tb) { + ta =3D a->frac_lo, tb =3D b->frac_lo; + if (ta =3D=3D tb) { + return 0; + } + } + return ta < tb ? -1 : 1; +} + +#define frac_cmp(A, B) FRAC_GENERIC_64_128(cmp, A)(A, B) + static void frac128_shl(FloatParts128 *a, int c) { shift128Left(a->frac_hi, a->frac_lo, c, &a->frac_hi, &a->frac_lo); @@ -919,27 +948,6 @@ static FloatParts64 round_canonical(FloatParts64 p, fl= oat_status *s, return p; } =20 -static FloatParts64 pick_nan(FloatParts64 a, FloatParts64 b, float_status = *s) -{ - if (is_snan(a.cls) || is_snan(b.cls)) { - float_raise(float_flag_invalid, s); - } - - if (s->default_nan_mode) { - parts_default_nan(&a, s); - } else { - if (pickNaN(a.cls, b.cls, - a.frac > b.frac || - (a.frac =3D=3D b.frac && a.sign < b.sign), s)) { - a =3D b; - } - if (is_snan(a.cls)) { - parts_silence_nan(&a, s); - } - } - return a; -} - static FloatParts64 pick_nan_muladd(FloatParts64 a, FloatParts64 b, FloatP= arts64 c, bool inf_zero, float_status *s) { @@ -1107,7 +1115,7 @@ static FloatParts64 addsub_floats(FloatParts64 a, Flo= atParts64 b, bool subtract, return a; } if (is_nan(a.cls) || is_nan(b.cls)) { - return pick_nan(a, b, s); + return *parts_pick_nan(&a, &b, s); } if (a.cls =3D=3D float_class_inf) { if (b.cls =3D=3D float_class_inf) { @@ -1145,7 +1153,7 @@ static FloatParts64 addsub_floats(FloatParts64 a, Flo= atParts64 b, bool subtract, return a; } if (is_nan(a.cls) || is_nan(b.cls)) { - return pick_nan(a, b, s); + return *parts_pick_nan(&a, &b, s); } if (a.cls =3D=3D float_class_inf || b.cls =3D=3D float_class_zero)= { return a; @@ -1361,7 +1369,7 @@ static FloatParts64 mul_floats(FloatParts64 a, FloatP= arts64 b, float_status *s) } /* handle all the NaN cases */ if (is_nan(a.cls) || is_nan(b.cls)) { - return pick_nan(a, b, s); + return *parts_pick_nan(&a, &b, s); } /* Inf * Zero =3D=3D NaN */ if ((a.cls =3D=3D float_class_inf && b.cls =3D=3D float_class_zero) || @@ -1888,7 +1896,7 @@ static FloatParts64 div_floats(FloatParts64 a, FloatP= arts64 b, float_status *s) } /* handle all the NaN cases */ if (is_nan(a.cls) || is_nan(b.cls)) { - return pick_nan(a, b, s); + return *parts_pick_nan(&a, &b, s); } /* 0/0 or Inf/Inf */ if (a.cls =3D=3D b.cls @@ -3296,14 +3304,14 @@ static FloatParts64 minmax_floats(FloatParts64 a, F= loatParts64 b, bool ismin, * the invalid exception is raised. */ if (is_snan(a.cls) || is_snan(b.cls)) { - return pick_nan(a, b, s); + return *parts_pick_nan(&a, &b, s); } else if (is_nan(a.cls) && !is_nan(b.cls)) { return b; } else if (is_nan(b.cls) && !is_nan(a.cls)) { return a; } } - return pick_nan(a, b, s); + return *parts_pick_nan(&a, &b, s); } else { int a_exp, b_exp; =20 diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc index 2a3075d6fe..11a71650f7 100644 --- a/fpu/softfloat-parts.c.inc +++ b/fpu/softfloat-parts.c.inc @@ -35,3 +35,28 @@ static void partsN(return_nan)(FloatPartsN *a, float_sta= tus *s) g_assert_not_reached(); } } + +static FloatPartsN *partsN(pick_nan)(FloatPartsN *a, FloatPartsN *b, + float_status *s) +{ + if (is_snan(a->cls) || is_snan(b->cls)) { + float_raise(float_flag_invalid, s); + } + + if (s->default_nan_mode) { + parts_default_nan(a, s); + } else { + int cmp =3D frac_cmp(a, b); + if (cmp =3D=3D 0) { + cmp =3D a->sign < b->sign; + } + + if (pickNaN(a->cls, b->cls, cmp > 0, s)) { + a =3D b; + } + if (is_snan(a->cls)) { + parts_silence_nan(a, s); + } + } + return a; +} --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169957; cv=none; d=zohomail.com; s=zohoarc; b=QkWEwtIzNCSeyIrzlARA594FXNn1vtJZjefuT75HjLWTdZBcuhA0lzrQB1rajaffKH6M/fcMp2Sx+tm97haPaMohvro1zqf+5zAybXdG9u/2INXk/fnhqT9E23JcNPba1mKfLAtDotXjCE5aL0S1RpLiQHgAoSeapyvYkqY+ESw= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169957; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=UDg46Ctpds96YRmJNkMfrK5vywLK/33iVAMWDMcAR0s=; b=YGNPgduOXqUbf6o5XYJjKYDEblc5Aa6Z1/CzMKOjA+6NDAzMZaNsHgcy8o+eLncBL+e3qFjNC/xEWmnqozCEQFD4AGkZhqJCcMgpIpadb5sIQmW6XgHG2YVE0Fp/R18G7JBkgik6xbV+6r/z+sXjsMUpnlBv8YkYBD7iIPI8jcs= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169957478873.5807595169936; Sun, 16 May 2021 05:59:17 -0700 (PDT) Received: from localhost ([::1]:60002 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGMW-0000Om-B6 for importer@patchew.org; Sun, 16 May 2021 08:59:16 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43376) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzW-0007jn-T7 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:30 -0400 Received: from mail-qk1-x730.google.com ([2607:f8b0:4864:20::730]:37612) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz2-0007oo-D1 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:30 -0400 Received: by mail-qk1-x730.google.com with SMTP id i67so3308988qkc.4 for ; Sun, 16 May 2021 05:34:57 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=UDg46Ctpds96YRmJNkMfrK5vywLK/33iVAMWDMcAR0s=; b=MtubWubTjlAQyAz0c/2NzAhoy77OQ3DYduyIRgQcYU/G15IMtoFMOT31f6y7v3yY7n Ne7E6VhedNXejcUGD/6wUhca7VXMYoEAmlzsNidRn9Uq+mIatZAYCxwtSHxdgkkPY+sb h6QGc8jBew/xLMTvE3a1Y+tFACTTkyhKsiPZgRgP6uK1oTn1TCYy607O8NfbndKkmOW8 VlsKDNULvfAzYyQLqG2WPG6N5Na96Wwhv6QGnAWruIlOXom1wUOItxAH+9iNQtMIEZf+ EATtsPrKUWy/oLlZP5NH/v2NpmUgdwf3j+Re2GZlrkhx+3XGsY8DBkCIdnfdBgfbH5UB pw3w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=UDg46Ctpds96YRmJNkMfrK5vywLK/33iVAMWDMcAR0s=; b=gepCGA5E/pzpU7I3T7+4l6N5+LLgH0xjJ4w5hehO3ji10lC1Tl3RQ4c+TaGv3DwseZ MtRPqMM6CozeASJIdl/WhNfnwQj9+0LM9mg8edz0qhU6CaDO9g7MnEtj+6qdeHtMkRSe 60w2S9snVRRBNOL5EpUfynLoNdQItRNpflJpm/IwKd8CxSrcfvdYrOuNOHpOF0QMsPOD WDNNFYcJ0fxXaFg2DM+1Sy8I8Oso+X3GPIWx+OCL9pw9zxRnvwkQy/VCRYcuzmmi/zfg QkIh1l0Q0UmmASJbttR+7I9x2Xpnmq/i/HjORklT88O34A0kC5qDiRPfI7fqbvw2bCtS UUIQ== X-Gm-Message-State: AOAM531lZzxES2N+u001cQCBG0svDVu8pNmreJRu1OE6J4fAPRKD/ajW qV8gIqKEZdZqL62APXcdFdap7qza0LVHWTs/8sc= X-Google-Smtp-Source: ABdhPJw2PeSidB0ZNkn9qi14x34AlELK1dF74z7JsYnmvyKIw/iolhY+dRtBi+kKI/kRGXi04C+TyA== X-Received: by 2002:a37:9ac1:: with SMTP id c184mr52847629qke.201.1621168497491; Sun, 16 May 2021 05:34:57 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 30/46] softfloat: Move pick_nan_muladd to softfloat-parts.c.inc Date: Sun, 16 May 2021 07:34:15 -0500 Message-Id: <20210516123431.718318-31-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::730; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x730.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Content-Type: text/plain; charset="utf-8" At the same time, convert to pointers, rename to pick_nan_muladd$N and define a macro for pick_nan_muladd using QEMU_GENERIC. Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- fpu/softfloat.c | 53 ++++++++++----------------------------- fpu/softfloat-parts.c.inc | 40 +++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+), 40 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 019b34d378..df004dbe2f 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -721,6 +721,18 @@ static FloatParts128 *parts128_pick_nan(FloatParts128 = *a, FloatParts128 *b, =20 #define parts_pick_nan(A, B, S) PARTS_GENERIC_64_128(pick_nan, A)(A, B,= S) =20 +static FloatParts64 *parts64_pick_nan_muladd(FloatParts64 *a, FloatParts64= *b, + FloatParts64 *c, float_status= *s, + int ab_mask, int abc_mask); +static FloatParts128 *parts128_pick_nan_muladd(FloatParts128 *a, + FloatParts128 *b, + FloatParts128 *c, + float_status *s, + int ab_mask, int abc_mask); + +#define parts_pick_nan_muladd(A, B, C, S, ABM, ABCM) \ + PARTS_GENERIC_64_128(pick_nan_muladd, A)(A, B, C, S, ABM, ABCM) + /* * Helper functions for softfloat-parts.c.inc, per-size operations. */ @@ -948,45 +960,6 @@ static FloatParts64 round_canonical(FloatParts64 p, fl= oat_status *s, return p; } =20 -static FloatParts64 pick_nan_muladd(FloatParts64 a, FloatParts64 b, FloatP= arts64 c, - bool inf_zero, float_status *s) -{ - int which; - - if (is_snan(a.cls) || is_snan(b.cls) || is_snan(c.cls)) { - float_raise(float_flag_invalid, s); - } - - which =3D pickNaNMulAdd(a.cls, b.cls, c.cls, inf_zero, s); - - if (s->default_nan_mode) { - /* Note that this check is after pickNaNMulAdd so that function - * has an opportunity to set the Invalid flag. - */ - which =3D 3; - } - - switch (which) { - case 0: - break; - case 1: - a =3D b; - break; - case 2: - a =3D c; - break; - case 3: - parts_default_nan(&a, s); - break; - default: - g_assert_not_reached(); - } - - if (is_snan(a.cls)) { - parts_silence_nan(&a, s); - } - return a; -} =20 #define partsN(NAME) parts64_##NAME #define FloatPartsN FloatParts64 @@ -1497,7 +1470,7 @@ static FloatParts64 muladd_floats(FloatParts64 a, Flo= atParts64 b, FloatParts64 c * off to the target-specific pick-a-NaN routine. */ if (unlikely(abc_mask & float_cmask_anynan)) { - return pick_nan_muladd(a, b, c, inf_zero, s); + return *parts_pick_nan_muladd(&a, &b, &c, s, ab_mask, abc_mask); } =20 if (inf_zero) { diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc index 11a71650f7..a78d61ea07 100644 --- a/fpu/softfloat-parts.c.inc +++ b/fpu/softfloat-parts.c.inc @@ -60,3 +60,43 @@ static FloatPartsN *partsN(pick_nan)(FloatPartsN *a, Flo= atPartsN *b, } return a; } + +static FloatPartsN *partsN(pick_nan_muladd)(FloatPartsN *a, FloatPartsN *b, + FloatPartsN *c, float_status *= s, + int ab_mask, int abc_mask) +{ + int which; + + if (unlikely(abc_mask & float_cmask_snan)) { + float_raise(float_flag_invalid, s); + } + + which =3D pickNaNMulAdd(a->cls, b->cls, c->cls, + ab_mask =3D=3D float_cmask_infzero, s); + + if (s->default_nan_mode || which =3D=3D 3) { + /* + * Note that this check is after pickNaNMulAdd so that function + * has an opportunity to set the Invalid flag for infzero. + */ + parts_default_nan(a, s); + return a; + } + + switch (which) { + case 0: + break; + case 1: + a =3D b; + break; + case 2: + a =3D c; + break; + default: + g_assert_not_reached(); + } + if (is_snan(a->cls)) { + parts_silence_nan(a, s); + } + return a; +} --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169616; cv=none; d=zohomail.com; s=zohoarc; b=VDEmP2K9g+DBs9oO1LdgpAg4/gWPihxoymnrFjm1UtcZuB5sefVNfG3JwQO9s632BdmcU77+lkLWWEym+z14+vrpPj3oZgqqhpmcqddMl5Pt0EaDR9tlsRWtUCFMpfMSYPHUvcub4prEL9Jiz2L3aUIiWMvDueGZ44cM3N/4pCU= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169616; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=hfY0ZaTydaVjsCvXo8wfDUit/9H1yCIOT+0mDLtjiOw=; b=FlvQhpVgnSDrVYfu9/MDBi318KpnbtARPGse1lj0ADsk6UV2bQIMrcpf8uWpYa0P+7+woUVmKyjcawQCuOEwLoY+Y60reG8cMMbZaJUfCTnxjsbyl1LMSxFE6KSEX6JMyGB8uW/Ymges1KP3YDCMEFa1+pIP0+meBXqtjVWLHbM= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169616186412.30131434121256; Sun, 16 May 2021 05:53:36 -0700 (PDT) Received: from localhost ([::1]:42938 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGH1-0005my-17 for importer@patchew.org; Sun, 16 May 2021 08:53:35 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43284) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzC-0007db-0A for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:10 -0400 Received: from mail-qk1-x732.google.com ([2607:f8b0:4864:20::732]:39756) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz1-0007ox-Eo for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:09 -0400 Received: by mail-qk1-x732.google.com with SMTP id k127so3306379qkc.6 for ; Sun, 16 May 2021 05:34:58 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:58 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=hfY0ZaTydaVjsCvXo8wfDUit/9H1yCIOT+0mDLtjiOw=; b=Vo9CyuGfVqQvqdkoA6+feffTl1rFmLbeEwVy8FifdOmS63Ai+FeJabEe0CbkfjVw5I hcmz0JRe8Mb04Pry5/2bZeeIpX66cerzxtP++osfOtr+GPcRZHqk1B3enO/1N0Tq2xxE 2E0leFbLQsWSBkYJY1Zkp4klAm8XG1QD/yXOUNvTJb4GtDlaHWdfMzuUlUCS9/28GixG cj+KL/TkDq+KBprIt1OB25YZG0RovLZZEQgjPwM+taopzj5wpKLF+DQqs62OXB+hMsfR Mw06afysHCAErz1VLm4nPw6IzUS8FfF4sE/ItQ1hESd97Kq9mnvPaYR1jJFje6uNsR0p m/ug== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=hfY0ZaTydaVjsCvXo8wfDUit/9H1yCIOT+0mDLtjiOw=; b=Y2d4WZt/Zcqk/RauKXPk4JgPULuDXaiRaLHKjb/1fvUDeX8Ny84werFXoG+UwNp4vW Um+TNf4P04o/+SIS626RzPBrnmOr5SLIkmJMomS0wCCq2SAz9/0QvLhEm0x2J3UpCH1m 0bcglbAYQX+UE9KsWY0BsOMldAdPoRr0ZYKALHapr0ZxxVa2EOUn1rvegVFv0H3x1hkj vWTbhlUtKileesFrxoKB5KbEOY1IH4xjFgiAT0TtHMB3lZj0aqyHcQLWuw039eFgE50B uGgYCJBsqmro7AKKNxrZT750Va7LR4iA9e3It0e0j0RryI+6HGnkR3PtQQNFDmCnAppE LnCw== X-Gm-Message-State: AOAM532sBMZJtcJc+s6f81Wgg6/lqFnAO1H89Xp9gqgWkuvv03M5laKy bJRslgmBJ43VA2D4J2UCkanpelJx1OmdRJLCSqE= X-Google-Smtp-Source: ABdhPJwm4AX5aYKtXRfmAQ5ffz9cexhuMEYX7uQhez0a/BxYO1ggoOt1nyOa4Q2TSdeaJKCJTdQJEg== X-Received: by 2002:a37:e40f:: with SMTP id y15mr53427637qkf.314.1621168498339; Sun, 16 May 2021 05:34:58 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 31/46] softfloat: Move sf_canonicalize to softfloat-parts.c.inc Date: Sun, 16 May 2021 07:34:16 -0500 Message-Id: <20210516123431.718318-32-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::732; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x732.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) At the same time, convert to pointers, rename to parts$N_canonicalize and define a macro for parts_canonicalize using QEMU_GENERIC. Rearrange the cases to recognize float_class_normal as early as possible. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 117 +++++++++++++++++++++++++------------- fpu/softfloat-parts.c.inc | 33 +++++++++++ 2 files changed, 112 insertions(+), 38 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index df004dbe2f..535261db44 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -733,6 +733,14 @@ static FloatParts128 *parts128_pick_nan_muladd(FloatPa= rts128 *a, #define parts_pick_nan_muladd(A, B, C, S, ABM, ABCM) \ PARTS_GENERIC_64_128(pick_nan_muladd, A)(A, B, C, S, ABM, ABCM) =20 +static void parts64_canonicalize(FloatParts64 *p, float_status *status, + const FloatFmt *fmt); +static void parts128_canonicalize(FloatParts128 *p, float_status *status, + const FloatFmt *fmt); + +#define parts_canonicalize(A, S, F) \ + PARTS_GENERIC_64_128(canonicalize, A)(A, S, F) + /* * Helper functions for softfloat-parts.c.inc, per-size operations. */ @@ -759,52 +767,85 @@ static int frac128_cmp(FloatParts128 *a, FloatParts12= 8 *b) =20 #define frac_cmp(A, B) FRAC_GENERIC_64_128(cmp, A)(A, B) =20 +static void frac64_clear(FloatParts64 *a) +{ + a->frac =3D 0; +} + +static void frac128_clear(FloatParts128 *a) +{ + a->frac_hi =3D a->frac_lo =3D 0; +} + +#define frac_clear(A) FRAC_GENERIC_64_128(clear, A)(A) + +static bool frac64_eqz(FloatParts64 *a) +{ + return a->frac =3D=3D 0; +} + +static bool frac128_eqz(FloatParts128 *a) +{ + return (a->frac_hi | a->frac_lo) =3D=3D 0; +} + +#define frac_eqz(A) FRAC_GENERIC_64_128(eqz, A)(A) + +static int frac64_normalize(FloatParts64 *a) +{ + if (a->frac) { + int shift =3D clz64(a->frac); + a->frac <<=3D shift; + return shift; + } + return 64; +} + +static int frac128_normalize(FloatParts128 *a) +{ + if (a->frac_hi) { + int shl =3D clz64(a->frac_hi); + if (shl) { + int shr =3D 64 - shl; + a->frac_hi =3D (a->frac_hi << shl) | (a->frac_lo >> shr); + a->frac_lo =3D (a->frac_lo << shl); + } + return shl; + } else if (a->frac_lo) { + int shl =3D clz64(a->frac_lo); + a->frac_hi =3D (a->frac_lo << shl); + a->frac_lo =3D 0; + return shl + 64; + } + return 128; +} + +#define frac_normalize(A) FRAC_GENERIC_64_128(normalize, A)(A) + +static void frac64_shl(FloatParts64 *a, int c) +{ + a->frac <<=3D c; +} + static void frac128_shl(FloatParts128 *a, int c) { shift128Left(a->frac_hi, a->frac_lo, c, &a->frac_hi, &a->frac_lo); } =20 -#define frac_shl(A, C) frac128_shl(A, C) +#define frac_shl(A, C) FRAC_GENERIC_64_128(shl, A)(A, C) + +static void frac64_shr(FloatParts64 *a, int c) +{ + a->frac >>=3D c; +} =20 static void frac128_shr(FloatParts128 *a, int c) { shift128Right(a->frac_hi, a->frac_lo, c, &a->frac_hi, &a->frac_lo); } =20 -#define frac_shr(A, C) frac128_shr(A, C) +#define frac_shr(A, C) FRAC_GENERIC_64_128(shr, A)(A, C) =20 -/* Canonicalize EXP and FRAC, setting CLS. */ -static FloatParts64 sf_canonicalize(FloatParts64 part, const FloatFmt *par= m, - float_status *status) -{ - if (part.exp =3D=3D parm->exp_max && !parm->arm_althp) { - if (part.frac =3D=3D 0) { - part.cls =3D float_class_inf; - } else { - part.frac <<=3D parm->frac_shift; - part.cls =3D (parts_is_snan_frac(part.frac, status) - ? float_class_snan : float_class_qnan); - } - } else if (part.exp =3D=3D 0) { - if (likely(part.frac =3D=3D 0)) { - part.cls =3D float_class_zero; - } else if (status->flush_inputs_to_zero) { - float_raise(float_flag_input_denormal, status); - part.cls =3D float_class_zero; - part.frac =3D 0; - } else { - int shift =3D clz64(part.frac); - part.cls =3D float_class_normal; - part.exp =3D parm->frac_shift - parm->exp_bias - shift + 1; - part.frac <<=3D shift; - } - } else { - part.cls =3D float_class_normal; - part.exp -=3D parm->exp_bias; - part.frac =3D DECOMPOSED_IMPLICIT_BIT + (part.frac << parm->frac_s= hift); - } - return part; -} =20 /* Round and uncanonicalize a floating-point number by parts. There * are FRAC_SHIFT bits that may require rounding at the bottom of the @@ -984,7 +1025,7 @@ static void float16a_unpack_canonical(FloatParts64 *p,= float16 f, float_status *s, const FloatFmt *par= ams) { float16_unpack_raw(p, f); - *p =3D sf_canonicalize(*p, params, s); + parts_canonicalize(p, s, params); } =20 static void float16_unpack_canonical(FloatParts64 *p, float16 f, @@ -997,7 +1038,7 @@ static void bfloat16_unpack_canonical(FloatParts64 *p,= bfloat16 f, float_status *s) { bfloat16_unpack_raw(p, f); - *p =3D sf_canonicalize(*p, &bfloat16_params, s); + parts_canonicalize(p, s, &bfloat16_params); } =20 static float16 float16a_round_pack_canonical(FloatParts64 *p, @@ -1025,7 +1066,7 @@ static void float32_unpack_canonical(FloatParts64 *p,= float32 f, float_status *s) { float32_unpack_raw(p, f); - *p =3D sf_canonicalize(*p, &float32_params, s); + parts_canonicalize(p, s, &float32_params); } =20 static float32 float32_round_pack_canonical(FloatParts64 *p, @@ -1039,7 +1080,7 @@ static void float64_unpack_canonical(FloatParts64 *p,= float64 f, float_status *s) { float64_unpack_raw(p, f); - *p =3D sf_canonicalize(*p, &float64_params, s); + parts_canonicalize(p, s, &float64_params); } =20 static float64 float64_round_pack_canonical(FloatParts64 *p, diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc index a78d61ea07..25bf99bd0f 100644 --- a/fpu/softfloat-parts.c.inc +++ b/fpu/softfloat-parts.c.inc @@ -100,3 +100,36 @@ static FloatPartsN *partsN(pick_nan_muladd)(FloatParts= N *a, FloatPartsN *b, } return a; } + +/* + * Canonicalize the FloatParts structure. Determine the class, + * unbias the exponent, and normalize the fraction. + */ +static void partsN(canonicalize)(FloatPartsN *p, float_status *status, + const FloatFmt *fmt) +{ + if (unlikely(p->exp =3D=3D 0)) { + if (likely(frac_eqz(p))) { + p->cls =3D float_class_zero; + } else if (status->flush_inputs_to_zero) { + float_raise(float_flag_input_denormal, status); + p->cls =3D float_class_zero; + frac_clear(p); + } else { + int shift =3D frac_normalize(p); + p->cls =3D float_class_normal; + p->exp =3D fmt->frac_shift - fmt->exp_bias - shift + 1; + } + } else if (likely(p->exp < fmt->exp_max) || fmt->arm_althp) { + p->cls =3D float_class_normal; + p->exp -=3D fmt->exp_bias; + frac_shl(p, fmt->frac_shift); + p->frac_hi |=3D DECOMPOSED_IMPLICIT_BIT; + } else if (likely(frac_eqz(p))) { + p->cls =3D float_class_inf; + } else { + frac_shl(p, fmt->frac_shift); + p->cls =3D (parts_is_snan_frac(p->frac_hi, status) + ? float_class_snan : float_class_qnan); + } +} --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169161; cv=none; d=zohomail.com; s=zohoarc; b=OYMxbCKtiACkyGoOPy3svv2n07IuvfhFnHhZ7nRKMKJyMgOBiyqwt1+m3TlqPVW75BJYMCNNXVVZT+53AJ9dq62Bn00f5xdpWcOUpewPb2khrLX0rYuUSR1BMgPLieRBxzW2RBlG7D87t9/8MIbGNFe/g8opkYk2+yWOQ/5jnBE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169161; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=74NlCKDbpHkPFqR2JzO3Ur0kB3kiLvQefB+wXAjOI4U=; b=MVvufmlBuSHbBxqF2ZNf1dExi37Z8SBT9aowk/11krfhmiZApWhz1PKGa3OoaE09jTg4VhuhQVmdJiKi8XyySuUS1v9erSg+vKxwfksca4A1DMfIhZ9KfKlZAV0t+PYeBQwXQmXm55YPGn52C0VGHtK5OhS2LI15NXrmxkc5Vlo= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169161755145.03160539321868; Sun, 16 May 2021 05:46:01 -0700 (PDT) Received: from localhost ([::1]:54026 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liG9e-0002E5-FV for importer@patchew.org; Sun, 16 May 2021 08:45:58 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43410) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzZ-0007nX-BY for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:34 -0400 Received: from mail-qk1-x72e.google.com ([2607:f8b0:4864:20::72e]:43926) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz2-0007p9-CV for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:31 -0400 Received: by mail-qk1-x72e.google.com with SMTP id a22so3279032qkl.10 for ; Sun, 16 May 2021 05:34:59 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.58 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=74NlCKDbpHkPFqR2JzO3Ur0kB3kiLvQefB+wXAjOI4U=; b=NOYD++5YbgYiHTHNiN9OyoZzOtlc9Dat/6gA/Cu6RtYQD4qnwQEx4T9DtQeepMGeBt Yhr7SpQbdzMfTbT119zJA3T++TuJdPafa1H3azsDz6vd1wPD6plcYnVc/XwsqnqHa+UK klOIYg+TcawFXDR0rfIy+EpD61OXxY9pDu3C3kw3EUDf2HOiumXZOfLOLBp5kQpN7ad/ 5PuxqCz/T4hTnXjcbcT9dpdN9Y2g+hCBqBq2ceE7Wfs05J4Z0WS/Ag5eprdhoOdoNMNs O7GW+BYk4LXYDSL4x+82YFOyxnZDqeowBXdkDAK8JtstggoFZJyrTz8Zn0lEqkqF3P+n 4Wmw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=74NlCKDbpHkPFqR2JzO3Ur0kB3kiLvQefB+wXAjOI4U=; b=IYAO1pKK97gSKHBAue9LK4tWWGLDfgH3uKWdqWw7xDIEZA/AuLDAGv/AlfMl1eEE/h biAantURqshxiC25coHenSV80A6o6CUbmVy2C4byprkEgfuk8xKBaAl6KlNwlDKsZ2/w wXqcez8OWz6yZQCzJdN+Y7zu10+Z/jW0ot0WviXfyFBhVgHVjr8t8Apds1KG2vkfnWWx qNQNNdd1ROVpLfrYbgOFQxUOWG1AMiEMORzfSkQtYTGZxRm3y9NtYp8M4gXY8HH5KmI7 7aKA7avDXKiXz6CfksbzylJd4HX1h2rn3cJ6ZBz2GGfKxGDckaP/6ryD79N6s5Dkc+60 2TFA== X-Gm-Message-State: AOAM532fE7oO37ctpxcsIZlWOQZCjB2EoMP9VhhT6IYpI4/AuCdfZKcr c4+Fagp9TGBG/6XUxnhkFsFiyBJw80SBexuciIU= X-Google-Smtp-Source: ABdhPJyZGgCSJrGdK79g2c7By0UgBbI5utoPv1w4yB6R/BVd81xKAt5Eef9GvCUUhS1dcn1AZNCmtA== X-Received: by 2002:a37:30c:: with SMTP id 12mr52829277qkd.355.1621168499233; Sun, 16 May 2021 05:34:59 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 32/46] softfloat: Move round_canonical to softfloat-parts.c.inc Date: Sun, 16 May 2021 07:34:17 -0500 Message-Id: <20210516123431.718318-33-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::72e; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x72e.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=unavailable autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) At the same time, convert to pointers, renaming to parts$N_uncanon, and define a macro for parts_uncanon using QEMU_GENERIC. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 201 +++++++++----------------------------- fpu/softfloat-parts.c.inc | 148 ++++++++++++++++++++++++++++ 2 files changed, 193 insertions(+), 156 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 535261db44..817a91de85 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -741,6 +741,14 @@ static void parts128_canonicalize(FloatParts128 *p, fl= oat_status *status, #define parts_canonicalize(A, S, F) \ PARTS_GENERIC_64_128(canonicalize, A)(A, S, F) =20 +static void parts64_uncanon(FloatParts64 *p, float_status *status, + const FloatFmt *fmt); +static void parts128_uncanon(FloatParts128 *p, float_status *status, + const FloatFmt *fmt); + +#define parts_uncanon(A, S, F) \ + PARTS_GENERIC_64_128(uncanon, A)(A, S, F) + /* * Helper functions for softfloat-parts.c.inc, per-size operations. */ @@ -748,6 +756,31 @@ static void parts128_canonicalize(FloatParts128 *p, fl= oat_status *status, #define FRAC_GENERIC_64_128(NAME, P) \ QEMU_GENERIC(P, (FloatParts128 *, frac128_##NAME), frac64_##NAME) =20 +static bool frac64_addi(FloatParts64 *r, FloatParts64 *a, uint64_t c) +{ + return uadd64_overflow(a->frac, c, &r->frac); +} + +static bool frac128_addi(FloatParts128 *r, FloatParts128 *a, uint64_t c) +{ + c =3D uadd64_overflow(a->frac_lo, c, &r->frac_lo); + return uadd64_overflow(a->frac_hi, c, &r->frac_hi); +} + +#define frac_addi(R, A, C) FRAC_GENERIC_64_128(addi, R)(R, A, C) + +static void frac64_allones(FloatParts64 *a) +{ + a->frac =3D -1; +} + +static void frac128_allones(FloatParts128 *a) +{ + a->frac_hi =3D a->frac_lo =3D -1; +} + +#define frac_allones(A) FRAC_GENERIC_64_128(allones, A)(A) + static int frac64_cmp(FloatParts64 *a, FloatParts64 *b) { return a->frac =3D=3D b->frac ? 0 : a->frac < b->frac ? -1 : 1; @@ -846,161 +879,17 @@ static void frac128_shr(FloatParts128 *a, int c) =20 #define frac_shr(A, C) FRAC_GENERIC_64_128(shr, A)(A, C) =20 - -/* Round and uncanonicalize a floating-point number by parts. There - * are FRAC_SHIFT bits that may require rounding at the bottom of the - * fraction; these bits will be removed. The exponent will be biased - * by EXP_BIAS and must be bounded by [EXP_MAX-1, 0]. - */ - -static FloatParts64 round_canonical(FloatParts64 p, float_status *s, - const FloatFmt *parm) +static void frac64_shrjam(FloatParts64 *a, int c) { - const uint64_t frac_lsb =3D parm->frac_lsb; - const uint64_t frac_lsbm1 =3D parm->frac_lsbm1; - const uint64_t round_mask =3D parm->round_mask; - const uint64_t roundeven_mask =3D parm->roundeven_mask; - const int exp_max =3D parm->exp_max; - const int frac_shift =3D parm->frac_shift; - uint64_t frac, inc; - int exp, flags =3D 0; - bool overflow_norm; - - frac =3D p.frac; - exp =3D p.exp; - - switch (p.cls) { - case float_class_normal: - switch (s->float_rounding_mode) { - case float_round_nearest_even: - overflow_norm =3D false; - inc =3D ((frac & roundeven_mask) !=3D frac_lsbm1 ? frac_lsbm1 = : 0); - break; - case float_round_ties_away: - overflow_norm =3D false; - inc =3D frac_lsbm1; - break; - case float_round_to_zero: - overflow_norm =3D true; - inc =3D 0; - break; - case float_round_up: - inc =3D p.sign ? 0 : round_mask; - overflow_norm =3D p.sign; - break; - case float_round_down: - inc =3D p.sign ? round_mask : 0; - overflow_norm =3D !p.sign; - break; - case float_round_to_odd: - overflow_norm =3D true; - inc =3D frac & frac_lsb ? 0 : round_mask; - break; - default: - g_assert_not_reached(); - } - - exp +=3D parm->exp_bias; - if (likely(exp > 0)) { - if (frac & round_mask) { - flags |=3D float_flag_inexact; - if (uadd64_overflow(frac, inc, &frac)) { - frac =3D (frac >> 1) | DECOMPOSED_IMPLICIT_BIT; - exp++; - } - } - frac >>=3D frac_shift; - - if (parm->arm_althp) { - /* ARM Alt HP eschews Inf and NaN for a wider exponent. */ - if (unlikely(exp > exp_max)) { - /* Overflow. Return the maximum normal. */ - flags =3D float_flag_invalid; - exp =3D exp_max; - frac =3D -1; - } - } else if (unlikely(exp >=3D exp_max)) { - flags |=3D float_flag_overflow | float_flag_inexact; - if (overflow_norm) { - exp =3D exp_max - 1; - frac =3D -1; - } else { - p.cls =3D float_class_inf; - goto do_inf; - } - } - } else if (s->flush_to_zero) { - flags |=3D float_flag_output_denormal; - p.cls =3D float_class_zero; - goto do_zero; - } else { - bool is_tiny =3D s->tininess_before_rounding || (exp < 0); - - if (!is_tiny) { - uint64_t discard; - is_tiny =3D !uadd64_overflow(frac, inc, &discard); - } - - shift64RightJamming(frac, 1 - exp, &frac); - if (frac & round_mask) { - /* Need to recompute round-to-even. */ - switch (s->float_rounding_mode) { - case float_round_nearest_even: - inc =3D ((frac & roundeven_mask) !=3D frac_lsbm1 - ? frac_lsbm1 : 0); - break; - case float_round_to_odd: - inc =3D frac & frac_lsb ? 0 : round_mask; - break; - default: - break; - } - flags |=3D float_flag_inexact; - frac +=3D inc; - } - - exp =3D (frac & DECOMPOSED_IMPLICIT_BIT ? 1 : 0); - frac >>=3D frac_shift; - - if (is_tiny && (flags & float_flag_inexact)) { - flags |=3D float_flag_underflow; - } - if (exp =3D=3D 0 && frac =3D=3D 0) { - p.cls =3D float_class_zero; - } - } - break; - - case float_class_zero: - do_zero: - exp =3D 0; - frac =3D 0; - break; - - case float_class_inf: - do_inf: - assert(!parm->arm_althp); - exp =3D exp_max; - frac =3D 0; - break; - - case float_class_qnan: - case float_class_snan: - assert(!parm->arm_althp); - exp =3D exp_max; - frac >>=3D parm->frac_shift; - break; - - default: - g_assert_not_reached(); - } - - float_raise(flags, s); - p.exp =3D exp; - p.frac =3D frac; - return p; + shift64RightJamming(a->frac, c, &a->frac); } =20 +static void frac128_shrjam(FloatParts128 *a, int c) +{ + shift128RightJamming(a->frac_hi, a->frac_lo, c, &a->frac_hi, &a->frac_= lo); +} + +#define frac_shrjam(A, C) FRAC_GENERIC_64_128(shrjam, A)(A, C) =20 #define partsN(NAME) parts64_##NAME #define FloatPartsN FloatParts64 @@ -1045,7 +934,7 @@ static float16 float16a_round_pack_canonical(FloatPart= s64 *p, float_status *s, const FloatFmt *params) { - *p =3D round_canonical(*p, s, params); + parts_uncanon(p, s, params); return float16_pack_raw(p); } =20 @@ -1058,7 +947,7 @@ static float16 float16_round_pack_canonical(FloatParts= 64 *p, static bfloat16 bfloat16_round_pack_canonical(FloatParts64 *p, float_status *s) { - *p =3D round_canonical(*p, s, &bfloat16_params); + parts_uncanon(p, s, &bfloat16_params); return bfloat16_pack_raw(p); } =20 @@ -1072,7 +961,7 @@ static void float32_unpack_canonical(FloatParts64 *p, = float32 f, static float32 float32_round_pack_canonical(FloatParts64 *p, float_status *s) { - *p =3D round_canonical(*p, s, &float32_params); + parts_uncanon(p, s, &float32_params); return float32_pack_raw(p); } =20 @@ -1086,7 +975,7 @@ static void float64_unpack_canonical(FloatParts64 *p, = float64 f, static float64 float64_round_pack_canonical(FloatParts64 *p, float_status *s) { - *p =3D round_canonical(*p, s, &float64_params); + parts_uncanon(p, s, &float64_params); return float64_pack_raw(p); } =20 diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc index 25bf99bd0f..efdc724770 100644 --- a/fpu/softfloat-parts.c.inc +++ b/fpu/softfloat-parts.c.inc @@ -133,3 +133,151 @@ static void partsN(canonicalize)(FloatPartsN *p, floa= t_status *status, ? float_class_snan : float_class_qnan); } } + +/* + * Round and uncanonicalize a floating-point number by parts. There + * are FRAC_SHIFT bits that may require rounding at the bottom of the + * fraction; these bits will be removed. The exponent will be biased + * by EXP_BIAS and must be bounded by [EXP_MAX-1, 0]. + */ +static void partsN(uncanon)(FloatPartsN *p, float_status *s, + const FloatFmt *fmt) +{ + const int exp_max =3D fmt->exp_max; + const int frac_shift =3D fmt->frac_shift; + const uint64_t frac_lsb =3D fmt->frac_lsb; + const uint64_t frac_lsbm1 =3D fmt->frac_lsbm1; + const uint64_t round_mask =3D fmt->round_mask; + const uint64_t roundeven_mask =3D fmt->roundeven_mask; + uint64_t inc; + bool overflow_norm; + int exp, flags =3D 0; + + if (unlikely(p->cls !=3D float_class_normal)) { + switch (p->cls) { + case float_class_zero: + p->exp =3D 0; + frac_clear(p); + return; + case float_class_inf: + g_assert(!fmt->arm_althp); + p->exp =3D fmt->exp_max; + frac_clear(p); + return; + case float_class_qnan: + case float_class_snan: + g_assert(!fmt->arm_althp); + p->exp =3D fmt->exp_max; + frac_shr(p, fmt->frac_shift); + return; + default: + break; + } + g_assert_not_reached(); + } + + switch (s->float_rounding_mode) { + case float_round_nearest_even: + overflow_norm =3D false; + inc =3D ((p->frac_lo & roundeven_mask) !=3D frac_lsbm1 ? frac_lsbm= 1 : 0); + break; + case float_round_ties_away: + overflow_norm =3D false; + inc =3D frac_lsbm1; + break; + case float_round_to_zero: + overflow_norm =3D true; + inc =3D 0; + break; + case float_round_up: + inc =3D p->sign ? 0 : round_mask; + overflow_norm =3D p->sign; + break; + case float_round_down: + inc =3D p->sign ? round_mask : 0; + overflow_norm =3D !p->sign; + break; + case float_round_to_odd: + overflow_norm =3D true; + inc =3D p->frac_lo & frac_lsb ? 0 : round_mask; + break; + default: + g_assert_not_reached(); + } + + exp =3D p->exp + fmt->exp_bias; + if (likely(exp > 0)) { + if (p->frac_lo & round_mask) { + flags |=3D float_flag_inexact; + if (frac_addi(p, p, inc)) { + frac_shr(p, 1); + p->frac_hi |=3D DECOMPOSED_IMPLICIT_BIT; + exp++; + } + } + frac_shr(p, frac_shift); + + if (fmt->arm_althp) { + /* ARM Alt HP eschews Inf and NaN for a wider exponent. */ + if (unlikely(exp > exp_max)) { + /* Overflow. Return the maximum normal. */ + flags =3D float_flag_invalid; + exp =3D exp_max; + frac_allones(p); + } + } else if (unlikely(exp >=3D exp_max)) { + flags |=3D float_flag_overflow | float_flag_inexact; + if (overflow_norm) { + exp =3D exp_max - 1; + frac_allones(p); + } else { + p->cls =3D float_class_inf; + exp =3D exp_max; + frac_clear(p); + } + } + } else if (s->flush_to_zero) { + flags |=3D float_flag_output_denormal; + p->cls =3D float_class_zero; + exp =3D 0; + frac_clear(p); + } else { + bool is_tiny =3D s->tininess_before_rounding || exp < 0; + + if (!is_tiny) { + FloatPartsN discard; + is_tiny =3D !frac_addi(&discard, p, inc); + } + + frac_shrjam(p, 1 - exp); + + if (p->frac_lo & round_mask) { + /* Need to recompute round-to-even/round-to-odd. */ + switch (s->float_rounding_mode) { + case float_round_nearest_even: + inc =3D ((p->frac_lo & roundeven_mask) !=3D frac_lsbm1 + ? frac_lsbm1 : 0); + break; + case float_round_to_odd: + inc =3D p->frac_lo & frac_lsb ? 0 : round_mask; + break; + default: + break; + } + flags |=3D float_flag_inexact; + frac_addi(p, p, inc); + } + + exp =3D (p->frac_hi & DECOMPOSED_IMPLICIT_BIT) !=3D 0; + frac_shr(p, frac_shift); + + if (is_tiny && (flags & float_flag_inexact)) { + flags |=3D float_flag_underflow; + } + if (exp =3D=3D 0 && frac_eqz(p)) { + p->cls =3D float_class_zero; + } + } + p->exp =3D exp; + float_raise(flags, s); +} --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170408; cv=none; d=zohomail.com; s=zohoarc; b=MCYzo4hbOakS+UEwA96nEnSlekllYl7QabDXp0+c76Mc3ZzRYnnnCGl5KEDjlXrLpNMwtiP7sIUwXbMTylEgFe5xMXcxR1ccRqf6JrQ1cQbSWrhOFuBX8zqle7it1vUUAo9svjAFpG0g8DI2J9cK2h49YDWyAVrqzGcJvE5COq0= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170408; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=Rn6Xd6npDUL4Fp5tLCCf06ZR2ZSQGYg1xXv43hvT9J8=; b=UW0+ayty5jlqfE+cS9zi97MbRvb/ntcaIqOzQ5wh6tKzjZqmHtC383RrLAeNrad2qgpd81C9foNRHQmWosRkbJBTnqSEnarfbl+sV35A7TlOFJmlNzp9HbFTGwVF3pfWZoHcY6TO+PTGDTYxRshGXkMGFZgAX6EDYQALcUFQIIA= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170408193769.6031125801629; Sun, 16 May 2021 06:06:48 -0700 (PDT) Received: from localhost ([::1]:54598 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGTn-0007PN-2y for importer@patchew.org; Sun, 16 May 2021 09:06:47 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43408) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzZ-0007nU-B7 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:34 -0400 Received: from mail-qk1-x733.google.com ([2607:f8b0:4864:20::733]:39757) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz3-0007pG-Hz for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:31 -0400 Received: by mail-qk1-x733.google.com with SMTP id k127so3306410qkc.6 for ; Sun, 16 May 2021 05:35:00 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.34.59 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:34:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Rn6Xd6npDUL4Fp5tLCCf06ZR2ZSQGYg1xXv43hvT9J8=; b=Ejtve6esBMBEDKCClDbqqYHMBl9Mn9U5XHe4tKN69JfWsgUfHjmXsZWyuxcIRhtt19 YgewJgaPQTCocUDnBZt1uU+19UyaOCDdmkhtqHQmpfac4ubouEOAdF2Sh11Ybz1cDDxS +F/6LV2T3ihM6pQKmRcDXUA3XNreFboGz3qBawK/SxG393vwbmx3nJxg96FduwIt8pJ6 8t/xC/ukkjVoX4d9kAuTU132M+HzlLP8i1R6cENsbuKSJb/33bG4mYdtpJvYaWoS6hsx s+ztuJ5v4q7yBfqu5F/VSmcvairyG3AJT3py0FXPY8dO8lcxqs2mGS/FT5PXJUIwBK/0 ZCqw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Rn6Xd6npDUL4Fp5tLCCf06ZR2ZSQGYg1xXv43hvT9J8=; b=Wa9t5rnKeKP9EGFexkGPjfyr1E6AU6n3kVVrGWsMvRPu/7WUVAvLKykGFxV0Qpx0PE pnCtETOH6fAjsKB48S3HqsRZv9Zakv5vap7mkFdB+it7GiL69ijdLYvwleZLGBbdInPK eGiRRKoVUijVLtZwEyx57jJbr6dzKxh+7G1EvOJKtQAhjTu5CtXegN8v+O8Ek9tEtFSz UTPWzYhQxP5HYDc6ult3OoTAVjdznZflMzXWsLzaY7mhpSWGVTNHcygwXLgovuhoMG0x hxr1n8u8r8cpSKDoMIKABLa5NNEWMZTZuyXt1+xTwx5L/hoecRxHzbQHk72kS48vssm3 Z4Ig== X-Gm-Message-State: AOAM532ZYLqKAPr8sNXElWnLqBCJfVHIq2ZTp8qMeT8etofC5yVWilgd YV0l4wqzBZYq5FpvABjTlhhPcpcLWcS+QDGP+dA= X-Google-Smtp-Source: ABdhPJzTaqT9y3mQqL2ToGnJupY34U154XU+3LGXd1PZNGfnUuZ0WY4ydy/W6BFQNMRmyEWolVY04g== X-Received: by 2002:a37:a9d2:: with SMTP id s201mr52638694qke.417.1621168499966; Sun, 16 May 2021 05:34:59 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 33/46] softfloat: Use uadd64_carry, usub64_borrow in softfloat-macros.h Date: Sun, 16 May 2021 07:34:18 -0500 Message-Id: <20210516123431.718318-34-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::733; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x733.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Use compiler support for carry arithmetic. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- include/fpu/softfloat-macros.h | 95 +++++++++------------------------- 1 file changed, 25 insertions(+), 70 deletions(-) diff --git a/include/fpu/softfloat-macros.h b/include/fpu/softfloat-macros.h index a35ec2893a..2e3760a9c1 100644 --- a/include/fpu/softfloat-macros.h +++ b/include/fpu/softfloat-macros.h @@ -83,6 +83,7 @@ this code that are retained. #define FPU_SOFTFLOAT_MACROS_H =20 #include "fpu/softfloat-types.h" +#include "qemu/host-utils.h" =20 /*------------------------------------------------------------------------= ---- | Shifts `a' right by the number of bits given in `count'. If any nonzero @@ -403,16 +404,12 @@ static inline void | are stored at the locations pointed to by `z0Ptr' and `z1Ptr'. *-------------------------------------------------------------------------= ---*/ =20 -static inline void - add128( - uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1, uint64_t *z0Ptr, = uint64_t *z1Ptr ) +static inline void add128(uint64_t a0, uint64_t a1, uint64_t b0, uint64_t = b1, + uint64_t *z0Ptr, uint64_t *z1Ptr) { - uint64_t z1; - - z1 =3D a1 + b1; - *z1Ptr =3D z1; - *z0Ptr =3D a0 + b0 + ( z1 < a1 ); - + bool c =3D 0; + *z1Ptr =3D uadd64_carry(a1, b1, &c); + *z0Ptr =3D uadd64_carry(a0, b0, &c); } =20 /*------------------------------------------------------------------------= ---- @@ -423,34 +420,14 @@ static inline void | `z1Ptr', and `z2Ptr'. *-------------------------------------------------------------------------= ---*/ =20 -static inline void - add192( - uint64_t a0, - uint64_t a1, - uint64_t a2, - uint64_t b0, - uint64_t b1, - uint64_t b2, - uint64_t *z0Ptr, - uint64_t *z1Ptr, - uint64_t *z2Ptr - ) +static inline void add192(uint64_t a0, uint64_t a1, uint64_t a2, + uint64_t b0, uint64_t b1, uint64_t b2, + uint64_t *z0Ptr, uint64_t *z1Ptr, uint64_t *z2Pt= r) { - uint64_t z0, z1, z2; - int8_t carry0, carry1; - - z2 =3D a2 + b2; - carry1 =3D ( z2 < a2 ); - z1 =3D a1 + b1; - carry0 =3D ( z1 < a1 ); - z0 =3D a0 + b0; - z1 +=3D carry1; - z0 +=3D ( z1 < carry1 ); - z0 +=3D carry0; - *z2Ptr =3D z2; - *z1Ptr =3D z1; - *z0Ptr =3D z0; - + bool c =3D 0; + *z2Ptr =3D uadd64_carry(a2, b2, &c); + *z1Ptr =3D uadd64_carry(a1, b1, &c); + *z0Ptr =3D uadd64_carry(a0, b0, &c); } =20 /*------------------------------------------------------------------------= ---- @@ -461,14 +438,12 @@ static inline void | `z1Ptr'. *-------------------------------------------------------------------------= ---*/ =20 -static inline void - sub128( - uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1, uint64_t *z0Ptr, = uint64_t *z1Ptr ) +static inline void sub128(uint64_t a0, uint64_t a1, uint64_t b0, uint64_t = b1, + uint64_t *z0Ptr, uint64_t *z1Ptr) { - - *z1Ptr =3D a1 - b1; - *z0Ptr =3D a0 - b0 - ( a1 < b1 ); - + bool c =3D 0; + *z1Ptr =3D usub64_borrow(a1, b1, &c); + *z0Ptr =3D usub64_borrow(a0, b0, &c); } =20 /*------------------------------------------------------------------------= ---- @@ -479,34 +454,14 @@ static inline void | pointed to by `z0Ptr', `z1Ptr', and `z2Ptr'. *-------------------------------------------------------------------------= ---*/ =20 -static inline void - sub192( - uint64_t a0, - uint64_t a1, - uint64_t a2, - uint64_t b0, - uint64_t b1, - uint64_t b2, - uint64_t *z0Ptr, - uint64_t *z1Ptr, - uint64_t *z2Ptr - ) +static inline void sub192(uint64_t a0, uint64_t a1, uint64_t a2, + uint64_t b0, uint64_t b1, uint64_t b2, + uint64_t *z0Ptr, uint64_t *z1Ptr, uint64_t *z2Pt= r) { - uint64_t z0, z1, z2; - int8_t borrow0, borrow1; - - z2 =3D a2 - b2; - borrow1 =3D ( a2 < b2 ); - z1 =3D a1 - b1; - borrow0 =3D ( a1 < b1 ); - z0 =3D a0 - b0; - z0 -=3D ( z1 < borrow1 ); - z1 -=3D borrow1; - z0 -=3D borrow0; - *z2Ptr =3D z2; - *z1Ptr =3D z1; - *z0Ptr =3D z0; - + bool c =3D 0; + *z2Ptr =3D usub64_borrow(a2, b2, &c); + *z1Ptr =3D usub64_borrow(a1, b1, &c); + *z0Ptr =3D usub64_borrow(a0, b0, &c); } =20 /*------------------------------------------------------------------------= ---- --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170138; cv=none; d=zohomail.com; s=zohoarc; b=IAKxO07xs3tvHhF85TbFZU3ng/5Y4GYMNPSdAtOzxN8ya0MXUk44EuzxAZxpDF5th9eI+XDaIEn/uF6NhKn8XhsImZpX4ejYtjOR/6p1URya/f/wO9dBrt+rTvx9glcBwQxfyFARnUYjzPzpm8nyRVM6DPhBbHbMoUCCTgGUlbU= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170138; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=03NFfJfR7Va9A6BPX7jobDuhZ8M2HBF6CsoZelx5Mi8=; b=Sf1IJQGIFbE88egSgf7BA/qX5USKGjDD4YrVShhPq46h/ln/+7Xz12S/crFLRuIZaYcaEVQZrBe0Ah6XW72QiXUQRvoJkzQ5tbSUSiINneah1LB53hPb2mwf/HZNLGNA9Q7YO3dxA+4UA/mSOhbhXBWmj6TG6LHlIn8lWCO+JXw= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170138633240.49317427343044; Sun, 16 May 2021 06:02:18 -0700 (PDT) Received: from localhost ([::1]:40266 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGPR-00067g-Fr for importer@patchew.org; Sun, 16 May 2021 09:02:17 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43428) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzb-0007ob-7A for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:35 -0400 Received: from mail-qv1-xf2f.google.com ([2607:f8b0:4864:20::f2f]:46936) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz4-0007py-Au for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:33 -0400 Received: by mail-qv1-xf2f.google.com with SMTP id w9so1838168qvi.13 for ; Sun, 16 May 2021 05:35:01 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.35.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:35:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=03NFfJfR7Va9A6BPX7jobDuhZ8M2HBF6CsoZelx5Mi8=; b=DYB9qGURHaFUSEafxrK3dmIgMfwUXeMZF/XPWxuPWkealeBMSEsGcnC/7QnHvIumrS nGZwWDi+BjQm/xfjf10Idj+eZ7D0XSL2XdelfsmcqbwLjOfvsm2NOFI6SkseFeJglHf2 eGM78UjGH6LxndVCSIChGCtUqaHrEUAXqO3WopdqfKsbauk74vVHl8WwEGVCVrBGh2V5 Upu34TrFl8rdL0WQjGBK7wQTHY0efu8OP2eIvJzyMqcDdTrBd1DGBlsHkWH8NQFFw5lZ 5fbWJxMypvCXamsv62NCpKpSCXpOk/OOr8FogRq+oY6cDHFhVeSdwTdxDYa0i3fkmB4p N9/A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=03NFfJfR7Va9A6BPX7jobDuhZ8M2HBF6CsoZelx5Mi8=; b=I5toYKWC8ZwUKi2RTQ80vvWGGJXEvUS0oyBp2u2FlTu7D3h5xO7q4UGqKzaXmuwztw a6+GdAC9HzSN4xnynD8WiErXUuuls+av9ExBlp5x03NdosApi9DTqWKGcagB8+V9FakG JpC16JMNvAT78Jo6izP66Xzh0uWHDzH5IIBrlI7K3ldXj73F6UQvFuvMb0qUucrwAjl1 hbyT7Vr9PLCRCpO+p9BXdP6jQquSc3E1EyxiRwRfAK0SZ3BQBcjgBnPvJP1zhZ2KJfzu QtJdGkWk+bSNGRaeN1X7SPAUrGCOYXpAZNqd9kt6CnEZU76SVdCs0YSIvU0yUBFUx+of Dfhw== X-Gm-Message-State: AOAM531ZMvCj7epz388l6e8TKNmbq7P28Skg/jz6f0qV7r7Ai8gyyOf9 wCxs9RqXhxrsb4Gha+vLHe4JfpXjZsqNq1fLlEA= X-Google-Smtp-Source: ABdhPJytyCF7zWjEXGCv1Gsg6w0GbqwGpe5Fu/QdEEJasQA+OYG+E8ndl+rTaNysIktu9GSqDgqjUQ== X-Received: by 2002:a05:6214:d84:: with SMTP id e4mr54820942qve.48.1621168500728; Sun, 16 May 2021 05:35:00 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 34/46] softfloat: Move addsub_floats to softfloat-parts.c.inc Date: Sun, 16 May 2021 07:34:19 -0500 Message-Id: <20210516123431.718318-35-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::f2f; envelope-from=richard.henderson@linaro.org; helo=mail-qv1-xf2f.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) In preparation for implementing multiple sizes. Rename to parts_addsub, split out parts_add/sub_normal for future reuse with muladd. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 253 ++++++++++++++----------------- fpu/softfloat-parts-addsub.c.inc | 62 ++++++++ fpu/softfloat-parts.c.inc | 81 ++++++++++ 3 files changed, 255 insertions(+), 141 deletions(-) create mode 100644 fpu/softfloat-parts-addsub.c.inc diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 817a91de85..afeef00097 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -749,6 +749,26 @@ static void parts128_uncanon(FloatParts128 *p, float_s= tatus *status, #define parts_uncanon(A, S, F) \ PARTS_GENERIC_64_128(uncanon, A)(A, S, F) =20 +static void parts64_add_normal(FloatParts64 *a, FloatParts64 *b); +static void parts128_add_normal(FloatParts128 *a, FloatParts128 *b); + +#define parts_add_normal(A, B) \ + PARTS_GENERIC_64_128(add_normal, A)(A, B) + +static bool parts64_sub_normal(FloatParts64 *a, FloatParts64 *b); +static bool parts128_sub_normal(FloatParts128 *a, FloatParts128 *b); + +#define parts_sub_normal(A, B) \ + PARTS_GENERIC_64_128(sub_normal, A)(A, B) + +static FloatParts64 *parts64_addsub(FloatParts64 *a, FloatParts64 *b, + float_status *s, bool subtract); +static FloatParts128 *parts128_addsub(FloatParts128 *a, FloatParts128 *b, + float_status *s, bool subtract); + +#define parts_addsub(A, B, S, Z) \ + PARTS_GENERIC_64_128(addsub, A)(A, B, S, Z) + /* * Helper functions for softfloat-parts.c.inc, per-size operations. */ @@ -756,6 +776,21 @@ static void parts128_uncanon(FloatParts128 *p, float_s= tatus *status, #define FRAC_GENERIC_64_128(NAME, P) \ QEMU_GENERIC(P, (FloatParts128 *, frac128_##NAME), frac64_##NAME) =20 +static bool frac64_add(FloatParts64 *r, FloatParts64 *a, FloatParts64 *b) +{ + return uadd64_overflow(a->frac, b->frac, &r->frac); +} + +static bool frac128_add(FloatParts128 *r, FloatParts128 *a, FloatParts128 = *b) +{ + bool c =3D 0; + r->frac_lo =3D uadd64_carry(a->frac_lo, b->frac_lo, &c); + r->frac_hi =3D uadd64_carry(a->frac_hi, b->frac_hi, &c); + return c; +} + +#define frac_add(R, A, B) FRAC_GENERIC_64_128(add, R)(R, A, B) + static bool frac64_addi(FloatParts64 *r, FloatParts64 *a, uint64_t c) { return uadd64_overflow(a->frac, c, &r->frac); @@ -824,6 +859,20 @@ static bool frac128_eqz(FloatParts128 *a) =20 #define frac_eqz(A) FRAC_GENERIC_64_128(eqz, A)(A) =20 +static void frac64_neg(FloatParts64 *a) +{ + a->frac =3D -a->frac; +} + +static void frac128_neg(FloatParts128 *a) +{ + bool c =3D 0; + a->frac_lo =3D usub64_borrow(0, a->frac_lo, &c); + a->frac_hi =3D usub64_borrow(0, a->frac_hi, &c); +} + +#define frac_neg(A) FRAC_GENERIC_64_128(neg, A)(A) + static int frac64_normalize(FloatParts64 *a) { if (a->frac) { @@ -891,18 +940,36 @@ static void frac128_shrjam(FloatParts128 *a, int c) =20 #define frac_shrjam(A, C) FRAC_GENERIC_64_128(shrjam, A)(A, C) =20 -#define partsN(NAME) parts64_##NAME -#define FloatPartsN FloatParts64 +static bool frac64_sub(FloatParts64 *r, FloatParts64 *a, FloatParts64 *b) +{ + return usub64_overflow(a->frac, b->frac, &r->frac); +} =20 +static bool frac128_sub(FloatParts128 *r, FloatParts128 *a, FloatParts128 = *b) +{ + bool c =3D 0; + r->frac_lo =3D usub64_borrow(a->frac_lo, b->frac_lo, &c); + r->frac_hi =3D usub64_borrow(a->frac_hi, b->frac_hi, &c); + return c; +} + +#define frac_sub(R, A, B) FRAC_GENERIC_64_128(sub, R)(R, A, B) + +#define partsN(NAME) glue(glue(glue(parts,N),_),NAME) +#define FloatPartsN glue(FloatParts,N) + +#define N 64 + +#include "softfloat-parts-addsub.c.inc" #include "softfloat-parts.c.inc" =20 -#undef partsN -#undef FloatPartsN -#define partsN(NAME) parts128_##NAME -#define FloatPartsN FloatParts128 +#undef N +#define N 128 =20 +#include "softfloat-parts-addsub.c.inc" #include "softfloat-parts.c.inc" =20 +#undef N #undef partsN #undef FloatPartsN =20 @@ -980,165 +1047,73 @@ static float64 float64_round_pack_canonical(FloatPa= rts64 *p, } =20 /* - * Returns the result of adding or subtracting the values of the - * floating-point values `a' and `b'. The operation is performed - * according to the IEC/IEEE Standard for Binary Floating-Point - * Arithmetic. + * Addition and subtraction */ =20 -static FloatParts64 addsub_floats(FloatParts64 a, FloatParts64 b, bool sub= tract, - float_status *s) +static float16 QEMU_FLATTEN +float16_addsub(float16 a, float16 b, float_status *status, bool subtract) { - bool a_sign =3D a.sign; - bool b_sign =3D b.sign ^ subtract; - - if (a_sign !=3D b_sign) { - /* Subtraction */ - - if (a.cls =3D=3D float_class_normal && b.cls =3D=3D float_class_no= rmal) { - if (a.exp > b.exp || (a.exp =3D=3D b.exp && a.frac >=3D b.frac= )) { - shift64RightJamming(b.frac, a.exp - b.exp, &b.frac); - a.frac =3D a.frac - b.frac; - } else { - shift64RightJamming(a.frac, b.exp - a.exp, &a.frac); - a.frac =3D b.frac - a.frac; - a.exp =3D b.exp; - a_sign ^=3D 1; - } - - if (a.frac =3D=3D 0) { - a.cls =3D float_class_zero; - a.sign =3D s->float_rounding_mode =3D=3D float_round_down; - } else { - int shift =3D clz64(a.frac); - a.frac =3D a.frac << shift; - a.exp =3D a.exp - shift; - a.sign =3D a_sign; - } - return a; - } - if (is_nan(a.cls) || is_nan(b.cls)) { - return *parts_pick_nan(&a, &b, s); - } - if (a.cls =3D=3D float_class_inf) { - if (b.cls =3D=3D float_class_inf) { - float_raise(float_flag_invalid, s); - parts_default_nan(&a, s); - } - return a; - } - if (a.cls =3D=3D float_class_zero && b.cls =3D=3D float_class_zero= ) { - a.sign =3D s->float_rounding_mode =3D=3D float_round_down; - return a; - } - if (a.cls =3D=3D float_class_zero || b.cls =3D=3D float_class_inf)= { - b.sign =3D a_sign ^ 1; - return b; - } - if (b.cls =3D=3D float_class_zero) { - return a; - } - } else { - /* Addition */ - if (a.cls =3D=3D float_class_normal && b.cls =3D=3D float_class_no= rmal) { - if (a.exp > b.exp) { - shift64RightJamming(b.frac, a.exp - b.exp, &b.frac); - } else if (a.exp < b.exp) { - shift64RightJamming(a.frac, b.exp - a.exp, &a.frac); - a.exp =3D b.exp; - } - - if (uadd64_overflow(a.frac, b.frac, &a.frac)) { - shift64RightJamming(a.frac, 1, &a.frac); - a.frac |=3D DECOMPOSED_IMPLICIT_BIT; - a.exp +=3D 1; - } - return a; - } - if (is_nan(a.cls) || is_nan(b.cls)) { - return *parts_pick_nan(&a, &b, s); - } - if (a.cls =3D=3D float_class_inf || b.cls =3D=3D float_class_zero)= { - return a; - } - if (b.cls =3D=3D float_class_inf || a.cls =3D=3D float_class_zero)= { - b.sign =3D b_sign; - return b; - } - } - g_assert_not_reached(); -} - -/* - * Returns the result of adding or subtracting the floating-point - * values `a' and `b'. The operation is performed according to the - * IEC/IEEE Standard for Binary Floating-Point Arithmetic. - */ - -float16 QEMU_FLATTEN float16_add(float16 a, float16 b, float_status *statu= s) -{ - FloatParts64 pa, pb, pr; + FloatParts64 pa, pb, *pr; =20 float16_unpack_canonical(&pa, a, status); float16_unpack_canonical(&pb, b, status); - pr =3D addsub_floats(pa, pb, false, status); + pr =3D parts_addsub(&pa, &pb, status, subtract); =20 - return float16_round_pack_canonical(&pr, status); + return float16_round_pack_canonical(pr, status); } =20 -float16 QEMU_FLATTEN float16_sub(float16 a, float16 b, float_status *statu= s) +float16 float16_add(float16 a, float16 b, float_status *status) { - FloatParts64 pa, pb, pr; + return float16_addsub(a, b, status, false); +} =20 - float16_unpack_canonical(&pa, a, status); - float16_unpack_canonical(&pb, b, status); - pr =3D addsub_floats(pa, pb, true, status); - - return float16_round_pack_canonical(&pr, status); +float16 float16_sub(float16 a, float16 b, float_status *status) +{ + return float16_addsub(a, b, status, true); } =20 static float32 QEMU_SOFTFLOAT_ATTR -soft_f32_addsub(float32 a, float32 b, bool subtract, float_status *status) +soft_f32_addsub(float32 a, float32 b, float_status *status, bool subtract) { - FloatParts64 pa, pb, pr; + FloatParts64 pa, pb, *pr; =20 float32_unpack_canonical(&pa, a, status); float32_unpack_canonical(&pb, b, status); - pr =3D addsub_floats(pa, pb, subtract, status); + pr =3D parts_addsub(&pa, &pb, status, subtract); =20 - return float32_round_pack_canonical(&pr, status); + return float32_round_pack_canonical(pr, status); } =20 -static inline float32 soft_f32_add(float32 a, float32 b, float_status *sta= tus) +static float32 soft_f32_add(float32 a, float32 b, float_status *status) { - return soft_f32_addsub(a, b, false, status); + return soft_f32_addsub(a, b, status, false); } =20 -static inline float32 soft_f32_sub(float32 a, float32 b, float_status *sta= tus) +static float32 soft_f32_sub(float32 a, float32 b, float_status *status) { - return soft_f32_addsub(a, b, true, status); + return soft_f32_addsub(a, b, status, true); } =20 static float64 QEMU_SOFTFLOAT_ATTR -soft_f64_addsub(float64 a, float64 b, bool subtract, float_status *status) +soft_f64_addsub(float64 a, float64 b, float_status *status, bool subtract) { - FloatParts64 pa, pb, pr; + FloatParts64 pa, pb, *pr; =20 float64_unpack_canonical(&pa, a, status); float64_unpack_canonical(&pb, b, status); - pr =3D addsub_floats(pa, pb, subtract, status); + pr =3D parts_addsub(&pa, &pb, status, subtract); =20 - return float64_round_pack_canonical(&pr, status); + return float64_round_pack_canonical(pr, status); } =20 -static inline float64 soft_f64_add(float64 a, float64 b, float_status *sta= tus) +static float64 soft_f64_add(float64 a, float64 b, float_status *status) { - return soft_f64_addsub(a, b, false, status); + return soft_f64_addsub(a, b, status, false); } =20 -static inline float64 soft_f64_sub(float64 a, float64 b, float_status *sta= tus) +static float64 soft_f64_sub(float64 a, float64 b, float_status *status) { - return soft_f64_addsub(a, b, true, status); + return soft_f64_addsub(a, b, status, true); } =20 static float hard_f32_add(float a, float b) @@ -1216,30 +1191,26 @@ float64_sub(float64 a, float64 b, float_status *s) return float64_addsub(a, b, s, hard_f64_sub, soft_f64_sub); } =20 -/* - * Returns the result of adding or subtracting the bfloat16 - * values `a' and `b'. - */ -bfloat16 QEMU_FLATTEN bfloat16_add(bfloat16 a, bfloat16 b, float_status *s= tatus) +static bfloat16 QEMU_FLATTEN +bfloat16_addsub(bfloat16 a, bfloat16 b, float_status *status, bool subtrac= t) { - FloatParts64 pa, pb, pr; + FloatParts64 pa, pb, *pr; =20 bfloat16_unpack_canonical(&pa, a, status); bfloat16_unpack_canonical(&pb, b, status); - pr =3D addsub_floats(pa, pb, false, status); + pr =3D parts_addsub(&pa, &pb, status, subtract); =20 - return bfloat16_round_pack_canonical(&pr, status); + return bfloat16_round_pack_canonical(pr, status); } =20 -bfloat16 QEMU_FLATTEN bfloat16_sub(bfloat16 a, bfloat16 b, float_status *s= tatus) +bfloat16 bfloat16_add(bfloat16 a, bfloat16 b, float_status *status) { - FloatParts64 pa, pb, pr; + return bfloat16_addsub(a, b, status, false); +} =20 - bfloat16_unpack_canonical(&pa, a, status); - bfloat16_unpack_canonical(&pb, b, status); - pr =3D addsub_floats(pa, pb, true, status); - - return bfloat16_round_pack_canonical(&pr, status); +bfloat16 bfloat16_sub(bfloat16 a, bfloat16 b, float_status *status) +{ + return bfloat16_addsub(a, b, status, true); } =20 /* diff --git a/fpu/softfloat-parts-addsub.c.inc b/fpu/softfloat-parts-addsub.= c.inc new file mode 100644 index 0000000000..ae5c1017c5 --- /dev/null +++ b/fpu/softfloat-parts-addsub.c.inc @@ -0,0 +1,62 @@ +/* + * Floating point arithmetic implementation + * + * The code in this source file is derived from release 2a of the SoftFloat + * IEC/IEEE Floating-point Arithmetic Package. Those parts of the code (and + * some later contributions) are provided under that license, as detailed = below. + * It has subsequently been modified by contributors to the QEMU Project, + * so some portions are provided under: + * the SoftFloat-2a license + * the BSD license + * GPL-v2-or-later + * + * Any future contributions to this file after December 1st 2014 will be + * taken to be licensed under the Softfloat-2a license unless specifically + * indicated otherwise. + */ + +static void partsN(add_normal)(FloatPartsN *a, FloatPartsN *b) +{ + int exp_diff =3D a->exp - b->exp; + + if (exp_diff > 0) { + frac_shrjam(b, exp_diff); + } else if (exp_diff < 0) { + frac_shrjam(a, -exp_diff); + a->exp =3D b->exp; + } + + if (frac_add(a, a, b)) { + frac_shrjam(a, 1); + a->frac_hi |=3D DECOMPOSED_IMPLICIT_BIT; + a->exp +=3D 1; + } +} + +static bool partsN(sub_normal)(FloatPartsN *a, FloatPartsN *b) +{ + int exp_diff =3D a->exp - b->exp; + int shift; + + if (exp_diff > 0) { + frac_shrjam(b, exp_diff); + frac_sub(a, a, b); + } else if (exp_diff < 0) { + a->exp =3D b->exp; + a->sign ^=3D 1; + frac_shrjam(a, -exp_diff); + frac_sub(a, b, a); + } else if (frac_sub(a, a, b)) { + /* Overflow means that A was less than B. */ + frac_neg(a); + a->sign ^=3D 1; + } + + shift =3D frac_normalize(a); + if (likely(shift < N)) { + a->exp -=3D shift; + return true; + } + a->cls =3D float_class_zero; + return false; +} diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc index efdc724770..cfce9f6421 100644 --- a/fpu/softfloat-parts.c.inc +++ b/fpu/softfloat-parts.c.inc @@ -281,3 +281,84 @@ static void partsN(uncanon)(FloatPartsN *p, float_stat= us *s, p->exp =3D exp; float_raise(flags, s); } + +/* + * Returns the result of adding or subtracting the values of the + * floating-point values `a' and `b'. The operation is performed + * according to the IEC/IEEE Standard for Binary Floating-Point + * Arithmetic. + */ +static FloatPartsN *partsN(addsub)(FloatPartsN *a, FloatPartsN *b, + float_status *s, bool subtract) +{ + bool b_sign =3D b->sign ^ subtract; + int ab_mask =3D float_cmask(a->cls) | float_cmask(b->cls); + + if (a->sign !=3D b_sign) { + /* Subtraction */ + if (likely(ab_mask =3D=3D float_cmask_normal)) { + if (parts_sub_normal(a, b)) { + return a; + } + /* Subtract was exact, fall through to set sign. */ + ab_mask =3D float_cmask_zero; + } + + if (ab_mask =3D=3D float_cmask_zero) { + a->sign =3D s->float_rounding_mode =3D=3D float_round_down; + return a; + } + + if (unlikely(ab_mask & float_cmask_anynan)) { + goto p_nan; + } + + if (ab_mask & float_cmask_inf) { + if (a->cls !=3D float_class_inf) { + /* N - Inf */ + goto return_b; + } + if (b->cls !=3D float_class_inf) { + /* Inf - N */ + return a; + } + /* Inf - Inf */ + float_raise(float_flag_invalid, s); + parts_default_nan(a, s); + return a; + } + } else { + /* Addition */ + if (likely(ab_mask =3D=3D float_cmask_normal)) { + parts_add_normal(a, b); + return a; + } + + if (ab_mask =3D=3D float_cmask_zero) { + return a; + } + + if (unlikely(ab_mask & float_cmask_anynan)) { + goto p_nan; + } + + if (ab_mask & float_cmask_inf) { + a->cls =3D float_class_inf; + return a; + } + } + + if (b->cls =3D=3D float_class_zero) { + g_assert(a->cls =3D=3D float_class_normal); + return a; + } + + g_assert(a->cls =3D=3D float_class_zero); + g_assert(b->cls =3D=3D float_class_normal); + return_b: + b->sign =3D b_sign; + return b; + + p_nan: + return parts_pick_nan(a, b, s); +} --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169365; cv=none; d=zohomail.com; s=zohoarc; b=ndEi8x3ikWUgQGxulcjCaZ8QR3JIfTwlSzwbZsr2aD0wUhQjCOej11UTU5YvufaqJrED5mr+k4Bs1MnoLlb7UzdA9HfRfHy82q0Cva/mrLzj365sqG4aeakqyx4vOjPgRglBu2YkOe8c5iikZvt43GUFf8zYQkJtfOGxcNwf0cs= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169365; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=/724DOTnSsXxgPOEGihu7EL04hGHfEbGiz+wNztnOCA=; b=jDKh651Rfu3w9lN/mZJoK98LgTXXzbsqnrQ3ppwJDYq9K5xVQtcE2edovH8uR9BBOiNcjQ+K+va+rVzWI0ynpwhKW1/sRAPJb19TTGC9llt7pVC5W0lnr7w4E7UFIPYzokAQaQBu7jU/izqdL7082xNv5QZJXNqnbZn070mgcjA= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169365770895.8689457045784; Sun, 16 May 2021 05:49:25 -0700 (PDT) Received: from localhost ([::1]:34356 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGCy-0008H8-KT for importer@patchew.org; Sun, 16 May 2021 08:49:24 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43432) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzb-0007p4-AH for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:35 -0400 Received: from mail-qv1-xf2e.google.com ([2607:f8b0:4864:20::f2e]:35564) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz4-0007qG-Dg for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:35 -0400 Received: by mail-qv1-xf2e.google.com with SMTP id q6so1874550qvb.2 for ; Sun, 16 May 2021 05:35:02 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.35.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:35:01 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=/724DOTnSsXxgPOEGihu7EL04hGHfEbGiz+wNztnOCA=; b=MoQDpXRTxAHtys1sbUuGJd3HTHq0Lx0T+gY3XmMptlElHQbqE2ixz1UEd9AXnzvOr/ mYpHhzcxWUqBs/G3kQXs4YXRN4AfZfgVClIplzTanc6ZG1KZCRYM7AkEJDb9d3J0/Miy YcYWB9/m6r/yfVKK98hjWQnfsqS13NEeBu21YnXpCj/y36eD3hWhMUJo7I96/iYkjRYa 0BUkMkXrBszuLAhVybbiLnQYLN+jRzyiDczhFnOUGIvbcMcUl0YqlilRBEn+O3Sv6/dc BWRY2lw9+n7HkKC1Ydvqan1I5FlNTDNb2+0BIkPoOyC2J/vK0WcRhT0IWaWo9NeycTuO GY9A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=/724DOTnSsXxgPOEGihu7EL04hGHfEbGiz+wNztnOCA=; b=C1wAHLi7apHACvpBCM1CLRguXYVuEMbYNRnGcjDdeCM7HDVrMdLwZySA1ENYLcMm0b tT+3/fcM3AuwWpKBTEayYsX637oO07kLn1oQmMl+4X0OoWo9wjQ/KAMOhn9EDjbNppaF UsIFl8IZc0bXmIZQniEeZLkr9u21uJRNdzVhgcx3H3fy6oz7LHlYXzlslfVxM382b42W 4xiuWxVElYSrJbsnFUkiadRh4yTjkS5/LghNL9Qz6rqxitXt4c1POWgYABZfJibYu0PF CQApd950L6QKY42zoFk88V3tl+9ndCAjWylIALjve+ax5sZJMWa4SKQam0kXUdS02kOX N0sw== X-Gm-Message-State: AOAM531T3r0na5T68qPeT3KyTvlMhkROxKUZS/9IbKTuUxWLMM6y4TDM WUbiaMAtGM0q5uSl+FqW4GgajxZ4+LMcLIXSDKU= X-Google-Smtp-Source: ABdhPJyIAljm+TPPZlkouDQ2PncwWVlCc/KeH1sjppgWP6dpPz+8/Iku8I6mASTGGVfEBX0QsAXAHQ== X-Received: by 2002:a05:6214:a91:: with SMTP id ev17mr10145348qvb.9.1621168501518; Sun, 16 May 2021 05:35:01 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 35/46] softfloat: Implement float128_add/sub via parts Date: Sun, 16 May 2021 07:34:20 -0500 Message-Id: <20210516123431.718318-36-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::f2e; envelope-from=richard.henderson@linaro.org; helo=mail-qv1-xf2e.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Replace the existing Berkeley implementation with the FloatParts implementation. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 257 +++++++----------------------------------------- 1 file changed, 36 insertions(+), 221 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index afeef00097..8f734f6020 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -1046,6 +1046,20 @@ static float64 float64_round_pack_canonical(FloatPar= ts64 *p, return float64_pack_raw(p); } =20 +static void float128_unpack_canonical(FloatParts128 *p, float128 f, + float_status *s) +{ + float128_unpack_raw(p, f); + parts_canonicalize(p, s, &float128_params); +} + +static float128 float128_round_pack_canonical(FloatParts128 *p, + float_status *s) +{ + parts_uncanon(p, s, &float128_params); + return float128_pack_raw(p); +} + /* * Addition and subtraction */ @@ -1213,6 +1227,28 @@ bfloat16 bfloat16_sub(bfloat16 a, bfloat16 b, float_= status *status) return bfloat16_addsub(a, b, status, true); } =20 +static float128 QEMU_FLATTEN +float128_addsub(float128 a, float128 b, float_status *status, bool subtrac= t) +{ + FloatParts128 pa, pb, *pr; + + float128_unpack_canonical(&pa, a, status); + float128_unpack_canonical(&pb, b, status); + pr =3D parts_addsub(&pa, &pb, status, subtract); + + return float128_round_pack_canonical(pr, status); +} + +float128 float128_add(float128 a, float128 b, float_status *status) +{ + return float128_addsub(a, b, status, false); +} + +float128 float128_sub(float128 a, float128 b, float_status *status) +{ + return float128_addsub(a, b, status, true); +} + /* * Returns the result of multiplying the floating-point values `a' and * `b'. The operation is performed according to the IEC/IEEE Standard @@ -7032,227 +7068,6 @@ float128 float128_round_to_int(float128 a, float_st= atus *status) =20 } =20 -/*------------------------------------------------------------------------= ---- -| Returns the result of adding the absolute values of the quadruple-precis= ion -| floating-point values `a' and `b'. If `zSign' is 1, the sum is negated -| before being returned. `zSign' is ignored if the result is a NaN. -| The addition is performed according to the IEC/IEEE Standard for Binary -| Floating-Point Arithmetic. -*-------------------------------------------------------------------------= ---*/ - -static float128 addFloat128Sigs(float128 a, float128 b, bool zSign, - float_status *status) -{ - int32_t aExp, bExp, zExp; - uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2; - int32_t expDiff; - - aSig1 =3D extractFloat128Frac1( a ); - aSig0 =3D extractFloat128Frac0( a ); - aExp =3D extractFloat128Exp( a ); - bSig1 =3D extractFloat128Frac1( b ); - bSig0 =3D extractFloat128Frac0( b ); - bExp =3D extractFloat128Exp( b ); - expDiff =3D aExp - bExp; - if ( 0 < expDiff ) { - if ( aExp =3D=3D 0x7FFF ) { - if (aSig0 | aSig1) { - return propagateFloat128NaN(a, b, status); - } - return a; - } - if ( bExp =3D=3D 0 ) { - --expDiff; - } - else { - bSig0 |=3D UINT64_C(0x0001000000000000); - } - shift128ExtraRightJamming( - bSig0, bSig1, 0, expDiff, &bSig0, &bSig1, &zSig2 ); - zExp =3D aExp; - } - else if ( expDiff < 0 ) { - if ( bExp =3D=3D 0x7FFF ) { - if (bSig0 | bSig1) { - return propagateFloat128NaN(a, b, status); - } - return packFloat128( zSign, 0x7FFF, 0, 0 ); - } - if ( aExp =3D=3D 0 ) { - ++expDiff; - } - else { - aSig0 |=3D UINT64_C(0x0001000000000000); - } - shift128ExtraRightJamming( - aSig0, aSig1, 0, - expDiff, &aSig0, &aSig1, &zSig2 ); - zExp =3D bExp; - } - else { - if ( aExp =3D=3D 0x7FFF ) { - if ( aSig0 | aSig1 | bSig0 | bSig1 ) { - return propagateFloat128NaN(a, b, status); - } - return a; - } - add128( aSig0, aSig1, bSig0, bSig1, &zSig0, &zSig1 ); - if ( aExp =3D=3D 0 ) { - if (status->flush_to_zero) { - if (zSig0 | zSig1) { - float_raise(float_flag_output_denormal, status); - } - return packFloat128(zSign, 0, 0, 0); - } - return packFloat128( zSign, 0, zSig0, zSig1 ); - } - zSig2 =3D 0; - zSig0 |=3D UINT64_C(0x0002000000000000); - zExp =3D aExp; - goto shiftRight1; - } - aSig0 |=3D UINT64_C(0x0001000000000000); - add128( aSig0, aSig1, bSig0, bSig1, &zSig0, &zSig1 ); - --zExp; - if ( zSig0 < UINT64_C(0x0002000000000000) ) goto roundAndPack; - ++zExp; - shiftRight1: - shift128ExtraRightJamming( - zSig0, zSig1, zSig2, 1, &zSig0, &zSig1, &zSig2 ); - roundAndPack: - return roundAndPackFloat128(zSign, zExp, zSig0, zSig1, zSig2, status); - -} - -/*------------------------------------------------------------------------= ---- -| Returns the result of subtracting the absolute values of the quadruple- -| precision floating-point values `a' and `b'. If `zSign' is 1, the -| difference is negated before being returned. `zSign' is ignored if the -| result is a NaN. The subtraction is performed according to the IEC/IEEE -| Standard for Binary Floating-Point Arithmetic. -*-------------------------------------------------------------------------= ---*/ - -static float128 subFloat128Sigs(float128 a, float128 b, bool zSign, - float_status *status) -{ - int32_t aExp, bExp, zExp; - uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1; - int32_t expDiff; - - aSig1 =3D extractFloat128Frac1( a ); - aSig0 =3D extractFloat128Frac0( a ); - aExp =3D extractFloat128Exp( a ); - bSig1 =3D extractFloat128Frac1( b ); - bSig0 =3D extractFloat128Frac0( b ); - bExp =3D extractFloat128Exp( b ); - expDiff =3D aExp - bExp; - shortShift128Left( aSig0, aSig1, 14, &aSig0, &aSig1 ); - shortShift128Left( bSig0, bSig1, 14, &bSig0, &bSig1 ); - if ( 0 < expDiff ) goto aExpBigger; - if ( expDiff < 0 ) goto bExpBigger; - if ( aExp =3D=3D 0x7FFF ) { - if ( aSig0 | aSig1 | bSig0 | bSig1 ) { - return propagateFloat128NaN(a, b, status); - } - float_raise(float_flag_invalid, status); - return float128_default_nan(status); - } - if ( aExp =3D=3D 0 ) { - aExp =3D 1; - bExp =3D 1; - } - if ( bSig0 < aSig0 ) goto aBigger; - if ( aSig0 < bSig0 ) goto bBigger; - if ( bSig1 < aSig1 ) goto aBigger; - if ( aSig1 < bSig1 ) goto bBigger; - return packFloat128(status->float_rounding_mode =3D=3D float_round_dow= n, - 0, 0, 0); - bExpBigger: - if ( bExp =3D=3D 0x7FFF ) { - if (bSig0 | bSig1) { - return propagateFloat128NaN(a, b, status); - } - return packFloat128( zSign ^ 1, 0x7FFF, 0, 0 ); - } - if ( aExp =3D=3D 0 ) { - ++expDiff; - } - else { - aSig0 |=3D UINT64_C(0x4000000000000000); - } - shift128RightJamming( aSig0, aSig1, - expDiff, &aSig0, &aSig1 ); - bSig0 |=3D UINT64_C(0x4000000000000000); - bBigger: - sub128( bSig0, bSig1, aSig0, aSig1, &zSig0, &zSig1 ); - zExp =3D bExp; - zSign ^=3D 1; - goto normalizeRoundAndPack; - aExpBigger: - if ( aExp =3D=3D 0x7FFF ) { - if (aSig0 | aSig1) { - return propagateFloat128NaN(a, b, status); - } - return a; - } - if ( bExp =3D=3D 0 ) { - --expDiff; - } - else { - bSig0 |=3D UINT64_C(0x4000000000000000); - } - shift128RightJamming( bSig0, bSig1, expDiff, &bSig0, &bSig1 ); - aSig0 |=3D UINT64_C(0x4000000000000000); - aBigger: - sub128( aSig0, aSig1, bSig0, bSig1, &zSig0, &zSig1 ); - zExp =3D aExp; - normalizeRoundAndPack: - --zExp; - return normalizeRoundAndPackFloat128(zSign, zExp - 14, zSig0, zSig1, - status); - -} - -/*------------------------------------------------------------------------= ---- -| Returns the result of adding the quadruple-precision floating-point valu= es -| `a' and `b'. The operation is performed according to the IEC/IEEE Stand= ard -| for Binary Floating-Point Arithmetic. -*-------------------------------------------------------------------------= ---*/ - -float128 float128_add(float128 a, float128 b, float_status *status) -{ - bool aSign, bSign; - - aSign =3D extractFloat128Sign( a ); - bSign =3D extractFloat128Sign( b ); - if ( aSign =3D=3D bSign ) { - return addFloat128Sigs(a, b, aSign, status); - } - else { - return subFloat128Sigs(a, b, aSign, status); - } - -} - -/*------------------------------------------------------------------------= ---- -| Returns the result of subtracting the quadruple-precision floating-point -| values `a' and `b'. The operation is performed according to the IEC/IEEE -| Standard for Binary Floating-Point Arithmetic. -*-------------------------------------------------------------------------= ---*/ - -float128 float128_sub(float128 a, float128 b, float_status *status) -{ - bool aSign, bSign; - - aSign =3D extractFloat128Sign( a ); - bSign =3D extractFloat128Sign( b ); - if ( aSign =3D=3D bSign ) { - return subFloat128Sigs(a, b, aSign, status); - } - else { - return addFloat128Sigs(a, b, aSign, status); - } - -} - /*------------------------------------------------------------------------= ---- | Returns the result of multiplying the quadruple-precision floating-point | values `a' and `b'. The operation is performed according to the IEC/IEEE --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170433; cv=none; d=zohomail.com; s=zohoarc; b=Oq7HiGJP6hgY+688dBqNP/bWC6c/BKlKYx5SM1JShE9LqFish/MY8G7SrM/ykh/U8no7SCkMMQBi82pYNjvvFztdzRn8fr945ZJbQ8QDQ2A8fjNo7Fx+E0iiKOc5V08rCTS+68CeFbcaulImXwPF3C0PhRCASbNmZgFBGxnD028= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170433; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=VFY3fKXhekP71qJT+a+OBWAvDgyOl17zqQbajQIX2VE=; b=FHAGlY895iddzOleXYxT67TUKNRGLknShfGtSV2SlcqH/4t3+sEC06bpdVK5POk49NKiJaXiNZDA5Vr/TKgAWhu/8ULQMogpxGmG/ezYgKmBImVS+ymIWUYux+d7tISJ7ZCpMUjtD8kl8tCcVQC5KTnHmlKEM3WlOBlDji9HCYY= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170433716842.4204149743871; Sun, 16 May 2021 06:07:13 -0700 (PDT) Received: from localhost ([::1]:57308 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGUC-0000ll-LV for importer@patchew.org; Sun, 16 May 2021 09:07:12 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43476) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzd-0007vN-5I for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:37 -0400 Received: from mail-qk1-x72c.google.com ([2607:f8b0:4864:20::72c]:44623) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz5-0007qw-An for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:36 -0400 Received: by mail-qk1-x72c.google.com with SMTP id a2so3284900qkh.11 for ; Sun, 16 May 2021 05:35:02 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.35.01 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:35:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=VFY3fKXhekP71qJT+a+OBWAvDgyOl17zqQbajQIX2VE=; b=V0/BjNRInnqxyX4DCQvJM0RlSXEp81J13tvBs33XiQ6iBxg2bA5RbQoheiBK8wFCa1 b+wQf2+9VpUkqT7jiX1YVf9+7n+egtNUG6uUK0LpQeJGR87ZjRKF7P0nhyXv6O9mC+im AEotjpuY5vlu3ZnOc9vPQsDAMumSFZ3jiK8OodmJji9XI4JtUntROxwj7s++uhR/f7Ju tbpRRzRqnoTs188tJKzfjf0suT/NKbWb4ca0xOLN3id75AU+dHnYi8H+2ZWc6BB20R5N 6T2jS+QaKNCYBqCowubMwyuvheYS2BdJZf2f92Eq6eMoIZKjVon6zyYGlRDDycKQ8fcn XJRQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=VFY3fKXhekP71qJT+a+OBWAvDgyOl17zqQbajQIX2VE=; b=Y1aX3/YKvXVEDd0EuvVA2aASeHg+PpSfbBW32T8bBskcMGYDi0UzvITxS5omt1s16P DhoXDC/wadHUJQsrxQ2NzjY5XBYJeMq2FwT6Y6jOlOuOOouAaHXxNB9Q8rdW/sDbAcOT IJUaDvS1E+QsB+A0/6Fmjf+DNlajGJMjTLTLBBkHeTnwfcp8RkZCJCPP2gi9EDURsN55 Lf1SV12KQe/4ddbxxpCo+ToGAsdYmeTrKfTzSwUi3OMUyjfKP/82G58Yp//nfkuG+Cyx 9buXWyVReXzogDWrGd/L7oprckqiaHhz2p+Q0Xk6CGU9rNv/lm7jTTMPn9XHgDFkugig eX+w== X-Gm-Message-State: AOAM533bbkXD7m9kOANeE8uRV0l0/kF6VSTlCUYUqTFvFI87OuTNzO8S ixszkM/3lwVMRjwAtT5h0o46FMKlcSW3J//qO7c= X-Google-Smtp-Source: ABdhPJx1A/mN3PJzyQi1vF6L7oonZNzgE2x3QxlmcwGK308FrJk3wzMcEKFW5H1j9sz3hFU8gM8PhA== X-Received: by 2002:a37:5f41:: with SMTP id t62mr51744725qkb.458.1621168502265; Sun, 16 May 2021 05:35:02 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 36/46] softfloat: Move mul_floats to softfloat-parts.c.inc Date: Sun, 16 May 2021 07:34:21 -0500 Message-Id: <20210516123431.718318-37-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::72c; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x72c.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Rename to parts$N_mul. Reimplement float128_mul with FloatParts128. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 206 ++++++++++++++------------------------ fpu/softfloat-parts.c.inc | 51 ++++++++++ 2 files changed, 128 insertions(+), 129 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 8f734f6020..ac7959557c 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -533,6 +533,16 @@ typedef struct { uint64_t frac_lo; } FloatParts128; =20 +typedef struct { + FloatClass cls; + bool sign; + int32_t exp; + uint64_t frac_hi; + uint64_t frac_hm; /* high-middle */ + uint64_t frac_lm; /* low-middle */ + uint64_t frac_lo; +} FloatParts256; + /* These apply to the most significant word of each FloatPartsN. */ #define DECOMPOSED_BINARY_POINT 63 #define DECOMPOSED_IMPLICIT_BIT (1ull << DECOMPOSED_BINARY_POINT) @@ -769,6 +779,14 @@ static FloatParts128 *parts128_addsub(FloatParts128 *a= , FloatParts128 *b, #define parts_addsub(A, B, S, Z) \ PARTS_GENERIC_64_128(addsub, A)(A, B, S, Z) =20 +static FloatParts64 *parts64_mul(FloatParts64 *a, FloatParts64 *b, + float_status *s); +static FloatParts128 *parts128_mul(FloatParts128 *a, FloatParts128 *b, + float_status *s); + +#define parts_mul(A, B, S) \ + PARTS_GENERIC_64_128(mul, A)(A, B, S) + /* * Helper functions for softfloat-parts.c.inc, per-size operations. */ @@ -859,6 +877,19 @@ static bool frac128_eqz(FloatParts128 *a) =20 #define frac_eqz(A) FRAC_GENERIC_64_128(eqz, A)(A) =20 +static void frac64_mulw(FloatParts128 *r, FloatParts64 *a, FloatParts64 *b) +{ + mulu64(&r->frac_lo, &r->frac_hi, a->frac, b->frac); +} + +static void frac128_mulw(FloatParts256 *r, FloatParts128 *a, FloatParts128= *b) +{ + mul128To256(a->frac_hi, a->frac_lo, b->frac_hi, b->frac_lo, + &r->frac_hi, &r->frac_hm, &r->frac_lm, &r->frac_lo); +} + +#define frac_mulw(R, A, B) FRAC_GENERIC_64_128(mulw, A)(R, A, B) + static void frac64_neg(FloatParts64 *a) { a->frac =3D -a->frac; @@ -955,23 +986,42 @@ static bool frac128_sub(FloatParts128 *r, FloatParts1= 28 *a, FloatParts128 *b) =20 #define frac_sub(R, A, B) FRAC_GENERIC_64_128(sub, R)(R, A, B) =20 +static void frac64_truncjam(FloatParts64 *r, FloatParts128 *a) +{ + r->frac =3D a->frac_hi | (a->frac_lo !=3D 0); +} + +static void frac128_truncjam(FloatParts128 *r, FloatParts256 *a) +{ + r->frac_hi =3D a->frac_hi; + r->frac_lo =3D a->frac_hm | ((a->frac_lm | a->frac_lo) !=3D 0); +} + +#define frac_truncjam(R, A) FRAC_GENERIC_64_128(truncjam, R)(R, A) + #define partsN(NAME) glue(glue(glue(parts,N),_),NAME) #define FloatPartsN glue(FloatParts,N) +#define FloatPartsW glue(FloatParts,W) =20 #define N 64 +#define W 128 =20 #include "softfloat-parts-addsub.c.inc" #include "softfloat-parts.c.inc" =20 #undef N +#undef W #define N 128 +#define W 256 =20 #include "softfloat-parts-addsub.c.inc" #include "softfloat-parts.c.inc" =20 #undef N +#undef W #undef partsN #undef FloatPartsN +#undef FloatPartsW =20 /* * Pack/unpack routines with a specific FloatFmt. @@ -1250,89 +1300,42 @@ float128 float128_sub(float128 a, float128 b, float= _status *status) } =20 /* - * Returns the result of multiplying the floating-point values `a' and - * `b'. The operation is performed according to the IEC/IEEE Standard - * for Binary Floating-Point Arithmetic. + * Multiplication */ =20 -static FloatParts64 mul_floats(FloatParts64 a, FloatParts64 b, float_statu= s *s) -{ - bool sign =3D a.sign ^ b.sign; - - if (a.cls =3D=3D float_class_normal && b.cls =3D=3D float_class_normal= ) { - uint64_t hi, lo; - int exp =3D a.exp + b.exp; - - mul64To128(a.frac, b.frac, &hi, &lo); - if (hi & DECOMPOSED_IMPLICIT_BIT) { - exp +=3D 1; - } else { - hi <<=3D 1; - } - hi |=3D (lo !=3D 0); - - /* Re-use a */ - a.exp =3D exp; - a.sign =3D sign; - a.frac =3D hi; - return a; - } - /* handle all the NaN cases */ - if (is_nan(a.cls) || is_nan(b.cls)) { - return *parts_pick_nan(&a, &b, s); - } - /* Inf * Zero =3D=3D NaN */ - if ((a.cls =3D=3D float_class_inf && b.cls =3D=3D float_class_zero) || - (a.cls =3D=3D float_class_zero && b.cls =3D=3D float_class_inf)) { - float_raise(float_flag_invalid, s); - parts_default_nan(&a, s); - return a; - } - /* Multiply by 0 or Inf */ - if (a.cls =3D=3D float_class_inf || a.cls =3D=3D float_class_zero) { - a.sign =3D sign; - return a; - } - if (b.cls =3D=3D float_class_inf || b.cls =3D=3D float_class_zero) { - b.sign =3D sign; - return b; - } - g_assert_not_reached(); -} - float16 QEMU_FLATTEN float16_mul(float16 a, float16 b, float_status *statu= s) { - FloatParts64 pa, pb, pr; + FloatParts64 pa, pb, *pr; =20 float16_unpack_canonical(&pa, a, status); float16_unpack_canonical(&pb, b, status); - pr =3D mul_floats(pa, pb, status); + pr =3D parts_mul(&pa, &pb, status); =20 - return float16_round_pack_canonical(&pr, status); + return float16_round_pack_canonical(pr, status); } =20 static float32 QEMU_SOFTFLOAT_ATTR soft_f32_mul(float32 a, float32 b, float_status *status) { - FloatParts64 pa, pb, pr; + FloatParts64 pa, pb, *pr; =20 float32_unpack_canonical(&pa, a, status); float32_unpack_canonical(&pb, b, status); - pr =3D mul_floats(pa, pb, status); + pr =3D parts_mul(&pa, &pb, status); =20 - return float32_round_pack_canonical(&pr, status); + return float32_round_pack_canonical(pr, status); } =20 static float64 QEMU_SOFTFLOAT_ATTR soft_f64_mul(float64 a, float64 b, float_status *status) { - FloatParts64 pa, pb, pr; + FloatParts64 pa, pb, *pr; =20 float64_unpack_canonical(&pa, a, status); float64_unpack_canonical(&pb, b, status); - pr =3D mul_floats(pa, pb, status); + pr =3D parts_mul(&pa, &pb, status); =20 - return float64_round_pack_canonical(&pr, status); + return float64_round_pack_canonical(pr, status); } =20 static float hard_f32_mul(float a, float b) @@ -1359,20 +1362,28 @@ float64_mul(float64 a, float64 b, float_status *s) f64_is_zon2, f64_addsubmul_post); } =20 -/* - * Returns the result of multiplying the bfloat16 - * values `a' and `b'. - */ - -bfloat16 QEMU_FLATTEN bfloat16_mul(bfloat16 a, bfloat16 b, float_status *s= tatus) +bfloat16 QEMU_FLATTEN +bfloat16_mul(bfloat16 a, bfloat16 b, float_status *status) { - FloatParts64 pa, pb, pr; + FloatParts64 pa, pb, *pr; =20 bfloat16_unpack_canonical(&pa, a, status); bfloat16_unpack_canonical(&pb, b, status); - pr =3D mul_floats(pa, pb, status); + pr =3D parts_mul(&pa, &pb, status); =20 - return bfloat16_round_pack_canonical(&pr, status); + return bfloat16_round_pack_canonical(pr, status); +} + +float128 QEMU_FLATTEN +float128_mul(float128 a, float128 b, float_status *status) +{ + FloatParts128 pa, pb, *pr; + + float128_unpack_canonical(&pa, a, status); + float128_unpack_canonical(&pb, b, status); + pr =3D parts_mul(&pa, &pb, status); + + return float128_round_pack_canonical(pr, status); } =20 /* @@ -7068,69 +7079,6 @@ float128 float128_round_to_int(float128 a, float_sta= tus *status) =20 } =20 -/*------------------------------------------------------------------------= ---- -| Returns the result of multiplying the quadruple-precision floating-point -| values `a' and `b'. The operation is performed according to the IEC/IEEE -| Standard for Binary Floating-Point Arithmetic. -*-------------------------------------------------------------------------= ---*/ - -float128 float128_mul(float128 a, float128 b, float_status *status) -{ - bool aSign, bSign, zSign; - int32_t aExp, bExp, zExp; - uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2, zSig3; - - aSig1 =3D extractFloat128Frac1( a ); - aSig0 =3D extractFloat128Frac0( a ); - aExp =3D extractFloat128Exp( a ); - aSign =3D extractFloat128Sign( a ); - bSig1 =3D extractFloat128Frac1( b ); - bSig0 =3D extractFloat128Frac0( b ); - bExp =3D extractFloat128Exp( b ); - bSign =3D extractFloat128Sign( b ); - zSign =3D aSign ^ bSign; - if ( aExp =3D=3D 0x7FFF ) { - if ( ( aSig0 | aSig1 ) - || ( ( bExp =3D=3D 0x7FFF ) && ( bSig0 | bSig1 ) ) ) { - return propagateFloat128NaN(a, b, status); - } - if ( ( bExp | bSig0 | bSig1 ) =3D=3D 0 ) goto invalid; - return packFloat128( zSign, 0x7FFF, 0, 0 ); - } - if ( bExp =3D=3D 0x7FFF ) { - if (bSig0 | bSig1) { - return propagateFloat128NaN(a, b, status); - } - if ( ( aExp | aSig0 | aSig1 ) =3D=3D 0 ) { - invalid: - float_raise(float_flag_invalid, status); - return float128_default_nan(status); - } - return packFloat128( zSign, 0x7FFF, 0, 0 ); - } - if ( aExp =3D=3D 0 ) { - if ( ( aSig0 | aSig1 ) =3D=3D 0 ) return packFloat128( zSign, 0, 0= , 0 ); - normalizeFloat128Subnormal( aSig0, aSig1, &aExp, &aSig0, &aSig1 ); - } - if ( bExp =3D=3D 0 ) { - if ( ( bSig0 | bSig1 ) =3D=3D 0 ) return packFloat128( zSign, 0, 0= , 0 ); - normalizeFloat128Subnormal( bSig0, bSig1, &bExp, &bSig0, &bSig1 ); - } - zExp =3D aExp + bExp - 0x4000; - aSig0 |=3D UINT64_C(0x0001000000000000); - shortShift128Left( bSig0, bSig1, 16, &bSig0, &bSig1 ); - mul128To256( aSig0, aSig1, bSig0, bSig1, &zSig0, &zSig1, &zSig2, &zSig= 3 ); - add128( zSig0, zSig1, aSig0, aSig1, &zSig0, &zSig1 ); - zSig2 |=3D ( zSig3 !=3D 0 ); - if (UINT64_C( 0x0002000000000000) <=3D zSig0 ) { - shift128ExtraRightJamming( - zSig0, zSig1, zSig2, 1, &zSig0, &zSig1, &zSig2 ); - ++zExp; - } - return roundAndPackFloat128(zSign, zExp, zSig0, zSig1, zSig2, status); - -} - /*------------------------------------------------------------------------= ---- | Returns the result of dividing the quadruple-precision floating-point va= lue | `a' by the corresponding value `b'. The operation is performed accordin= g to diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc index cfce9f6421..9a67ab2bea 100644 --- a/fpu/softfloat-parts.c.inc +++ b/fpu/softfloat-parts.c.inc @@ -362,3 +362,54 @@ static FloatPartsN *partsN(addsub)(FloatPartsN *a, Flo= atPartsN *b, p_nan: return parts_pick_nan(a, b, s); } + +/* + * Returns the result of multiplying the floating-point values `a' and + * `b'. The operation is performed according to the IEC/IEEE Standard + * for Binary Floating-Point Arithmetic. + */ +static FloatPartsN *partsN(mul)(FloatPartsN *a, FloatPartsN *b, + float_status *s) +{ + int ab_mask =3D float_cmask(a->cls) | float_cmask(b->cls); + bool sign =3D a->sign ^ b->sign; + + if (likely(ab_mask =3D=3D float_cmask_normal)) { + FloatPartsW tmp; + + frac_mulw(&tmp, a, b); + frac_truncjam(a, &tmp); + + a->exp +=3D b->exp + 1; + if (!(a->frac_hi & DECOMPOSED_IMPLICIT_BIT)) { + frac_add(a, a, a); + a->exp -=3D 1; + } + + a->sign =3D sign; + return a; + } + + /* Inf * Zero =3D=3D NaN */ + if (unlikely(ab_mask =3D=3D float_cmask_infzero)) { + float_raise(float_flag_invalid, s); + parts_default_nan(a, s); + return a; + } + + if (unlikely(ab_mask & float_cmask_anynan)) { + return parts_pick_nan(a, b, s); + } + + /* Multiply by 0 or Inf */ + if (ab_mask & float_cmask_inf) { + a->cls =3D float_class_inf; + a->sign =3D sign; + return a; + } + + g_assert(ab_mask & float_cmask_zero); + a->cls =3D float_class_zero; + a->sign =3D sign; + return a; +} --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170310; cv=none; d=zohomail.com; s=zohoarc; b=m7BxnM4iInhcN+m7MN9QaZp9nIncSyEW1IapQ6YAu73h9FInmsuFdegHOooAkMhXh0zpJG2M5FCrRLlzqoWr1gv1ymshrGctVXqFRDoxtSv3fUh4On/MUeU0dvD+d00RhQjzwuZGgmMXUI1fcrCb4O3oMVpvkNiqc1PeOR7u7NM= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170310; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=h63JB+Xfo4tZfImqzyHHosgnDSTAKuqJZje3Qt5e7Rg=; b=kDUsu6Kr/fErtslj1TiDS9ElX6ep9+9U+XkxLklh4/maMmC6AQfqnoOYnYmJXrt1vaqUXTUXCYS4A+zbxg2pLhLTHtUZGxcmvhQEwZX5sR0fx3FQypDPoXn0sPGBTYZvNGPQWakyL8aytB1jbusobKmekgC/IhX5q4XcdPn3aI4= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170310746286.77775619066335; Sun, 16 May 2021 06:05:10 -0700 (PDT) Received: from localhost ([::1]:48746 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGSD-0003RL-H9 for importer@patchew.org; Sun, 16 May 2021 09:05:09 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43466) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzc-0007to-PK for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:36 -0400 Received: from mail-qk1-x736.google.com ([2607:f8b0:4864:20::736]:43934) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz7-0007r5-Cj for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:36 -0400 Received: by mail-qk1-x736.google.com with SMTP id a22so3279117qkl.10 for ; Sun, 16 May 2021 05:35:03 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.35.02 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:35:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=h63JB+Xfo4tZfImqzyHHosgnDSTAKuqJZje3Qt5e7Rg=; b=Vt1pPGIM8nIN8AwQVN2s8p1fZVOhrgjP7dRgEKDSuBacVv56L/PQp8o3/jcFR05VAd YpKx2K/oy20SfjprTPqqqVeDohqSY6iyaQHdSkq6jzZGffIVSlfEGT4jq7MKZGDF4PFZ F5nCejZKa+Cg6Q0lwf1X0igGLR+JtVkU2fcJstRgVvq/+6eLyM8GXus+x2wbbyf3WM8K PFa2ztm2zGmVOLcpQ/L3G6Vwl3ihr43jC7hnneRnYphFs2nSe0EgL8Vzs8mBi4/QlCqn O7+7EDtdkP7JRNzdgOCbKTQC7MsMXnfjJyPKyBIuY8YVvM8IEQxeSvM6gwrk8hYN5yvu DESA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=h63JB+Xfo4tZfImqzyHHosgnDSTAKuqJZje3Qt5e7Rg=; b=tkCojFnjE47+gCxak/Ivr6EtsrA35hORKoT4R1lMfLMbi09wV4x3q4sl1U/0lnd5mx D0gIFomaKPjxzPdbDKvde6jl2a9O5NpTPSSrOK5sjKntyWiHnwuxSMdpjNLhsoGHfnZH 3xBFa13jmckZ8YBF0sor5GWcFB/rSCORTmDzwpyDBRlIwM9To5NrIFooMM/ZUEXTC+8d O60VWj1dISe11OLtfo1efrF4LPQ4Zp24vjIiQmNbQ3Mov9Cv6HhsekleaSl0Syb4nuIT /q7XXvQD6yfn8qHS6JJUH47wNvunaPSiPyZ2QD9PMnOy+UJElPZmzySwp5ulrXRRgLA/ TvVg== X-Gm-Message-State: AOAM530HT448jbYXz2DL1JH+6R9T5i9cDRdalBfiL6o8QBa4xX0zJwFk xnhtmfW3mww9Aik2mxupYozsbKto9uzEHtGj9WY= X-Google-Smtp-Source: ABdhPJyaz+54RHgWlFx6djNriQNYNpnFs5d0dLzF9Gjl4RU+D/CCxfwJq8lZ7nKDOLLleh7BIlhOSQ== X-Received: by 2002:a05:620a:12b6:: with SMTP id x22mr52308670qki.97.1621168503103; Sun, 16 May 2021 05:35:03 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 37/46] softfloat: Move muladd_floats to softfloat-parts.c.inc Date: Sun, 16 May 2021 07:34:22 -0500 Message-Id: <20210516123431.718318-38-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::736; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x736.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Rename to parts$N_muladd. Implement float128_muladd with FloatParts128. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- include/fpu/softfloat.h | 2 + fpu/softfloat.c | 406 ++++++++++++++++++-------------------- tests/fp/fp-bench.c | 8 +- tests/fp/fp-test.c | 2 +- fpu/softfloat-parts.c.inc | 126 ++++++++++++ tests/fp/wrap.c.inc | 12 ++ 6 files changed, 342 insertions(+), 214 deletions(-) diff --git a/include/fpu/softfloat.h b/include/fpu/softfloat.h index 019c2ec66d..53f2c2ea3c 100644 --- a/include/fpu/softfloat.h +++ b/include/fpu/softfloat.h @@ -1197,6 +1197,8 @@ float128 float128_round_to_int(float128, float_status= *status); float128 float128_add(float128, float128, float_status *status); float128 float128_sub(float128, float128, float_status *status); float128 float128_mul(float128, float128, float_status *status); +float128 float128_muladd(float128, float128, float128, int, + float_status *status); float128 float128_div(float128, float128, float_status *status); float128 float128_rem(float128, float128, float_status *status); float128 float128_sqrt(float128, float_status *status); diff --git a/fpu/softfloat.c b/fpu/softfloat.c index ac7959557c..571309e74f 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -716,6 +716,10 @@ static float128 float128_pack_raw(const FloatParts128 = *p) #define PARTS_GENERIC_64_128(NAME, P) \ QEMU_GENERIC(P, (FloatParts128 *, parts128_##NAME), parts64_##NAME) =20 +#define PARTS_GENERIC_64_128_256(NAME, P) \ + QEMU_GENERIC(P, (FloatParts256 *, parts256_##NAME), \ + (FloatParts128 *, parts128_##NAME), parts64_##NAME) + #define parts_default_nan(P, S) PARTS_GENERIC_64_128(default_nan, P)(P,= S) #define parts_silence_nan(P, S) PARTS_GENERIC_64_128(silence_nan, P)(P,= S) =20 @@ -761,15 +765,17 @@ static void parts128_uncanon(FloatParts128 *p, float_= status *status, =20 static void parts64_add_normal(FloatParts64 *a, FloatParts64 *b); static void parts128_add_normal(FloatParts128 *a, FloatParts128 *b); +static void parts256_add_normal(FloatParts256 *a, FloatParts256 *b); =20 #define parts_add_normal(A, B) \ - PARTS_GENERIC_64_128(add_normal, A)(A, B) + PARTS_GENERIC_64_128_256(add_normal, A)(A, B) =20 static bool parts64_sub_normal(FloatParts64 *a, FloatParts64 *b); static bool parts128_sub_normal(FloatParts128 *a, FloatParts128 *b); +static bool parts256_sub_normal(FloatParts256 *a, FloatParts256 *b); =20 #define parts_sub_normal(A, B) \ - PARTS_GENERIC_64_128(sub_normal, A)(A, B) + PARTS_GENERIC_64_128_256(sub_normal, A)(A, B) =20 static FloatParts64 *parts64_addsub(FloatParts64 *a, FloatParts64 *b, float_status *s, bool subtract); @@ -787,6 +793,16 @@ static FloatParts128 *parts128_mul(FloatParts128 *a, F= loatParts128 *b, #define parts_mul(A, B, S) \ PARTS_GENERIC_64_128(mul, A)(A, B, S) =20 +static FloatParts64 *parts64_muladd(FloatParts64 *a, FloatParts64 *b, + FloatParts64 *c, int flags, + float_status *s); +static FloatParts128 *parts128_muladd(FloatParts128 *a, FloatParts128 *b, + FloatParts128 *c, int flags, + float_status *s); + +#define parts_muladd(A, B, C, Z, S) \ + PARTS_GENERIC_64_128(muladd, A)(A, B, C, Z, S) + /* * Helper functions for softfloat-parts.c.inc, per-size operations. */ @@ -794,6 +810,10 @@ static FloatParts128 *parts128_mul(FloatParts128 *a, F= loatParts128 *b, #define FRAC_GENERIC_64_128(NAME, P) \ QEMU_GENERIC(P, (FloatParts128 *, frac128_##NAME), frac64_##NAME) =20 +#define FRAC_GENERIC_64_128_256(NAME, P) \ + QEMU_GENERIC(P, (FloatParts256 *, frac256_##NAME), \ + (FloatParts128 *, frac128_##NAME), frac64_##NAME) + static bool frac64_add(FloatParts64 *r, FloatParts64 *a, FloatParts64 *b) { return uadd64_overflow(a->frac, b->frac, &r->frac); @@ -807,7 +827,17 @@ static bool frac128_add(FloatParts128 *r, FloatParts12= 8 *a, FloatParts128 *b) return c; } =20 -#define frac_add(R, A, B) FRAC_GENERIC_64_128(add, R)(R, A, B) +static bool frac256_add(FloatParts256 *r, FloatParts256 *a, FloatParts256 = *b) +{ + bool c =3D 0; + r->frac_lo =3D uadd64_carry(a->frac_lo, b->frac_lo, &c); + r->frac_lm =3D uadd64_carry(a->frac_lm, b->frac_lm, &c); + r->frac_hm =3D uadd64_carry(a->frac_hm, b->frac_hm, &c); + r->frac_hi =3D uadd64_carry(a->frac_hi, b->frac_hi, &c); + return c; +} + +#define frac_add(R, A, B) FRAC_GENERIC_64_128_256(add, R)(R, A, B) =20 static bool frac64_addi(FloatParts64 *r, FloatParts64 *a, uint64_t c) { @@ -902,7 +932,16 @@ static void frac128_neg(FloatParts128 *a) a->frac_hi =3D usub64_borrow(0, a->frac_hi, &c); } =20 -#define frac_neg(A) FRAC_GENERIC_64_128(neg, A)(A) +static void frac256_neg(FloatParts256 *a) +{ + bool c =3D 0; + a->frac_lo =3D usub64_borrow(0, a->frac_lo, &c); + a->frac_lm =3D usub64_borrow(0, a->frac_lm, &c); + a->frac_hm =3D usub64_borrow(0, a->frac_hm, &c); + a->frac_hi =3D usub64_borrow(0, a->frac_hi, &c); +} + +#define frac_neg(A) FRAC_GENERIC_64_128_256(neg, A)(A) =20 static int frac64_normalize(FloatParts64 *a) { @@ -933,7 +972,55 @@ static int frac128_normalize(FloatParts128 *a) return 128; } =20 -#define frac_normalize(A) FRAC_GENERIC_64_128(normalize, A)(A) +static int frac256_normalize(FloatParts256 *a) +{ + uint64_t a0 =3D a->frac_hi, a1 =3D a->frac_hm; + uint64_t a2 =3D a->frac_lm, a3 =3D a->frac_lo; + int ret, shl, shr; + + if (likely(a0)) { + shl =3D clz64(a0); + if (shl =3D=3D 0) { + return 0; + } + ret =3D shl; + } else { + if (a1) { + ret =3D 64; + a0 =3D a1, a1 =3D a2, a2 =3D a3, a3 =3D 0; + } else if (a2) { + ret =3D 128; + a0 =3D a2, a1 =3D a3, a2 =3D 0, a3 =3D 0; + } else if (a3) { + ret =3D 192; + a0 =3D a3, a1 =3D 0, a2 =3D 0, a3 =3D 0; + } else { + ret =3D 256; + a0 =3D 0, a1 =3D 0, a2 =3D 0, a3 =3D 0; + goto done; + } + shl =3D clz64(a0); + if (shl =3D=3D 0) { + goto done; + } + ret +=3D shl; + } + + shr =3D -shl & 63; + a0 =3D (a0 << shl) | (a1 >> shr); + a1 =3D (a1 << shl) | (a2 >> shr); + a2 =3D (a2 << shl) | (a3 >> shr); + a3 =3D (a3 << shl); + + done: + a->frac_hi =3D a0; + a->frac_hm =3D a1; + a->frac_lm =3D a2; + a->frac_lo =3D a3; + return ret; +} + +#define frac_normalize(A) FRAC_GENERIC_64_128_256(normalize, A)(A) =20 static void frac64_shl(FloatParts64 *a, int c) { @@ -969,7 +1056,51 @@ static void frac128_shrjam(FloatParts128 *a, int c) shift128RightJamming(a->frac_hi, a->frac_lo, c, &a->frac_hi, &a->frac_= lo); } =20 -#define frac_shrjam(A, C) FRAC_GENERIC_64_128(shrjam, A)(A, C) +static void frac256_shrjam(FloatParts256 *a, int c) +{ + uint64_t a0 =3D a->frac_hi, a1 =3D a->frac_hm; + uint64_t a2 =3D a->frac_lm, a3 =3D a->frac_lo; + uint64_t sticky =3D 0; + int invc; + + if (unlikely(c =3D=3D 0)) { + return; + } else if (likely(c < 64)) { + /* nothing */ + } else if (likely(c < 256)) { + if (unlikely(c & 128)) { + sticky |=3D a2 | a3; + a3 =3D a1, a2 =3D a0, a1 =3D 0, a0 =3D 0; + } + if (unlikely(c & 64)) { + sticky |=3D a3; + a3 =3D a2, a2 =3D a1, a1 =3D a0, a0 =3D 0; + } + c &=3D 63; + if (c =3D=3D 0) { + goto done; + } + } else { + sticky =3D a0 | a1 | a2 | a3; + a0 =3D a1 =3D a2 =3D a3 =3D 0; + goto done; + } + + invc =3D -c & 63; + sticky |=3D a3 << invc; + a3 =3D (a3 >> c) | (a2 << invc); + a2 =3D (a2 >> c) | (a1 << invc); + a1 =3D (a1 >> c) | (a0 << invc); + a0 =3D (a0 >> c); + + done: + a->frac_lo =3D a3 | (sticky !=3D 0); + a->frac_lm =3D a2; + a->frac_hm =3D a1; + a->frac_hi =3D a0; +} + +#define frac_shrjam(A, C) FRAC_GENERIC_64_128_256(shrjam, A)(A, C) =20 static bool frac64_sub(FloatParts64 *r, FloatParts64 *a, FloatParts64 *b) { @@ -984,7 +1115,17 @@ static bool frac128_sub(FloatParts128 *r, FloatParts1= 28 *a, FloatParts128 *b) return c; } =20 -#define frac_sub(R, A, B) FRAC_GENERIC_64_128(sub, R)(R, A, B) +static bool frac256_sub(FloatParts256 *r, FloatParts256 *a, FloatParts256 = *b) +{ + bool c =3D 0; + r->frac_lo =3D usub64_borrow(a->frac_lo, b->frac_lo, &c); + r->frac_lm =3D usub64_borrow(a->frac_lm, b->frac_lm, &c); + r->frac_hm =3D usub64_borrow(a->frac_hm, b->frac_hm, &c); + r->frac_hi =3D usub64_borrow(a->frac_hi, b->frac_hi, &c); + return c; +} + +#define frac_sub(R, A, B) FRAC_GENERIC_64_128_256(sub, R)(R, A, B) =20 static void frac64_truncjam(FloatParts64 *r, FloatParts128 *a) { @@ -999,6 +1140,22 @@ static void frac128_truncjam(FloatParts128 *r, FloatP= arts256 *a) =20 #define frac_truncjam(R, A) FRAC_GENERIC_64_128(truncjam, R)(R, A) =20 +static void frac64_widen(FloatParts128 *r, FloatParts64 *a) +{ + r->frac_hi =3D a->frac; + r->frac_lo =3D 0; +} + +static void frac128_widen(FloatParts256 *r, FloatParts128 *a) +{ + r->frac_hi =3D a->frac_hi; + r->frac_hm =3D a->frac_lo; + r->frac_lm =3D 0; + r->frac_lo =3D 0; +} + +#define frac_widen(A, B) FRAC_GENERIC_64_128(widen, B)(A, B) + #define partsN(NAME) glue(glue(glue(parts,N),_),NAME) #define FloatPartsN glue(FloatParts,N) #define FloatPartsW glue(FloatParts,W) @@ -1017,6 +1174,12 @@ static void frac128_truncjam(FloatParts128 *r, Float= Parts256 *a) #include "softfloat-parts-addsub.c.inc" #include "softfloat-parts.c.inc" =20 +#undef N +#undef W +#define N 256 + +#include "softfloat-parts-addsub.c.inc" + #undef N #undef W #undef partsN @@ -1387,230 +1550,48 @@ float128_mul(float128 a, float128 b, float_status = *status) } =20 /* - * Returns the result of multiplying the floating-point values `a' and - * `b' then adding 'c', with no intermediate rounding step after the - * multiplication. The operation is performed according to the - * IEC/IEEE Standard for Binary Floating-Point Arithmetic 754-2008. - * The flags argument allows the caller to select negation of the - * addend, the intermediate product, or the final result. (The - * difference between this and having the caller do a separate - * negation is that negating externally will flip the sign bit on - * NaNs.) + * Fused multiply-add */ =20 -static FloatParts64 muladd_floats(FloatParts64 a, FloatParts64 b, FloatPar= ts64 c, - int flags, float_status *s) -{ - bool inf_zero, p_sign; - bool sign_flip =3D flags & float_muladd_negate_result; - FloatClass p_class; - uint64_t hi, lo; - int p_exp; - int ab_mask, abc_mask; - - ab_mask =3D float_cmask(a.cls) | float_cmask(b.cls); - abc_mask =3D float_cmask(c.cls) | ab_mask; - inf_zero =3D ab_mask =3D=3D float_cmask_infzero; - - /* It is implementation-defined whether the cases of (0,inf,qnan) - * and (inf,0,qnan) raise InvalidOperation or not (and what QNaN - * they return if they do), so we have to hand this information - * off to the target-specific pick-a-NaN routine. - */ - if (unlikely(abc_mask & float_cmask_anynan)) { - return *parts_pick_nan_muladd(&a, &b, &c, s, ab_mask, abc_mask); - } - - if (inf_zero) { - float_raise(float_flag_invalid, s); - parts_default_nan(&a, s); - return a; - } - - if (flags & float_muladd_negate_c) { - c.sign ^=3D 1; - } - - p_sign =3D a.sign ^ b.sign; - - if (flags & float_muladd_negate_product) { - p_sign ^=3D 1; - } - - if (ab_mask & float_cmask_inf) { - p_class =3D float_class_inf; - } else if (ab_mask & float_cmask_zero) { - p_class =3D float_class_zero; - } else { - p_class =3D float_class_normal; - } - - if (c.cls =3D=3D float_class_inf) { - if (p_class =3D=3D float_class_inf && p_sign !=3D c.sign) { - float_raise(float_flag_invalid, s); - parts_default_nan(&c, s); - } else { - c.sign ^=3D sign_flip; - } - return c; - } - - if (p_class =3D=3D float_class_inf) { - a.cls =3D float_class_inf; - a.sign =3D p_sign ^ sign_flip; - return a; - } - - if (p_class =3D=3D float_class_zero) { - if (c.cls =3D=3D float_class_zero) { - if (p_sign !=3D c.sign) { - p_sign =3D s->float_rounding_mode =3D=3D float_round_down; - } - c.sign =3D p_sign; - } else if (flags & float_muladd_halve_result) { - c.exp -=3D 1; - } - c.sign ^=3D sign_flip; - return c; - } - - /* a & b should be normals now... */ - assert(a.cls =3D=3D float_class_normal && - b.cls =3D=3D float_class_normal); - - p_exp =3D a.exp + b.exp; - - mul64To128(a.frac, b.frac, &hi, &lo); - - /* Renormalize to the msb. */ - if (hi & DECOMPOSED_IMPLICIT_BIT) { - p_exp +=3D 1; - } else { - shortShift128Left(hi, lo, 1, &hi, &lo); - } - - /* + add/sub */ - if (c.cls !=3D float_class_zero) { - int exp_diff =3D p_exp - c.exp; - if (p_sign =3D=3D c.sign) { - /* Addition */ - if (exp_diff <=3D 0) { - shift64RightJamming(hi, -exp_diff, &hi); - p_exp =3D c.exp; - if (uadd64_overflow(hi, c.frac, &hi)) { - shift64RightJamming(hi, 1, &hi); - hi |=3D DECOMPOSED_IMPLICIT_BIT; - p_exp +=3D 1; - } - } else { - uint64_t c_hi, c_lo, over; - shift128RightJamming(c.frac, 0, exp_diff, &c_hi, &c_lo); - add192(0, hi, lo, 0, c_hi, c_lo, &over, &hi, &lo); - if (over) { - shift64RightJamming(hi, 1, &hi); - hi |=3D DECOMPOSED_IMPLICIT_BIT; - p_exp +=3D 1; - } - } - } else { - /* Subtraction */ - uint64_t c_hi =3D c.frac, c_lo =3D 0; - - if (exp_diff <=3D 0) { - shift128RightJamming(hi, lo, -exp_diff, &hi, &lo); - if (exp_diff =3D=3D 0 - && - (hi > c_hi || (hi =3D=3D c_hi && lo >=3D c_lo))) { - sub128(hi, lo, c_hi, c_lo, &hi, &lo); - } else { - sub128(c_hi, c_lo, hi, lo, &hi, &lo); - p_sign ^=3D 1; - p_exp =3D c.exp; - } - } else { - shift128RightJamming(c_hi, c_lo, - exp_diff, - &c_hi, &c_lo); - sub128(hi, lo, c_hi, c_lo, &hi, &lo); - } - - if (hi =3D=3D 0 && lo =3D=3D 0) { - a.cls =3D float_class_zero; - a.sign =3D s->float_rounding_mode =3D=3D float_round_down; - a.sign ^=3D sign_flip; - return a; - } else { - int shift; - if (hi !=3D 0) { - shift =3D clz64(hi); - } else { - shift =3D clz64(lo) + 64; - } - /* Normalizing to a binary point of 124 is the - correct adjust for the exponent. However since we're - shifting, we might as well put the binary point back - at 63 where we really want it. Therefore shift as - if we're leaving 1 bit at the top of the word, but - adjust the exponent as if we're leaving 3 bits. */ - shift128Left(hi, lo, shift, &hi, &lo); - p_exp -=3D shift; - } - } - } - hi |=3D (lo !=3D 0); - - if (flags & float_muladd_halve_result) { - p_exp -=3D 1; - } - - /* finally prepare our result */ - a.cls =3D float_class_normal; - a.sign =3D p_sign ^ sign_flip; - a.exp =3D p_exp; - a.frac =3D hi; - - return a; -} - float16 QEMU_FLATTEN float16_muladd(float16 a, float16 b, float16 c, - int flags, float_status *s= tatus) + int flags, float_status *status) { - FloatParts64 pa, pb, pc, pr; + FloatParts64 pa, pb, pc, *pr; =20 float16_unpack_canonical(&pa, a, status); float16_unpack_canonical(&pb, b, status); float16_unpack_canonical(&pc, c, status); - pr =3D muladd_floats(pa, pb, pc, flags, status); + pr =3D parts_muladd(&pa, &pb, &pc, flags, status); =20 - return float16_round_pack_canonical(&pr, status); + return float16_round_pack_canonical(pr, status); } =20 static float32 QEMU_SOFTFLOAT_ATTR soft_f32_muladd(float32 a, float32 b, float32 c, int flags, float_status *status) { - FloatParts64 pa, pb, pc, pr; + FloatParts64 pa, pb, pc, *pr; =20 float32_unpack_canonical(&pa, a, status); float32_unpack_canonical(&pb, b, status); float32_unpack_canonical(&pc, c, status); - pr =3D muladd_floats(pa, pb, pc, flags, status); + pr =3D parts_muladd(&pa, &pb, &pc, flags, status); =20 - return float32_round_pack_canonical(&pr, status); + return float32_round_pack_canonical(pr, status); } =20 static float64 QEMU_SOFTFLOAT_ATTR soft_f64_muladd(float64 a, float64 b, float64 c, int flags, float_status *status) { - FloatParts64 pa, pb, pc, pr; + FloatParts64 pa, pb, pc, *pr; =20 float64_unpack_canonical(&pa, a, status); float64_unpack_canonical(&pb, b, status); float64_unpack_canonical(&pc, c, status); - pr =3D muladd_floats(pa, pb, pc, flags, status); + pr =3D parts_muladd(&pa, &pb, &pc, flags, status); =20 - return float64_round_pack_canonical(&pr, status); + return float64_round_pack_canonical(pr, status); } =20 static bool force_soft_fma; @@ -1757,23 +1738,30 @@ float64_muladd(float64 xa, float64 xb, float64 xc, = int flags, float_status *s) return soft_f64_muladd(ua.s, ub.s, uc.s, flags, s); } =20 -/* - * Returns the result of multiplying the bfloat16 values `a' - * and `b' then adding 'c', with no intermediate rounding step after the - * multiplication. - */ - bfloat16 QEMU_FLATTEN bfloat16_muladd(bfloat16 a, bfloat16 b, bfloat16 c, int flags, float_status *status) { - FloatParts64 pa, pb, pc, pr; + FloatParts64 pa, pb, pc, *pr; =20 bfloat16_unpack_canonical(&pa, a, status); bfloat16_unpack_canonical(&pb, b, status); bfloat16_unpack_canonical(&pc, c, status); - pr =3D muladd_floats(pa, pb, pc, flags, status); + pr =3D parts_muladd(&pa, &pb, &pc, flags, status); =20 - return bfloat16_round_pack_canonical(&pr, status); + return bfloat16_round_pack_canonical(pr, status); +} + +float128 QEMU_FLATTEN float128_muladd(float128 a, float128 b, float128 c, + int flags, float_status *status) +{ + FloatParts128 pa, pb, pc, *pr; + + float128_unpack_canonical(&pa, a, status); + float128_unpack_canonical(&pb, b, status); + float128_unpack_canonical(&pc, c, status); + pr =3D parts_muladd(&pa, &pb, &pc, flags, status); + + return float128_round_pack_canonical(pr, status); } =20 /* diff --git a/tests/fp/fp-bench.c b/tests/fp/fp-bench.c index d319993280..c24baf8535 100644 --- a/tests/fp/fp-bench.c +++ b/tests/fp/fp-bench.c @@ -386,7 +386,7 @@ static void bench(enum precision prec, enum op op, int = n_ops, bool no_neg) for (i =3D 0; i < OPS_PER_ITER; i++) { float128 a =3D ops[0].f128; float128 b =3D ops[1].f128; - /* float128 c =3D ops[2].f128; */ + float128 c =3D ops[2].f128; =20 switch (op) { case OP_ADD: @@ -401,9 +401,9 @@ static void bench(enum precision prec, enum op op, int = n_ops, bool no_neg) case OP_DIV: res.f128 =3D float128_div(a, b, &soft_status); break; - /* case OP_FMA: */ - /* res.f128 =3D float128_muladd(a, b, c, 0, &soft_stat= us); */ - /* break; */ + case OP_FMA: + res.f128 =3D float128_muladd(a, b, c, 0, &soft_status); + break; case OP_SQRT: res.f128 =3D float128_sqrt(a, &soft_status); break; diff --git a/tests/fp/fp-test.c b/tests/fp/fp-test.c index 5a4cad8c8b..ff131afbde 100644 --- a/tests/fp/fp-test.c +++ b/tests/fp/fp-test.c @@ -717,7 +717,7 @@ static void do_testfloat(int op, int rmode, bool exact) test_abz_f128(true_abz_f128M, subj_abz_f128M); break; case F128_MULADD: - not_implemented(); + test_abcz_f128(slow_f128M_mulAdd, qemu_f128M_mulAdd); break; case F128_SQRT: test_az_f128(slow_f128M_sqrt, qemu_f128M_sqrt); diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc index 9a67ab2bea..a203811299 100644 --- a/fpu/softfloat-parts.c.inc +++ b/fpu/softfloat-parts.c.inc @@ -413,3 +413,129 @@ static FloatPartsN *partsN(mul)(FloatPartsN *a, Float= PartsN *b, a->sign =3D sign; return a; } + +/* + * Returns the result of multiplying the floating-point values `a' and + * `b' then adding 'c', with no intermediate rounding step after the + * multiplication. The operation is performed according to the + * IEC/IEEE Standard for Binary Floating-Point Arithmetic 754-2008. + * The flags argument allows the caller to select negation of the + * addend, the intermediate product, or the final result. (The + * difference between this and having the caller do a separate + * negation is that negating externally will flip the sign bit on NaNs.) + * + * Requires A and C extracted into a double-sized structure to provide the + * extra space for the widening multiply. + */ +static FloatPartsN *partsN(muladd)(FloatPartsN *a, FloatPartsN *b, + FloatPartsN *c, int flags, float_status= *s) +{ + int ab_mask, abc_mask; + FloatPartsW p_widen, c_widen; + + ab_mask =3D float_cmask(a->cls) | float_cmask(b->cls); + abc_mask =3D float_cmask(c->cls) | ab_mask; + + /* + * It is implementation-defined whether the cases of (0,inf,qnan) + * and (inf,0,qnan) raise InvalidOperation or not (and what QNaN + * they return if they do), so we have to hand this information + * off to the target-specific pick-a-NaN routine. + */ + if (unlikely(abc_mask & float_cmask_anynan)) { + return parts_pick_nan_muladd(a, b, c, s, ab_mask, abc_mask); + } + + if (flags & float_muladd_negate_c) { + c->sign ^=3D 1; + } + + /* Compute the sign of the product into A. */ + a->sign ^=3D b->sign; + if (flags & float_muladd_negate_product) { + a->sign ^=3D 1; + } + + if (unlikely(ab_mask !=3D float_cmask_normal)) { + if (unlikely(ab_mask =3D=3D float_cmask_infzero)) { + goto d_nan; + } + + if (ab_mask & float_cmask_inf) { + if (c->cls =3D=3D float_class_inf && a->sign !=3D c->sign) { + goto d_nan; + } + goto return_inf; + } + + g_assert(ab_mask & float_cmask_zero); + if (c->cls =3D=3D float_class_normal) { + *a =3D *c; + goto return_normal; + } + if (c->cls =3D=3D float_class_zero) { + if (a->sign !=3D c->sign) { + goto return_sub_zero; + } + goto return_zero; + } + g_assert(c->cls =3D=3D float_class_inf); + } + + if (unlikely(c->cls =3D=3D float_class_inf)) { + a->sign =3D c->sign; + goto return_inf; + } + + /* Perform the multiplication step. */ + p_widen.sign =3D a->sign; + p_widen.exp =3D a->exp + b->exp + 1; + frac_mulw(&p_widen, a, b); + if (!(p_widen.frac_hi & DECOMPOSED_IMPLICIT_BIT)) { + frac_add(&p_widen, &p_widen, &p_widen); + p_widen.exp -=3D 1; + } + + /* Perform the addition step. */ + if (c->cls !=3D float_class_zero) { + /* Zero-extend C to less significant bits. */ + frac_widen(&c_widen, c); + c_widen.exp =3D c->exp; + + if (a->sign =3D=3D c->sign) { + parts_add_normal(&p_widen, &c_widen); + } else if (!parts_sub_normal(&p_widen, &c_widen)) { + goto return_sub_zero; + } + } + + /* Narrow with sticky bit, for proper rounding later. */ + frac_truncjam(a, &p_widen); + a->sign =3D p_widen.sign; + a->exp =3D p_widen.exp; + + return_normal: + if (flags & float_muladd_halve_result) { + a->exp -=3D 1; + } + finish_sign: + if (flags & float_muladd_negate_result) { + a->sign ^=3D 1; + } + return a; + + return_sub_zero: + a->sign =3D s->float_rounding_mode =3D=3D float_round_down; + return_zero: + a->cls =3D float_class_zero; + goto finish_sign; + + return_inf: + a->cls =3D float_class_inf; + goto finish_sign; + + d_nan: + float_raise(float_flag_invalid, s); + parts_default_nan(a, s); + return a; +} diff --git a/tests/fp/wrap.c.inc b/tests/fp/wrap.c.inc index 0cbd20013e..cb1bb77e4c 100644 --- a/tests/fp/wrap.c.inc +++ b/tests/fp/wrap.c.inc @@ -574,6 +574,18 @@ WRAP_MULADD(qemu_f32_mulAdd, float32_muladd, float32) WRAP_MULADD(qemu_f64_mulAdd, float64_muladd, float64) #undef WRAP_MULADD =20 +static void qemu_f128M_mulAdd(const float128_t *ap, const float128_t *bp, + const float128_t *cp, float128_t *res) +{ + float128 a, b, c, ret; + + a =3D soft_to_qemu128(*ap); + b =3D soft_to_qemu128(*bp); + c =3D soft_to_qemu128(*cp); + ret =3D float128_muladd(a, b, c, 0, &qsf); + *res =3D qemu_to_soft128(ret); +} + #define WRAP_CMP16(name, func, retcond) \ static bool name(float16_t a, float16_t b) \ { \ --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170509; cv=none; d=zohomail.com; s=zohoarc; b=c+uWokT5ylJs2MeZPfXcyFiu2x1v1GeRH2JNqdqWTA1tvM0O2Hbd1trLl0tQn4hBaqgt+WayuhJHCYrh4VUA8wbBYy1psgjDwwW3DZZM5nGkTwm/TmZGIPistz36MMmBOsBeJibdq2Pk+D3GsFYRXJ0Bfcw+41T0ZsK76hTOZfY= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170509; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=RndXytbTpyoZf87SoTBz0zxUXITxwgpEDPn6NB45UNI=; b=mqSyK2O+jSMjQ/4nfyJERxvnOODfxwKYobDJ5CsH+SFPw9PsZYOy5cUoHNthyBot/Nc30MEPf75NMzpnJdqo6p3xCsOmOekGGvFJ+YKcVg+X2OidyPFeTZ0Ztvf3mFfIUYmNAJ8/kLxC7hbQFD9QbJP2DO3o8L9Hprd74xbcnpI= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170509752616.1434837625638; Sun, 16 May 2021 06:08:29 -0700 (PDT) Received: from localhost ([::1]:33438 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGVQ-0003eI-Of for importer@patchew.org; Sun, 16 May 2021 09:08:28 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43444) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzb-0007qQ-KP for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:35 -0400 Received: from mail-qk1-x729.google.com ([2607:f8b0:4864:20::729]:36452) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz7-0007rj-Bc for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:35 -0400 Received: by mail-qk1-x729.google.com with SMTP id c20so3322063qkm.3 for ; Sun, 16 May 2021 05:35:04 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.35.03 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:35:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=RndXytbTpyoZf87SoTBz0zxUXITxwgpEDPn6NB45UNI=; b=Iyvgq1tZ+Wc/X3y9EH47MrrlnfZrHPU64rQ7pY94+3Nc0wQo2ccTHg6hSLcLSs3/zL 4Z7fIhuZwZN5oa/PB0ttML1tVdBF125qddRGssIEXS4IIJAguAQyvbl4cPRopt5ZWuQQ ucQAvz5a9tYRdYK8x36Xq+aV993J/ZAgpaBqTHtL3mPSKHdwHacTRUXdlPiDsm9PSHvE Evw45OlpJWPPgG6Fv8KZt2CIwCKwKjDGQXwORWNan7juohfmR280uImstyDjdoBl8rY0 Jb9iA7ZPmvhl5uGKAToKVLi/jQIxKmiIpvTO1dLPZG90DALoyLIYqRmypSBFDC0YpQEb jODQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=RndXytbTpyoZf87SoTBz0zxUXITxwgpEDPn6NB45UNI=; b=sgcBEC8lpy47CHSL6k4YjFq7+lpni6/g5QBO3w5lC6rZyQciMa/O1HpNMTTewjewkT WnNAfQ6kZVtwEzc3XYB35Oj9fCbkXplZ/LvYvjaBIOPDsl5wSyNBam85BWIsonGPwtvT F0RtTNWYwmNYuIqKTcfGrgSO72htytvMkB3Gr43LlOx3hzNL22QuX1QOv2wxtRiS1lio L+ieUz1uviYs9fmxdPwaPc36wXq0YVQc8BsMGW8eGYHy1Dakn6njGE0JeOR0PgYwiRKM DdMn/hiq2n7CECInVjoZ8MFsBmnJYqTFU6cRmFx7MW3Ecj1F6DDK6Q4xmakPy0zL99QX x9TA== X-Gm-Message-State: AOAM530a4ybcaXbmDcNyU1uDwU1/hxUKkuMg9DqVRJ0M7R8Nxxg17u9z Q/8431mNDK4KXU+UTgc0I9DH2dUzak3uNZuQvkQ= X-Google-Smtp-Source: ABdhPJwEUjEr1XBxA3GZoz7BvcbcP+aDRF2Ohj8eR8BqPJKnmErvKrZqBokuOJyEl27X+9pLfL9LTA== X-Received: by 2002:a37:a3d7:: with SMTP id m206mr51287967qke.343.1621168504040; Sun, 16 May 2021 05:35:04 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 38/46] softfloat: Use mulu64 for mul64To128 Date: Sun, 16 May 2021 07:34:23 -0500 Message-Id: <20210516123431.718318-39-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::729; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x729.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Via host-utils.h, we use a host widening multiply for 64-bit hosts, and a common subroutine for 32-bit hosts. Reviewed-by: Alex Benn=C3=A9e Reviewed-by: David Hildenbrand Signed-off-by: Richard Henderson --- include/fpu/softfloat-macros.h | 23 +++-------------------- 1 file changed, 3 insertions(+), 20 deletions(-) diff --git a/include/fpu/softfloat-macros.h b/include/fpu/softfloat-macros.h index 2e3760a9c1..f6dfbe108d 100644 --- a/include/fpu/softfloat-macros.h +++ b/include/fpu/softfloat-macros.h @@ -470,27 +470,10 @@ static inline void sub192(uint64_t a0, uint64_t a1, u= int64_t a2, | `z0Ptr' and `z1Ptr'. *-------------------------------------------------------------------------= ---*/ =20 -static inline void mul64To128( uint64_t a, uint64_t b, uint64_t *z0Ptr, ui= nt64_t *z1Ptr ) +static inline void +mul64To128(uint64_t a, uint64_t b, uint64_t *z0Ptr, uint64_t *z1Ptr) { - uint32_t aHigh, aLow, bHigh, bLow; - uint64_t z0, zMiddleA, zMiddleB, z1; - - aLow =3D a; - aHigh =3D a>>32; - bLow =3D b; - bHigh =3D b>>32; - z1 =3D ( (uint64_t) aLow ) * bLow; - zMiddleA =3D ( (uint64_t) aLow ) * bHigh; - zMiddleB =3D ( (uint64_t) aHigh ) * bLow; - z0 =3D ( (uint64_t) aHigh ) * bHigh; - zMiddleA +=3D zMiddleB; - z0 +=3D ( ( (uint64_t) ( zMiddleA < zMiddleB ) )<<32 ) + ( zMiddleA>>3= 2 ); - zMiddleA <<=3D 32; - z1 +=3D zMiddleA; - z0 +=3D ( z1 < zMiddleA ); - *z1Ptr =3D z1; - *z0Ptr =3D z0; - + mulu64(z1Ptr, z0Ptr, a, b); } =20 /*------------------------------------------------------------------------= ---- --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170612; cv=none; d=zohomail.com; s=zohoarc; b=IkM9BSJn1IQ6oLGEMyzTtkyjt0o574Wg3KmyDkWzSWjUgI/F9OHNcojwfY2EJoIW8qA3cGsOKMAVabwwGq3jIoQ4ZW/2Ewn+5nmrQrWAKwCrmGGHlV7rQSXR7z5mZJ+12Ec5c+M19TnhlwbWLJvhmyudAnyYJdvAD7KNn8XKKV4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170612; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=g5JrLWpPIY2+zmkGea0CLj546B5kax6Igz9HQumup6Y=; b=MfppA+QKnUkCbIMfIgdnw2AhEwB3kDjh7grdcPYlxHwee8Qwmhg7T6qv4gk5dTYwzZ3faB0d/ZgXAKuOAAwyvaN2SxU1cULLHuttLio/YfD+qH4kx9gBXFnVDWL93Pmfno+5QfQb0GDiws4Eq453Nl9D4DWtuWSPQlqhqJJCoWA= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170612342435.0304449974283; Sun, 16 May 2021 06:10:12 -0700 (PDT) Received: from localhost ([::1]:39774 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGX5-0007pW-5E for importer@patchew.org; Sun, 16 May 2021 09:10:11 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43458) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liFzc-0007sJ-Bp for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:36 -0400 Received: from mail-qk1-x72f.google.com ([2607:f8b0:4864:20::72f]:42745) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liFz7-0007rr-QB for qemu-devel@nongnu.org; Sun, 16 May 2021 08:35:36 -0400 Received: by mail-qk1-x72f.google.com with SMTP id o27so3288084qkj.9 for ; Sun, 16 May 2021 05:35:05 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id s5sm8500553qkg.88.2021.05.16.05.35.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:35:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=g5JrLWpPIY2+zmkGea0CLj546B5kax6Igz9HQumup6Y=; b=wBjeJnjq56qyDsvLr6dujVjn5vRr6AVblwxMcjjZKjdeU9FwYv4QubAp1p4aYt8CQR 0KS7XTwX+n0bpv/u1NMoDm1bDeW9ZXt32I0C7IpjYkhcLxNVplXVXaocxNy5RSRXiag2 zMFZ8D9NVZky+WaewFlk8uInJmZOc5FgcifeGDjJrBMKSB0zyhNMLRcrwQo2VhjrfgFz 3sUI3aitw8a1rlLwPtZiGyvZD6vrC/dYv5tDquyWjD8eav3PITNzVIPxrkB2Mo3UmWLN DCwh9/ti9vCcUaPi38nooxs/yLdD2LYK6UbS5qj2RsXXygzy3IggLJmismdxXhj8OI9B DXRQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=g5JrLWpPIY2+zmkGea0CLj546B5kax6Igz9HQumup6Y=; b=d8ba9G3joedWr6cf4B3DGYi5NKiBm2R70hcCYxp+dM02MMlcR3LFx5x/FiAGIrKOyF bWUMoKHrfXwuLJ0CoBvxXRPLXIHOJf8ZGa4sst6xSQsRB04ghKodNVEb5ItS3jk9Drg6 JBp96f1xL3pJoNwvrpDu2zBh9BcJkS1PnttnN7uLd3F8f5f0IIuUAlGzzp8XsR7GPwTv ENCPnfjXuTHuqxbHkmFCtmUF8gDx3Sp5sTHYqxuNc0qIugXr1SwtDEL6TJfHJe1QU1BI RQ/JVXG1gCa8qp3pTtWKMZwwSPMpq/ZPPsX5IoF5KDi8fEEBvdVu4qVCMJLkRpTsGtVW GrJQ== X-Gm-Message-State: AOAM5331XVUwFZU8CvwiHbd2U97nYje+liwNZ/l7/8z89Br8YXAa6QiH O2MdnYohSPVO5a2mAnddSVGqJcanD1OxGuJO0VE= X-Google-Smtp-Source: ABdhPJwck5D1QNznmMtx71FQMv2T2jKIMIYS1M0Esl94jf0goWXR0f9WtPsNIGHEkmHaQJFDcbNtNg== X-Received: by 2002:a05:620a:1585:: with SMTP id d5mr20319823qkk.29.1621168504786; Sun, 16 May 2021 05:35:04 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 39/46] softfloat: Use add192 in mul128To256 Date: Sun, 16 May 2021 07:34:24 -0500 Message-Id: <20210516123431.718318-40-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::72f; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x72f.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) We can perform the operation in 6 total adds instead of 8. Reviewed-by: Alex Benn=C3=A9e Tested-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- include/fpu/softfloat-macros.h | 37 +++++++++++----------------------- 1 file changed, 12 insertions(+), 25 deletions(-) diff --git a/include/fpu/softfloat-macros.h b/include/fpu/softfloat-macros.h index f6dfbe108d..76327d844d 100644 --- a/include/fpu/softfloat-macros.h +++ b/include/fpu/softfloat-macros.h @@ -511,34 +511,21 @@ static inline void | the locations pointed to by `z0Ptr', `z1Ptr', `z2Ptr', and `z3Ptr'. *-------------------------------------------------------------------------= ---*/ =20 -static inline void - mul128To256( - uint64_t a0, - uint64_t a1, - uint64_t b0, - uint64_t b1, - uint64_t *z0Ptr, - uint64_t *z1Ptr, - uint64_t *z2Ptr, - uint64_t *z3Ptr - ) +static inline void mul128To256(uint64_t a0, uint64_t a1, + uint64_t b0, uint64_t b1, + uint64_t *z0Ptr, uint64_t *z1Ptr, + uint64_t *z2Ptr, uint64_t *z3Ptr) { - uint64_t z0, z1, z2, z3; - uint64_t more1, more2; + uint64_t z0, z1, z2; + uint64_t m0, m1, m2, n1, n2; =20 - mul64To128( a1, b1, &z2, &z3 ); - mul64To128( a1, b0, &z1, &more2 ); - add128( z1, more2, 0, z2, &z1, &z2 ); - mul64To128( a0, b0, &z0, &more1 ); - add128( z0, more1, 0, z1, &z0, &z1 ); - mul64To128( a0, b1, &more1, &more2 ); - add128( more1, more2, 0, z2, &more1, &z2 ); - add128( z0, z1, 0, more1, &z0, &z1 ); - *z3Ptr =3D z3; - *z2Ptr =3D z2; - *z1Ptr =3D z1; - *z0Ptr =3D z0; + mul64To128(a1, b0, &m1, &m2); + mul64To128(a0, b1, &n1, &n2); + mul64To128(a1, b1, &z2, z3Ptr); + mul64To128(a0, b0, &z0, &z1); =20 + add192( 0, m1, m2, 0, n1, n2, &m0, &m1, &m2); + add192(m0, m1, m2, z0, z1, z2, z0Ptr, z1Ptr, z2Ptr); } =20 /*------------------------------------------------------------------------= ---- --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169615; cv=none; d=zohomail.com; s=zohoarc; b=ipUv/g07p/lYavh4lWmkUPzCsdUuL53z+ORDyPMrKZ63MkqkR/pAbRnGFB61WeEgndxymltDCKFqsIiRz8YC9sgRm8ByS/AP3QgGQg4ug1hTc1mzG2KJS1jW4BHRRTNRBcXFrJdy5u7jUGTUERrDaOOe81VWTfMOSwfihNQNic0= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169615; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=rR/O6eCn0zcsoJsAaT3zOMU5ZGw713+1KRblmR0NHXY=; b=L2Rw4SxnaYFw1/U8uC2xTC9RsueYE5IRP4QT40/Tm8/vrFRz7kFHEZQPRJvws1OC7grPBjTBZEUuFWx9gtTZJl3yNzloL+n7+T5OGRzDZz/dal6fZMrnl6O59r/AaQIcXz1x07ckk/6BZtwUBBHb4gOiDJUeJGsziDK0uvB859w= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169615100849.9650759154935; Sun, 16 May 2021 05:53:35 -0700 (PDT) Received: from localhost ([::1]:42916 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGH0-0005mN-1k for importer@patchew.org; Sun, 16 May 2021 08:53:34 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43986) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liG29-0003g7-Hq for qemu-devel@nongnu.org; Sun, 16 May 2021 08:38:13 -0400 Received: from mail-qv1-xf2e.google.com ([2607:f8b0:4864:20::f2e]:35571) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liG24-0001L5-B6 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:38:13 -0400 Received: by mail-qv1-xf2e.google.com with SMTP id q6so1876376qvb.2 for ; Sun, 16 May 2021 05:38:06 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id 195sm8180765qkj.1.2021.05.16.05.38.05 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:38:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=rR/O6eCn0zcsoJsAaT3zOMU5ZGw713+1KRblmR0NHXY=; b=LaA54A17xisnp9+1oBC4VYSuFx53RDypObxxUKTvnDSKlM6zIkqnBVdhhKtPWxDxgJ WWOcwl8NMedH+emKJrsZox8yErtx4ks+uFhSPSSyqfTkrgIpvy4avFijkUwJ6ZzLyMWx mZ/BFag+ZkcvPu1CmmhyVsA8p5+KSbYc697mT1QoF6nuSf0g7dAeEyVUt+zz814evmVN hhJ93aia+IlrIWv3RnyZ2P5kd5wG4z6usVrTcMWIA7ukqIQJGg7igVCiuynUH8ibAuEW zR7O0e0PnHbGxMDr8gCmTHjsQRnFe0GmjjtBnKzRSVEgPEbSp9w29/Zm9rF8n+xk0XwH XUxg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=rR/O6eCn0zcsoJsAaT3zOMU5ZGw713+1KRblmR0NHXY=; b=cZtCGr4fdC0cUWF/RQJ1oYHepmhJM3iOh67fiG+67QFIA2oxxWpF2fgtrXsvaVzYBg 8o8gT3Kwk+SToTbIAxHiCqy3bhjkn1nzNDnIQJ2NtDLUJEOureOvXLugG7XQup7YlJAG dNtW3EI8UdBBROdHkykhYKIggyg3ll6gZGCQP95M5kW2eBrATUUnPJJOOOvlaiFG3NVp WMjP2V+WQYtZ5Ps9EBSXT9cN4M9EWVuz/kfflj2vzWqWKcMewjpUOLIKNzxDqjYj/m1Q /+2ntvEkodudUBJMjYZr5qnBuLHVOPg0e/GKDhTn5dsNqtMtNpBoewHIvD0SgKi/gnnQ xO1Q== X-Gm-Message-State: AOAM5324mSDAqT77+mzKEB/AofH8OjWmolWezhUiPYTauBWan0l+jz01 kpuw0N9Sus5wTfarTdh3aI2rzw17f6NFByIJEl8= X-Google-Smtp-Source: ABdhPJzH+5bMuvV+4jL0OZBYC4iZ5nY43i1KeFJsNa41q35t08PAgBaeJONbpuxhCblMsfBl0lchUQ== X-Received: by 2002:a05:6214:248e:: with SMTP id gi14mr55274969qvb.7.1621168686518; Sun, 16 May 2021 05:38:06 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 40/46] softfloat: Tidy mul128By64To192 Date: Sun, 16 May 2021 07:34:25 -0500 Message-Id: <20210516123431.718318-41-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::f2e; envelope-from=richard.henderson@linaro.org; helo=mail-qv1-xf2e.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Clean up the formatting and variables; no functional change. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- include/fpu/softfloat-macros.h | 22 ++++++---------------- 1 file changed, 6 insertions(+), 16 deletions(-) diff --git a/include/fpu/softfloat-macros.h b/include/fpu/softfloat-macros.h index 76327d844d..672c1db555 100644 --- a/include/fpu/softfloat-macros.h +++ b/include/fpu/softfloat-macros.h @@ -484,24 +484,14 @@ mul64To128(uint64_t a, uint64_t b, uint64_t *z0Ptr, u= int64_t *z1Ptr) *-------------------------------------------------------------------------= ---*/ =20 static inline void - mul128By64To192( - uint64_t a0, - uint64_t a1, - uint64_t b, - uint64_t *z0Ptr, - uint64_t *z1Ptr, - uint64_t *z2Ptr - ) +mul128By64To192(uint64_t a0, uint64_t a1, uint64_t b, + uint64_t *z0Ptr, uint64_t *z1Ptr, uint64_t *z2Ptr) { - uint64_t z0, z1, z2, more1; - - mul64To128( a1, b, &z1, &z2 ); - mul64To128( a0, b, &z0, &more1 ); - add128( z0, more1, 0, z1, &z0, &z1 ); - *z2Ptr =3D z2; - *z1Ptr =3D z1; - *z0Ptr =3D z0; + uint64_t z0, z1, m1; =20 + mul64To128(a1, b, &m1, z2Ptr); + mul64To128(a0, b, &z0, &z1); + add128(z0, z1, 0, m1, z0Ptr, z1Ptr); } =20 /*------------------------------------------------------------------------= ---- --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170542; cv=none; d=zohomail.com; s=zohoarc; b=bTM+OQQ+S0PfmR/HKdyZOB73+egWyyGCUdgXMOf78jv3BOF2zHftwU2BaEZ+L5Sdv5bp8ZOo4MvMOojNarEJtjit5kLFS3A8eG5L711jtAbtz//iriixKlpO+U/LPRlScmn01evcLdl97CbmVAw27FRC8BmOx6toMdru64Z9JOc= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170542; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=CPFctG9/cLngKncN4O5I0codA/JGixseHkiyOUbj7XY=; b=kOYSMLnAyGF8IFEggIrWzHNDz+C5hHe3aDidunuhJ/9ivlc+ecOwYNvysA171bCG1JvGfY+Yl+3BUt/E2TEZGuSaWKXvlZVedOaFjoqA2k6Cm6WyPQbTbhJ8cxUILyUEuwK+hYpU7jG+eNBowj9PiqKjo2lqA/LJ/Gi5sBq65eo= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170542054562.5891059893614; Sun, 16 May 2021 06:09:02 -0700 (PDT) Received: from localhost ([::1]:35670 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGVx-00058J-21 for importer@patchew.org; Sun, 16 May 2021 09:09:01 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43956) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liG27-0003Zs-WE for qemu-devel@nongnu.org; Sun, 16 May 2021 08:38:12 -0400 Received: from mail-qv1-xf36.google.com ([2607:f8b0:4864:20::f36]:36653) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liG24-0001Lh-B7 for qemu-devel@nongnu.org; Sun, 16 May 2021 08:38:11 -0400 Received: by mail-qv1-xf36.google.com with SMTP id ez19so1870930qvb.3 for ; Sun, 16 May 2021 05:38:07 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id 195sm8180765qkj.1.2021.05.16.05.38.06 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:38:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=CPFctG9/cLngKncN4O5I0codA/JGixseHkiyOUbj7XY=; b=VVwu1XhanPZWGSZoJuKeT4TpnU/AVjbP/0mK/2PE5Nl4eQ48x8f07xFvw284kGH7+i W0dSDZ9Iriw176kXDgk/dG1QUg8/2vpzN6/Mbw3RFmRsUgOvPU5PemWTHeSmt+4ipCjS 5/WOUeQDaTt4gn3plkGC30ckQLGQoOtlZbJWtfO5BRMu3Y6ArZJfEwWI617oQC6NmI5o rh/X4GFApMJMeA0gKAeieVcMbFdnvttGdrKAx4uO0cE55K/X5lO6+oNnWtoCbpL+fjEg U+6jrzrUPerJPtv7o/65kzJ9dapedOQUIDxlZo2POJfg2v5FvZw62NSdoPGrxbA1+jRI fWHQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=CPFctG9/cLngKncN4O5I0codA/JGixseHkiyOUbj7XY=; b=uN+5XBfiVopgObR3fgi2uiNUClaubi3G0NTzO3kkQmx41GEmGhllp5ZpgmQrSljtVL d7jQRG1o1jok42unnmcDiLobolTjOMjG2jDqZo7mWcejE8mOuEAKS1+AxKRlQiwGYwHt 2XLf8B8hHLGx8LujBnclX4MENrbE2ipRY3q7ZXxpB+NCmbKBSuWz7Ovcw2aBbKU3Onzl ITerrkBeEuMvX4u/jiHomlZsXY05bG2CNVggCc2LPZRam5cUYcDiU9tiaAogOR/eLuvx c3leuqgoEMDpKL3HAPV7pxiaCFdibdKu2fbXFP7Ge3r0XBwRUi8Q5w6WcTtGZPy8yrHp ELpQ== X-Gm-Message-State: AOAM532Qf4GODA+4LOgkC5UMe78tTOigTyhvFo7fYyc7Wa/FLKweE1Sx WIDz+agqMJb6rVvFyNqVrceWZLDIqHgwa4/SFzo= X-Google-Smtp-Source: ABdhPJwds3UGfLpRk9jEJHQ/r9V3+atckhVgTBuJHLpzei01JaG7kVWyblKDbkFi9UrVFO4qHaxlIw== X-Received: by 2002:a05:6214:766:: with SMTP id f6mr54539192qvz.17.1621168687273; Sun, 16 May 2021 05:38:07 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 41/46] softfloat: Introduce sh[lr]_double primitives Date: Sun, 16 May 2021 07:34:26 -0500 Message-Id: <20210516123431.718318-42-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::f36; envelope-from=richard.henderson@linaro.org; helo=mail-qv1-xf36.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Have x86_64 assembly for them, with a fallback. This avoids shuffling values through %cl in the x86 case. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- include/fpu/softfloat-macros.h | 36 ++++++++++++ fpu/softfloat.c | 102 +++++++++++++++++++++++++-------- 2 files changed, 115 insertions(+), 23 deletions(-) diff --git a/include/fpu/softfloat-macros.h b/include/fpu/softfloat-macros.h index 672c1db555..ec4e27a595 100644 --- a/include/fpu/softfloat-macros.h +++ b/include/fpu/softfloat-macros.h @@ -85,6 +85,42 @@ this code that are retained. #include "fpu/softfloat-types.h" #include "qemu/host-utils.h" =20 +/** + * shl_double: double-word merging left shift + * @l: left or most-significant word + * @r: right or least-significant word + * @c: shift count + * + * Shift @l left by @c bits, shifting in bits from @r. + */ +static inline uint64_t shl_double(uint64_t l, uint64_t r, int c) +{ +#if defined(__x86_64__) + asm("shld %b2, %1, %0" : "+r"(l) : "r"(r), "ci"(c)); + return l; +#else + return c ? (l << c) | (r >> (64 - c)) : l; +#endif +} + +/** + * shr_double: double-word merging right shift + * @l: left or most-significant word + * @r: right or least-significant word + * @c: shift count + * + * Shift @r right by @c bits, shifting in bits from @l. + */ +static inline uint64_t shr_double(uint64_t l, uint64_t r, int c) +{ +#if defined(__x86_64__) + asm("shrd %b2, %1, %0" : "+r"(r) : "r"(l), "ci"(c)); + return r; +#else + return c ? (r >> c) | (l << (64 - c)) : r; +#endif +} + /*------------------------------------------------------------------------= ---- | Shifts `a' right by the number of bits given in `count'. If any nonzero | bits are shifted off, they are ``jammed'' into the least significant bit= of diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 571309e74f..34689959a9 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -957,15 +957,12 @@ static int frac128_normalize(FloatParts128 *a) { if (a->frac_hi) { int shl =3D clz64(a->frac_hi); - if (shl) { - int shr =3D 64 - shl; - a->frac_hi =3D (a->frac_hi << shl) | (a->frac_lo >> shr); - a->frac_lo =3D (a->frac_lo << shl); - } + a->frac_hi =3D shl_double(a->frac_hi, a->frac_lo, shl); + a->frac_lo <<=3D shl; return shl; } else if (a->frac_lo) { int shl =3D clz64(a->frac_lo); - a->frac_hi =3D (a->frac_lo << shl); + a->frac_hi =3D a->frac_lo << shl; a->frac_lo =3D 0; return shl + 64; } @@ -976,7 +973,7 @@ static int frac256_normalize(FloatParts256 *a) { uint64_t a0 =3D a->frac_hi, a1 =3D a->frac_hm; uint64_t a2 =3D a->frac_lm, a3 =3D a->frac_lo; - int ret, shl, shr; + int ret, shl; =20 if (likely(a0)) { shl =3D clz64(a0); @@ -1006,11 +1003,10 @@ static int frac256_normalize(FloatParts256 *a) ret +=3D shl; } =20 - shr =3D -shl & 63; - a0 =3D (a0 << shl) | (a1 >> shr); - a1 =3D (a1 << shl) | (a2 >> shr); - a2 =3D (a2 << shl) | (a3 >> shr); - a3 =3D (a3 << shl); + a0 =3D shl_double(a0, a1, shl); + a1 =3D shl_double(a1, a2, shl); + a2 =3D shl_double(a2, a3, shl); + a3 <<=3D shl; =20 done: a->frac_hi =3D a0; @@ -1029,7 +1025,20 @@ static void frac64_shl(FloatParts64 *a, int c) =20 static void frac128_shl(FloatParts128 *a, int c) { - shift128Left(a->frac_hi, a->frac_lo, c, &a->frac_hi, &a->frac_lo); + uint64_t a0 =3D a->frac_hi, a1 =3D a->frac_lo; + + if (c & 64) { + a0 =3D a1, a1 =3D 0; + } + + c &=3D 63; + if (c) { + a0 =3D shl_double(a0, a1, c); + a1 =3D a1 << c; + } + + a->frac_hi =3D a0; + a->frac_lo =3D a1; } =20 #define frac_shl(A, C) FRAC_GENERIC_64_128(shl, A)(A, C) @@ -1041,19 +1050,68 @@ static void frac64_shr(FloatParts64 *a, int c) =20 static void frac128_shr(FloatParts128 *a, int c) { - shift128Right(a->frac_hi, a->frac_lo, c, &a->frac_hi, &a->frac_lo); + uint64_t a0 =3D a->frac_hi, a1 =3D a->frac_lo; + + if (c & 64) { + a1 =3D a0, a0 =3D 0; + } + + c &=3D 63; + if (c) { + a1 =3D shr_double(a0, a1, c); + a0 =3D a0 >> c; + } + + a->frac_hi =3D a0; + a->frac_lo =3D a1; } =20 #define frac_shr(A, C) FRAC_GENERIC_64_128(shr, A)(A, C) =20 static void frac64_shrjam(FloatParts64 *a, int c) { - shift64RightJamming(a->frac, c, &a->frac); + uint64_t a0 =3D a->frac; + + if (likely(c !=3D 0)) { + if (likely(c < 64)) { + a0 =3D (a0 >> c) | (shr_double(a0, 0, c) !=3D 0); + } else { + a0 =3D a0 !=3D 0; + } + a->frac =3D a0; + } } =20 static void frac128_shrjam(FloatParts128 *a, int c) { - shift128RightJamming(a->frac_hi, a->frac_lo, c, &a->frac_hi, &a->frac_= lo); + uint64_t a0 =3D a->frac_hi, a1 =3D a->frac_lo; + uint64_t sticky =3D 0; + + if (unlikely(c =3D=3D 0)) { + return; + } else if (likely(c < 64)) { + /* nothing */ + } else if (likely(c < 128)) { + sticky =3D a1; + a1 =3D a0; + a0 =3D 0; + c &=3D 63; + if (c =3D=3D 0) { + goto done; + } + } else { + sticky =3D a0 | a1; + a0 =3D a1 =3D 0; + goto done; + } + + sticky |=3D shr_double(a1, 0, c); + a1 =3D shr_double(a0, a1, c); + a0 =3D a0 >> c; + + done: + a->frac_lo =3D a1 | (sticky !=3D 0); + a->frac_hi =3D a0; } =20 static void frac256_shrjam(FloatParts256 *a, int c) @@ -1061,7 +1119,6 @@ static void frac256_shrjam(FloatParts256 *a, int c) uint64_t a0 =3D a->frac_hi, a1 =3D a->frac_hm; uint64_t a2 =3D a->frac_lm, a3 =3D a->frac_lo; uint64_t sticky =3D 0; - int invc; =20 if (unlikely(c =3D=3D 0)) { return; @@ -1086,12 +1143,11 @@ static void frac256_shrjam(FloatParts256 *a, int c) goto done; } =20 - invc =3D -c & 63; - sticky |=3D a3 << invc; - a3 =3D (a3 >> c) | (a2 << invc); - a2 =3D (a2 >> c) | (a1 << invc); - a1 =3D (a1 >> c) | (a0 << invc); - a0 =3D (a0 >> c); + sticky |=3D shr_double(a3, 0, c); + a3 =3D shr_double(a2, a3, c); + a2 =3D shr_double(a1, a2, c); + a1 =3D shr_double(a0, a1, c); + a0 =3D a0 >> c; =20 done: a->frac_lo =3D a3 | (sticky !=3D 0); --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170854; cv=none; d=zohomail.com; s=zohoarc; b=Ub93sERRsKclu1tvZGiHCGKQo4Ep8K76zKq8DXoQMeKBrDZcGRKHGfOsj7hn2NolQ7aQPA1Q2PF8ndDeYWdDT0wGUIuadNsNmu7Ud0l2wNEs7bPLZU/o6WlsUC1JcpJJUTXzdOBxL+B3X+7ioOyT8+a1tKTiRDIfaFJKDNFOdoY= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170854; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=vUvih7yvdAQh/jJm6map1MSzGxBUJiLQ3dW0rYUzqL8=; b=Hae3uIvGiUJ3+UiZAXsLz/aqLq2d/ZKyriVj4Qfy2JnmQ+88FPfDf/1zViui5BCuqRujmV+ZXRFs47UfAEQ8LLfvYezOrpw7S162YkM4Gf0MuXUfG95CQwPc7Fyo5KikUMRgrBsOdDshT4PG2CAe2saGCNX0+SmEje047SLQHoU= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170854199371.3639897357966; Sun, 16 May 2021 06:14:14 -0700 (PDT) Received: from localhost ([::1]:56690 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGaz-0002Jr-4z for importer@patchew.org; Sun, 16 May 2021 09:14:13 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43998) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liG2A-0003js-Ee for qemu-devel@nongnu.org; Sun, 16 May 2021 08:38:14 -0400 Received: from mail-qk1-x733.google.com ([2607:f8b0:4864:20::733]:46708) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liG25-0001Ln-1o for qemu-devel@nongnu.org; Sun, 16 May 2021 08:38:14 -0400 Received: by mail-qk1-x733.google.com with SMTP id 76so3274033qkn.13 for ; Sun, 16 May 2021 05:38:08 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id 195sm8180765qkj.1.2021.05.16.05.38.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:38:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=vUvih7yvdAQh/jJm6map1MSzGxBUJiLQ3dW0rYUzqL8=; b=KIANJ/NZ17u43356fHO/KALwZMJYy4yQi1+G52CBh/ZfWP6XdcOKc7LNmDYGBjzQS9 sEfDzQxiomh9RwG78aaXO9EZ/KrE5nQLk6HNB7qcIS7zpuqw07CgM+g3WqwKzD8o3Ltt B7liqFb4aWoIWI+9IO3azb62l7zAizuEWCmGB1Ab2IxqXJ4cxuvF1+tGkWvAqS4MhyWR bX0REyAJWJKImC7FAeFmu6ETIAjMIf0nfLiYjqlMf9fU7fQv9+l6hbFyc/n34WW9TsYi 8REsto9pCFpmrIEa1R0zNqWJlDLBJKgT3iIq1ay6p//uMwSGYDhmCkUxF0Hxn4QXzOOc obdw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=vUvih7yvdAQh/jJm6map1MSzGxBUJiLQ3dW0rYUzqL8=; b=RzDvWs4a+Aw6ndu+WDpvOSNsfzByQMEvFaCHQIiB6gYMQfy595LlGLSzYzWhmarriq pdN/zZeoZi0MPpao5e3XshU9BM2Irgrm4AYX2ed5oE2iULrvREo/hQChqEmS17AhP83I Yhoki1YhCPB4y68xAobaydP32l2/3Q7d/H0Z6WXtlKdOG4HtGbo6I2Cp2HYvJlg5n2g8 zobo3Ry0YqbczMKLZTamEgWRtj3biIOMBSXcnziIL+DhAJHCsZ2LOq7f+3UBqfsvHR0P TjscHkDcydyD1h013Gcl4I8Pd5Jc9f2njlbI9kmogM/ZuIrlQgd88t9ZmTvCPaiEMqmJ BOgg== X-Gm-Message-State: AOAM532XQoJ/ZbHUVDusrCaCeeMv8bQMxDRnI5UiuRItiqqCwr540bwj 8MAufyU5y+VzMLPNiZVLKzo+ywCR2mWUpZoSr1U= X-Google-Smtp-Source: ABdhPJzbUZWsgy86oIGxag+Egd3vZMNGBfMIihNKVVgiObnBDfOpxupfEN09KDTyIxyM5a2zQRmBZw== X-Received: by 2002:a37:715:: with SMTP id 21mr20409611qkh.383.1621168688124; Sun, 16 May 2021 05:38:08 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 42/46] softfloat: Move div_floats to softfloat-parts.c.inc Date: Sun, 16 May 2021 07:34:27 -0500 Message-Id: <20210516123431.718318-43-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::733; envelope-from=richard.henderson@linaro.org; helo=mail-qk1-x733.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Rename to parts$N_div. Implement float128_div with FloatParts128. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 290 +++++++++++++++----------------------- fpu/softfloat-parts.c.inc | 55 ++++++++ 2 files changed, 171 insertions(+), 174 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 34689959a9..a6dbb1dabf 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -803,6 +803,14 @@ static FloatParts128 *parts128_muladd(FloatParts128 *a= , FloatParts128 *b, #define parts_muladd(A, B, C, Z, S) \ PARTS_GENERIC_64_128(muladd, A)(A, B, C, Z, S) =20 +static FloatParts64 *parts64_div(FloatParts64 *a, FloatParts64 *b, + float_status *s); +static FloatParts128 *parts128_div(FloatParts128 *a, FloatParts128 *b, + float_status *s); + +#define parts_div(A, B, S) \ + PARTS_GENERIC_64_128(div, A)(A, B, S) + /* * Helper functions for softfloat-parts.c.inc, per-size operations. */ @@ -895,6 +903,87 @@ static void frac128_clear(FloatParts128 *a) =20 #define frac_clear(A) FRAC_GENERIC_64_128(clear, A)(A) =20 +static bool frac64_div(FloatParts64 *a, FloatParts64 *b) +{ + uint64_t n1, n0, r, q; + bool ret; + + /* + * We want a 2*N / N-bit division to produce exactly an N-bit + * result, so that we do not lose any precision and so that we + * do not have to renormalize afterward. If A.frac < B.frac, + * then division would produce an (N-1)-bit result; shift A left + * by one to produce the an N-bit result, and return true to + * decrement the exponent to match. + * + * The udiv_qrnnd algorithm that we're using requires normalization, + * i.e. the msb of the denominator must be set, which is already true. + */ + ret =3D a->frac < b->frac; + if (ret) { + n0 =3D a->frac; + n1 =3D 0; + } else { + n0 =3D a->frac >> 1; + n1 =3D a->frac << 63; + } + q =3D udiv_qrnnd(&r, n0, n1, b->frac); + + /* Set lsb if there is a remainder, to set inexact. */ + a->frac =3D q | (r !=3D 0); + + return ret; +} + +static bool frac128_div(FloatParts128 *a, FloatParts128 *b) +{ + uint64_t q0, q1, a0, a1, b0, b1; + uint64_t r0, r1, r2, r3, t0, t1, t2, t3; + bool ret =3D false; + + a0 =3D a->frac_hi, a1 =3D a->frac_lo; + b0 =3D b->frac_hi, b1 =3D b->frac_lo; + + ret =3D lt128(a0, a1, b0, b1); + if (!ret) { + a1 =3D shr_double(a0, a1, 1); + a0 =3D a0 >> 1; + } + + /* Use 128/64 -> 64 division as estimate for 192/128 -> 128 division. = */ + q0 =3D estimateDiv128To64(a0, a1, b0); + + /* + * Estimate is high because B1 was not included (unless B1 =3D=3D 0). + * Reduce quotient and increase remainder until remainder is non-negat= ive. + * This loop will execute 0 to 2 times. + */ + mul128By64To192(b0, b1, q0, &t0, &t1, &t2); + sub192(a0, a1, 0, t0, t1, t2, &r0, &r1, &r2); + while (r0 !=3D 0) { + q0--; + add192(r0, r1, r2, 0, b0, b1, &r0, &r1, &r2); + } + + /* Repeat using the remainder, producing a second word of quotient. */ + q1 =3D estimateDiv128To64(r1, r2, b0); + mul128By64To192(b0, b1, q1, &t1, &t2, &t3); + sub192(r1, r2, 0, t1, t2, t3, &r1, &r2, &r3); + while (r1 !=3D 0) { + q1--; + add192(r1, r2, r3, 0, b0, b1, &r1, &r2, &r3); + } + + /* Any remainder indicates inexact; set sticky bit. */ + q1 |=3D (r2 | r3) !=3D 0; + + a->frac_hi =3D q0; + a->frac_lo =3D q1; + return ret; +} + +#define frac_div(A, B) FRAC_GENERIC_64_128(div, A)(A, B) + static bool frac64_eqz(FloatParts64 *a) { return a->frac =3D=3D 0; @@ -1821,110 +1910,42 @@ float128 QEMU_FLATTEN float128_muladd(float128 a, = float128 b, float128 c, } =20 /* - * Returns the result of dividing the floating-point value `a' by the - * corresponding value `b'. The operation is performed according to - * the IEC/IEEE Standard for Binary Floating-Point Arithmetic. + * Division */ =20 -static FloatParts64 div_floats(FloatParts64 a, FloatParts64 b, float_statu= s *s) -{ - bool sign =3D a.sign ^ b.sign; - - if (a.cls =3D=3D float_class_normal && b.cls =3D=3D float_class_normal= ) { - uint64_t n0, n1, q, r; - int exp =3D a.exp - b.exp; - - /* - * We want a 2*N / N-bit division to produce exactly an N-bit - * result, so that we do not lose any precision and so that we - * do not have to renormalize afterward. If A.frac < B.frac, - * then division would produce an (N-1)-bit result; shift A left - * by one to produce the an N-bit result, and decrement the - * exponent to match. - * - * The udiv_qrnnd algorithm that we're using requires normalizatio= n, - * i.e. the msb of the denominator must be set, which is already t= rue. - */ - if (a.frac < b.frac) { - exp -=3D 1; - shift128Left(0, a.frac, DECOMPOSED_BINARY_POINT + 1, &n1, &n0); - } else { - shift128Left(0, a.frac, DECOMPOSED_BINARY_POINT, &n1, &n0); - } - q =3D udiv_qrnnd(&r, n1, n0, b.frac); - - /* Set lsb if there is a remainder, to set inexact. */ - a.frac =3D q | (r !=3D 0); - a.sign =3D sign; - a.exp =3D exp; - return a; - } - /* handle all the NaN cases */ - if (is_nan(a.cls) || is_nan(b.cls)) { - return *parts_pick_nan(&a, &b, s); - } - /* 0/0 or Inf/Inf */ - if (a.cls =3D=3D b.cls - && - (a.cls =3D=3D float_class_inf || a.cls =3D=3D float_class_zero)) { - float_raise(float_flag_invalid, s); - parts_default_nan(&a, s); - return a; - } - /* Inf / x or 0 / x */ - if (a.cls =3D=3D float_class_inf || a.cls =3D=3D float_class_zero) { - a.sign =3D sign; - return a; - } - /* Div 0 =3D> Inf */ - if (b.cls =3D=3D float_class_zero) { - float_raise(float_flag_divbyzero, s); - a.cls =3D float_class_inf; - a.sign =3D sign; - return a; - } - /* Div by Inf */ - if (b.cls =3D=3D float_class_inf) { - a.cls =3D float_class_zero; - a.sign =3D sign; - return a; - } - g_assert_not_reached(); -} - float16 float16_div(float16 a, float16 b, float_status *status) { - FloatParts64 pa, pb, pr; + FloatParts64 pa, pb, *pr; =20 float16_unpack_canonical(&pa, a, status); float16_unpack_canonical(&pb, b, status); - pr =3D div_floats(pa, pb, status); + pr =3D parts_div(&pa, &pb, status); =20 - return float16_round_pack_canonical(&pr, status); + return float16_round_pack_canonical(pr, status); } =20 static float32 QEMU_SOFTFLOAT_ATTR soft_f32_div(float32 a, float32 b, float_status *status) { - FloatParts64 pa, pb, pr; + FloatParts64 pa, pb, *pr; =20 float32_unpack_canonical(&pa, a, status); float32_unpack_canonical(&pb, b, status); - pr =3D div_floats(pa, pb, status); + pr =3D parts_div(&pa, &pb, status); =20 - return float32_round_pack_canonical(&pr, status); + return float32_round_pack_canonical(pr, status); } =20 static float64 QEMU_SOFTFLOAT_ATTR soft_f64_div(float64 a, float64 b, float_status *status) { - FloatParts64 pa, pb, pr; + FloatParts64 pa, pb, *pr; =20 float64_unpack_canonical(&pa, a, status); float64_unpack_canonical(&pb, b, status); - pr =3D div_floats(pa, pb, status); + pr =3D parts_div(&pa, &pb, status); =20 - return float64_round_pack_canonical(&pr, status); + return float64_round_pack_canonical(pr, status); } =20 static float hard_f32_div(float a, float b) @@ -1985,20 +2006,28 @@ float64_div(float64 a, float64 b, float_status *s) f64_div_pre, f64_div_post); } =20 -/* - * Returns the result of dividing the bfloat16 - * value `a' by the corresponding value `b'. - */ - -bfloat16 bfloat16_div(bfloat16 a, bfloat16 b, float_status *status) +bfloat16 QEMU_FLATTEN +bfloat16_div(bfloat16 a, bfloat16 b, float_status *status) { - FloatParts64 pa, pb, pr; + FloatParts64 pa, pb, *pr; =20 bfloat16_unpack_canonical(&pa, a, status); bfloat16_unpack_canonical(&pb, b, status); - pr =3D div_floats(pa, pb, status); + pr =3D parts_div(&pa, &pb, status); =20 - return bfloat16_round_pack_canonical(&pr, status); + return bfloat16_round_pack_canonical(pr, status); +} + +float128 QEMU_FLATTEN +float128_div(float128 a, float128 b, float_status *status) +{ + FloatParts128 pa, pb, *pr; + + float128_unpack_canonical(&pa, a, status); + float128_unpack_canonical(&pb, b, status); + pr =3D parts_div(&pa, &pb, status); + + return float128_round_pack_canonical(pr, status); } =20 /* @@ -7123,93 +7152,6 @@ float128 float128_round_to_int(float128 a, float_sta= tus *status) =20 } =20 -/*------------------------------------------------------------------------= ---- -| Returns the result of dividing the quadruple-precision floating-point va= lue -| `a' by the corresponding value `b'. The operation is performed accordin= g to -| the IEC/IEEE Standard for Binary Floating-Point Arithmetic. -*-------------------------------------------------------------------------= ---*/ - -float128 float128_div(float128 a, float128 b, float_status *status) -{ - bool aSign, bSign, zSign; - int32_t aExp, bExp, zExp; - uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2; - uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3; - - aSig1 =3D extractFloat128Frac1( a ); - aSig0 =3D extractFloat128Frac0( a ); - aExp =3D extractFloat128Exp( a ); - aSign =3D extractFloat128Sign( a ); - bSig1 =3D extractFloat128Frac1( b ); - bSig0 =3D extractFloat128Frac0( b ); - bExp =3D extractFloat128Exp( b ); - bSign =3D extractFloat128Sign( b ); - zSign =3D aSign ^ bSign; - if ( aExp =3D=3D 0x7FFF ) { - if (aSig0 | aSig1) { - return propagateFloat128NaN(a, b, status); - } - if ( bExp =3D=3D 0x7FFF ) { - if (bSig0 | bSig1) { - return propagateFloat128NaN(a, b, status); - } - goto invalid; - } - return packFloat128( zSign, 0x7FFF, 0, 0 ); - } - if ( bExp =3D=3D 0x7FFF ) { - if (bSig0 | bSig1) { - return propagateFloat128NaN(a, b, status); - } - return packFloat128( zSign, 0, 0, 0 ); - } - if ( bExp =3D=3D 0 ) { - if ( ( bSig0 | bSig1 ) =3D=3D 0 ) { - if ( ( aExp | aSig0 | aSig1 ) =3D=3D 0 ) { - invalid: - float_raise(float_flag_invalid, status); - return float128_default_nan(status); - } - float_raise(float_flag_divbyzero, status); - return packFloat128( zSign, 0x7FFF, 0, 0 ); - } - normalizeFloat128Subnormal( bSig0, bSig1, &bExp, &bSig0, &bSig1 ); - } - if ( aExp =3D=3D 0 ) { - if ( ( aSig0 | aSig1 ) =3D=3D 0 ) return packFloat128( zSign, 0, 0= , 0 ); - normalizeFloat128Subnormal( aSig0, aSig1, &aExp, &aSig0, &aSig1 ); - } - zExp =3D aExp - bExp + 0x3FFD; - shortShift128Left( - aSig0 | UINT64_C(0x0001000000000000), aSig1, 15, &aSig0, &aSig1 ); - shortShift128Left( - bSig0 | UINT64_C(0x0001000000000000), bSig1, 15, &bSig0, &bSig1 ); - if ( le128( bSig0, bSig1, aSig0, aSig1 ) ) { - shift128Right( aSig0, aSig1, 1, &aSig0, &aSig1 ); - ++zExp; - } - zSig0 =3D estimateDiv128To64( aSig0, aSig1, bSig0 ); - mul128By64To192( bSig0, bSig1, zSig0, &term0, &term1, &term2 ); - sub192( aSig0, aSig1, 0, term0, term1, term2, &rem0, &rem1, &rem2 ); - while ( (int64_t) rem0 < 0 ) { - --zSig0; - add192( rem0, rem1, rem2, 0, bSig0, bSig1, &rem0, &rem1, &rem2 ); - } - zSig1 =3D estimateDiv128To64( rem1, rem2, bSig0 ); - if ( ( zSig1 & 0x3FFF ) <=3D 4 ) { - mul128By64To192( bSig0, bSig1, zSig1, &term1, &term2, &term3 ); - sub192( rem1, rem2, 0, term1, term2, term3, &rem1, &rem2, &rem3 ); - while ( (int64_t) rem1 < 0 ) { - --zSig1; - add192( rem1, rem2, rem3, 0, bSig0, bSig1, &rem1, &rem2, &rem3= ); - } - zSig1 |=3D ( ( rem1 | rem2 | rem3 ) !=3D 0 ); - } - shift128ExtraRightJamming( zSig0, zSig1, 0, 15, &zSig0, &zSig1, &zSig2= ); - return roundAndPackFloat128(zSign, zExp, zSig0, zSig1, zSig2, status); - -} - /*------------------------------------------------------------------------= ---- | Returns the remainder of the quadruple-precision floating-point value `a' | with respect to the corresponding value `b'. The operation is performed diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc index a203811299..f8165d92f9 100644 --- a/fpu/softfloat-parts.c.inc +++ b/fpu/softfloat-parts.c.inc @@ -539,3 +539,58 @@ static FloatPartsN *partsN(muladd)(FloatPartsN *a, Flo= atPartsN *b, parts_default_nan(a, s); return a; } + +/* + * Returns the result of dividing the floating-point value `a' by the + * corresponding value `b'. The operation is performed according to + * the IEC/IEEE Standard for Binary Floating-Point Arithmetic. + */ +static FloatPartsN *partsN(div)(FloatPartsN *a, FloatPartsN *b, + float_status *s) +{ + int ab_mask =3D float_cmask(a->cls) | float_cmask(b->cls); + bool sign =3D a->sign ^ b->sign; + + if (likely(ab_mask =3D=3D float_cmask_normal)) { + a->sign =3D sign; + a->exp -=3D b->exp + frac_div(a, b); + return a; + } + + /* 0/0 or Inf/Inf =3D> NaN */ + if (unlikely(ab_mask =3D=3D float_cmask_zero) || + unlikely(ab_mask =3D=3D float_cmask_inf)) { + float_raise(float_flag_invalid, s); + parts_default_nan(a, s); + return a; + } + + /* All the NaN cases */ + if (unlikely(ab_mask & float_cmask_anynan)) { + return parts_pick_nan(a, b, s); + } + + a->sign =3D sign; + + /* Inf / X */ + if (a->cls =3D=3D float_class_inf) { + return a; + } + + /* 0 / X */ + if (a->cls =3D=3D float_class_zero) { + return a; + } + + /* X / Inf */ + if (b->cls =3D=3D float_class_inf) { + a->cls =3D float_class_zero; + return a; + } + + /* X / 0 =3D> Inf */ + g_assert(b->cls =3D=3D float_class_zero); + float_raise(float_flag_divbyzero, s); + a->cls =3D float_class_inf; + return a; +} --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170771; cv=none; d=zohomail.com; s=zohoarc; b=HkYvvmdNs3IZvqlF7Bi54/EM96ltfOi9C7l8sE6vPjkJIIF85ACSKjr5pJpQzc3o9zHzv6G/lMnHRLhXEp7PcBLdaEfHlXgeGWvV1crMF1QlV7oADODuRGk4jiR68I665Oas2rmHfqEZJAcWBqhFSxtN+xSyKnzw1NcQC5lWK2U= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170771; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=UZ1hSMuOPZm/hbcoYgOK5xvaD0/Vou60KStb6uIk1O0=; b=a9d4bKAXH2hQjqwo0loinebl+UZoaGHV9QtsDi9hYKwc+b6ZuI7BiqBZsZiXmd+r9jOv/qaVZabNNRoTVC4U0dMhB/6/ddBqYWpRmR5VvSL4pIJlr7lH+UgSqs9c+wtOXRnwhFodEVyKXYBMpJVhBl7jO3e4NZ7fMD1j7i74Ihs= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170771090549.8336638104424; Sun, 16 May 2021 06:12:51 -0700 (PDT) Received: from localhost ([::1]:49956 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGZd-0006EQ-Lo for importer@patchew.org; Sun, 16 May 2021 09:12:49 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43996) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liG2A-0003iC-2r for qemu-devel@nongnu.org; Sun, 16 May 2021 08:38:14 -0400 Received: from mail-qv1-xf2b.google.com ([2607:f8b0:4864:20::f2b]:41589) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liG26-0001MQ-KN for qemu-devel@nongnu.org; Sun, 16 May 2021 08:38:13 -0400 Received: by mail-qv1-xf2b.google.com with SMTP id ee9so1849054qvb.8 for ; Sun, 16 May 2021 05:38:09 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id 195sm8180765qkj.1.2021.05.16.05.38.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:38:08 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=UZ1hSMuOPZm/hbcoYgOK5xvaD0/Vou60KStb6uIk1O0=; b=cxV/kNjx+kl08cEQIkTjmm0C7mwFE6qxrkOBQNDPzg7geZrHI8rcFIDRaBRw8q/jhs XvFwF75Ay+TDBhzeGlO7ZhVf2+n8TRt/9J2Bo8IleEPdGVnrJO+DZ40JhdoovCU59JaH BgmMIQXDcFa7sdnPEDyuuUJDbs3Q6VZDyc51+V+QkjheD6y734KXv0DpCWF0b8eS1UEb dHNxuRuDS4cyMlLAwBigDSO57+Bgb1/tJ6hoN2q4uxdk6ci5U22taWCzOuS+N84cA9dC dMzikZrMOlOVgCMAO1EbRmQ4YIOnH7rjQyAW4gfB/YIxuWkxhcB5rEB+8yAvCw15/HNR tjkA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=UZ1hSMuOPZm/hbcoYgOK5xvaD0/Vou60KStb6uIk1O0=; b=GvVrOC7n1hjFgwVz8h8mvEzbJzsbJEWaO0Lc3xgw/gvO+cmwNn9m7wrdrbNlsL0eah CFxy+NJWcXPLknA2vpxQxyhFXbs1CfganNSHZ0wPhlsB9WkVVBgfykaERDsstNERA5kP 7e/vkzb305rWbMVeJVWjZ3IgFoufnvchOKp84tu3MAFTgfFYUVv2honxSiP1uhRSsANb IhZX2cPN8isAOt7pjAvPY6WWnDFX2VKcjQaoLUL/QDXik8UbdR5vEPquxlI2jKreQGgl netlYTsncClmtCZAKYZuxQ+p2tJRw2ZHBJl/Mxzs222pBFQpY66Ew+yNAtgQ5+yYD2KP E2Lg== X-Gm-Message-State: AOAM533FWyk9nX2w1cS9AYYdA1wiayMtFIx2ULelKZdeOx1NtcE832Af L7AQkKkwlv2lJ9dqfFZMwvXiyLsvYf0KIcxPEQ8= X-Google-Smtp-Source: ABdhPJzMlrOSn8AUuq1PAesNv7Id/5YarKGRjKSUIGY3Grv8bCe4zSS8Cdt1S/kKqu3hCaDty1zn1g== X-Received: by 2002:a0c:e20f:: with SMTP id q15mr2879415qvl.56.1621168688965; Sun, 16 May 2021 05:38:08 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 43/46] softfloat: Split float_to_float Date: Sun, 16 May 2021 07:34:28 -0500 Message-Id: <20210516123431.718318-44-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::f2b; envelope-from=richard.henderson@linaro.org; helo=mail-qv1-xf2b.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Split out parts_float_to_ahp and parts_float_to_float. Convert to pointers. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 174 ++++++++++++++++++++++++++++-------------------- 1 file changed, 101 insertions(+), 73 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index a6dbb1dabf..80025539ef 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -2037,83 +2037,105 @@ float128_div(float128 a, float128 b, float_status = *status) * conversion is performed according to the IEC/IEEE Standard for * Binary Floating-Point Arithmetic. * - * The float_to_float helper only needs to take care of raising - * invalid exceptions and handling the conversion on NaNs. + * Usually this only needs to take care of raising invalid exceptions + * and handling the conversion on NaNs. */ =20 -static FloatParts64 float_to_float(FloatParts64 a, const FloatFmt *dstf, - float_status *s) +static void parts_float_to_ahp(FloatParts64 *a, float_status *s) { - if (dstf->arm_althp) { - switch (a.cls) { - case float_class_qnan: - case float_class_snan: - /* There is no NaN in the destination format. Raise Invalid - * and return a zero with the sign of the input NaN. - */ - float_raise(float_flag_invalid, s); - a.cls =3D float_class_zero; - a.frac =3D 0; - a.exp =3D 0; - break; + switch (a->cls) { + case float_class_qnan: + case float_class_snan: + /* + * There is no NaN in the destination format. Raise Invalid + * and return a zero with the sign of the input NaN. + */ + float_raise(float_flag_invalid, s); + a->cls =3D float_class_zero; + break; =20 - case float_class_inf: - /* There is no Inf in the destination format. Raise Invalid - * and return the maximum normal with the correct sign. - */ - float_raise(float_flag_invalid, s); - a.cls =3D float_class_normal; - a.exp =3D dstf->exp_max; - a.frac =3D ((1ull << dstf->frac_size) - 1) << dstf->frac_shift; - break; + case float_class_inf: + /* + * There is no Inf in the destination format. Raise Invalid + * and return the maximum normal with the correct sign. + */ + float_raise(float_flag_invalid, s); + a->cls =3D float_class_normal; + a->exp =3D float16_params_ahp.exp_max; + a->frac =3D MAKE_64BIT_MASK(float16_params_ahp.frac_shift, + float16_params_ahp.frac_size + 1); + break; =20 - default: - break; - } - } else if (is_nan(a.cls)) { - parts_return_nan(&a, s); + case float_class_normal: + case float_class_zero: + break; + + default: + g_assert_not_reached(); } - return a; } =20 +static void parts64_float_to_float(FloatParts64 *a, float_status *s) +{ + if (is_nan(a->cls)) { + parts_return_nan(a, s); + } +} + +static void parts128_float_to_float(FloatParts128 *a, float_status *s) +{ + if (is_nan(a->cls)) { + parts_return_nan(a, s); + } +} + +#define parts_float_to_float(P, S) \ + PARTS_GENERIC_64_128(float_to_float, P)(P, S) + float32 float16_to_float32(float16 a, bool ieee, float_status *s) { const FloatFmt *fmt16 =3D ieee ? &float16_params : &float16_params_ahp; - FloatParts64 pa, pr; + FloatParts64 p; =20 - float16a_unpack_canonical(&pa, a, s, fmt16); - pr =3D float_to_float(pa, &float32_params, s); - return float32_round_pack_canonical(&pr, s); + float16a_unpack_canonical(&p, a, s, fmt16); + parts_float_to_float(&p, s); + return float32_round_pack_canonical(&p, s); } =20 float64 float16_to_float64(float16 a, bool ieee, float_status *s) { const FloatFmt *fmt16 =3D ieee ? &float16_params : &float16_params_ahp; - FloatParts64 pa, pr; + FloatParts64 p; =20 - float16a_unpack_canonical(&pa, a, s, fmt16); - pr =3D float_to_float(pa, &float64_params, s); - return float64_round_pack_canonical(&pr, s); + float16a_unpack_canonical(&p, a, s, fmt16); + parts_float_to_float(&p, s); + return float64_round_pack_canonical(&p, s); } =20 float16 float32_to_float16(float32 a, bool ieee, float_status *s) { - const FloatFmt *fmt16 =3D ieee ? &float16_params : &float16_params_ahp; - FloatParts64 pa, pr; + FloatParts64 p; + const FloatFmt *fmt; =20 - float32_unpack_canonical(&pa, a, s); - pr =3D float_to_float(pa, fmt16, s); - return float16a_round_pack_canonical(&pr, s, fmt16); + float32_unpack_canonical(&p, a, s); + if (ieee) { + parts_float_to_float(&p, s); + fmt =3D &float16_params; + } else { + parts_float_to_ahp(&p, s); + fmt =3D &float16_params_ahp; + } + return float16a_round_pack_canonical(&p, s, fmt); } =20 static float64 QEMU_SOFTFLOAT_ATTR soft_float32_to_float64(float32 a, float_status *s) { - FloatParts64 pa, pr; + FloatParts64 p; =20 - float32_unpack_canonical(&pa, a, s); - pr =3D float_to_float(pa, &float64_params, s); - return float64_round_pack_canonical(&pr, s); + float32_unpack_canonical(&p, a, s); + parts_float_to_float(&p, s); + return float64_round_pack_canonical(&p, s); } =20 float64 float32_to_float64(float32 a, float_status *s) @@ -2134,57 +2156,63 @@ float64 float32_to_float64(float32 a, float_status = *s) =20 float16 float64_to_float16(float64 a, bool ieee, float_status *s) { - const FloatFmt *fmt16 =3D ieee ? &float16_params : &float16_params_ahp; - FloatParts64 pa, pr; + FloatParts64 p; + const FloatFmt *fmt; =20 - float64_unpack_canonical(&pa, a, s); - pr =3D float_to_float(pa, fmt16, s); - return float16a_round_pack_canonical(&pr, s, fmt16); + float64_unpack_canonical(&p, a, s); + if (ieee) { + parts_float_to_float(&p, s); + fmt =3D &float16_params; + } else { + parts_float_to_ahp(&p, s); + fmt =3D &float16_params_ahp; + } + return float16a_round_pack_canonical(&p, s, fmt); } =20 float32 float64_to_float32(float64 a, float_status *s) { - FloatParts64 pa, pr; + FloatParts64 p; =20 - float64_unpack_canonical(&pa, a, s); - pr =3D float_to_float(pa, &float32_params, s); - return float32_round_pack_canonical(&pr, s); + float64_unpack_canonical(&p, a, s); + parts_float_to_float(&p, s); + return float32_round_pack_canonical(&p, s); } =20 float32 bfloat16_to_float32(bfloat16 a, float_status *s) { - FloatParts64 pa, pr; + FloatParts64 p; =20 - bfloat16_unpack_canonical(&pa, a, s); - pr =3D float_to_float(pa, &float32_params, s); - return float32_round_pack_canonical(&pr, s); + bfloat16_unpack_canonical(&p, a, s); + parts_float_to_float(&p, s); + return float32_round_pack_canonical(&p, s); } =20 float64 bfloat16_to_float64(bfloat16 a, float_status *s) { - FloatParts64 pa, pr; + FloatParts64 p; =20 - bfloat16_unpack_canonical(&pa, a, s); - pr =3D float_to_float(pa, &float64_params, s); - return float64_round_pack_canonical(&pr, s); + bfloat16_unpack_canonical(&p, a, s); + parts_float_to_float(&p, s); + return float64_round_pack_canonical(&p, s); } =20 bfloat16 float32_to_bfloat16(float32 a, float_status *s) { - FloatParts64 pa, pr; + FloatParts64 p; =20 - float32_unpack_canonical(&pa, a, s); - pr =3D float_to_float(pa, &bfloat16_params, s); - return bfloat16_round_pack_canonical(&pr, s); + float32_unpack_canonical(&p, a, s); + parts_float_to_float(&p, s); + return bfloat16_round_pack_canonical(&p, s); } =20 bfloat16 float64_to_bfloat16(float64 a, float_status *s) { - FloatParts64 pa, pr; + FloatParts64 p; =20 - float64_unpack_canonical(&pa, a, s); - pr =3D float_to_float(pa, &bfloat16_params, s); - return bfloat16_round_pack_canonical(&pr, s); + float64_unpack_canonical(&p, a, s); + parts_float_to_float(&p, s); + return bfloat16_round_pack_canonical(&p, s); } =20 /* --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169959; cv=none; d=zohomail.com; s=zohoarc; b=PmcXiIbCD0e63vUvYuwOPRwp2N9Lwi29QV+NlLFrrZra7pbI8HRFI8D9MqqjBrgD8MZ5i5wHgbcde48yPsssxcLU5OzD6UN2lgYQUdhY/+BFLOp9m/DmChi+GwsdACI/T1BF6dP6i7CrWxaFJOQZjNImXHVrgcFmpAxR8cn1yvA= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169959; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=rtiGKpdh5DJMz2+k60GL7qgBI13NuhGDzP/LkQRlm78=; b=E5rs+ZKhd5PryJhQfA8oD1SPj6I7yYo3gCpWkb7AIRpxhbZPLQLp/9bZZA/zyewDHhEfGtlnaJamLA3+LFQUHRzUv6BNz39XiVYhAbORhZs51BNa2m4ZOReLo5Jc8X0aL+nbO/BIUnUmciZZnBjEHCcaZpxemEKQJ/12tRn6EFE= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621169959702764.8060814384722; Sun, 16 May 2021 05:59:19 -0700 (PDT) Received: from localhost ([::1]:60130 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGMY-0000To-DT for importer@patchew.org; Sun, 16 May 2021 08:59:18 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:44026) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liG2B-0003or-MU for qemu-devel@nongnu.org; Sun, 16 May 2021 08:38:15 -0400 Received: from mail-qv1-xf2c.google.com ([2607:f8b0:4864:20::f2c]:33772) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liG26-0001N6-Vm for qemu-devel@nongnu.org; Sun, 16 May 2021 08:38:15 -0400 Received: by mail-qv1-xf2c.google.com with SMTP id 5so1894278qvk.0 for ; Sun, 16 May 2021 05:38:10 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id 195sm8180765qkj.1.2021.05.16.05.38.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:38:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=rtiGKpdh5DJMz2+k60GL7qgBI13NuhGDzP/LkQRlm78=; b=HgaqwUlOkAIUlhIHZaI+AuBq5O8vddp+5nZOlJUdmmnPuerImvG7RRK8Gb75mUqmQ/ EWpZwUc7si52FbIlvcaPTbg/eeihUy1aCMO8MfqdRxDhlYf0Jge6GUro5HPMcXtObtau mKyr+zx65y2UKMaMrXr5k8zBwstDWQEdjs979Mq6Z0LF1yuDXjOHsc1RdkFeGtaLmKQG WqdIn7pYe5L3HQxKup8prGu3U4CVgiknHUGPzGdOtvx9SxBZJPlwFAnicJt4f+rBCrpx QI6Og5LnrnROt1+bn/qPx4SM4RM6e9bABYEPMUbgfvEcLCLQTovRPMOtuz5ES2b2M9tv 1tmg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=rtiGKpdh5DJMz2+k60GL7qgBI13NuhGDzP/LkQRlm78=; b=qq/gHawIpuHb6FEOI4v3Q5Najs0GfWQLA4j6AvMJjJVwi50nkCMPWQfDhABilHEc87 4sITqf67N+Ag6pvqKfd5tziVhqI0ji6djBMN+T07yfOGYYOUOXMOSPJ3SGiUbY+8Fx2s gvnY3g7/CkM6O4hbfbRM7Y9kJ1J+JVl7hYszET6pc1NcYHRVgUxAvIIeOVamq9Ntxq0z Jj7HrHa4QTw960A8QWKfVDgD4mXPNxcblNViz+LNowV9WtFu1fqtHN271apHveQjhJIy kbdhlZzX1S9tuvWLI/xy8tKKVUz+XDwqaUX9fW2YckbkQFTX7Lz+baMkxRcTKoG5lMJF A2Zg== X-Gm-Message-State: AOAM530tsPP2hEsr93qVDMzdQ+0tTDWB/0vw0rw9E0qD/zrFGhaM1PDV spOAyWHZvzp1RacA/NJCAzdDBlOf9WNL4XOExss= X-Google-Smtp-Source: ABdhPJyFgwrVC9c5XRgXKD2XYOdzG3PAlCDUZFRv/iB4vsrWrk6mEnOoRCpNdxM7ErBMI9NFFInKOw== X-Received: by 2002:a0c:a909:: with SMTP id y9mr55091304qva.20.1621168689817; Sun, 16 May 2021 05:38:09 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 44/46] softfloat: Convert float-to-float conversions with float128 Date: Sun, 16 May 2021 07:34:29 -0500 Message-Id: <20210516123431.718318-45-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::f2c; envelope-from=richard.henderson@linaro.org; helo=mail-qv1-xf2c.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Introduce parts_float_to_float_widen and parts_float_to_float_narrow. Use them for float128_to_float{32,64} and float{32,64}_to_float128. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 203 ++++++++++++++++-------------------------------- 1 file changed, 69 insertions(+), 134 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 80025539ef..d056b5730b 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -2092,6 +2092,35 @@ static void parts128_float_to_float(FloatParts128 *a= , float_status *s) #define parts_float_to_float(P, S) \ PARTS_GENERIC_64_128(float_to_float, P)(P, S) =20 +static void parts_float_to_float_narrow(FloatParts64 *a, FloatParts128 *b, + float_status *s) +{ + a->cls =3D b->cls; + a->sign =3D b->sign; + a->exp =3D b->exp; + + if (a->cls =3D=3D float_class_normal) { + frac_truncjam(a, b); + } else if (is_nan(a->cls)) { + /* Discard the low bits of the NaN. */ + a->frac =3D b->frac_hi; + parts_return_nan(a, s); + } +} + +static void parts_float_to_float_widen(FloatParts128 *a, FloatParts64 *b, + float_status *s) +{ + a->cls =3D b->cls; + a->sign =3D b->sign; + a->exp =3D b->exp; + frac_widen(a, b); + + if (is_nan(a->cls)) { + parts_return_nan(a, s); + } +} + float32 float16_to_float32(float16 a, bool ieee, float_status *s) { const FloatFmt *fmt16 =3D ieee ? &float16_params : &float16_params_ahp; @@ -2215,6 +2244,46 @@ bfloat16 float64_to_bfloat16(float64 a, float_status= *s) return bfloat16_round_pack_canonical(&p, s); } =20 +float32 float128_to_float32(float128 a, float_status *s) +{ + FloatParts64 p64; + FloatParts128 p128; + + float128_unpack_canonical(&p128, a, s); + parts_float_to_float_narrow(&p64, &p128, s); + return float32_round_pack_canonical(&p64, s); +} + +float64 float128_to_float64(float128 a, float_status *s) +{ + FloatParts64 p64; + FloatParts128 p128; + + float128_unpack_canonical(&p128, a, s); + parts_float_to_float_narrow(&p64, &p128, s); + return float64_round_pack_canonical(&p64, s); +} + +float128 float32_to_float128(float32 a, float_status *s) +{ + FloatParts64 p64; + FloatParts128 p128; + + float32_unpack_canonical(&p64, a, s); + parts_float_to_float_widen(&p128, &p64, s); + return float128_round_pack_canonical(&p128, s); +} + +float128 float64_to_float128(float64 a, float_status *s) +{ + FloatParts64 p64; + FloatParts128 p128; + + float64_unpack_canonical(&p64, a, s); + parts_float_to_float_widen(&p128, &p64, s); + return float128_round_pack_canonical(&p128, s); +} + /* * Rounds the floating-point value `a' to an integer, and returns the * result as a floating-point value. The operation is performed @@ -5175,38 +5244,6 @@ floatx80 float32_to_floatx80(float32 a, float_status= *status) =20 } =20 -/*------------------------------------------------------------------------= ---- -| Returns the result of converting the single-precision floating-point val= ue -| `a' to the double-precision floating-point format. The conversion is -| performed according to the IEC/IEEE Standard for Binary Floating-Point -| Arithmetic. -*-------------------------------------------------------------------------= ---*/ - -float128 float32_to_float128(float32 a, float_status *status) -{ - bool aSign; - int aExp; - uint32_t aSig; - - a =3D float32_squash_input_denormal(a, status); - aSig =3D extractFloat32Frac( a ); - aExp =3D extractFloat32Exp( a ); - aSign =3D extractFloat32Sign( a ); - if ( aExp =3D=3D 0xFF ) { - if (aSig) { - return commonNaNToFloat128(float32ToCommonNaN(a, status), stat= us); - } - return packFloat128( aSign, 0x7FFF, 0, 0 ); - } - if ( aExp =3D=3D 0 ) { - if ( aSig =3D=3D 0 ) return packFloat128( aSign, 0, 0, 0 ); - normalizeFloat32Subnormal( aSig, &aExp, &aSig ); - --aExp; - } - return packFloat128( aSign, aExp + 0x3F80, ( (uint64_t) aSig )<<25, 0 = ); - -} - /*------------------------------------------------------------------------= ---- | Returns the remainder of the single-precision floating-point value `a' | with respect to the corresponding value `b'. The operation is performed @@ -5480,40 +5517,6 @@ floatx80 float64_to_floatx80(float64 a, float_status= *status) =20 } =20 -/*------------------------------------------------------------------------= ---- -| Returns the result of converting the double-precision floating-point val= ue -| `a' to the quadruple-precision floating-point format. The conversion is -| performed according to the IEC/IEEE Standard for Binary Floating-Point -| Arithmetic. -*-------------------------------------------------------------------------= ---*/ - -float128 float64_to_float128(float64 a, float_status *status) -{ - bool aSign; - int aExp; - uint64_t aSig, zSig0, zSig1; - - a =3D float64_squash_input_denormal(a, status); - aSig =3D extractFloat64Frac( a ); - aExp =3D extractFloat64Exp( a ); - aSign =3D extractFloat64Sign( a ); - if ( aExp =3D=3D 0x7FF ) { - if (aSig) { - return commonNaNToFloat128(float64ToCommonNaN(a, status), stat= us); - } - return packFloat128( aSign, 0x7FFF, 0, 0 ); - } - if ( aExp =3D=3D 0 ) { - if ( aSig =3D=3D 0 ) return packFloat128( aSign, 0, 0, 0 ); - normalizeFloat64Subnormal( aSig, &aExp, &aSig ); - --aExp; - } - shift128Right( aSig, 0, 4, &zSig0, &zSig1 ); - return packFloat128( aSign, aExp + 0x3C00, zSig0, zSig1 ); - -} - - /*------------------------------------------------------------------------= ---- | Returns the remainder of the double-precision floating-point value `a' | with respect to the corresponding value `b'. The operation is performed @@ -6915,74 +6918,6 @@ uint32_t float128_to_uint32(float128 a, float_status= *status) return res; } =20 -/*------------------------------------------------------------------------= ---- -| Returns the result of converting the quadruple-precision floating-point -| value `a' to the single-precision floating-point format. The conversion -| is performed according to the IEC/IEEE Standard for Binary Floating-Point -| Arithmetic. -*-------------------------------------------------------------------------= ---*/ - -float32 float128_to_float32(float128 a, float_status *status) -{ - bool aSign; - int32_t aExp; - uint64_t aSig0, aSig1; - uint32_t zSig; - - aSig1 =3D extractFloat128Frac1( a ); - aSig0 =3D extractFloat128Frac0( a ); - aExp =3D extractFloat128Exp( a ); - aSign =3D extractFloat128Sign( a ); - if ( aExp =3D=3D 0x7FFF ) { - if ( aSig0 | aSig1 ) { - return commonNaNToFloat32(float128ToCommonNaN(a, status), stat= us); - } - return packFloat32( aSign, 0xFF, 0 ); - } - aSig0 |=3D ( aSig1 !=3D 0 ); - shift64RightJamming( aSig0, 18, &aSig0 ); - zSig =3D aSig0; - if ( aExp || zSig ) { - zSig |=3D 0x40000000; - aExp -=3D 0x3F81; - } - return roundAndPackFloat32(aSign, aExp, zSig, status); - -} - -/*------------------------------------------------------------------------= ---- -| Returns the result of converting the quadruple-precision floating-point -| value `a' to the double-precision floating-point format. The conversion -| is performed according to the IEC/IEEE Standard for Binary Floating-Point -| Arithmetic. -*-------------------------------------------------------------------------= ---*/ - -float64 float128_to_float64(float128 a, float_status *status) -{ - bool aSign; - int32_t aExp; - uint64_t aSig0, aSig1; - - aSig1 =3D extractFloat128Frac1( a ); - aSig0 =3D extractFloat128Frac0( a ); - aExp =3D extractFloat128Exp( a ); - aSign =3D extractFloat128Sign( a ); - if ( aExp =3D=3D 0x7FFF ) { - if ( aSig0 | aSig1 ) { - return commonNaNToFloat64(float128ToCommonNaN(a, status), stat= us); - } - return packFloat64( aSign, 0x7FF, 0 ); - } - shortShift128Left( aSig0, aSig1, 14, &aSig0, &aSig1 ); - aSig0 |=3D ( aSig1 !=3D 0 ); - if ( aExp || aSig0 ) { - aSig0 |=3D UINT64_C(0x4000000000000000); - aExp -=3D 0x3C01; - } - return roundAndPackFloat64(aSign, aExp, aSig0, status); - -} - /*------------------------------------------------------------------------= ---- | Returns the result of converting the quadruple-precision floating-point | value `a' to the extended double-precision floating-point format. The --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621169791; cv=none; d=zohomail.com; s=zohoarc; b=WhZEEUwBwwUVVm2ZtE7q/YIf6D6+hBgLP1Mcc+3oxBipV1pX6quuWNRtRArlHxy7iwz3jwwEkLMi7ScYS7xSmdOl6f07QlP7uTynAOGBf7tUptfSUidP11KI5KAZEADrIIogNedM1OnCEuMWhPKxBQnYyO9E9Y3O7p5dEbSTy+Y= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621169791; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=OZDvLli2igstFJD87/ITs0fbiD+10ATx9SB8oW/xrxc=; b=bnT1kI0mle0AOYdKAoAYgfQstvFi7oXEX/012rVNCBV1N4NA8xgzjny11W2oz4tgld1+mBkftGW66VLhudVghtSQ+zOSBvVfimC98dZoBMl+mV/qLiRJstJs7Wm4GWP/7APe4QoMs+QGgwLks5eMGNGKgw57TceznFiCE12d/Ps= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 162116979173156.68815995680245; Sun, 16 May 2021 05:56:31 -0700 (PDT) Received: from localhost ([::1]:51480 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGJp-00030L-3m for importer@patchew.org; Sun, 16 May 2021 08:56:30 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:44014) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liG2A-0003m3-VL for qemu-devel@nongnu.org; Sun, 16 May 2021 08:38:14 -0400 Received: from mail-qv1-xf33.google.com ([2607:f8b0:4864:20::f33]:45999) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liG27-0001NT-Mk for qemu-devel@nongnu.org; Sun, 16 May 2021 08:38:14 -0400 Received: by mail-qv1-xf33.google.com with SMTP id h7so1210394qvs.12 for ; Sun, 16 May 2021 05:38:11 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id 195sm8180765qkj.1.2021.05.16.05.38.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:38:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=OZDvLli2igstFJD87/ITs0fbiD+10ATx9SB8oW/xrxc=; b=GNow779AGOPZZJFBWXsCJF/LD1wuQ/R7jcvBVsypyhP5G8azbBpaefyLTRbDjSHXf6 okgGK5n3Vszvbgu4SbIP2YKigcMkjf0hpHwIRthY+NE3u50+qXoVDCBTeKpO+xorgVDl 6n+ScKiqw1rsnEcPUrrmNDn4M49vCGIL6nXLOHrSC1IiX0a/oOv9bFzTj69hRw3SVjaJ JYJwUP7S1vPJynoAjiAZiZV1Yb1xYnHMTmGC+pQEYz8FUL9Z9U3ho8eqnwR6TPzpNK0y de6gEV+MUoDPOSNDSCaX1n08W9WpIDGh7RR6XuvOCOICkuOJJ9iWuHfTDgJnItsZ/X1+ 9Cyg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=OZDvLli2igstFJD87/ITs0fbiD+10ATx9SB8oW/xrxc=; b=pIFr+1OymWiumJnC8TkTRpL9pKWEbFf4+00/D6S3+LwP6zLFwpjP6NLKMpVnf4LnGE z9sZQxsJEwak0FYir3CBG9VuMhu6OrmaEzwZmgU6VbCN8zU35S8BtuFNvgYDDGBQOML1 gNYdEcDolMcV7g19cZr5omgi3l/wJX7Fa5fQ5PHkYSn8awmZWlQTXXgJHigvrdBRIzK+ aavvtiodw37Jw/YTcweY0KAjSoijOVtBUzm86+HftiwrcM7IUKR+YPrnMNVMLHitk6bw Xcgpqc0MCb31jiseCibuA6xT4AlHO9fkEYAGYVjmT/eHB2tVCGwZSK2k3Yzqd2oFvfOD kjQw== X-Gm-Message-State: AOAM533ctVcQdWDHHEpQGPcE3DQRrWvsvBGz/FlhI+LcbB7l4SovniyQ 85MjfJI9vGI7AqL8vje5kzgauNmtOb9tYrCBOEY= X-Google-Smtp-Source: ABdhPJw7n4SkiyFaqu8wcyqxHG4yqxCHJhjpcOk7uc9gEIDIpoCh7c+/Y4w+1QUKgdq8Q0WsP3LFvA== X-Received: by 2002:a05:6214:e8f:: with SMTP id hf15mr28465803qvb.51.1621168690671; Sun, 16 May 2021 05:38:10 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 45/46] softfloat: Move round_to_int to softfloat-parts.c.inc Date: Sun, 16 May 2021 07:34:30 -0500 Message-Id: <20210516123431.718318-46-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::f33; envelope-from=richard.henderson@linaro.org; helo=mail-qv1-xf33.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) At the same time, convert to pointers, split out parts$N_round_to_int_normal, define a macro for parts_round_to_int using QEMU_GENERIC. This necessarily meant some rearrangement to the rount_to_{,u}int_and_pack routines, so go ahead and convert to parts_round_to_int_normal, which in turn allows cleaning up of the raised exception handling. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 434 ++++++++++---------------------------- fpu/softfloat-parts.c.inc | 157 ++++++++++++++ 2 files changed, 263 insertions(+), 328 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index d056b5730b..5647a05d5d 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -811,6 +811,24 @@ static FloatParts128 *parts128_div(FloatParts128 *a, F= loatParts128 *b, #define parts_div(A, B, S) \ PARTS_GENERIC_64_128(div, A)(A, B, S) =20 +static bool parts64_round_to_int_normal(FloatParts64 *a, FloatRoundMode rm, + int scale, int frac_size); +static bool parts128_round_to_int_normal(FloatParts128 *a, FloatRoundMode = r, + int scale, int frac_size); + +#define parts_round_to_int_normal(A, R, C, F) \ + PARTS_GENERIC_64_128(round_to_int_normal, A)(A, R, C, F) + +static void parts64_round_to_int(FloatParts64 *a, FloatRoundMode rm, + int scale, float_status *s, + const FloatFmt *fmt); +static void parts128_round_to_int(FloatParts128 *a, FloatRoundMode r, + int scale, float_status *s, + const FloatFmt *fmt); + +#define parts_round_to_int(A, R, C, S, F) \ + PARTS_GENERIC_64_128(round_to_int, A)(A, R, C, S, F) + /* * Helper functions for softfloat-parts.c.inc, per-size operations. */ @@ -2285,153 +2303,52 @@ float128 float64_to_float128(float64 a, float_stat= us *s) } =20 /* - * Rounds the floating-point value `a' to an integer, and returns the - * result as a floating-point value. The operation is performed - * according to the IEC/IEEE Standard for Binary Floating-Point - * Arithmetic. + * Round to integral value */ =20 -static FloatParts64 round_to_int(FloatParts64 a, FloatRoundMode rmode, - int scale, float_status *s) -{ - switch (a.cls) { - case float_class_qnan: - case float_class_snan: - parts_return_nan(&a, s); - break; - - case float_class_zero: - case float_class_inf: - /* already "integral" */ - break; - - case float_class_normal: - scale =3D MIN(MAX(scale, -0x10000), 0x10000); - a.exp +=3D scale; - - if (a.exp >=3D DECOMPOSED_BINARY_POINT) { - /* already integral */ - break; - } - if (a.exp < 0) { - bool one; - /* all fractional */ - float_raise(float_flag_inexact, s); - switch (rmode) { - case float_round_nearest_even: - one =3D a.exp =3D=3D -1 && a.frac > DECOMPOSED_IMPLICIT_BI= T; - break; - case float_round_ties_away: - one =3D a.exp =3D=3D -1 && a.frac >=3D DECOMPOSED_IMPLICIT= _BIT; - break; - case float_round_to_zero: - one =3D false; - break; - case float_round_up: - one =3D !a.sign; - break; - case float_round_down: - one =3D a.sign; - break; - case float_round_to_odd: - one =3D true; - break; - default: - g_assert_not_reached(); - } - - if (one) { - a.frac =3D DECOMPOSED_IMPLICIT_BIT; - a.exp =3D 0; - } else { - a.cls =3D float_class_zero; - } - } else { - uint64_t frac_lsb =3D DECOMPOSED_IMPLICIT_BIT >> a.exp; - uint64_t frac_lsbm1 =3D frac_lsb >> 1; - uint64_t rnd_even_mask =3D (frac_lsb - 1) | frac_lsb; - uint64_t rnd_mask =3D rnd_even_mask >> 1; - uint64_t inc; - - switch (rmode) { - case float_round_nearest_even: - inc =3D ((a.frac & rnd_even_mask) !=3D frac_lsbm1 ? frac_l= sbm1 : 0); - break; - case float_round_ties_away: - inc =3D frac_lsbm1; - break; - case float_round_to_zero: - inc =3D 0; - break; - case float_round_up: - inc =3D a.sign ? 0 : rnd_mask; - break; - case float_round_down: - inc =3D a.sign ? rnd_mask : 0; - break; - case float_round_to_odd: - inc =3D a.frac & frac_lsb ? 0 : rnd_mask; - break; - default: - g_assert_not_reached(); - } - - if (a.frac & rnd_mask) { - float_raise(float_flag_inexact, s); - if (uadd64_overflow(a.frac, inc, &a.frac)) { - a.frac >>=3D 1; - a.frac |=3D DECOMPOSED_IMPLICIT_BIT; - a.exp++; - } - a.frac &=3D ~rnd_mask; - } - } - break; - default: - g_assert_not_reached(); - } - return a; -} - float16 float16_round_to_int(float16 a, float_status *s) { - FloatParts64 pa, pr; + FloatParts64 p; =20 - float16_unpack_canonical(&pa, a, s); - pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); - return float16_round_pack_canonical(&pr, s); + float16_unpack_canonical(&p, a, s); + parts_round_to_int(&p, s->float_rounding_mode, 0, s, &float16_params); + return float16_round_pack_canonical(&p, s); } =20 float32 float32_round_to_int(float32 a, float_status *s) { - FloatParts64 pa, pr; + FloatParts64 p; =20 - float32_unpack_canonical(&pa, a, s); - pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); - return float32_round_pack_canonical(&pr, s); + float32_unpack_canonical(&p, a, s); + parts_round_to_int(&p, s->float_rounding_mode, 0, s, &float32_params); + return float32_round_pack_canonical(&p, s); } =20 float64 float64_round_to_int(float64 a, float_status *s) { - FloatParts64 pa, pr; + FloatParts64 p; =20 - float64_unpack_canonical(&pa, a, s); - pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); - return float64_round_pack_canonical(&pr, s); + float64_unpack_canonical(&p, a, s); + parts_round_to_int(&p, s->float_rounding_mode, 0, s, &float64_params); + return float64_round_pack_canonical(&p, s); } =20 -/* - * Rounds the bfloat16 value `a' to an integer, and returns the - * result as a bfloat16 value. - */ - bfloat16 bfloat16_round_to_int(bfloat16 a, float_status *s) { - FloatParts64 pa, pr; + FloatParts64 p; =20 - bfloat16_unpack_canonical(&pa, a, s); - pr =3D round_to_int(pa, s->float_rounding_mode, 0, s); - return bfloat16_round_pack_canonical(&pr, s); + bfloat16_unpack_canonical(&p, a, s); + parts_round_to_int(&p, s->float_rounding_mode, 0, s, &bfloat16_params); + return bfloat16_round_pack_canonical(&p, s); +} + +float128 float128_round_to_int(float128 a, float_status *s) +{ + FloatParts128 p; + + float128_unpack_canonical(&p, a, s); + parts_round_to_int(&p, s->float_rounding_mode, 0, s, &float128_params); + return float128_round_pack_canonical(&p, s); } =20 /* @@ -2445,48 +2362,58 @@ bfloat16 bfloat16_round_to_int(bfloat16 a, float_st= atus *s) * is returned. */ =20 -static int64_t round_to_int_and_pack(FloatParts64 in, FloatRoundMode rmode, +static int64_t round_to_int_and_pack(FloatParts64 p, FloatRoundMode rmode, int scale, int64_t min, int64_t max, float_status *s) { + int flags =3D 0; uint64_t r; - int orig_flags =3D get_float_exception_flags(s); - FloatParts64 p =3D round_to_int(in, rmode, scale, s); =20 switch (p.cls) { case float_class_snan: case float_class_qnan: - s->float_exception_flags =3D orig_flags | float_flag_invalid; - return max; + flags =3D float_flag_invalid; + r =3D max; + break; + case float_class_inf: - s->float_exception_flags =3D orig_flags | float_flag_invalid; - return p.sign ? min : max; + flags =3D float_flag_invalid; + r =3D p.sign ? min : max; + break; + case float_class_zero: return 0; + case float_class_normal: + /* TODO: 62 =3D N - 2, frac_size for rounding */ + if (parts_round_to_int_normal(&p, rmode, scale, 62)) { + flags =3D float_flag_inexact; + } + if (p.exp <=3D DECOMPOSED_BINARY_POINT) { r =3D p.frac >> (DECOMPOSED_BINARY_POINT - p.exp); } else { r =3D UINT64_MAX; } if (p.sign) { - if (r <=3D -(uint64_t) min) { - return -r; + if (r <=3D -(uint64_t)min) { + r =3D -r; } else { - s->float_exception_flags =3D orig_flags | float_flag_inval= id; - return min; - } - } else { - if (r <=3D max) { - return r; - } else { - s->float_exception_flags =3D orig_flags | float_flag_inval= id; - return max; + flags =3D float_flag_invalid; + r =3D min; } + } else if (r > max) { + flags =3D float_flag_invalid; + r =3D max; } + break; + default: g_assert_not_reached(); } + + float_raise(flags, s); + return r; } =20 int8_t float16_to_int8_scalbn(float16 a, FloatRoundMode rmode, int scale, @@ -2749,49 +2676,59 @@ int64_t bfloat16_to_int64_round_to_zero(bfloat16 a,= float_status *s) * flag. */ =20 -static uint64_t round_to_uint_and_pack(FloatParts64 in, FloatRoundMode rmo= de, +static uint64_t round_to_uint_and_pack(FloatParts64 p, FloatRoundMode rmod= e, int scale, uint64_t max, float_status *s) { - int orig_flags =3D get_float_exception_flags(s); - FloatParts64 p =3D round_to_int(in, rmode, scale, s); + int flags =3D 0; uint64_t r; =20 switch (p.cls) { case float_class_snan: case float_class_qnan: - s->float_exception_flags =3D orig_flags | float_flag_invalid; - return max; + flags =3D float_flag_invalid; + r =3D max; + break; + case float_class_inf: - s->float_exception_flags =3D orig_flags | float_flag_invalid; - return p.sign ? 0 : max; + flags =3D float_flag_invalid; + r =3D p.sign ? 0 : max; + break; + case float_class_zero: return 0; + case float_class_normal: + /* TODO: 62 =3D N - 2, frac_size for rounding */ + if (parts_round_to_int_normal(&p, rmode, scale, 62)) { + flags =3D float_flag_inexact; + if (p.cls =3D=3D float_class_zero) { + r =3D 0; + break; + } + } + if (p.sign) { - s->float_exception_flags =3D orig_flags | float_flag_invalid; - return 0; - } - - if (p.exp <=3D DECOMPOSED_BINARY_POINT) { - r =3D p.frac >> (DECOMPOSED_BINARY_POINT - p.exp); + flags =3D float_flag_invalid; + r =3D 0; + } else if (p.exp > DECOMPOSED_BINARY_POINT) { + flags =3D float_flag_invalid; + r =3D max; } else { - s->float_exception_flags =3D orig_flags | float_flag_invalid; - return max; + r =3D p.frac >> (DECOMPOSED_BINARY_POINT - p.exp); + if (r > max) { + flags =3D float_flag_invalid; + r =3D max; + } } + break; =20 - /* For uint64 this will never trip, but if p.exp is too large - * to shift a decomposed fraction we shall have exited via the - * 3rd leg above. - */ - if (r > max) { - s->float_exception_flags =3D orig_flags | float_flag_invalid; - return max; - } - return r; default: g_assert_not_reached(); } + + float_raise(flags, s); + return r; } =20 uint8_t float16_to_uint8_scalbn(float16 a, FloatRoundMode rmode, int scale, @@ -6956,165 +6893,6 @@ floatx80 float128_to_floatx80(float128 a, float_sta= tus *status) =20 } =20 -/*------------------------------------------------------------------------= ---- -| Rounds the quadruple-precision floating-point value `a' to an integer, a= nd -| returns the result as a quadruple-precision floating-point value. The -| operation is performed according to the IEC/IEEE Standard for Binary -| Floating-Point Arithmetic. -*-------------------------------------------------------------------------= ---*/ - -float128 float128_round_to_int(float128 a, float_status *status) -{ - bool aSign; - int32_t aExp; - uint64_t lastBitMask, roundBitsMask; - float128 z; - - aExp =3D extractFloat128Exp( a ); - if ( 0x402F <=3D aExp ) { - if ( 0x406F <=3D aExp ) { - if ( ( aExp =3D=3D 0x7FFF ) - && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a = ) ) - ) { - return propagateFloat128NaN(a, a, status); - } - return a; - } - lastBitMask =3D 1; - lastBitMask =3D ( lastBitMask<<( 0x406E - aExp ) )<<1; - roundBitsMask =3D lastBitMask - 1; - z =3D a; - switch (status->float_rounding_mode) { - case float_round_nearest_even: - if ( lastBitMask ) { - add128( z.high, z.low, 0, lastBitMask>>1, &z.high, &z.low = ); - if ( ( z.low & roundBitsMask ) =3D=3D 0 ) z.low &=3D ~ las= tBitMask; - } - else { - if ( (int64_t) z.low < 0 ) { - ++z.high; - if ( (uint64_t) ( z.low<<1 ) =3D=3D 0 ) z.high &=3D ~1; - } - } - break; - case float_round_ties_away: - if (lastBitMask) { - add128(z.high, z.low, 0, lastBitMask >> 1, &z.high, &z.low= ); - } else { - if ((int64_t) z.low < 0) { - ++z.high; - } - } - break; - case float_round_to_zero: - break; - case float_round_up: - if (!extractFloat128Sign(z)) { - add128(z.high, z.low, 0, roundBitsMask, &z.high, &z.low); - } - break; - case float_round_down: - if (extractFloat128Sign(z)) { - add128(z.high, z.low, 0, roundBitsMask, &z.high, &z.low); - } - break; - case float_round_to_odd: - /* - * Note that if lastBitMask =3D=3D 0, the last bit is the lsb - * of high, and roundBitsMask =3D=3D -1. - */ - if ((lastBitMask ? z.low & lastBitMask : z.high & 1) =3D=3D 0)= { - add128(z.high, z.low, 0, roundBitsMask, &z.high, &z.low); - } - break; - default: - abort(); - } - z.low &=3D ~ roundBitsMask; - } - else { - if ( aExp < 0x3FFF ) { - if ( ( ( (uint64_t) ( a.high<<1 ) ) | a.low ) =3D=3D 0 ) retur= n a; - float_raise(float_flag_inexact, status); - aSign =3D extractFloat128Sign( a ); - switch (status->float_rounding_mode) { - case float_round_nearest_even: - if ( ( aExp =3D=3D 0x3FFE ) - && ( extractFloat128Frac0( a ) - | extractFloat128Frac1( a ) ) - ) { - return packFloat128( aSign, 0x3FFF, 0, 0 ); - } - break; - case float_round_ties_away: - if (aExp =3D=3D 0x3FFE) { - return packFloat128(aSign, 0x3FFF, 0, 0); - } - break; - case float_round_down: - return - aSign ? packFloat128( 1, 0x3FFF, 0, 0 ) - : packFloat128( 0, 0, 0, 0 ); - case float_round_up: - return - aSign ? packFloat128( 1, 0, 0, 0 ) - : packFloat128( 0, 0x3FFF, 0, 0 ); - - case float_round_to_odd: - return packFloat128(aSign, 0x3FFF, 0, 0); - - case float_round_to_zero: - break; - } - return packFloat128( aSign, 0, 0, 0 ); - } - lastBitMask =3D 1; - lastBitMask <<=3D 0x402F - aExp; - roundBitsMask =3D lastBitMask - 1; - z.low =3D 0; - z.high =3D a.high; - switch (status->float_rounding_mode) { - case float_round_nearest_even: - z.high +=3D lastBitMask>>1; - if ( ( ( z.high & roundBitsMask ) | a.low ) =3D=3D 0 ) { - z.high &=3D ~ lastBitMask; - } - break; - case float_round_ties_away: - z.high +=3D lastBitMask>>1; - break; - case float_round_to_zero: - break; - case float_round_up: - if (!extractFloat128Sign(z)) { - z.high |=3D ( a.low !=3D 0 ); - z.high +=3D roundBitsMask; - } - break; - case float_round_down: - if (extractFloat128Sign(z)) { - z.high |=3D (a.low !=3D 0); - z.high +=3D roundBitsMask; - } - break; - case float_round_to_odd: - if ((z.high & lastBitMask) =3D=3D 0) { - z.high |=3D (a.low !=3D 0); - z.high +=3D roundBitsMask; - } - break; - default: - abort(); - } - z.high &=3D ~ roundBitsMask; - } - if ( ( z.low !=3D a.low ) || ( z.high !=3D a.high ) ) { - float_raise(float_flag_inexact, status); - } - return z; - -} - /*------------------------------------------------------------------------= ---- | Returns the remainder of the quadruple-precision floating-point value `a' | with respect to the corresponding value `b'. The operation is performed diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc index f8165d92f9..b2c4624d8c 100644 --- a/fpu/softfloat-parts.c.inc +++ b/fpu/softfloat-parts.c.inc @@ -594,3 +594,160 @@ static FloatPartsN *partsN(div)(FloatPartsN *a, Float= PartsN *b, a->cls =3D float_class_inf; return a; } + +/* + * Rounds the floating-point value `a' to an integer, and returns the + * result as a floating-point value. The operation is performed + * according to the IEC/IEEE Standard for Binary Floating-Point + * Arithmetic. + * + * parts_round_to_int_normal is an internal helper function for + * normal numbers only, returning true for inexact but not directly + * raising float_flag_inexact. + */ +static bool partsN(round_to_int_normal)(FloatPartsN *a, FloatRoundMode rmo= de, + int scale, int frac_size) +{ + uint64_t frac_lsb, frac_lsbm1, rnd_even_mask, rnd_mask, inc; + int shift_adj; + + scale =3D MIN(MAX(scale, -0x10000), 0x10000); + a->exp +=3D scale; + + if (a->exp < 0) { + bool one; + + /* All fractional */ + switch (rmode) { + case float_round_nearest_even: + one =3D false; + if (a->exp =3D=3D -1) { + FloatPartsN tmp; + /* Shift left one, discarding DECOMPOSED_IMPLICIT_BIT */ + frac_add(&tmp, a, a); + /* Anything remaining means frac > 0.5. */ + one =3D !frac_eqz(&tmp); + } + break; + case float_round_ties_away: + one =3D a->exp =3D=3D -1; + break; + case float_round_to_zero: + one =3D false; + break; + case float_round_up: + one =3D !a->sign; + break; + case float_round_down: + one =3D a->sign; + break; + case float_round_to_odd: + one =3D true; + break; + default: + g_assert_not_reached(); + } + + frac_clear(a); + a->exp =3D 0; + if (one) { + a->frac_hi =3D DECOMPOSED_IMPLICIT_BIT; + } else { + a->cls =3D float_class_zero; + } + return true; + } + + if (a->exp >=3D frac_size) { + /* All integral */ + return false; + } + + if (N > 64 && a->exp < N - 64) { + /* + * Rounding is not in the low word -- shift lsb to bit 2, + * which leaves room for sticky and rounding bit. + */ + shift_adj =3D (N - 1) - (a->exp + 2); + frac_shrjam(a, shift_adj); + frac_lsb =3D 1 << 2; + } else { + shift_adj =3D 0; + frac_lsb =3D DECOMPOSED_IMPLICIT_BIT >> (a->exp & 63); + } + + frac_lsbm1 =3D frac_lsb >> 1; + rnd_mask =3D frac_lsb - 1; + rnd_even_mask =3D rnd_mask | frac_lsb; + + if (!(a->frac_lo & rnd_mask)) { + /* Fractional bits already clear, undo the shift above. */ + frac_shl(a, shift_adj); + return false; + } + + switch (rmode) { + case float_round_nearest_even: + inc =3D ((a->frac_lo & rnd_even_mask) !=3D frac_lsbm1 ? frac_lsbm1= : 0); + break; + case float_round_ties_away: + inc =3D frac_lsbm1; + break; + case float_round_to_zero: + inc =3D 0; + break; + case float_round_up: + inc =3D a->sign ? 0 : rnd_mask; + break; + case float_round_down: + inc =3D a->sign ? rnd_mask : 0; + break; + case float_round_to_odd: + inc =3D a->frac_lo & frac_lsb ? 0 : rnd_mask; + break; + default: + g_assert_not_reached(); + } + + if (shift_adj =3D=3D 0) { + if (frac_addi(a, a, inc)) { + frac_shr(a, 1); + a->frac_hi |=3D DECOMPOSED_IMPLICIT_BIT; + a->exp++; + } + a->frac_lo &=3D ~rnd_mask; + } else { + frac_addi(a, a, inc); + a->frac_lo &=3D ~rnd_mask; + /* Be careful shifting back, not to overflow */ + frac_shl(a, shift_adj - 1); + if (a->frac_hi & DECOMPOSED_IMPLICIT_BIT) { + a->exp++; + } else { + frac_add(a, a, a); + } + } + return true; +} + +static void partsN(round_to_int)(FloatPartsN *a, FloatRoundMode rmode, + int scale, float_status *s, + const FloatFmt *fmt) +{ + switch (a->cls) { + case float_class_qnan: + case float_class_snan: + parts_return_nan(a, s); + break; + case float_class_zero: + case float_class_inf: + break; + case float_class_normal: + if (parts_round_to_int_normal(a, rmode, scale, fmt->frac_size)) { + float_raise(float_flag_inexact, s); + } + break; + default: + g_assert_not_reached(); + } +} --=20 2.25.1 From nobody Mon May 13 12:58:07 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1621170623; cv=none; d=zohomail.com; s=zohoarc; b=IE06lwj/ZtRBq9kaXMn0zZrBAq350o4Yu+PfVjxlKXoy5x124aBFk4YprBP045Tk4S2URF/19Aoyk2E+dRnsaZ+xqwAjDbiFJ2c8fDnoJq3B41X3RnMMPzSFnw8ih2oxaAcTia2c/uMBz2gLk08UrYzsFkZVhoPemYzQUaZe/iY= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1621170623; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=hGH6lSBF2ucXpR+KjGUauv5JDd302RCzJcJtTVF6swc=; b=VE7P5YuuL7FlmBMqwVaszvYEkdjtc/lgiwHbw60vfKnKTvQDDqJ0Kb+Fy8NRp0wts5HK39MB6SEKgQPwtctwsUpAV/mX65BgZmesVrTdF6SmdU7EmK3oMM58WGixYHt24ZxU6JGzqwL4ZqCYrBr+egm1HPM2qJVNR2kaLF8+xpY= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1621170623376485.38957913599165; Sun, 16 May 2021 06:10:23 -0700 (PDT) Received: from localhost ([::1]:40604 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1liGXG-0008O6-9s for importer@patchew.org; Sun, 16 May 2021 09:10:22 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:44028) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1liG2C-0003r1-7V for qemu-devel@nongnu.org; Sun, 16 May 2021 08:38:16 -0400 Received: from mail-qv1-xf2a.google.com ([2607:f8b0:4864:20::f2a]:34656) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1liG28-0001OJ-OO for qemu-devel@nongnu.org; Sun, 16 May 2021 08:38:15 -0400 Received: by mail-qv1-xf2a.google.com with SMTP id o59so1879831qva.1 for ; Sun, 16 May 2021 05:38:12 -0700 (PDT) Received: from localhost.localdomain (163.189-204-200.bestelclientes.com.mx. [189.204.200.163]) by smtp.gmail.com with ESMTPSA id 195sm8180765qkj.1.2021.05.16.05.38.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 16 May 2021 05:38:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=hGH6lSBF2ucXpR+KjGUauv5JDd302RCzJcJtTVF6swc=; b=wbbIU4Ki4ry4K+xVhpt0OE/D91iR+I5VKEQ7NWJkRIr408sOG8h6PGIWh4UiB/DPha XbFXd6swxF7OqQ4UpeUcrTqvR8edru8K3qC0tOQOSXtvR418OfxwGA4hffk/6nU46XWj uVsj26fTWg7g6neudksSDcyu0JkSzUCdSlu//bpRX+aw0S4Z02Uh9pyV6Gp/oyil3swB 6GTM/n+/fwlzQN3e7u6qdtkbcIPOXmYvbzfXof6dpSLoR/EijF9Jgs5XogHquidMCQ+Y CYmc0VDiPpfPNSXrgfAzMuQCxwThW55HWJLWiaHgtmyxHhwzqd8jiqVNh8CK/9X6Quy6 oB5g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=hGH6lSBF2ucXpR+KjGUauv5JDd302RCzJcJtTVF6swc=; b=F+IcuU3OT1ijW80dlzpDoeXBItFMmqKXWBVv6vD7tgEzpS44mEnYlzAPPHJCnMz5J+ Nr2QW2JFQegBTtn4qD3prdpz9rMrrl5kDlhJ9shAdsv2vFag5gkOcSXnloTpQUveLzfy HinXCuL1XEaD0LQ+TCGZuigF0i07b+MNqxnUkUKTiJuDXU8I1DDIu40rvt37aY7BkbCZ Mr6MI+0Uvy8yp3pptEiJFz+jR52VS2N+P29Yqeh03elRhL47m7TTXjotN3YKWhsg+NBF 0FUO45PAL2BuD9zKxHmwCyLf57XRkXqpGq1xjxqqrif10E5iZB63kAY0FngXHCYyETy4 iR0g== X-Gm-Message-State: AOAM533uN2Yvm6OyLp+Kf7UAKOiwp68CP/6KTW7y/0bPLXdHxIpHab5a w6d5tZncxB1cpkAbclp00b1CKi3SzjqCVEL9P28= X-Google-Smtp-Source: ABdhPJzGNMP3ovL78eSXeEDCFU8tSVGDqeZ8h2wCqm8YJ7phKWNiL9Fop8F2rIhCKeohdWlByDl1aQ== X-Received: by 2002:a0c:e6c5:: with SMTP id l5mr55790665qvn.2.1621168691690; Sun, 16 May 2021 05:38:11 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Subject: [PULL 46/46] softfloat: Move round_to_int_and_pack to softfloat-parts.c.inc Date: Sun, 16 May 2021 07:34:31 -0500 Message-Id: <20210516123431.718318-47-richard.henderson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210516123431.718318-1-richard.henderson@linaro.org> References: <20210516123431.718318-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::f2a; envelope-from=richard.henderson@linaro.org; helo=mail-qv1-xf2a.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, =?UTF-8?q?Alex=20Benn=C3=A9e?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @linaro.org) Rename to parts$N_float_to_sint. Reimplement float128_to_int{32,64}{_round_to_zero} with FloatParts128. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- fpu/softfloat.c | 365 +++++++++----------------------------- fpu/softfloat-parts.c.inc | 64 +++++++ 2 files changed, 145 insertions(+), 284 deletions(-) diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 5647a05d5d..0dc2203477 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -829,6 +829,16 @@ static void parts128_round_to_int(FloatParts128 *a, Fl= oatRoundMode r, #define parts_round_to_int(A, R, C, S, F) \ PARTS_GENERIC_64_128(round_to_int, A)(A, R, C, S, F) =20 +static int64_t parts64_float_to_sint(FloatParts64 *p, FloatRoundMode rmode, + int scale, int64_t min, int64_t max, + float_status *s); +static int64_t parts128_float_to_sint(FloatParts128 *p, FloatRoundMode rmo= de, + int scale, int64_t min, int64_t max, + float_status *s); + +#define parts_float_to_sint(P, R, Z, MN, MX, S) \ + PARTS_GENERIC_64_128(float_to_sint, P)(P, R, Z, MN, MX, S) + /* * Helper functions for softfloat-parts.c.inc, per-size operations. */ @@ -2352,69 +2362,8 @@ float128 float128_round_to_int(float128 a, float_sta= tus *s) } =20 /* - * Returns the result of converting the floating-point value `a' to - * the two's complement integer format. The conversion is performed - * according to the IEC/IEEE Standard for Binary Floating-Point - * Arithmetic---which means in particular that the conversion is - * rounded according to the current rounding mode. If `a' is a NaN, - * the largest positive integer is returned. Otherwise, if the - * conversion overflows, the largest integer with the same sign as `a' - * is returned. -*/ - -static int64_t round_to_int_and_pack(FloatParts64 p, FloatRoundMode rmode, - int scale, int64_t min, int64_t max, - float_status *s) -{ - int flags =3D 0; - uint64_t r; - - switch (p.cls) { - case float_class_snan: - case float_class_qnan: - flags =3D float_flag_invalid; - r =3D max; - break; - - case float_class_inf: - flags =3D float_flag_invalid; - r =3D p.sign ? min : max; - break; - - case float_class_zero: - return 0; - - case float_class_normal: - /* TODO: 62 =3D N - 2, frac_size for rounding */ - if (parts_round_to_int_normal(&p, rmode, scale, 62)) { - flags =3D float_flag_inexact; - } - - if (p.exp <=3D DECOMPOSED_BINARY_POINT) { - r =3D p.frac >> (DECOMPOSED_BINARY_POINT - p.exp); - } else { - r =3D UINT64_MAX; - } - if (p.sign) { - if (r <=3D -(uint64_t)min) { - r =3D -r; - } else { - flags =3D float_flag_invalid; - r =3D min; - } - } else if (r > max) { - flags =3D float_flag_invalid; - r =3D max; - } - break; - - default: - g_assert_not_reached(); - } - - float_raise(flags, s); - return r; -} + * Floating-point to signed integer conversions + */ =20 int8_t float16_to_int8_scalbn(float16 a, FloatRoundMode rmode, int scale, float_status *s) @@ -2422,7 +2371,7 @@ int8_t float16_to_int8_scalbn(float16 a, FloatRoundMo= de rmode, int scale, FloatParts64 p; =20 float16_unpack_canonical(&p, a, s); - return round_to_int_and_pack(p, rmode, scale, INT8_MIN, INT8_MAX, s); + return parts_float_to_sint(&p, rmode, scale, INT8_MIN, INT8_MAX, s); } =20 int16_t float16_to_int16_scalbn(float16 a, FloatRoundMode rmode, int scale, @@ -2431,7 +2380,7 @@ int16_t float16_to_int16_scalbn(float16 a, FloatRound= Mode rmode, int scale, FloatParts64 p; =20 float16_unpack_canonical(&p, a, s); - return round_to_int_and_pack(p, rmode, scale, INT16_MIN, INT16_MAX, s); + return parts_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s); } =20 int32_t float16_to_int32_scalbn(float16 a, FloatRoundMode rmode, int scale, @@ -2440,7 +2389,7 @@ int32_t float16_to_int32_scalbn(float16 a, FloatRound= Mode rmode, int scale, FloatParts64 p; =20 float16_unpack_canonical(&p, a, s); - return round_to_int_and_pack(p, rmode, scale, INT32_MIN, INT32_MAX, s); + return parts_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s); } =20 int64_t float16_to_int64_scalbn(float16 a, FloatRoundMode rmode, int scale, @@ -2449,7 +2398,7 @@ int64_t float16_to_int64_scalbn(float16 a, FloatRound= Mode rmode, int scale, FloatParts64 p; =20 float16_unpack_canonical(&p, a, s); - return round_to_int_and_pack(p, rmode, scale, INT64_MIN, INT64_MAX, s); + return parts_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s); } =20 int16_t float32_to_int16_scalbn(float32 a, FloatRoundMode rmode, int scale, @@ -2458,7 +2407,7 @@ int16_t float32_to_int16_scalbn(float32 a, FloatRound= Mode rmode, int scale, FloatParts64 p; =20 float32_unpack_canonical(&p, a, s); - return round_to_int_and_pack(p, rmode, scale, INT16_MIN, INT16_MAX, s); + return parts_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s); } =20 int32_t float32_to_int32_scalbn(float32 a, FloatRoundMode rmode, int scale, @@ -2467,7 +2416,7 @@ int32_t float32_to_int32_scalbn(float32 a, FloatRound= Mode rmode, int scale, FloatParts64 p; =20 float32_unpack_canonical(&p, a, s); - return round_to_int_and_pack(p, rmode, scale, INT32_MIN, INT32_MAX, s); + return parts_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s); } =20 int64_t float32_to_int64_scalbn(float32 a, FloatRoundMode rmode, int scale, @@ -2476,7 +2425,7 @@ int64_t float32_to_int64_scalbn(float32 a, FloatRound= Mode rmode, int scale, FloatParts64 p; =20 float32_unpack_canonical(&p, a, s); - return round_to_int_and_pack(p, rmode, scale, INT64_MIN, INT64_MAX, s); + return parts_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s); } =20 int16_t float64_to_int16_scalbn(float64 a, FloatRoundMode rmode, int scale, @@ -2485,7 +2434,7 @@ int16_t float64_to_int16_scalbn(float64 a, FloatRound= Mode rmode, int scale, FloatParts64 p; =20 float64_unpack_canonical(&p, a, s); - return round_to_int_and_pack(p, rmode, scale, INT16_MIN, INT16_MAX, s); + return parts_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s); } =20 int32_t float64_to_int32_scalbn(float64 a, FloatRoundMode rmode, int scale, @@ -2494,7 +2443,7 @@ int32_t float64_to_int32_scalbn(float64 a, FloatRound= Mode rmode, int scale, FloatParts64 p; =20 float64_unpack_canonical(&p, a, s); - return round_to_int_and_pack(p, rmode, scale, INT32_MIN, INT32_MAX, s); + return parts_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s); } =20 int64_t float64_to_int64_scalbn(float64 a, FloatRoundMode rmode, int scale, @@ -2503,7 +2452,52 @@ int64_t float64_to_int64_scalbn(float64 a, FloatRoun= dMode rmode, int scale, FloatParts64 p; =20 float64_unpack_canonical(&p, a, s); - return round_to_int_and_pack(p, rmode, scale, INT64_MIN, INT64_MAX, s); + return parts_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s); +} + +int16_t bfloat16_to_int16_scalbn(bfloat16 a, FloatRoundMode rmode, int sca= le, + float_status *s) +{ + FloatParts64 p; + + bfloat16_unpack_canonical(&p, a, s); + return parts_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s); +} + +int32_t bfloat16_to_int32_scalbn(bfloat16 a, FloatRoundMode rmode, int sca= le, + float_status *s) +{ + FloatParts64 p; + + bfloat16_unpack_canonical(&p, a, s); + return parts_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s); +} + +int64_t bfloat16_to_int64_scalbn(bfloat16 a, FloatRoundMode rmode, int sca= le, + float_status *s) +{ + FloatParts64 p; + + bfloat16_unpack_canonical(&p, a, s); + return parts_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s); +} + +static int32_t float128_to_int32_scalbn(float128 a, FloatRoundMode rmode, + int scale, float_status *s) +{ + FloatParts128 p; + + float128_unpack_canonical(&p, a, s); + return parts_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s); +} + +static int64_t float128_to_int64_scalbn(float128 a, FloatRoundMode rmode, + int scale, float_status *s) +{ + FloatParts128 p; + + float128_unpack_canonical(&p, a, s); + return parts_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s); } =20 int8_t float16_to_int8(float16 a, float_status *s) @@ -2556,6 +2550,16 @@ int64_t float64_to_int64(float64 a, float_status *s) return float64_to_int64_scalbn(a, s->float_rounding_mode, 0, s); } =20 +int32_t float128_to_int32(float128 a, float_status *s) +{ + return float128_to_int32_scalbn(a, s->float_rounding_mode, 0, s); +} + +int64_t float128_to_int64(float128 a, float_status *s) +{ + return float128_to_int64_scalbn(a, s->float_rounding_mode, 0, s); +} + int16_t float16_to_int16_round_to_zero(float16 a, float_status *s) { return float16_to_int16_scalbn(a, float_round_to_zero, 0, s); @@ -2601,36 +2605,14 @@ int64_t float64_to_int64_round_to_zero(float64 a, f= loat_status *s) return float64_to_int64_scalbn(a, float_round_to_zero, 0, s); } =20 -/* - * Returns the result of converting the floating-point value `a' to - * the two's complement integer format. - */ - -int16_t bfloat16_to_int16_scalbn(bfloat16 a, FloatRoundMode rmode, int sca= le, - float_status *s) +int32_t float128_to_int32_round_to_zero(float128 a, float_status *s) { - FloatParts64 p; - - bfloat16_unpack_canonical(&p, a, s); - return round_to_int_and_pack(p, rmode, scale, INT16_MIN, INT16_MAX, s); + return float128_to_int32_scalbn(a, float_round_to_zero, 0, s); } =20 -int32_t bfloat16_to_int32_scalbn(bfloat16 a, FloatRoundMode rmode, int sca= le, - float_status *s) +int64_t float128_to_int64_round_to_zero(float128 a, float_status *s) { - FloatParts64 p; - - bfloat16_unpack_canonical(&p, a, s); - return round_to_int_and_pack(p, rmode, scale, INT32_MIN, INT32_MAX, s); -} - -int64_t bfloat16_to_int64_scalbn(bfloat16 a, FloatRoundMode rmode, int sca= le, - float_status *s) -{ - FloatParts64 p; - - bfloat16_unpack_canonical(&p, a, s); - return round_to_int_and_pack(p, rmode, scale, INT64_MIN, INT64_MAX, s); + return float128_to_int64_scalbn(a, float_round_to_zero, 0, s); } =20 int16_t bfloat16_to_int16(bfloat16 a, float_status *s) @@ -6554,191 +6536,6 @@ floatx80 floatx80_sqrt(floatx80 a, float_status *st= atus) 0, zExp, zSig0, zSig1, status); } =20 -/*------------------------------------------------------------------------= ---- -| Returns the result of converting the quadruple-precision floating-point -| value `a' to the 32-bit two's complement integer format. The conversion -| is performed according to the IEC/IEEE Standard for Binary Floating-Point -| Arithmetic---which means in particular that the conversion is rounded -| according to the current rounding mode. If `a' is a NaN, the largest -| positive integer is returned. Otherwise, if the conversion overflows, t= he -| largest integer with the same sign as `a' is returned. -*-------------------------------------------------------------------------= ---*/ - -int32_t float128_to_int32(float128 a, float_status *status) -{ - bool aSign; - int32_t aExp, shiftCount; - uint64_t aSig0, aSig1; - - aSig1 =3D extractFloat128Frac1( a ); - aSig0 =3D extractFloat128Frac0( a ); - aExp =3D extractFloat128Exp( a ); - aSign =3D extractFloat128Sign( a ); - if ( ( aExp =3D=3D 0x7FFF ) && ( aSig0 | aSig1 ) ) aSign =3D 0; - if ( aExp ) aSig0 |=3D UINT64_C(0x0001000000000000); - aSig0 |=3D ( aSig1 !=3D 0 ); - shiftCount =3D 0x4028 - aExp; - if ( 0 < shiftCount ) shift64RightJamming( aSig0, shiftCount, &aSig0 ); - return roundAndPackInt32(aSign, aSig0, status); - -} - -/*------------------------------------------------------------------------= ---- -| Returns the result of converting the quadruple-precision floating-point -| value `a' to the 32-bit two's complement integer format. The conversion -| is performed according to the IEC/IEEE Standard for Binary Floating-Point -| Arithmetic, except that the conversion is always rounded toward zero. If -| `a' is a NaN, the largest positive integer is returned. Otherwise, if t= he -| conversion overflows, the largest integer with the same sign as `a' is -| returned. -*-------------------------------------------------------------------------= ---*/ - -int32_t float128_to_int32_round_to_zero(float128 a, float_status *status) -{ - bool aSign; - int32_t aExp, shiftCount; - uint64_t aSig0, aSig1, savedASig; - int32_t z; - - aSig1 =3D extractFloat128Frac1( a ); - aSig0 =3D extractFloat128Frac0( a ); - aExp =3D extractFloat128Exp( a ); - aSign =3D extractFloat128Sign( a ); - aSig0 |=3D ( aSig1 !=3D 0 ); - if ( 0x401E < aExp ) { - if ( ( aExp =3D=3D 0x7FFF ) && aSig0 ) aSign =3D 0; - goto invalid; - } - else if ( aExp < 0x3FFF ) { - if (aExp || aSig0) { - float_raise(float_flag_inexact, status); - } - return 0; - } - aSig0 |=3D UINT64_C(0x0001000000000000); - shiftCount =3D 0x402F - aExp; - savedASig =3D aSig0; - aSig0 >>=3D shiftCount; - z =3D aSig0; - if ( aSign ) z =3D - z; - if ( ( z < 0 ) ^ aSign ) { - invalid: - float_raise(float_flag_invalid, status); - return aSign ? INT32_MIN : INT32_MAX; - } - if ( ( aSig0<>( ( - shiftCount ) & 63 ) ); - if ( (uint64_t) ( aSig1<>( - shiftCount ); - if ( aSig1 - || ( shiftCount && (uint64_t) ( aSig0<<( shiftCount & 63 ) ) = ) ) { - float_raise(float_flag_inexact, status); - } - } - if ( aSign ) z =3D - z; - return z; - -} - /*------------------------------------------------------------------------= ---- | Returns the result of converting the quadruple-precision floating-point = value | `a' to the 64-bit unsigned integer format. The conversion is diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc index b2c4624d8c..a897a5a743 100644 --- a/fpu/softfloat-parts.c.inc +++ b/fpu/softfloat-parts.c.inc @@ -751,3 +751,67 @@ static void partsN(round_to_int)(FloatPartsN *a, Float= RoundMode rmode, g_assert_not_reached(); } } + +/* + * Returns the result of converting the floating-point value `a' to + * the two's complement integer format. The conversion is performed + * according to the IEC/IEEE Standard for Binary Floating-Point + * Arithmetic---which means in particular that the conversion is + * rounded according to the current rounding mode. If `a' is a NaN, + * the largest positive integer is returned. Otherwise, if the + * conversion overflows, the largest integer with the same sign as `a' + * is returned. +*/ +static int64_t partsN(float_to_sint)(FloatPartsN *p, FloatRoundMode rmode, + int scale, int64_t min, int64_t max, + float_status *s) +{ + int flags =3D 0; + uint64_t r; + + switch (p->cls) { + case float_class_snan: + case float_class_qnan: + flags =3D float_flag_invalid; + r =3D max; + break; + + case float_class_inf: + flags =3D float_flag_invalid; + r =3D p->sign ? min : max; + break; + + case float_class_zero: + return 0; + + case float_class_normal: + /* TODO: N - 2 is frac_size for rounding; could use input fmt. */ + if (parts_round_to_int_normal(p, rmode, scale, N - 2)) { + flags =3D float_flag_inexact; + } + + if (p->exp <=3D DECOMPOSED_BINARY_POINT) { + r =3D p->frac_hi >> (DECOMPOSED_BINARY_POINT - p->exp); + } else { + r =3D UINT64_MAX; + } + if (p->sign) { + if (r <=3D -(uint64_t)min) { + r =3D -r; + } else { + flags =3D float_flag_invalid; + r =3D min; + } + } else if (r > max) { + flags =3D float_flag_invalid; + r =3D max; + } + break; + + default: + g_assert_not_reached(); + } + + float_raise(flags, s); + return r; +} --=20 2.25.1