mirror of
https://github.com/xemu-project/xemu.git
synced 2025-02-26 07:27:39 +00:00
Testing updates plus alpha FP fixes:
- fix alpha handling of FtoI overflow - various docker cleanups - fix docker.py cleanup race - fix podman invocation - tests/tcg: add float and record/replay tests - remove unused docker images - expand documentation for check-tcg -----BEGIN PGP SIGNATURE----- iQEzBAABCgAdFiEEZoWumedRZ7yvyN81+9DbCVqeKkQFAl2NBIIACgkQ+9DbCVqe KkQSawf8DD0ns6Mv8dQH7qonpRDLg71onyWcWniJ2/A9M5hjtDi0PLkLYi6EuoGD IIj2emOpWLuhLJhfjroGW+q8flIogmgcu5svPLHThUfsEpERKpSiQ2tjdg54GmLB IPLFQ+1N7ioW72Nw29P3TJrDb1/8kyfjkf5bnx1EQa+W2nP3+sWEh4QLjYnQWyoF UwyvE7JgztixBmNrdjNP9r+iPlAsKi4KXXmz5gT8LlpkPXrfMxK5VH8EjQqNHN/q jUgT0/XShFAcIC//OjpiCf9J2C3mPc+9QLVLRdeIsA/LYxZjeoMGTK6oC+MXkVi+ DUTXJGxPpbfEPPAVNqSf51CUd4yDWg== =MOvl -----END PGP SIGNATURE----- Merge remote-tracking branch 'remotes/stsquad/tags/pull-testing-next-260919-1' into staging Testing updates plus alpha FP fixes: - fix alpha handling of FtoI overflow - various docker cleanups - fix docker.py cleanup race - fix podman invocation - tests/tcg: add float and record/replay tests - remove unused docker images - expand documentation for check-tcg # gpg: Signature made Thu 26 Sep 2019 19:33:38 BST # gpg: using RSA key 6685AE99E75167BCAFC8DF35FBD0DB095A9E2A44 # gpg: Good signature from "Alex Bennée (Master Work Key) <alex.bennee@linaro.org>" [full] # Primary key fingerprint: 6685 AE99 E751 67BC AFC8 DF35 FBD0 DB09 5A9E 2A44 * remotes/stsquad/tags/pull-testing-next-260919-1: (28 commits) tests/docker: remove debian-powerpc-user-cross docker: move tests from python2 to python3 docker: remove unused debian-sid docker: remove unused debian-ports docker: remove 'deprecated' image definitions docker: remove unused debian8 partial image docker: remove debian8-mxe definitions target/i386: Fix broken build with WHPX enabled docs/devel: add "check-tcg" to testing.rst configure: preserve PKG_CONFIG for subdir builds tests/tcg: add simple record/replay smoke test for aarch64 tests/tcg: add generic version of float_convs tests/tcg: add float_madds test to multiarch tests/tcg: re-enable linux-test for ppc64abi32 tests/tcg: clean-up some comments after the de-tangling podman: fix command invocation tests/docker: reduce scary warnings by cleaning up clean up tests/docker: remove python2.7 from debian9-mxe tests/docker: fix DOCKER_PARTIAL_IMAGES tests/docker: add sanitizers back to clang build ... Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell
commit
c6f5012ba5
6
Makefile
6
Makefile
@ -510,7 +510,11 @@ capstone/all: .git-submodule-status
|
||||
|
||||
.PHONY: slirp/all
|
||||
slirp/all: .git-submodule-status
|
||||
$(call quiet-command,$(MAKE) -C $(SRC_PATH)/slirp BUILD_DIR="$(BUILD_DIR)/slirp" CC="$(CC)" AR="$(AR)" LD="$(LD)" RANLIB="$(RANLIB)" CFLAGS="$(QEMU_CFLAGS) $(CFLAGS)" LDFLAGS="$(LDFLAGS)")
|
||||
$(call quiet-command,$(MAKE) -C $(SRC_PATH)/slirp \
|
||||
BUILD_DIR="$(BUILD_DIR)/slirp" \
|
||||
PKG_CONFIG="$(PKG_CONFIG)" \
|
||||
CC="$(CC)" AR="$(AR)" LD="$(LD)" RANLIB="$(RANLIB)" \
|
||||
CFLAGS="$(QEMU_CFLAGS) $(CFLAGS)" LDFLAGS="$(LDFLAGS)")
|
||||
|
||||
# Compatibility gunk to keep make working across the rename of targets
|
||||
# for recursion, to be removed some time after 4.1.
|
||||
|
||||
1
configure
vendored
1
configure
vendored
@ -7302,6 +7302,7 @@ echo "OBJCOPY=$objcopy" >> $config_host_mak
|
||||
echo "LD=$ld" >> $config_host_mak
|
||||
echo "RANLIB=$ranlib" >> $config_host_mak
|
||||
echo "NM=$nm" >> $config_host_mak
|
||||
echo "PKG_CONFIG=$pkg_config_exe" >> $config_host_mak
|
||||
echo "WINDRES=$windres" >> $config_host_mak
|
||||
echo "CFLAGS=$CFLAGS" >> $config_host_mak
|
||||
echo "CFLAGS_NOPIE=$CFLAGS_NOPIE" >> $config_host_mak
|
||||
|
||||
@ -266,6 +266,8 @@ another application on the host may have locked the file, possibly leading to a
|
||||
test failure. If using such devices are explicitly desired, consider adding
|
||||
``locking=off`` option to disable image locking.
|
||||
|
||||
.. _docker-ref:
|
||||
|
||||
Docker based tests
|
||||
==================
|
||||
|
||||
@ -799,3 +801,77 @@ And remove any package you want with::
|
||||
|
||||
If you've used ``make check-acceptance``, the Python virtual environment where
|
||||
Avocado is installed will be cleaned up as part of ``make check-clean``.
|
||||
|
||||
Testing with "make check-tcg"
|
||||
=============================
|
||||
|
||||
The check-tcg tests are intended for simple smoke tests of both
|
||||
linux-user and softmmu TCG functionality. However to build test
|
||||
programs for guest targets you need to have cross compilers available.
|
||||
If your distribution supports cross compilers you can do something as
|
||||
simple as::
|
||||
|
||||
apt install gcc-aarch64-linux-gnu
|
||||
|
||||
The configure script will automatically pick up their presence.
|
||||
Sometimes compilers have slightly odd names so the availability of
|
||||
them can be prompted by passing in the appropriate configure option
|
||||
for the architecture in question, for example::
|
||||
|
||||
$(configure) --cross-cc-aarch64=aarch64-cc
|
||||
|
||||
There is also a ``--cross-cc-flags-ARCH`` flag in case additional
|
||||
compiler flags are needed to build for a given target.
|
||||
|
||||
If you have the ability to run containers as the user you can also
|
||||
take advantage of the build systems "Docker" support. It will then use
|
||||
containers to build any test case for an enabled guest where there is
|
||||
no system compiler available. See :ref: `_docker-ref` for details.
|
||||
|
||||
Running subset of tests
|
||||
-----------------------
|
||||
|
||||
You can build the tests for one architecture::
|
||||
|
||||
make build-tcg-tests-$TARGET
|
||||
|
||||
And run with::
|
||||
|
||||
make run-tcg-tests-$TARGET
|
||||
|
||||
Adding ``V=1`` to the invocation will show the details of how to
|
||||
invoke QEMU for the test which is useful for debugging tests.
|
||||
|
||||
TCG test dependencies
|
||||
---------------------
|
||||
|
||||
The TCG tests are deliberately very light on dependencies and are
|
||||
either totally bare with minimal gcc lib support (for softmmu tests)
|
||||
or just glibc (for linux-user tests). This is because getting a cross
|
||||
compiler to work with additional libraries can be challenging.
|
||||
|
||||
Other TCG Tests
|
||||
---------------
|
||||
|
||||
There are a number of out-of-tree test suites that are used for more
|
||||
extensive testing of processor features.
|
||||
|
||||
KVM Unit Tests
|
||||
~~~~~~~~~~~~~~
|
||||
|
||||
The KVM unit tests are designed to run as a Guest OS under KVM but
|
||||
there is no reason why they can't exercise the TCG as well. It
|
||||
provides a minimal OS kernel with hooks for enabling the MMU as well
|
||||
as reporting test results via a special device::
|
||||
|
||||
https://git.kernel.org/pub/scm/virt/kvm/kvm-unit-tests.git
|
||||
|
||||
Linux Test Project
|
||||
~~~~~~~~~~~~~~~~~~
|
||||
|
||||
The LTP is focused on exercising the syscall interface of a Linux
|
||||
kernel. It checks that syscalls behave as documented and strives to
|
||||
exercise as many corner cases as possible. It is a useful test suite
|
||||
to run to exercise QEMU's linux-user code::
|
||||
|
||||
https://linux-test-project.github.io/
|
||||
|
||||
@ -501,7 +501,9 @@ void setup_rt_frame(int sig, struct target_sigaction *ka,
|
||||
int i, err = 0;
|
||||
#if defined(TARGET_PPC64)
|
||||
struct target_sigcontext *sc = 0;
|
||||
#if !defined(TARGET_ABI32)
|
||||
struct image_info *image = ((TaskState *)thread_cpu->opaque)->info;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf));
|
||||
@ -557,7 +559,7 @@ void setup_rt_frame(int sig, struct target_sigaction *ka,
|
||||
env->gpr[5] = (target_ulong) h2g(&rt_sf->uc);
|
||||
env->gpr[6] = (target_ulong) h2g(rt_sf);
|
||||
|
||||
#if defined(TARGET_PPC64)
|
||||
#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
|
||||
if (get_ppc64_abi(image) < 2) {
|
||||
/* ELFv1 PPC64 function pointers are pointers to OPD entries. */
|
||||
struct target_func_ptr *handler =
|
||||
|
||||
@ -90,25 +90,18 @@ void helper_fp_exc_raise_s(CPUAlphaState *env, uint32_t ignore, uint32_t regno)
|
||||
uint32_t exc = env->error_code & ~ignore;
|
||||
if (exc) {
|
||||
env->fpcr |= exc;
|
||||
exc &= ~ignore;
|
||||
#ifdef CONFIG_USER_ONLY
|
||||
/*
|
||||
* In user mode, the kernel's software handler only
|
||||
* delivers a signal if the exception is enabled.
|
||||
*/
|
||||
if (!(exc & env->fpcr_exc_enable)) {
|
||||
return;
|
||||
}
|
||||
#else
|
||||
exc &= env->fpcr_exc_enable;
|
||||
/*
|
||||
* In system mode, the software handler gets invoked
|
||||
* for any non-ignored exception.
|
||||
* In user mode, the kernel's software handler only
|
||||
* delivers a signal if the exception is enabled.
|
||||
*/
|
||||
#ifdef CONFIG_USER_ONLY
|
||||
if (!exc) {
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
exc &= env->fpcr_exc_enable;
|
||||
fp_exc_raise1(env, GETPC(), exc, regno, EXC_M_SWC);
|
||||
}
|
||||
}
|
||||
|
||||
@ -36,37 +36,18 @@ uint64_t cpu_alpha_load_fpcr(CPUAlphaState *env)
|
||||
|
||||
void cpu_alpha_store_fpcr(CPUAlphaState *env, uint64_t val)
|
||||
{
|
||||
static const uint8_t rm_map[] = {
|
||||
[FPCR_DYN_NORMAL >> FPCR_DYN_SHIFT] = float_round_nearest_even,
|
||||
[FPCR_DYN_CHOPPED >> FPCR_DYN_SHIFT] = float_round_to_zero,
|
||||
[FPCR_DYN_MINUS >> FPCR_DYN_SHIFT] = float_round_down,
|
||||
[FPCR_DYN_PLUS >> FPCR_DYN_SHIFT] = float_round_up,
|
||||
};
|
||||
|
||||
uint32_t fpcr = val >> 32;
|
||||
uint32_t t = 0;
|
||||
|
||||
t |= CONVERT_BIT(fpcr, FPCR_INED, FPCR_INE);
|
||||
t |= CONVERT_BIT(fpcr, FPCR_UNFD, FPCR_UNF);
|
||||
t |= CONVERT_BIT(fpcr, FPCR_OVFD, FPCR_OVF);
|
||||
t |= CONVERT_BIT(fpcr, FPCR_DZED, FPCR_DZE);
|
||||
t |= CONVERT_BIT(fpcr, FPCR_INVD, FPCR_INV);
|
||||
|
||||
/* Record the raw value before adjusting for linux-user. */
|
||||
env->fpcr = fpcr;
|
||||
env->fpcr_exc_enable = ~t & FPCR_STATUS_MASK;
|
||||
|
||||
switch (fpcr & FPCR_DYN_MASK) {
|
||||
case FPCR_DYN_NORMAL:
|
||||
default:
|
||||
t = float_round_nearest_even;
|
||||
break;
|
||||
case FPCR_DYN_CHOPPED:
|
||||
t = float_round_to_zero;
|
||||
break;
|
||||
case FPCR_DYN_MINUS:
|
||||
t = float_round_down;
|
||||
break;
|
||||
case FPCR_DYN_PLUS:
|
||||
t = float_round_up;
|
||||
break;
|
||||
}
|
||||
env->fpcr_dyn_round = t;
|
||||
|
||||
env->fpcr_flush_to_zero = (fpcr & FPCR_UNFD) && (fpcr & FPCR_UNDZ);
|
||||
env->fp_status.flush_inputs_to_zero = (fpcr & FPCR_DNZ) != 0;
|
||||
|
||||
#ifdef CONFIG_USER_ONLY
|
||||
/*
|
||||
@ -75,14 +56,33 @@ void cpu_alpha_store_fpcr(CPUAlphaState *env, uint64_t val)
|
||||
* which point the kernel's handler would emulate and apply
|
||||
* the software exception mask.
|
||||
*/
|
||||
if (env->swcr & SWCR_MAP_DMZ) {
|
||||
env->fp_status.flush_inputs_to_zero = 1;
|
||||
}
|
||||
if (env->swcr & SWCR_MAP_UMZ) {
|
||||
env->fp_status.flush_to_zero = 1;
|
||||
}
|
||||
env->fpcr_exc_enable &= ~(alpha_ieee_swcr_to_fpcr(env->swcr) >> 32);
|
||||
uint32_t soft_fpcr = alpha_ieee_swcr_to_fpcr(env->swcr) >> 32;
|
||||
fpcr |= soft_fpcr & (FPCR_STATUS_MASK | FPCR_DNZ);
|
||||
|
||||
/*
|
||||
* The IOV exception is disabled by the kernel with SWCR_TRAP_ENABLE_INV,
|
||||
* which got mapped by alpha_ieee_swcr_to_fpcr to FPCR_INVD.
|
||||
* Add FPCR_IOV to fpcr_exc_enable so that it is handled identically.
|
||||
*/
|
||||
t |= CONVERT_BIT(soft_fpcr, FPCR_INVD, FPCR_IOV);
|
||||
#endif
|
||||
|
||||
t |= CONVERT_BIT(fpcr, FPCR_INED, FPCR_INE);
|
||||
t |= CONVERT_BIT(fpcr, FPCR_UNFD, FPCR_UNF);
|
||||
t |= CONVERT_BIT(fpcr, FPCR_OVFD, FPCR_OVF);
|
||||
t |= CONVERT_BIT(fpcr, FPCR_DZED, FPCR_DZE);
|
||||
t |= CONVERT_BIT(fpcr, FPCR_INVD, FPCR_INV);
|
||||
|
||||
env->fpcr_exc_enable = ~t & FPCR_STATUS_MASK;
|
||||
|
||||
env->fpcr_dyn_round = rm_map[(fpcr & FPCR_DYN_MASK) >> FPCR_DYN_SHIFT];
|
||||
env->fp_status.flush_inputs_to_zero = (fpcr & FPCR_DNZ) != 0;
|
||||
|
||||
t = (fpcr & FPCR_UNFD) && (fpcr & FPCR_UNDZ);
|
||||
#ifdef CONFIG_USER_ONLY
|
||||
t |= (env->swcr & SWCR_MAP_UMZ) != 0;
|
||||
#endif
|
||||
env->fpcr_flush_to_zero = t;
|
||||
}
|
||||
|
||||
uint64_t helper_load_fpcr(CPUAlphaState *env)
|
||||
|
||||
@ -18,6 +18,7 @@
|
||||
#include "sysemu/cpus.h"
|
||||
#include "sysemu/runstate.h"
|
||||
#include "qemu/main-loop.h"
|
||||
#include "hw/boards.h"
|
||||
#include "qemu/error-report.h"
|
||||
#include "qapi/error.h"
|
||||
#include "migration/blocker.h"
|
||||
|
||||
@ -4,11 +4,10 @@
|
||||
|
||||
DOCKER_SUFFIX := .docker
|
||||
DOCKER_FILES_DIR := $(SRC_PATH)/tests/docker/dockerfiles
|
||||
DOCKER_DEPRECATED_IMAGES := debian
|
||||
# we don't run tests on intermediate images (used as base by another image)
|
||||
DOCKER_PARTIAL_IMAGES := debian debian8 debian9 debian10 debian-sid
|
||||
DEBIAN_PARTIAL_IMAGES += debian8-mxe debian-9-mxe debian-ports debian-bootstrap
|
||||
DOCKER_IMAGES := $(filter-out $(DOCKER_DEPRECATED_IMAGES),$(sort $(notdir $(basename $(wildcard $(DOCKER_FILES_DIR)/*.docker)))))
|
||||
DOCKER_PARTIAL_IMAGES := debian9 debian10
|
||||
DOCKER_PARTIAL_IMAGES += debian9-mxe debian-bootstrap
|
||||
DOCKER_IMAGES := $(sort $(notdir $(basename $(wildcard $(DOCKER_FILES_DIR)/*.docker))))
|
||||
DOCKER_TARGETS := $(patsubst %,docker-image-%,$(DOCKER_IMAGES))
|
||||
# Use a global constant ccache directory to speed up repetitive builds
|
||||
DOCKER_CCACHE_DIR := $$HOME/.cache/qemu-docker-ccache
|
||||
@ -148,17 +147,8 @@ DOCKER_PARTIAL_IMAGES += fedora-i386-cross fedora-cris-cross
|
||||
# work around issues with poorly working multi-arch systems and broken
|
||||
# packages.
|
||||
|
||||
# Jessie is the last supported release for powerpc, but multi-arch is
|
||||
# broken so we need a qemu-linux-user for this target
|
||||
docker-binfmt-image-debian-powerpc-user: DEB_ARCH = powerpc
|
||||
docker-binfmt-image-debian-powerpc-user: DEB_TYPE = jessie
|
||||
docker-binfmt-image-debian-powerpc-user: DEB_URL = http://snapshot.debian.org/archive/debian/20180615T211437Z
|
||||
docker-binfmt-image-debian-powerpc-user: EXECUTABLE = ${BUILD_DIR}/ppc-linux-user/qemu-ppc
|
||||
docker-image-debian-powerpc-user-cross: docker-binfmt-image-debian-powerpc-user
|
||||
DOCKER_USER_IMAGES += debian-powerpc-user
|
||||
|
||||
# Expand all the pre-requistes for each docker image and test combination
|
||||
$(foreach i,$(filter-out $(DOCKER_PARTIAL_IMAGES),$(DOCKER_IMAGES) $(DOCKER_DEPRECATED_IMAGES)), \
|
||||
$(foreach i,$(filter-out $(DOCKER_PARTIAL_IMAGES),$(DOCKER_IMAGES)), \
|
||||
$(foreach t,$(DOCKER_TESTS) $(DOCKER_TOOLS), \
|
||||
$(eval .PHONY: docker-$t@$i) \
|
||||
$(eval docker-$t@$i: docker-image-$i docker-run-$t@$i) \
|
||||
|
||||
@ -215,7 +215,7 @@ class Docker(object):
|
||||
""" Running Docker commands """
|
||||
def __init__(self):
|
||||
self._command = _guess_engine_command()
|
||||
self._instances = []
|
||||
self._instance = None
|
||||
atexit.register(self._kill_instances)
|
||||
signal.signal(signal.SIGTERM, self._kill_instances)
|
||||
signal.signal(signal.SIGHUP, self._kill_instances)
|
||||
@ -234,21 +234,19 @@ class Docker(object):
|
||||
cmd = ["ps", "-q"]
|
||||
if not only_active:
|
||||
cmd.append("-a")
|
||||
|
||||
filter = "--filter=label=com.qemu.instance.uuid"
|
||||
if only_known:
|
||||
if self._instance:
|
||||
filter += "=%s" % (self._instance)
|
||||
else:
|
||||
# no point trying to kill, we finished
|
||||
return
|
||||
|
||||
print("filter=%s" % (filter))
|
||||
cmd.append(filter)
|
||||
for i in self._output(cmd).split():
|
||||
resp = self._output(["inspect", i])
|
||||
labels = json.loads(resp)[0]["Config"]["Labels"]
|
||||
active = json.loads(resp)[0]["State"]["Running"]
|
||||
if not labels:
|
||||
continue
|
||||
instance_uuid = labels.get("com.qemu.instance.uuid", None)
|
||||
if not instance_uuid:
|
||||
continue
|
||||
if only_known and instance_uuid not in self._instances:
|
||||
continue
|
||||
print("Terminating", i)
|
||||
if active:
|
||||
self._do(["kill", i])
|
||||
self._do(["rm", i])
|
||||
self._do(["rm", "-f", i])
|
||||
|
||||
def clean(self):
|
||||
self._do_kill_instances(False, False)
|
||||
@ -325,22 +323,22 @@ class Docker(object):
|
||||
return checksum == _text_checksum(_dockerfile_preprocess(dockerfile))
|
||||
|
||||
def run(self, cmd, keep, quiet, as_user=False):
|
||||
label = uuid.uuid1().hex
|
||||
label = uuid.uuid4().hex
|
||||
if not keep:
|
||||
self._instances.append(label)
|
||||
self._instance = label
|
||||
|
||||
if as_user:
|
||||
uid = os.getuid()
|
||||
cmd = [ "-u", str(uid) ] + cmd
|
||||
# podman requires a bit more fiddling
|
||||
if self._command[0] == "podman":
|
||||
argv.insert(0, '--userns=keep-id')
|
||||
cmd.insert(0, '--userns=keep-id')
|
||||
|
||||
ret = self._do_check(["run", "--label",
|
||||
"com.qemu.instance.uuid=" + label] + cmd,
|
||||
quiet=quiet)
|
||||
if not keep:
|
||||
self._instances.remove(label)
|
||||
self._instance = None
|
||||
return ret
|
||||
|
||||
def command(self, cmd, argv, quiet):
|
||||
|
||||
@ -25,6 +25,7 @@ ENV PACKAGES \
|
||||
nettle-devel \
|
||||
perl-Test-Harness \
|
||||
pixman-devel \
|
||||
python3 \
|
||||
SDL-devel \
|
||||
spice-glib-devel \
|
||||
spice-server-devel \
|
||||
@ -34,4 +35,3 @@ ENV PACKAGES \
|
||||
zlib-devel
|
||||
RUN yum install -y $PACKAGES
|
||||
RUN rpm -q $PACKAGES | sort > /packages.txt
|
||||
|
||||
|
||||
@ -1,36 +0,0 @@
|
||||
#
|
||||
# Docker multiarch cross-compiler target
|
||||
#
|
||||
# This docker target is builds on Debian Ports cross compiler targets
|
||||
# to build distro with a selection of cross compilers for building test binaries.
|
||||
#
|
||||
# On its own you can't build much but the docker-foo-cross targets
|
||||
# build on top of the base debian image.
|
||||
#
|
||||
FROM debian:unstable
|
||||
|
||||
MAINTAINER Philippe Mathieu-Daudé <f4bug@amsat.org>
|
||||
|
||||
RUN echo "deb [arch=amd64] http://deb.debian.org/debian unstable main" > /etc/apt/sources.list
|
||||
|
||||
# Duplicate deb line as deb-src
|
||||
RUN cat /etc/apt/sources.list | sed -ne "s/^deb\ \(\[.*\]\ \)\?\(.*\)/deb-src \2/p" >> /etc/apt/sources.list
|
||||
|
||||
# Setup some basic tools we need
|
||||
RUN apt-get update && \
|
||||
DEBIAN_FRONTEND=noninteractive apt install -yy eatmydata && \
|
||||
DEBIAN_FRONTEND=noninteractive eatmydata \
|
||||
apt-get install -y --no-install-recommends \
|
||||
bison \
|
||||
build-essential \
|
||||
ca-certificates \
|
||||
clang \
|
||||
debian-ports-archive-keyring \
|
||||
flex \
|
||||
gettext \
|
||||
git \
|
||||
pkg-config \
|
||||
psmisc \
|
||||
python \
|
||||
texinfo \
|
||||
$(apt-get -s build-dep qemu | egrep ^Inst | fgrep '[all]' | cut -d\ -f2)
|
||||
@ -1,21 +0,0 @@
|
||||
#
|
||||
# Docker powerpc cross-compiler target for QEMU
|
||||
#
|
||||
# We can't use current Debian stable cross-compilers to build powerpc
|
||||
# as it has been dropped as a release architecture. Using Debian Sid
|
||||
# is just far too sketchy a build environment. This leaves us the
|
||||
# final option of using linux-user. This image is based of the
|
||||
# debootstrapped qemu:debian-powerpc-user but doesn't need any extra
|
||||
# magic once it is setup.
|
||||
#
|
||||
# It can be used to build old versions of QEMU, current versions need
|
||||
# newer dependencies than Jessie provides.
|
||||
#
|
||||
FROM qemu:debian-powerpc-user
|
||||
|
||||
RUN echo man-db man-db/auto-update boolean false | debconf-set-selections
|
||||
RUN apt-get update && \
|
||||
DEBIAN_FRONTEND=noninteractive apt-get build-dep -yy qemu
|
||||
|
||||
ENV QEMU_CONFIGURE_OPTS --disable-werror
|
||||
ENV DEF_TARGET_LIST powerpc-softmmu,arm-linux-user,aarch64-linux-user
|
||||
@ -1,35 +0,0 @@
|
||||
#
|
||||
# Debian Sid Base
|
||||
#
|
||||
# Currently we can build all our guests with cross-compilers in the
|
||||
# latest Debian release (Buster). However new compilers will first
|
||||
# arrive in Sid. However Sid is a rolling distro which may be broken
|
||||
# at any particular time. To try and mitigate this we use Debian's
|
||||
# snapshot archive which provides a "stable" view of what state Sid
|
||||
# was in.
|
||||
#
|
||||
|
||||
# This must be earlier than the snapshot date we are aiming for
|
||||
FROM debian:sid-20190812-slim
|
||||
|
||||
# Use a snapshot known to work (see http://snapshot.debian.org/#Usage)
|
||||
ENV DEBIAN_SNAPSHOT_DATE "20190820"
|
||||
RUN sed -i "s%^deb \(https\?://\)deb.debian.org/debian/\? \(.*\)%deb [check-valid-until=no] \1snapshot.debian.org/archive/debian/${DEBIAN_SNAPSHOT_DATE} \2%" /etc/apt/sources.list
|
||||
|
||||
# Duplicate deb line as deb-src
|
||||
RUN cat /etc/apt/sources.list | sed "s/^deb\ /deb-src /" >> /etc/apt/sources.list
|
||||
|
||||
# Install common build utilities
|
||||
RUN apt update && \
|
||||
DEBIAN_FRONTEND=noninteractive apt install -yy eatmydata && \
|
||||
DEBIAN_FRONTEND=noninteractive eatmydata \
|
||||
apt install -y --no-install-recommends \
|
||||
bison \
|
||||
build-essential \
|
||||
ca-certificates \
|
||||
flex \
|
||||
git \
|
||||
pkg-config \
|
||||
psmisc \
|
||||
python \
|
||||
texinfo || { echo "Failed to build - see debian-sid.docker notes"; exit 1; }
|
||||
@ -18,7 +18,7 @@ RUN apt-get update && \
|
||||
flex \
|
||||
gettext \
|
||||
git \
|
||||
python-minimal
|
||||
python3-minimal
|
||||
|
||||
ENV CPU_LIST csp dc232b dc233c
|
||||
ENV TOOLCHAIN_RELEASE 2018.02
|
||||
|
||||
@ -26,7 +26,7 @@ RUN apt update && \
|
||||
git \
|
||||
pkg-config \
|
||||
psmisc \
|
||||
python \
|
||||
python3 \
|
||||
python3-sphinx \
|
||||
texinfo \
|
||||
$(apt-get -s build-dep qemu | egrep ^Inst | fgrep '[all]' | cut -d\ -f2)
|
||||
|
||||
@ -1,34 +0,0 @@
|
||||
#
|
||||
# Docker multiarch cross-compiler target
|
||||
#
|
||||
# This docker target is builds on Debian and Emdebian's cross compiler targets
|
||||
# to build distro with a selection of cross compilers for building test binaries.
|
||||
#
|
||||
# On its own you can't build much but the docker-foo-cross targets
|
||||
# build on top of the base debian image.
|
||||
#
|
||||
FROM debian:jessie-slim
|
||||
|
||||
MAINTAINER Philippe Mathieu-Daudé <f4bug@amsat.org>
|
||||
|
||||
# Duplicate deb line as deb-src
|
||||
RUN cat /etc/apt/sources.list | sed "s/^deb\ /deb-src /" >> /etc/apt/sources.list
|
||||
|
||||
# Setup some basic tools we need
|
||||
RUN apt update && \
|
||||
DEBIAN_FRONTEND=noninteractive apt-get install -yy eatmydata && \
|
||||
DEBIAN_FRONTEND=noninteractive eatmydata \
|
||||
apt-get install -y --no-install-recommends \
|
||||
bison \
|
||||
binutils-multiarch \
|
||||
build-essential \
|
||||
ca-certificates \
|
||||
clang \
|
||||
curl \
|
||||
flex \
|
||||
gettext \
|
||||
git \
|
||||
gnupg \
|
||||
pkg-config \
|
||||
python-minimal
|
||||
|
||||
@ -16,7 +16,6 @@ RUN apt-key adv --keyserver keyserver.ubuntu.com --recv-keys C6BF758A33A3A276 &&
|
||||
RUN apt-get update && \
|
||||
DEBIAN_FRONTEND=noninteractive eatmydata \
|
||||
apt-get install -y --no-install-recommends \
|
||||
libpython2.7-stdlib \
|
||||
$(apt-get -s install -y --no-install-recommends gw32.shared-mingw-w64 | egrep "^Inst mxe-x86-64-unknown-" | cut -d\ -f2)
|
||||
|
||||
ENV PATH $PATH:/usr/lib/mxe/usr/bin/
|
||||
ENV PATH $PATH:/usr/lib/mxe/usr/bin/
|
||||
|
||||
@ -26,7 +26,7 @@ RUN apt update && \
|
||||
git \
|
||||
pkg-config \
|
||||
psmisc \
|
||||
python \
|
||||
python3 \
|
||||
python3-sphinx \
|
||||
texinfo \
|
||||
$(apt-get -s build-dep qemu | egrep ^Inst | fgrep '[all]' | cut -d\ -f2)
|
||||
|
||||
@ -5,7 +5,7 @@ ENV LC_ALL en_US.UTF-8
|
||||
RUN sed -i "s/# deb-src/deb-src/" /etc/apt/sources.list
|
||||
RUN apt-get update
|
||||
RUN apt-get -y build-dep qemu
|
||||
RUN apt-get -y install device-tree-compiler python2.7 python-yaml dh-autoreconf gdb strace lsof net-tools gcovr
|
||||
RUN apt-get -y install device-tree-compiler python3 python3-yaml dh-autoreconf gdb strace lsof net-tools gcovr
|
||||
# Travis tools require PhantomJS / Neo4j / Maven accessible
|
||||
# in their PATH (QEMU build won't access them).
|
||||
ENV PATH /usr/local/phantomjs/bin:/usr/local/phantomjs:/usr/local/neo4j-3.2.7/bin:/usr/local/maven-3.5.2/bin:/usr/local/cmake-3.9.2/bin:/usr/local/clang-5.0.0/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
|
||||
|
||||
@ -60,7 +60,7 @@ ENV PACKAGES flex bison \
|
||||
libvte-2.91-dev \
|
||||
libxen-dev \
|
||||
make \
|
||||
python-yaml \
|
||||
python3-yaml \
|
||||
python3-sphinx \
|
||||
sparse \
|
||||
texinfo \
|
||||
|
||||
@ -47,7 +47,7 @@ ENV PACKAGES flex bison \
|
||||
libvte-2.91-dev \
|
||||
libxen-dev \
|
||||
make \
|
||||
python-yaml \
|
||||
python3-yaml \
|
||||
python3-sphinx \
|
||||
sparse \
|
||||
texinfo \
|
||||
|
||||
@ -17,11 +17,7 @@ requires clang
|
||||
|
||||
cd "$BUILD_DIR"
|
||||
|
||||
OPTS="--cxx=clang++ --cc=clang --host-cc=clang"
|
||||
# -fsanitize=undefined is broken on Fedora 23, skip it for now
|
||||
# See also: https://bugzilla.redhat.com/show_bug.cgi?id=1263834
|
||||
#OPTS="$OPTS --extra-cflags=-fsanitize=undefined \
|
||||
#--extra-cflags=-fno-sanitize=float-divide-by-zero"
|
||||
OPTS="--cxx=clang++ --cc=clang --host-cc=clang --enable-sanitizers"
|
||||
build_qemu $OPTS
|
||||
check_qemu
|
||||
install_qemu
|
||||
|
||||
@ -55,6 +55,15 @@ diff-out = $(call quiet-command, diff -q $1.out $2 || \
|
||||
# $1 = test name, $2 = reason
|
||||
skip-test = @printf " SKIPPED %s on $(TARGET_NAME) because %s\n" $1 $2
|
||||
|
||||
# $1 = test name, $2 = reference
|
||||
# As above but only diff if reference file exists, otherwise the test
|
||||
# passes if it managed to complete with a status of zero
|
||||
conditional-diff-out = \
|
||||
$(if $(wildcard $2), \
|
||||
$(call diff-out,$1,$2), \
|
||||
$(call skip-test,"$1 check","no reference"))
|
||||
|
||||
|
||||
# Tests we are building
|
||||
TESTS=
|
||||
|
||||
@ -74,8 +83,11 @@ TIMEOUT=15
|
||||
endif
|
||||
|
||||
ifdef CONFIG_USER_ONLY
|
||||
# The order we include is important. We include multiarch, base arch
|
||||
# and finally arch if it's not the same as base arch.
|
||||
# The order we include is important. We include multiarch first and
|
||||
# then the target. If there are common tests shared between
|
||||
# sub-targets (e.g. ARM & AArch64) then it is up to
|
||||
# $(TARGET_NAME)/Makefile.target to include the common parent
|
||||
# architecture in its VPATH.
|
||||
-include $(SRC_PATH)/tests/tcg/multiarch/Makefile.target
|
||||
-include $(SRC_PATH)/tests/tcg/$(TARGET_NAME)/Makefile.target
|
||||
|
||||
|
||||
@ -32,3 +32,24 @@ memory: CFLAGS+=-DCHECK_UNALIGNED=1
|
||||
|
||||
# Running
|
||||
QEMU_OPTS+=-M virt -cpu max -display none -semihosting-config enable=on,target=native,chardev=output -kernel
|
||||
|
||||
# Simple Record/Replay Test
|
||||
.PHONY: memory-record
|
||||
run-memory-record: memory-record memory
|
||||
$(call run-test, $<, \
|
||||
$(QEMU) -monitor none -display none \
|
||||
-chardev file$(COMMA)path=$<.out$(COMMA)id=output \
|
||||
-icount shift=5$(COMMA)rr=record$(COMMA)rrfile=record.bin \
|
||||
$(QEMU_OPTS) memory, \
|
||||
"$< on $(TARGET_NAME)")
|
||||
|
||||
.PHONY: memory-replay
|
||||
run-memory-replay: memory-replay run-memory-record
|
||||
$(call run-test, $<, \
|
||||
$(QEMU) -monitor none -display none \
|
||||
-chardev file$(COMMA)path=$<.out$(COMMA)id=output \
|
||||
-icount shift=5$(COMMA)rr=replay$(COMMA)rrfile=record.bin \
|
||||
$(QEMU_OPTS) memory, \
|
||||
"$< on $(TARGET_NAME)")
|
||||
|
||||
TESTS+=memory-record memory-replay
|
||||
|
||||
@ -8,7 +8,7 @@ VPATH += $(ARM_SRC)
|
||||
AARCH64_SRC=$(SRC_PATH)/tests/tcg/aarch64
|
||||
VPATH += $(AARCH64_SRC)
|
||||
|
||||
# we don't build any other ARM test
|
||||
# Float-convert Tests
|
||||
AARCH64_TESTS=fcvt
|
||||
|
||||
fcvt: LDFLAGS+=-lm
|
||||
@ -17,6 +17,7 @@ run-fcvt: fcvt
|
||||
$(call run-test,$<,$(QEMU) $<, "$< on $(TARGET_NAME)")
|
||||
$(call diff-out,$<,$(AARCH64_SRC)/fcvt.ref)
|
||||
|
||||
# Pauth Tests
|
||||
AARCH64_TESTS += pauth-1 pauth-2
|
||||
run-pauth-%: QEMU_OPTS += -cpu max
|
||||
|
||||
|
||||
748
tests/tcg/aarch64/float_convs.ref
Executable file
748
tests/tcg/aarch64/float_convs.ref
Executable file
@ -0,0 +1,748 @@
|
||||
### Rounding to nearest
|
||||
from single: f32(-nan:0xffa00000)
|
||||
to double: f64(-nan:0x00fffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-nan:0xffc00000)
|
||||
to double: f64(-nan:0x00fff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-inf:0xff800000)
|
||||
to double: f64(-inf:0x00fff0000000000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
to double: f64(-0x1.fffffe00000000000000p+127:0x00c7efffffe0000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
to double: f64(-0x1.1874b200000000000000p+103:0x00c661874b20000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
to double: f64(-0x1.c0bab600000000000000p+99:0x00c62c0bab60000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
to double: f64(-0x1.31f75000000000000000p-40:0x00bd731f7500000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
to double: f64(-0x1.50544400000000000000p-66:0x00bbd5054440000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
to double: f64(-0x1.00000000000000000000p-126:0x00b810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x0.00000000000000000000p+0:0000000000)
|
||||
to double: f64(0x0.00000000000000000000p+0:00000000000000000000) (OK)
|
||||
to int32: 0 (OK)
|
||||
to int64: 0 (OK)
|
||||
to uint32: 0 (OK)
|
||||
to uint64: 0 (OK)
|
||||
from single: f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
to double: f64(0x1.00000000000000000000p-126:0x003810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
to double: f64(0x1.00000000000000000000p-25:0x003e60000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
to double: f64(0x1.ffffe600000000000000p-25:0x003e6ffffe60000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
to double: f64(0x1.ff801a00000000000000p-15:0x003f0ff801a0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
to double: f64(0x1.00000c00000000000000p-14:0x003f100000c0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
to double: f64(0x1.00000000000000000000p+0:0x003ff0000000000000) (OK)
|
||||
to int32: 1 (OK)
|
||||
to int64: 1 (OK)
|
||||
to uint32: 1 (OK)
|
||||
to uint64: 1 (OK)
|
||||
from single: f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
to double: f64(0x1.00400000000000000000p+0:0x003ff0040000000000) (OK)
|
||||
to int32: 1 (INEXACT )
|
||||
to int64: 1 (INEXACT )
|
||||
to uint32: 1 (INEXACT )
|
||||
to uint64: 1 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
to double: f64(0x1.00000000000000000000p+1:0x004000000000000000) (OK)
|
||||
to int32: 2 (OK)
|
||||
to int64: 2 (OK)
|
||||
to uint32: 2 (OK)
|
||||
to uint64: 2 (OK)
|
||||
from single: f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
to double: f64(0x1.5bf0a800000000000000p+1:0x004005bf0a80000000) (OK)
|
||||
to int32: 2 (INEXACT )
|
||||
to int64: 2 (INEXACT )
|
||||
to uint32: 2 (INEXACT )
|
||||
to uint64: 2 (INEXACT )
|
||||
from single: f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
to double: f64(0x1.921fb600000000000000p+1:0x00400921fb60000000) (OK)
|
||||
to int32: 3 (INEXACT )
|
||||
to int64: 3 (INEXACT )
|
||||
to uint32: 3 (INEXACT )
|
||||
to uint64: 3 (INEXACT )
|
||||
from single: f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
to double: f64(0x1.ffbe0000000000000000p+15:0x0040effbe000000000) (OK)
|
||||
to int32: 65503 (OK)
|
||||
to int64: 65503 (OK)
|
||||
to uint32: 65503 (OK)
|
||||
to uint64: 65503 (OK)
|
||||
from single: f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+15:0x0040effc0000000000) (OK)
|
||||
to int32: 65504 (OK)
|
||||
to int64: 65504 (OK)
|
||||
to uint32: 65504 (OK)
|
||||
to uint64: 65504 (OK)
|
||||
from single: f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
to double: f64(0x1.ffc20000000000000000p+15:0x0040effc2000000000) (OK)
|
||||
to int32: 65505 (OK)
|
||||
to int64: 65505 (OK)
|
||||
to uint32: 65505 (OK)
|
||||
to uint64: 65505 (OK)
|
||||
from single: f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
to double: f64(0x1.ffbf0000000000000000p+16:0x0040fffbf000000000) (OK)
|
||||
to int32: 131007 (OK)
|
||||
to int64: 131007 (OK)
|
||||
to uint32: 131007 (OK)
|
||||
to uint64: 131007 (OK)
|
||||
from single: f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+16:0x0040fffc0000000000) (OK)
|
||||
to int32: 131008 (OK)
|
||||
to int64: 131008 (OK)
|
||||
to uint32: 131008 (OK)
|
||||
to uint64: 131008 (OK)
|
||||
from single: f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
to double: f64(0x1.ffc10000000000000000p+16:0x0040fffc1000000000) (OK)
|
||||
to int32: 131009 (OK)
|
||||
to int64: 131009 (OK)
|
||||
to uint32: 131009 (OK)
|
||||
to uint64: 131009 (OK)
|
||||
from single: f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
to double: f64(0x1.c0bab600000000000000p+99:0x00462c0bab60000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: 9223372036854775807 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
to double: f64(0x1.fffffe00000000000000p+127:0x0047efffffe0000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: 9223372036854775807 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(inf:0x7f800000)
|
||||
to double: f64(inf:0x007ff0000000000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: 9223372036854775807 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(nan:0x7fc00000)
|
||||
to double: f64(nan:0x007ff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(nan:0x7fa00000)
|
||||
to double: f64(nan:0x007ffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
### Rounding upwards
|
||||
from single: f32(-nan:0xffa00000)
|
||||
to double: f64(-nan:0x00fffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-nan:0xffc00000)
|
||||
to double: f64(-nan:0x00fff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-inf:0xff800000)
|
||||
to double: f64(-inf:0x00fff0000000000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
to double: f64(-0x1.fffffe00000000000000p+127:0x00c7efffffe0000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
to double: f64(-0x1.1874b200000000000000p+103:0x00c661874b20000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
to double: f64(-0x1.c0bab600000000000000p+99:0x00c62c0bab60000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
to double: f64(-0x1.31f75000000000000000p-40:0x00bd731f7500000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
to double: f64(-0x1.50544400000000000000p-66:0x00bbd5054440000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
to double: f64(-0x1.00000000000000000000p-126:0x00b810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x0.00000000000000000000p+0:0000000000)
|
||||
to double: f64(0x0.00000000000000000000p+0:00000000000000000000) (OK)
|
||||
to int32: 0 (OK)
|
||||
to int64: 0 (OK)
|
||||
to uint32: 0 (OK)
|
||||
to uint64: 0 (OK)
|
||||
from single: f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
to double: f64(0x1.00000000000000000000p-126:0x003810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
to double: f64(0x1.00000000000000000000p-25:0x003e60000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
to double: f64(0x1.ffffe600000000000000p-25:0x003e6ffffe60000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
to double: f64(0x1.ff801a00000000000000p-15:0x003f0ff801a0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
to double: f64(0x1.00000c00000000000000p-14:0x003f100000c0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
to double: f64(0x1.00000000000000000000p+0:0x003ff0000000000000) (OK)
|
||||
to int32: 1 (OK)
|
||||
to int64: 1 (OK)
|
||||
to uint32: 1 (OK)
|
||||
to uint64: 1 (OK)
|
||||
from single: f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
to double: f64(0x1.00400000000000000000p+0:0x003ff0040000000000) (OK)
|
||||
to int32: 1 (INEXACT )
|
||||
to int64: 1 (INEXACT )
|
||||
to uint32: 1 (INEXACT )
|
||||
to uint64: 1 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
to double: f64(0x1.00000000000000000000p+1:0x004000000000000000) (OK)
|
||||
to int32: 2 (OK)
|
||||
to int64: 2 (OK)
|
||||
to uint32: 2 (OK)
|
||||
to uint64: 2 (OK)
|
||||
from single: f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
to double: f64(0x1.5bf0a800000000000000p+1:0x004005bf0a80000000) (OK)
|
||||
to int32: 2 (INEXACT )
|
||||
to int64: 2 (INEXACT )
|
||||
to uint32: 2 (INEXACT )
|
||||
to uint64: 2 (INEXACT )
|
||||
from single: f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
to double: f64(0x1.921fb600000000000000p+1:0x00400921fb60000000) (OK)
|
||||
to int32: 3 (INEXACT )
|
||||
to int64: 3 (INEXACT )
|
||||
to uint32: 3 (INEXACT )
|
||||
to uint64: 3 (INEXACT )
|
||||
from single: f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
to double: f64(0x1.ffbe0000000000000000p+15:0x0040effbe000000000) (OK)
|
||||
to int32: 65503 (OK)
|
||||
to int64: 65503 (OK)
|
||||
to uint32: 65503 (OK)
|
||||
to uint64: 65503 (OK)
|
||||
from single: f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+15:0x0040effc0000000000) (OK)
|
||||
to int32: 65504 (OK)
|
||||
to int64: 65504 (OK)
|
||||
to uint32: 65504 (OK)
|
||||
to uint64: 65504 (OK)
|
||||
from single: f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
to double: f64(0x1.ffc20000000000000000p+15:0x0040effc2000000000) (OK)
|
||||
to int32: 65505 (OK)
|
||||
to int64: 65505 (OK)
|
||||
to uint32: 65505 (OK)
|
||||
to uint64: 65505 (OK)
|
||||
from single: f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
to double: f64(0x1.ffbf0000000000000000p+16:0x0040fffbf000000000) (OK)
|
||||
to int32: 131007 (OK)
|
||||
to int64: 131007 (OK)
|
||||
to uint32: 131007 (OK)
|
||||
to uint64: 131007 (OK)
|
||||
from single: f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+16:0x0040fffc0000000000) (OK)
|
||||
to int32: 131008 (OK)
|
||||
to int64: 131008 (OK)
|
||||
to uint32: 131008 (OK)
|
||||
to uint64: 131008 (OK)
|
||||
from single: f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
to double: f64(0x1.ffc10000000000000000p+16:0x0040fffc1000000000) (OK)
|
||||
to int32: 131009 (OK)
|
||||
to int64: 131009 (OK)
|
||||
to uint32: 131009 (OK)
|
||||
to uint64: 131009 (OK)
|
||||
from single: f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
to double: f64(0x1.c0bab600000000000000p+99:0x00462c0bab60000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: 9223372036854775807 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
to double: f64(0x1.fffffe00000000000000p+127:0x0047efffffe0000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: 9223372036854775807 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(inf:0x7f800000)
|
||||
to double: f64(inf:0x007ff0000000000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: 9223372036854775807 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(nan:0x7fc00000)
|
||||
to double: f64(nan:0x007ff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(nan:0x7fa00000)
|
||||
to double: f64(nan:0x007ffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
### Rounding downwards
|
||||
from single: f32(-nan:0xffa00000)
|
||||
to double: f64(-nan:0x00fffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-nan:0xffc00000)
|
||||
to double: f64(-nan:0x00fff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-inf:0xff800000)
|
||||
to double: f64(-inf:0x00fff0000000000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
to double: f64(-0x1.fffffe00000000000000p+127:0x00c7efffffe0000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
to double: f64(-0x1.1874b200000000000000p+103:0x00c661874b20000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
to double: f64(-0x1.c0bab600000000000000p+99:0x00c62c0bab60000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
to double: f64(-0x1.31f75000000000000000p-40:0x00bd731f7500000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
to double: f64(-0x1.50544400000000000000p-66:0x00bbd5054440000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
to double: f64(-0x1.00000000000000000000p-126:0x00b810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x0.00000000000000000000p+0:0000000000)
|
||||
to double: f64(0x0.00000000000000000000p+0:00000000000000000000) (OK)
|
||||
to int32: 0 (OK)
|
||||
to int64: 0 (OK)
|
||||
to uint32: 0 (OK)
|
||||
to uint64: 0 (OK)
|
||||
from single: f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
to double: f64(0x1.00000000000000000000p-126:0x003810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
to double: f64(0x1.00000000000000000000p-25:0x003e60000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
to double: f64(0x1.ffffe600000000000000p-25:0x003e6ffffe60000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
to double: f64(0x1.ff801a00000000000000p-15:0x003f0ff801a0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
to double: f64(0x1.00000c00000000000000p-14:0x003f100000c0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
to double: f64(0x1.00000000000000000000p+0:0x003ff0000000000000) (OK)
|
||||
to int32: 1 (OK)
|
||||
to int64: 1 (OK)
|
||||
to uint32: 1 (OK)
|
||||
to uint64: 1 (OK)
|
||||
from single: f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
to double: f64(0x1.00400000000000000000p+0:0x003ff0040000000000) (OK)
|
||||
to int32: 1 (INEXACT )
|
||||
to int64: 1 (INEXACT )
|
||||
to uint32: 1 (INEXACT )
|
||||
to uint64: 1 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
to double: f64(0x1.00000000000000000000p+1:0x004000000000000000) (OK)
|
||||
to int32: 2 (OK)
|
||||
to int64: 2 (OK)
|
||||
to uint32: 2 (OK)
|
||||
to uint64: 2 (OK)
|
||||
from single: f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
to double: f64(0x1.5bf0a800000000000000p+1:0x004005bf0a80000000) (OK)
|
||||
to int32: 2 (INEXACT )
|
||||
to int64: 2 (INEXACT )
|
||||
to uint32: 2 (INEXACT )
|
||||
to uint64: 2 (INEXACT )
|
||||
from single: f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
to double: f64(0x1.921fb600000000000000p+1:0x00400921fb60000000) (OK)
|
||||
to int32: 3 (INEXACT )
|
||||
to int64: 3 (INEXACT )
|
||||
to uint32: 3 (INEXACT )
|
||||
to uint64: 3 (INEXACT )
|
||||
from single: f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
to double: f64(0x1.ffbe0000000000000000p+15:0x0040effbe000000000) (OK)
|
||||
to int32: 65503 (OK)
|
||||
to int64: 65503 (OK)
|
||||
to uint32: 65503 (OK)
|
||||
to uint64: 65503 (OK)
|
||||
from single: f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+15:0x0040effc0000000000) (OK)
|
||||
to int32: 65504 (OK)
|
||||
to int64: 65504 (OK)
|
||||
to uint32: 65504 (OK)
|
||||
to uint64: 65504 (OK)
|
||||
from single: f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
to double: f64(0x1.ffc20000000000000000p+15:0x0040effc2000000000) (OK)
|
||||
to int32: 65505 (OK)
|
||||
to int64: 65505 (OK)
|
||||
to uint32: 65505 (OK)
|
||||
to uint64: 65505 (OK)
|
||||
from single: f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
to double: f64(0x1.ffbf0000000000000000p+16:0x0040fffbf000000000) (OK)
|
||||
to int32: 131007 (OK)
|
||||
to int64: 131007 (OK)
|
||||
to uint32: 131007 (OK)
|
||||
to uint64: 131007 (OK)
|
||||
from single: f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+16:0x0040fffc0000000000) (OK)
|
||||
to int32: 131008 (OK)
|
||||
to int64: 131008 (OK)
|
||||
to uint32: 131008 (OK)
|
||||
to uint64: 131008 (OK)
|
||||
from single: f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
to double: f64(0x1.ffc10000000000000000p+16:0x0040fffc1000000000) (OK)
|
||||
to int32: 131009 (OK)
|
||||
to int64: 131009 (OK)
|
||||
to uint32: 131009 (OK)
|
||||
to uint64: 131009 (OK)
|
||||
from single: f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
to double: f64(0x1.c0bab600000000000000p+99:0x00462c0bab60000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: 9223372036854775807 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
to double: f64(0x1.fffffe00000000000000p+127:0x0047efffffe0000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: 9223372036854775807 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(inf:0x7f800000)
|
||||
to double: f64(inf:0x007ff0000000000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: 9223372036854775807 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(nan:0x7fc00000)
|
||||
to double: f64(nan:0x007ff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(nan:0x7fa00000)
|
||||
to double: f64(nan:0x007ffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
### Rounding to zero
|
||||
from single: f32(-nan:0xffa00000)
|
||||
to double: f64(-nan:0x00fffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-nan:0xffc00000)
|
||||
to double: f64(-nan:0x00fff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-inf:0xff800000)
|
||||
to double: f64(-inf:0x00fff0000000000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
to double: f64(-0x1.fffffe00000000000000p+127:0x00c7efffffe0000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
to double: f64(-0x1.1874b200000000000000p+103:0x00c661874b20000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
to double: f64(-0x1.c0bab600000000000000p+99:0x00c62c0bab60000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: -9223372036854775808 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
to double: f64(-0x1.31f75000000000000000p-40:0x00bd731f7500000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
to double: f64(-0x1.50544400000000000000p-66:0x00bbd5054440000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
to double: f64(-0x1.00000000000000000000p-126:0x00b810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x0.00000000000000000000p+0:0000000000)
|
||||
to double: f64(0x0.00000000000000000000p+0:00000000000000000000) (OK)
|
||||
to int32: 0 (OK)
|
||||
to int64: 0 (OK)
|
||||
to uint32: 0 (OK)
|
||||
to uint64: 0 (OK)
|
||||
from single: f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
to double: f64(0x1.00000000000000000000p-126:0x003810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
to double: f64(0x1.00000000000000000000p-25:0x003e60000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
to double: f64(0x1.ffffe600000000000000p-25:0x003e6ffffe60000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
to double: f64(0x1.ff801a00000000000000p-15:0x003f0ff801a0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
to double: f64(0x1.00000c00000000000000p-14:0x003f100000c0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
to double: f64(0x1.00000000000000000000p+0:0x003ff0000000000000) (OK)
|
||||
to int32: 1 (OK)
|
||||
to int64: 1 (OK)
|
||||
to uint32: 1 (OK)
|
||||
to uint64: 1 (OK)
|
||||
from single: f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
to double: f64(0x1.00400000000000000000p+0:0x003ff0040000000000) (OK)
|
||||
to int32: 1 (INEXACT )
|
||||
to int64: 1 (INEXACT )
|
||||
to uint32: 1 (INEXACT )
|
||||
to uint64: 1 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
to double: f64(0x1.00000000000000000000p+1:0x004000000000000000) (OK)
|
||||
to int32: 2 (OK)
|
||||
to int64: 2 (OK)
|
||||
to uint32: 2 (OK)
|
||||
to uint64: 2 (OK)
|
||||
from single: f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
to double: f64(0x1.5bf0a800000000000000p+1:0x004005bf0a80000000) (OK)
|
||||
to int32: 2 (INEXACT )
|
||||
to int64: 2 (INEXACT )
|
||||
to uint32: 2 (INEXACT )
|
||||
to uint64: 2 (INEXACT )
|
||||
from single: f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
to double: f64(0x1.921fb600000000000000p+1:0x00400921fb60000000) (OK)
|
||||
to int32: 3 (INEXACT )
|
||||
to int64: 3 (INEXACT )
|
||||
to uint32: 3 (INEXACT )
|
||||
to uint64: 3 (INEXACT )
|
||||
from single: f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
to double: f64(0x1.ffbe0000000000000000p+15:0x0040effbe000000000) (OK)
|
||||
to int32: 65503 (OK)
|
||||
to int64: 65503 (OK)
|
||||
to uint32: 65503 (OK)
|
||||
to uint64: 65503 (OK)
|
||||
from single: f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+15:0x0040effc0000000000) (OK)
|
||||
to int32: 65504 (OK)
|
||||
to int64: 65504 (OK)
|
||||
to uint32: 65504 (OK)
|
||||
to uint64: 65504 (OK)
|
||||
from single: f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
to double: f64(0x1.ffc20000000000000000p+15:0x0040effc2000000000) (OK)
|
||||
to int32: 65505 (OK)
|
||||
to int64: 65505 (OK)
|
||||
to uint32: 65505 (OK)
|
||||
to uint64: 65505 (OK)
|
||||
from single: f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
to double: f64(0x1.ffbf0000000000000000p+16:0x0040fffbf000000000) (OK)
|
||||
to int32: 131007 (OK)
|
||||
to int64: 131007 (OK)
|
||||
to uint32: 131007 (OK)
|
||||
to uint64: 131007 (OK)
|
||||
from single: f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+16:0x0040fffc0000000000) (OK)
|
||||
to int32: 131008 (OK)
|
||||
to int64: 131008 (OK)
|
||||
to uint32: 131008 (OK)
|
||||
to uint64: 131008 (OK)
|
||||
from single: f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
to double: f64(0x1.ffc10000000000000000p+16:0x0040fffc1000000000) (OK)
|
||||
to int32: 131009 (OK)
|
||||
to int64: 131009 (OK)
|
||||
to uint32: 131009 (OK)
|
||||
to uint64: 131009 (OK)
|
||||
from single: f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
to double: f64(0x1.c0bab600000000000000p+99:0x00462c0bab60000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: 9223372036854775807 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
to double: f64(0x1.fffffe00000000000000p+127:0x0047efffffe0000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: 9223372036854775807 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(inf:0x7f800000)
|
||||
to double: f64(inf:0x007ff0000000000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: 9223372036854775807 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(nan:0x7fc00000)
|
||||
to double: f64(nan:0x007ff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(nan:0x7fa00000)
|
||||
to double: f64(nan:0x007ffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
768
tests/tcg/aarch64/float_madds.ref
Normal file
768
tests/tcg/aarch64/float_madds.ref
Normal file
@ -0,0 +1,768 @@
|
||||
### Rounding to nearest
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/0)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/1)
|
||||
op : f32(-inf:0xff800000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/2)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/0)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/1)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/2)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/0)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-inf:0xff800000)
|
||||
res: f32(-inf:0xff800000) flags=OK (2/1)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/2)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (3/0)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (3/1)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (3/2)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (4/0)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(-0x1.1874b200000000000000p+103:0xf30c3a59) flags=INEXACT (4/1)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) flags=INEXACT (4/2)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(0x1.0c27fa00000000000000p+60:0x5d8613fd) flags=INEXACT (5/0)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) flags=INEXACT (5/1)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(0x1.26c46200000000000000p+34:0x50936231) flags=INEXACT (5/2)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(0x1.91f94000000000000000p-106:0x0ac8fca0) flags=INEXACT (6/0)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(-0x1.31f75000000000000000p-40:0xab98fba8) flags=INEXACT (6/1)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544400000000000000p-66:0x9ea82a22) flags=INEXACT (6/2)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=UNDERFLOW INEXACT (7/0)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544400000000000000p-66:0x9ea82a22) flags=OK (7/1)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (7/2)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (8/0)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (8/1)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(-0x0.00000000000000000000p+0:0x80000000) flags=UNDERFLOW INEXACT (8/2)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000000000000000000p-25:0x33000000) flags=OK (9/0)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=UNDERFLOW INEXACT (9/1)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (9/2)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.ffffe600000000000000p-25:0x337ffff3) flags=INEXACT (10/0)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.ffffe600000000000000p-50:0x26fffff3) flags=INEXACT (10/1)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000000000000000000p-25:0x33000000) flags=INEXACT (10/2)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801a00000000000000p-15:0x387fc00d) flags=INEXACT (11/0)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.0007fe00000000000000p-25:0x330003ff) flags=INEXACT (11/1)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0001f200000000000000p-24:0x338000f9) flags=INEXACT (11/2)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00000c00000000000000p-14:0x38800006) flags=INEXACT (12/0)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0ffbf400000000000000p-24:0x3387fdfa) flags=INEXACT (12/1)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801c00000000000000p-15:0x387fc00e) flags=INEXACT (12/2)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00000000000000000000p+0:0x3f800000) flags=INEXACT (13/0)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ffc01800000000000000p-14:0x38ffe00c) flags=INEXACT (13/1)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.ffc01800000000000000p-14:0x38ffe00c) flags=INEXACT (13/2)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.00440000000000000000p+0:0x3f802200) flags=INEXACT (14/0)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00440000000000000000p+0:0x3f802200) flags=INEXACT (14/1)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00040200000000000000p+0:0x3f800201) flags=INEXACT (14/2)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/0)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.80400000000000000000p+1:0x40402000) flags=OK (15/1)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/2)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.2e185400000000000000p+2:0x40970c2a) flags=OK (16/0)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.9c00a800000000000000p+2:0x40ce0054) flags=OK (16/1)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.2e23d200000000000000p+2:0x409711e9) flags=INEXACT (16/2)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.12804200000000000000p+3:0x41094021) flags=INEXACT (17/0)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.51458000000000000000p+3:0x4128a2c0) flags=INEXACT (17/1)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.200c0400000000000000p+3:0x41100602) flags=INEXACT (17/2)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ffcf1400000000000000p+15:0x477fe78a) flags=INEXACT (18/0)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.91ed3c00000000000000p+17:0x4848f69e) flags=INEXACT (18/1)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.5bc56000000000000000p+17:0x482de2b0) flags=INEXACT (18/2)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.08edf000000000000000p+18:0x488476f8) flags=INEXACT (19/0)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.ff7e0800000000000000p+31:0x4f7fbf04) flags=INEXACT (19/1)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.08ee7a00000000000000p+18:0x4884773d) flags=INEXACT (19/2)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800800000000000000p+31:0x4f7fc004) flags=INEXACT (20/0)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ff840800000000000000p+31:0x4f7fc204) flags=INEXACT (20/1)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820800000000000000p+31:0x4f7fc104) flags=INEXACT (20/2)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff860800000000000000p+31:0x4f7fc304) flags=INEXACT (21/0)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820800000000000000p+32:0x4fffc104) flags=INEXACT (21/1)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800800000000000000p+32:0x4fffc004) flags=INEXACT (21/2)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff830800000000000000p+32:0x4fffc184) flags=INEXACT (22/0)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff7f8800000000000000p+33:0x507fbfc4) flags=INEXACT (22/1)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff840800000000000000p+32:0x4fffc204) flags=INEXACT (22/2)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.ff800800000000000000p+33:0x507fc004) flags=INEXACT (23/0)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff820800000000000000p+33:0x507fc104) flags=INEXACT (23/1)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff810800000000000000p+33:0x507fc084) flags=INEXACT (23/2)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(0x1.c0bab600000000000000p+99:0x71605d5b) flags=INEXACT (24/0)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.c0838000000000000000p+116:0x79e041c0) flags=INEXACT (24/1)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.c0829e00000000000000p+116:0x79e0414f) flags=INEXACT (24/2)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (25/0)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (25/1)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (25/2)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/0)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/1)
|
||||
op : f32(inf:0x7f800000) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/2)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/0)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/1)
|
||||
op : f32(nan:0x7fc00000) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/2)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/0)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/1)
|
||||
op : f32(nan:0x7fa00000) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/2)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (29/0)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/1)
|
||||
op : f32(-nan:0xffa00000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/2)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/0)
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/1)
|
||||
op : f32(-nan:0xffc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (30/2)
|
||||
# LP184149
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-1:0x3f000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=OK (31/0)
|
||||
op : f32(0x1.00000000000000000000p-149:0x00000001) * f32(0x1.00000000000000000000p-149:0x00000001) + f32(0x1.00000000000000000000p-149:0x00000001)
|
||||
res: f32(0x1.00000000000000000000p-149:0x00000001) flags=UNDERFLOW INEXACT (32/0)
|
||||
### Rounding upwards
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/0)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/1)
|
||||
op : f32(-inf:0xff800000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/2)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/0)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/1)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/2)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/0)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-inf:0xff800000)
|
||||
res: f32(-inf:0xff800000) flags=OK (2/1)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/2)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (3/0)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (3/1)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (3/2)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (4/0)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(-0x1.1874b000000000000000p+103:0xf30c3a58) flags=INEXACT (4/1)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab400000000000000p+99:0xf1605d5a) flags=INEXACT (4/2)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(0x1.0c27fa00000000000000p+60:0x5d8613fd) flags=INEXACT (5/0)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab400000000000000p+99:0xf1605d5a) flags=INEXACT (5/1)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(0x1.26c46200000000000000p+34:0x50936231) flags=INEXACT (5/2)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(0x1.91f94000000000000000p-106:0x0ac8fca0) flags=INEXACT (6/0)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(-0x1.31f74e00000000000000p-40:0xab98fba7) flags=INEXACT (6/1)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544200000000000000p-66:0x9ea82a21) flags=INEXACT (6/2)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x1.00000000000000000000p-149:0x00000001) flags=UNDERFLOW INEXACT (7/0)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544400000000000000p-66:0x9ea82a22) flags=OK (7/1)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (7/2)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (8/0)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (8/1)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(-0x0.00000000000000000000p+0:0x80000000) flags=UNDERFLOW INEXACT (8/2)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000000000000000000p-25:0x33000000) flags=OK (9/0)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x1.00000000000000000000p-149:0x00000001) flags=UNDERFLOW INEXACT (9/1)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (9/2)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.ffffe800000000000000p-25:0x337ffff4) flags=INEXACT (10/0)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.ffffe800000000000000p-50:0x26fffff4) flags=INEXACT (10/1)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000200000000000000p-25:0x33000001) flags=INEXACT (10/2)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801c00000000000000p-15:0x387fc00e) flags=INEXACT (11/0)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00080000000000000000p-25:0x33000400) flags=INEXACT (11/1)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0001f400000000000000p-24:0x338000fa) flags=INEXACT (11/2)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00000e00000000000000p-14:0x38800007) flags=INEXACT (12/0)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0ffbf600000000000000p-24:0x3387fdfb) flags=INEXACT (12/1)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801c00000000000000p-15:0x387fc00e) flags=INEXACT (12/2)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00000200000000000000p+0:0x3f800001) flags=INEXACT (13/0)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ffc01a00000000000000p-14:0x38ffe00d) flags=INEXACT (13/1)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.ffc01a00000000000000p-14:0x38ffe00d) flags=INEXACT (13/2)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.00440200000000000000p+0:0x3f802201) flags=INEXACT (14/0)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00440200000000000000p+0:0x3f802201) flags=INEXACT (14/1)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00040200000000000000p+0:0x3f800201) flags=INEXACT (14/2)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/0)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.80400000000000000000p+1:0x40402000) flags=OK (15/1)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/2)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.2e185400000000000000p+2:0x40970c2a) flags=OK (16/0)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.9c00a800000000000000p+2:0x40ce0054) flags=OK (16/1)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.2e23d400000000000000p+2:0x409711ea) flags=INEXACT (16/2)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.12804200000000000000p+3:0x41094021) flags=INEXACT (17/0)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.51458200000000000000p+3:0x4128a2c1) flags=INEXACT (17/1)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.200c0600000000000000p+3:0x41100603) flags=INEXACT (17/2)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ffcf1600000000000000p+15:0x477fe78b) flags=INEXACT (18/0)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.91ed3c00000000000000p+17:0x4848f69e) flags=INEXACT (18/1)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.5bc56200000000000000p+17:0x482de2b1) flags=INEXACT (18/2)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.08edf000000000000000p+18:0x488476f8) flags=INEXACT (19/0)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.ff7e0a00000000000000p+31:0x4f7fbf05) flags=INEXACT (19/1)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.08ee7a00000000000000p+18:0x4884773d) flags=INEXACT (19/2)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800a00000000000000p+31:0x4f7fc005) flags=INEXACT (20/0)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ff840800000000000000p+31:0x4f7fc204) flags=INEXACT (20/1)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820800000000000000p+31:0x4f7fc104) flags=INEXACT (20/2)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff860800000000000000p+31:0x4f7fc304) flags=INEXACT (21/0)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820800000000000000p+32:0x4fffc104) flags=INEXACT (21/1)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800a00000000000000p+32:0x4fffc005) flags=INEXACT (21/2)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff830800000000000000p+32:0x4fffc184) flags=INEXACT (22/0)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff7f8a00000000000000p+33:0x507fbfc5) flags=INEXACT (22/1)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff840800000000000000p+32:0x4fffc204) flags=INEXACT (22/2)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.ff800a00000000000000p+33:0x507fc005) flags=INEXACT (23/0)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff820800000000000000p+33:0x507fc104) flags=INEXACT (23/1)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff810800000000000000p+33:0x507fc084) flags=INEXACT (23/2)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(0x1.c0bab800000000000000p+99:0x71605d5c) flags=INEXACT (24/0)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.c0838000000000000000p+116:0x79e041c0) flags=INEXACT (24/1)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.c082a000000000000000p+116:0x79e04150) flags=INEXACT (24/2)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (25/0)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (25/1)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (25/2)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/0)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/1)
|
||||
op : f32(inf:0x7f800000) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/2)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/0)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/1)
|
||||
op : f32(nan:0x7fc00000) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/2)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/0)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/1)
|
||||
op : f32(nan:0x7fa00000) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/2)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (29/0)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/1)
|
||||
op : f32(-nan:0xffa00000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/2)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/0)
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/1)
|
||||
op : f32(-nan:0xffc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (30/2)
|
||||
# LP184149
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-1:0x3f000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=OK (31/0)
|
||||
op : f32(0x1.00000000000000000000p-149:0x00000001) * f32(0x1.00000000000000000000p-149:0x00000001) + f32(0x1.00000000000000000000p-149:0x00000001)
|
||||
res: f32(0x1.00000000000000000000p-148:0x00000002) flags=UNDERFLOW INEXACT (32/0)
|
||||
### Rounding downwards
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/0)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/1)
|
||||
op : f32(-inf:0xff800000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/2)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/0)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/1)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/2)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/0)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-inf:0xff800000)
|
||||
res: f32(-inf:0xff800000) flags=OK (2/1)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/2)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (3/0)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (3/1)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (3/2)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (4/0)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(-0x1.1874b200000000000000p+103:0xf30c3a59) flags=INEXACT (4/1)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) flags=INEXACT (4/2)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(0x1.0c27f800000000000000p+60:0x5d8613fc) flags=INEXACT (5/0)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) flags=INEXACT (5/1)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(0x1.26c46000000000000000p+34:0x50936230) flags=INEXACT (5/2)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(0x1.91f93e00000000000000p-106:0x0ac8fc9f) flags=INEXACT (6/0)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(-0x1.31f75000000000000000p-40:0xab98fba8) flags=INEXACT (6/1)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544400000000000000p-66:0x9ea82a22) flags=INEXACT (6/2)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=UNDERFLOW INEXACT (7/0)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544400000000000000p-66:0x9ea82a22) flags=OK (7/1)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (7/2)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (8/0)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (8/1)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(-0x1.00000000000000000000p-149:0x80000001) flags=UNDERFLOW INEXACT (8/2)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000000000000000000p-25:0x33000000) flags=OK (9/0)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=UNDERFLOW INEXACT (9/1)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (9/2)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.ffffe600000000000000p-25:0x337ffff3) flags=INEXACT (10/0)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.ffffe600000000000000p-50:0x26fffff3) flags=INEXACT (10/1)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000000000000000000p-25:0x33000000) flags=INEXACT (10/2)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801a00000000000000p-15:0x387fc00d) flags=INEXACT (11/0)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.0007fe00000000000000p-25:0x330003ff) flags=INEXACT (11/1)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0001f200000000000000p-24:0x338000f9) flags=INEXACT (11/2)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00000c00000000000000p-14:0x38800006) flags=INEXACT (12/0)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0ffbf400000000000000p-24:0x3387fdfa) flags=INEXACT (12/1)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801a00000000000000p-15:0x387fc00d) flags=INEXACT (12/2)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00000000000000000000p+0:0x3f800000) flags=INEXACT (13/0)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ffc01800000000000000p-14:0x38ffe00c) flags=INEXACT (13/1)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.ffc01800000000000000p-14:0x38ffe00c) flags=INEXACT (13/2)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.00440000000000000000p+0:0x3f802200) flags=INEXACT (14/0)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00440000000000000000p+0:0x3f802200) flags=INEXACT (14/1)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00040000000000000000p+0:0x3f800200) flags=INEXACT (14/2)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/0)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.80400000000000000000p+1:0x40402000) flags=OK (15/1)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/2)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.2e185400000000000000p+2:0x40970c2a) flags=OK (16/0)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.9c00a800000000000000p+2:0x40ce0054) flags=OK (16/1)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.2e23d200000000000000p+2:0x409711e9) flags=INEXACT (16/2)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.12804000000000000000p+3:0x41094020) flags=INEXACT (17/0)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.51458000000000000000p+3:0x4128a2c0) flags=INEXACT (17/1)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.200c0400000000000000p+3:0x41100602) flags=INEXACT (17/2)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ffcf1400000000000000p+15:0x477fe78a) flags=INEXACT (18/0)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.91ed3a00000000000000p+17:0x4848f69d) flags=INEXACT (18/1)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.5bc56000000000000000p+17:0x482de2b0) flags=INEXACT (18/2)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.08edee00000000000000p+18:0x488476f7) flags=INEXACT (19/0)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.ff7e0800000000000000p+31:0x4f7fbf04) flags=INEXACT (19/1)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.08ee7800000000000000p+18:0x4884773c) flags=INEXACT (19/2)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800800000000000000p+31:0x4f7fc004) flags=INEXACT (20/0)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ff840600000000000000p+31:0x4f7fc203) flags=INEXACT (20/1)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820600000000000000p+31:0x4f7fc103) flags=INEXACT (20/2)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff860600000000000000p+31:0x4f7fc303) flags=INEXACT (21/0)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820600000000000000p+32:0x4fffc103) flags=INEXACT (21/1)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800800000000000000p+32:0x4fffc004) flags=INEXACT (21/2)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff830600000000000000p+32:0x4fffc183) flags=INEXACT (22/0)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff7f8800000000000000p+33:0x507fbfc4) flags=INEXACT (22/1)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff840600000000000000p+32:0x4fffc203) flags=INEXACT (22/2)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.ff800800000000000000p+33:0x507fc004) flags=INEXACT (23/0)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff820600000000000000p+33:0x507fc103) flags=INEXACT (23/1)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff810600000000000000p+33:0x507fc083) flags=INEXACT (23/2)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(0x1.c0bab600000000000000p+99:0x71605d5b) flags=INEXACT (24/0)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.c0837e00000000000000p+116:0x79e041bf) flags=INEXACT (24/1)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.c0829e00000000000000p+116:0x79e0414f) flags=INEXACT (24/2)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (25/0)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (25/1)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (25/2)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/0)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/1)
|
||||
op : f32(inf:0x7f800000) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/2)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/0)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/1)
|
||||
op : f32(nan:0x7fc00000) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/2)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/0)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/1)
|
||||
op : f32(nan:0x7fa00000) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/2)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (29/0)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/1)
|
||||
op : f32(-nan:0xffa00000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/2)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/0)
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/1)
|
||||
op : f32(-nan:0xffc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (30/2)
|
||||
# LP184149
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-1:0x3f000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=OK (31/0)
|
||||
op : f32(0x1.00000000000000000000p-149:0x00000001) * f32(0x1.00000000000000000000p-149:0x00000001) + f32(0x1.00000000000000000000p-149:0x00000001)
|
||||
res: f32(0x1.00000000000000000000p-149:0x00000001) flags=UNDERFLOW INEXACT (32/0)
|
||||
### Rounding to zero
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/0)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/1)
|
||||
op : f32(-inf:0xff800000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/2)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/0)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/1)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/2)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/0)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-inf:0xff800000)
|
||||
res: f32(-inf:0xff800000) flags=OK (2/1)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/2)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (3/0)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (3/1)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (3/2)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (4/0)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(-0x1.1874b000000000000000p+103:0xf30c3a58) flags=INEXACT (4/1)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab400000000000000p+99:0xf1605d5a) flags=INEXACT (4/2)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(0x1.0c27f800000000000000p+60:0x5d8613fc) flags=INEXACT (5/0)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab400000000000000p+99:0xf1605d5a) flags=INEXACT (5/1)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(0x1.26c46000000000000000p+34:0x50936230) flags=INEXACT (5/2)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(0x1.91f93e00000000000000p-106:0x0ac8fc9f) flags=INEXACT (6/0)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(-0x1.31f74e00000000000000p-40:0xab98fba7) flags=INEXACT (6/1)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544200000000000000p-66:0x9ea82a21) flags=INEXACT (6/2)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=UNDERFLOW INEXACT (7/0)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544400000000000000p-66:0x9ea82a22) flags=OK (7/1)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (7/2)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (8/0)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (8/1)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(-0x0.00000000000000000000p+0:0x80000000) flags=UNDERFLOW INEXACT (8/2)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000000000000000000p-25:0x33000000) flags=OK (9/0)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=UNDERFLOW INEXACT (9/1)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (9/2)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.ffffe600000000000000p-25:0x337ffff3) flags=INEXACT (10/0)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.ffffe600000000000000p-50:0x26fffff3) flags=INEXACT (10/1)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000000000000000000p-25:0x33000000) flags=INEXACT (10/2)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801a00000000000000p-15:0x387fc00d) flags=INEXACT (11/0)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.0007fe00000000000000p-25:0x330003ff) flags=INEXACT (11/1)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0001f200000000000000p-24:0x338000f9) flags=INEXACT (11/2)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00000c00000000000000p-14:0x38800006) flags=INEXACT (12/0)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0ffbf400000000000000p-24:0x3387fdfa) flags=INEXACT (12/1)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801a00000000000000p-15:0x387fc00d) flags=INEXACT (12/2)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00000000000000000000p+0:0x3f800000) flags=INEXACT (13/0)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ffc01800000000000000p-14:0x38ffe00c) flags=INEXACT (13/1)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.ffc01800000000000000p-14:0x38ffe00c) flags=INEXACT (13/2)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.00440000000000000000p+0:0x3f802200) flags=INEXACT (14/0)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00440000000000000000p+0:0x3f802200) flags=INEXACT (14/1)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00040000000000000000p+0:0x3f800200) flags=INEXACT (14/2)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/0)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.80400000000000000000p+1:0x40402000) flags=OK (15/1)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/2)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.2e185400000000000000p+2:0x40970c2a) flags=OK (16/0)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.9c00a800000000000000p+2:0x40ce0054) flags=OK (16/1)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.2e23d200000000000000p+2:0x409711e9) flags=INEXACT (16/2)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.12804000000000000000p+3:0x41094020) flags=INEXACT (17/0)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.51458000000000000000p+3:0x4128a2c0) flags=INEXACT (17/1)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.200c0400000000000000p+3:0x41100602) flags=INEXACT (17/2)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ffcf1400000000000000p+15:0x477fe78a) flags=INEXACT (18/0)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.91ed3a00000000000000p+17:0x4848f69d) flags=INEXACT (18/1)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.5bc56000000000000000p+17:0x482de2b0) flags=INEXACT (18/2)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.08edee00000000000000p+18:0x488476f7) flags=INEXACT (19/0)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.ff7e0800000000000000p+31:0x4f7fbf04) flags=INEXACT (19/1)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.08ee7800000000000000p+18:0x4884773c) flags=INEXACT (19/2)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800800000000000000p+31:0x4f7fc004) flags=INEXACT (20/0)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ff840600000000000000p+31:0x4f7fc203) flags=INEXACT (20/1)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820600000000000000p+31:0x4f7fc103) flags=INEXACT (20/2)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff860600000000000000p+31:0x4f7fc303) flags=INEXACT (21/0)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820600000000000000p+32:0x4fffc103) flags=INEXACT (21/1)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800800000000000000p+32:0x4fffc004) flags=INEXACT (21/2)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff830600000000000000p+32:0x4fffc183) flags=INEXACT (22/0)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff7f8800000000000000p+33:0x507fbfc4) flags=INEXACT (22/1)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff840600000000000000p+32:0x4fffc203) flags=INEXACT (22/2)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.ff800800000000000000p+33:0x507fc004) flags=INEXACT (23/0)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff820600000000000000p+33:0x507fc103) flags=INEXACT (23/1)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff810600000000000000p+33:0x507fc083) flags=INEXACT (23/2)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(0x1.c0bab600000000000000p+99:0x71605d5b) flags=INEXACT (24/0)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.c0837e00000000000000p+116:0x79e041bf) flags=INEXACT (24/1)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.c0829e00000000000000p+116:0x79e0414f) flags=INEXACT (24/2)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (25/0)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (25/1)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (25/2)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/0)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/1)
|
||||
op : f32(inf:0x7f800000) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/2)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/0)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/1)
|
||||
op : f32(nan:0x7fc00000) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/2)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/0)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/1)
|
||||
op : f32(nan:0x7fa00000) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/2)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (29/0)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/1)
|
||||
op : f32(-nan:0xffa00000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/2)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/0)
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/1)
|
||||
op : f32(-nan:0xffc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (30/2)
|
||||
# LP184149
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-1:0x3f000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=OK (31/0)
|
||||
op : f32(0x1.00000000000000000000p-149:0x00000001) * f32(0x1.00000000000000000000p-149:0x00000001) + f32(0x1.00000000000000000000p-149:0x00000001)
|
||||
res: f32(0x1.00000000000000000000p-149:0x00000001) flags=UNDERFLOW INEXACT (32/0)
|
||||
@ -8,25 +8,29 @@ ARM_SRC=$(SRC_PATH)/tests/tcg/arm
|
||||
# Set search path for all sources
|
||||
VPATH += $(ARM_SRC)
|
||||
|
||||
ARM_TESTS=hello-arm test-arm-iwmmxt
|
||||
|
||||
TESTS += $(ARM_TESTS) fcvt
|
||||
# Multiarch Tests
|
||||
float_madds: CFLAGS+=-mfpu=neon-vfpv4
|
||||
|
||||
# Basic Hello World
|
||||
ARM_TESTS = hello-arm
|
||||
hello-arm: CFLAGS+=-marm -ffreestanding
|
||||
hello-arm: LDFLAGS+=-nostdlib
|
||||
|
||||
# IWMXT floating point extensions
|
||||
ARM_TESTS += test-arm-iwmmxt
|
||||
test-arm-iwmmxt: CFLAGS+=-marm -march=iwmmxt -mabi=aapcs -mfpu=fpv4-sp-d16
|
||||
test-arm-iwmmxt: test-arm-iwmmxt.S
|
||||
$(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)
|
||||
|
||||
ifeq ($(TARGET_NAME), arm)
|
||||
# Float-convert Tests
|
||||
ARM_TESTS += fcvt
|
||||
fcvt: LDFLAGS+=-lm
|
||||
# fcvt: CFLAGS+=-march=armv8.2-a+fp16 -mfpu=neon-fp-armv8
|
||||
|
||||
run-fcvt: fcvt
|
||||
$(call run-test,fcvt,$(QEMU) $<,"$< on $(TARGET_NAME)")
|
||||
$(call diff-out,fcvt,$(ARM_SRC)/fcvt.ref)
|
||||
endif
|
||||
|
||||
TESTS += $(ARM_TESTS)
|
||||
|
||||
# On ARM Linux only supports 4k pages
|
||||
EXTRA_RUNS+=run-test-mmap-4096
|
||||
|
||||
748
tests/tcg/arm/float_convs.ref
Normal file
748
tests/tcg/arm/float_convs.ref
Normal file
@ -0,0 +1,748 @@
|
||||
### Rounding to nearest
|
||||
from single: f32(-nan:0xffa00000)
|
||||
to double: f64(-nan:0x00fffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-nan:0xffc00000)
|
||||
to double: f64(-nan:0x00fff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-inf:0xff800000)
|
||||
to double: f64(-inf:0x00fff0000000000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
to double: f64(-0x1.fffffe00000000000000p+127:0x00c7efffffe0000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INEXACT INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
to double: f64(-0x1.1874b200000000000000p+103:0x00c661874b20000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INEXACT INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
to double: f64(-0x1.c0bab600000000000000p+99:0x00c62c0bab60000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INEXACT INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
to double: f64(-0x1.31f75000000000000000p-40:0x00bd731f7500000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
to double: f64(-0x1.50544400000000000000p-66:0x00bbd5054440000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
to double: f64(-0x1.00000000000000000000p-126:0x00b810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x0.00000000000000000000p+0:0000000000)
|
||||
to double: f64(0x0.00000000000000000000p+0:00000000000000000000) (OK)
|
||||
to int32: 0 (OK)
|
||||
to int64: 0 (OK)
|
||||
to uint32: 0 (OK)
|
||||
to uint64: 0 (OK)
|
||||
from single: f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
to double: f64(0x1.00000000000000000000p-126:0x003810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
to double: f64(0x1.00000000000000000000p-25:0x003e60000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
to double: f64(0x1.ffffe600000000000000p-25:0x003e6ffffe60000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
to double: f64(0x1.ff801a00000000000000p-15:0x003f0ff801a0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
to double: f64(0x1.00000c00000000000000p-14:0x003f100000c0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
to double: f64(0x1.00000000000000000000p+0:0x003ff0000000000000) (OK)
|
||||
to int32: 1 (OK)
|
||||
to int64: 1 (INEXACT )
|
||||
to uint32: 1 (OK)
|
||||
to uint64: 1 (INEXACT )
|
||||
from single: f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
to double: f64(0x1.00400000000000000000p+0:0x003ff0040000000000) (OK)
|
||||
to int32: 1 (INEXACT )
|
||||
to int64: 1 (INEXACT )
|
||||
to uint32: 1 (INEXACT )
|
||||
to uint64: 1 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
to double: f64(0x1.00000000000000000000p+1:0x004000000000000000) (OK)
|
||||
to int32: 2 (OK)
|
||||
to int64: 2 (INEXACT )
|
||||
to uint32: 2 (OK)
|
||||
to uint64: 2 (INEXACT )
|
||||
from single: f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
to double: f64(0x1.5bf0a800000000000000p+1:0x004005bf0a80000000) (OK)
|
||||
to int32: 2 (INEXACT )
|
||||
to int64: 2 (INEXACT )
|
||||
to uint32: 2 (INEXACT )
|
||||
to uint64: 2 (INEXACT )
|
||||
from single: f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
to double: f64(0x1.921fb600000000000000p+1:0x00400921fb60000000) (OK)
|
||||
to int32: 3 (INEXACT )
|
||||
to int64: 3 (INEXACT )
|
||||
to uint32: 3 (INEXACT )
|
||||
to uint64: 3 (INEXACT )
|
||||
from single: f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
to double: f64(0x1.ffbe0000000000000000p+15:0x0040effbe000000000) (OK)
|
||||
to int32: 65503 (OK)
|
||||
to int64: 65503 (INEXACT )
|
||||
to uint32: 65503 (OK)
|
||||
to uint64: 65503 (INEXACT )
|
||||
from single: f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+15:0x0040effc0000000000) (OK)
|
||||
to int32: 65504 (OK)
|
||||
to int64: 65504 (INEXACT )
|
||||
to uint32: 65504 (OK)
|
||||
to uint64: 65504 (INEXACT )
|
||||
from single: f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
to double: f64(0x1.ffc20000000000000000p+15:0x0040effc2000000000) (OK)
|
||||
to int32: 65505 (OK)
|
||||
to int64: 65505 (INEXACT )
|
||||
to uint32: 65505 (OK)
|
||||
to uint64: 65505 (INEXACT )
|
||||
from single: f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
to double: f64(0x1.ffbf0000000000000000p+16:0x0040fffbf000000000) (OK)
|
||||
to int32: 131007 (OK)
|
||||
to int64: 131007 (INEXACT )
|
||||
to uint32: 131007 (OK)
|
||||
to uint64: 131007 (INEXACT )
|
||||
from single: f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+16:0x0040fffc0000000000) (OK)
|
||||
to int32: 131008 (OK)
|
||||
to int64: 131008 (INEXACT )
|
||||
to uint32: 131008 (OK)
|
||||
to uint64: 131008 (INEXACT )
|
||||
from single: f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
to double: f64(0x1.ffc10000000000000000p+16:0x0040fffc1000000000) (OK)
|
||||
to int32: 131009 (OK)
|
||||
to int64: 131009 (INEXACT )
|
||||
to uint32: 131009 (OK)
|
||||
to uint64: 131009 (INEXACT )
|
||||
from single: f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
to double: f64(0x1.c0bab600000000000000p+99:0x00462c0bab60000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: -1 (INEXACT INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INEXACT INVALID)
|
||||
from single: f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
to double: f64(0x1.fffffe00000000000000p+127:0x0047efffffe0000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: -1 (INEXACT INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INEXACT INVALID)
|
||||
from single: f32(inf:0x7f800000)
|
||||
to double: f64(inf:0x007ff0000000000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: -1 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(nan:0x7fc00000)
|
||||
to double: f64(nan:0x007ff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(nan:0x7fa00000)
|
||||
to double: f64(nan:0x007ffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
### Rounding upwards
|
||||
from single: f32(-nan:0xffa00000)
|
||||
to double: f64(-nan:0x00fffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-nan:0xffc00000)
|
||||
to double: f64(-nan:0x00fff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-inf:0xff800000)
|
||||
to double: f64(-inf:0x00fff0000000000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
to double: f64(-0x1.fffffe00000000000000p+127:0x00c7efffffe0000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INEXACT INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
to double: f64(-0x1.1874b200000000000000p+103:0x00c661874b20000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INEXACT INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
to double: f64(-0x1.c0bab600000000000000p+99:0x00c62c0bab60000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INEXACT INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
to double: f64(-0x1.31f75000000000000000p-40:0x00bd731f7500000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
to double: f64(-0x1.50544400000000000000p-66:0x00bbd5054440000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
to double: f64(-0x1.00000000000000000000p-126:0x00b810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x0.00000000000000000000p+0:0000000000)
|
||||
to double: f64(0x0.00000000000000000000p+0:00000000000000000000) (OK)
|
||||
to int32: 0 (OK)
|
||||
to int64: 0 (OK)
|
||||
to uint32: 0 (OK)
|
||||
to uint64: 0 (OK)
|
||||
from single: f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
to double: f64(0x1.00000000000000000000p-126:0x003810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
to double: f64(0x1.00000000000000000000p-25:0x003e60000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
to double: f64(0x1.ffffe600000000000000p-25:0x003e6ffffe60000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
to double: f64(0x1.ff801a00000000000000p-15:0x003f0ff801a0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
to double: f64(0x1.00000c00000000000000p-14:0x003f100000c0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
to double: f64(0x1.00000000000000000000p+0:0x003ff0000000000000) (OK)
|
||||
to int32: 1 (OK)
|
||||
to int64: 1 (INEXACT )
|
||||
to uint32: 1 (OK)
|
||||
to uint64: 1 (INEXACT )
|
||||
from single: f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
to double: f64(0x1.00400000000000000000p+0:0x003ff0040000000000) (OK)
|
||||
to int32: 1 (INEXACT )
|
||||
to int64: 1 (INEXACT )
|
||||
to uint32: 1 (INEXACT )
|
||||
to uint64: 1 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
to double: f64(0x1.00000000000000000000p+1:0x004000000000000000) (OK)
|
||||
to int32: 2 (OK)
|
||||
to int64: 2 (INEXACT )
|
||||
to uint32: 2 (OK)
|
||||
to uint64: 2 (INEXACT )
|
||||
from single: f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
to double: f64(0x1.5bf0a800000000000000p+1:0x004005bf0a80000000) (OK)
|
||||
to int32: 2 (INEXACT )
|
||||
to int64: 2 (INEXACT )
|
||||
to uint32: 2 (INEXACT )
|
||||
to uint64: 2 (INEXACT )
|
||||
from single: f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
to double: f64(0x1.921fb600000000000000p+1:0x00400921fb60000000) (OK)
|
||||
to int32: 3 (INEXACT )
|
||||
to int64: 3 (INEXACT )
|
||||
to uint32: 3 (INEXACT )
|
||||
to uint64: 3 (INEXACT )
|
||||
from single: f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
to double: f64(0x1.ffbe0000000000000000p+15:0x0040effbe000000000) (OK)
|
||||
to int32: 65503 (OK)
|
||||
to int64: 65503 (INEXACT )
|
||||
to uint32: 65503 (OK)
|
||||
to uint64: 65503 (INEXACT )
|
||||
from single: f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+15:0x0040effc0000000000) (OK)
|
||||
to int32: 65504 (OK)
|
||||
to int64: 65504 (INEXACT )
|
||||
to uint32: 65504 (OK)
|
||||
to uint64: 65504 (INEXACT )
|
||||
from single: f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
to double: f64(0x1.ffc20000000000000000p+15:0x0040effc2000000000) (OK)
|
||||
to int32: 65505 (OK)
|
||||
to int64: 65505 (INEXACT )
|
||||
to uint32: 65505 (OK)
|
||||
to uint64: 65505 (INEXACT )
|
||||
from single: f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
to double: f64(0x1.ffbf0000000000000000p+16:0x0040fffbf000000000) (OK)
|
||||
to int32: 131007 (OK)
|
||||
to int64: 131007 (INEXACT )
|
||||
to uint32: 131007 (OK)
|
||||
to uint64: 131007 (INEXACT )
|
||||
from single: f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+16:0x0040fffc0000000000) (OK)
|
||||
to int32: 131008 (OK)
|
||||
to int64: 131008 (INEXACT )
|
||||
to uint32: 131008 (OK)
|
||||
to uint64: 131008 (INEXACT )
|
||||
from single: f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
to double: f64(0x1.ffc10000000000000000p+16:0x0040fffc1000000000) (OK)
|
||||
to int32: 131009 (OK)
|
||||
to int64: 131009 (INEXACT )
|
||||
to uint32: 131009 (OK)
|
||||
to uint64: 131009 (INEXACT )
|
||||
from single: f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
to double: f64(0x1.c0bab600000000000000p+99:0x00462c0bab60000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: -1 (INEXACT INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INEXACT INVALID)
|
||||
from single: f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
to double: f64(0x1.fffffe00000000000000p+127:0x0047efffffe0000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: -1 (INEXACT INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INEXACT INVALID)
|
||||
from single: f32(inf:0x7f800000)
|
||||
to double: f64(inf:0x007ff0000000000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: -1 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(nan:0x7fc00000)
|
||||
to double: f64(nan:0x007ff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(nan:0x7fa00000)
|
||||
to double: f64(nan:0x007ffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
### Rounding downwards
|
||||
from single: f32(-nan:0xffa00000)
|
||||
to double: f64(-nan:0x00fffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-nan:0xffc00000)
|
||||
to double: f64(-nan:0x00fff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-inf:0xff800000)
|
||||
to double: f64(-inf:0x00fff0000000000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
to double: f64(-0x1.fffffe00000000000000p+127:0x00c7efffffe0000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INEXACT INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
to double: f64(-0x1.1874b200000000000000p+103:0x00c661874b20000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INEXACT INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
to double: f64(-0x1.c0bab600000000000000p+99:0x00c62c0bab60000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INEXACT INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
to double: f64(-0x1.31f75000000000000000p-40:0x00bd731f7500000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
to double: f64(-0x1.50544400000000000000p-66:0x00bbd5054440000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
to double: f64(-0x1.00000000000000000000p-126:0x00b810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x0.00000000000000000000p+0:0000000000)
|
||||
to double: f64(0x0.00000000000000000000p+0:00000000000000000000) (OK)
|
||||
to int32: 0 (OK)
|
||||
to int64: 0 (OK)
|
||||
to uint32: 0 (OK)
|
||||
to uint64: 0 (OK)
|
||||
from single: f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
to double: f64(0x1.00000000000000000000p-126:0x003810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
to double: f64(0x1.00000000000000000000p-25:0x003e60000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
to double: f64(0x1.ffffe600000000000000p-25:0x003e6ffffe60000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
to double: f64(0x1.ff801a00000000000000p-15:0x003f0ff801a0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
to double: f64(0x1.00000c00000000000000p-14:0x003f100000c0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
to double: f64(0x1.00000000000000000000p+0:0x003ff0000000000000) (OK)
|
||||
to int32: 1 (OK)
|
||||
to int64: 1 (INEXACT )
|
||||
to uint32: 1 (OK)
|
||||
to uint64: 1 (INEXACT )
|
||||
from single: f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
to double: f64(0x1.00400000000000000000p+0:0x003ff0040000000000) (OK)
|
||||
to int32: 1 (INEXACT )
|
||||
to int64: 1 (INEXACT )
|
||||
to uint32: 1 (INEXACT )
|
||||
to uint64: 1 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
to double: f64(0x1.00000000000000000000p+1:0x004000000000000000) (OK)
|
||||
to int32: 2 (OK)
|
||||
to int64: 2 (INEXACT )
|
||||
to uint32: 2 (OK)
|
||||
to uint64: 2 (INEXACT )
|
||||
from single: f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
to double: f64(0x1.5bf0a800000000000000p+1:0x004005bf0a80000000) (OK)
|
||||
to int32: 2 (INEXACT )
|
||||
to int64: 2 (INEXACT )
|
||||
to uint32: 2 (INEXACT )
|
||||
to uint64: 2 (INEXACT )
|
||||
from single: f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
to double: f64(0x1.921fb600000000000000p+1:0x00400921fb60000000) (OK)
|
||||
to int32: 3 (INEXACT )
|
||||
to int64: 3 (INEXACT )
|
||||
to uint32: 3 (INEXACT )
|
||||
to uint64: 3 (INEXACT )
|
||||
from single: f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
to double: f64(0x1.ffbe0000000000000000p+15:0x0040effbe000000000) (OK)
|
||||
to int32: 65503 (OK)
|
||||
to int64: 65503 (INEXACT )
|
||||
to uint32: 65503 (OK)
|
||||
to uint64: 65503 (INEXACT )
|
||||
from single: f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+15:0x0040effc0000000000) (OK)
|
||||
to int32: 65504 (OK)
|
||||
to int64: 65504 (INEXACT )
|
||||
to uint32: 65504 (OK)
|
||||
to uint64: 65504 (INEXACT )
|
||||
from single: f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
to double: f64(0x1.ffc20000000000000000p+15:0x0040effc2000000000) (OK)
|
||||
to int32: 65505 (OK)
|
||||
to int64: 65505 (INEXACT )
|
||||
to uint32: 65505 (OK)
|
||||
to uint64: 65505 (INEXACT )
|
||||
from single: f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
to double: f64(0x1.ffbf0000000000000000p+16:0x0040fffbf000000000) (OK)
|
||||
to int32: 131007 (OK)
|
||||
to int64: 131007 (INEXACT )
|
||||
to uint32: 131007 (OK)
|
||||
to uint64: 131007 (INEXACT )
|
||||
from single: f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+16:0x0040fffc0000000000) (OK)
|
||||
to int32: 131008 (OK)
|
||||
to int64: 131008 (INEXACT )
|
||||
to uint32: 131008 (OK)
|
||||
to uint64: 131008 (INEXACT )
|
||||
from single: f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
to double: f64(0x1.ffc10000000000000000p+16:0x0040fffc1000000000) (OK)
|
||||
to int32: 131009 (OK)
|
||||
to int64: 131009 (INEXACT )
|
||||
to uint32: 131009 (OK)
|
||||
to uint64: 131009 (INEXACT )
|
||||
from single: f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
to double: f64(0x1.c0bab600000000000000p+99:0x00462c0bab60000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: -1 (INEXACT INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INEXACT INVALID)
|
||||
from single: f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
to double: f64(0x1.fffffe00000000000000p+127:0x0047efffffe0000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: -1 (INEXACT INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INEXACT INVALID)
|
||||
from single: f32(inf:0x7f800000)
|
||||
to double: f64(inf:0x007ff0000000000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: -1 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(nan:0x7fc00000)
|
||||
to double: f64(nan:0x007ff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(nan:0x7fa00000)
|
||||
to double: f64(nan:0x007ffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
### Rounding to zero
|
||||
from single: f32(-nan:0xffa00000)
|
||||
to double: f64(-nan:0x00fffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-nan:0xffc00000)
|
||||
to double: f64(-nan:0x00fff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-inf:0xff800000)
|
||||
to double: f64(-inf:0x00fff0000000000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
to double: f64(-0x1.fffffe00000000000000p+127:0x00c7efffffe0000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INEXACT INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
to double: f64(-0x1.1874b200000000000000p+103:0x00c661874b20000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INEXACT INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
to double: f64(-0x1.c0bab600000000000000p+99:0x00c62c0bab60000000) (OK)
|
||||
to int32: -2147483648 (INVALID)
|
||||
to int64: 1 (INEXACT INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
to double: f64(-0x1.31f75000000000000000p-40:0x00bd731f7500000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
to double: f64(-0x1.50544400000000000000p-66:0x00bbd5054440000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
to double: f64(-0x1.00000000000000000000p-126:0x00b810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x0.00000000000000000000p+0:0000000000)
|
||||
to double: f64(0x0.00000000000000000000p+0:00000000000000000000) (OK)
|
||||
to int32: 0 (OK)
|
||||
to int64: 0 (OK)
|
||||
to uint32: 0 (OK)
|
||||
to uint64: 0 (OK)
|
||||
from single: f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
to double: f64(0x1.00000000000000000000p-126:0x003810000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
to double: f64(0x1.00000000000000000000p-25:0x003e60000000000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
to double: f64(0x1.ffffe600000000000000p-25:0x003e6ffffe60000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
to double: f64(0x1.ff801a00000000000000p-15:0x003f0ff801a0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
to double: f64(0x1.00000c00000000000000p-14:0x003f100000c0000000) (OK)
|
||||
to int32: 0 (INEXACT )
|
||||
to int64: 0 (INEXACT )
|
||||
to uint32: 0 (INEXACT )
|
||||
to uint64: 0 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
to double: f64(0x1.00000000000000000000p+0:0x003ff0000000000000) (OK)
|
||||
to int32: 1 (OK)
|
||||
to int64: 1 (INEXACT )
|
||||
to uint32: 1 (OK)
|
||||
to uint64: 1 (INEXACT )
|
||||
from single: f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
to double: f64(0x1.00400000000000000000p+0:0x003ff0040000000000) (OK)
|
||||
to int32: 1 (INEXACT )
|
||||
to int64: 1 (INEXACT )
|
||||
to uint32: 1 (INEXACT )
|
||||
to uint64: 1 (INEXACT )
|
||||
from single: f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
to double: f64(0x1.00000000000000000000p+1:0x004000000000000000) (OK)
|
||||
to int32: 2 (OK)
|
||||
to int64: 2 (INEXACT )
|
||||
to uint32: 2 (OK)
|
||||
to uint64: 2 (INEXACT )
|
||||
from single: f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
to double: f64(0x1.5bf0a800000000000000p+1:0x004005bf0a80000000) (OK)
|
||||
to int32: 2 (INEXACT )
|
||||
to int64: 2 (INEXACT )
|
||||
to uint32: 2 (INEXACT )
|
||||
to uint64: 2 (INEXACT )
|
||||
from single: f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
to double: f64(0x1.921fb600000000000000p+1:0x00400921fb60000000) (OK)
|
||||
to int32: 3 (INEXACT )
|
||||
to int64: 3 (INEXACT )
|
||||
to uint32: 3 (INEXACT )
|
||||
to uint64: 3 (INEXACT )
|
||||
from single: f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
to double: f64(0x1.ffbe0000000000000000p+15:0x0040effbe000000000) (OK)
|
||||
to int32: 65503 (OK)
|
||||
to int64: 65503 (INEXACT )
|
||||
to uint32: 65503 (OK)
|
||||
to uint64: 65503 (INEXACT )
|
||||
from single: f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+15:0x0040effc0000000000) (OK)
|
||||
to int32: 65504 (OK)
|
||||
to int64: 65504 (INEXACT )
|
||||
to uint32: 65504 (OK)
|
||||
to uint64: 65504 (INEXACT )
|
||||
from single: f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
to double: f64(0x1.ffc20000000000000000p+15:0x0040effc2000000000) (OK)
|
||||
to int32: 65505 (OK)
|
||||
to int64: 65505 (INEXACT )
|
||||
to uint32: 65505 (OK)
|
||||
to uint64: 65505 (INEXACT )
|
||||
from single: f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
to double: f64(0x1.ffbf0000000000000000p+16:0x0040fffbf000000000) (OK)
|
||||
to int32: 131007 (OK)
|
||||
to int64: 131007 (INEXACT )
|
||||
to uint32: 131007 (OK)
|
||||
to uint64: 131007 (INEXACT )
|
||||
from single: f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
to double: f64(0x1.ffc00000000000000000p+16:0x0040fffc0000000000) (OK)
|
||||
to int32: 131008 (OK)
|
||||
to int64: 131008 (INEXACT )
|
||||
to uint32: 131008 (OK)
|
||||
to uint64: 131008 (INEXACT )
|
||||
from single: f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
to double: f64(0x1.ffc10000000000000000p+16:0x0040fffc1000000000) (OK)
|
||||
to int32: 131009 (OK)
|
||||
to int64: 131009 (INEXACT )
|
||||
to uint32: 131009 (OK)
|
||||
to uint64: 131009 (INEXACT )
|
||||
from single: f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
to double: f64(0x1.c0bab600000000000000p+99:0x00462c0bab60000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: -1 (INEXACT INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INEXACT INVALID)
|
||||
from single: f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
to double: f64(0x1.fffffe00000000000000p+127:0x0047efffffe0000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: -1 (INEXACT INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INEXACT INVALID)
|
||||
from single: f32(inf:0x7f800000)
|
||||
to double: f64(inf:0x007ff0000000000000) (OK)
|
||||
to int32: 2147483647 (INVALID)
|
||||
to int64: -1 (INVALID)
|
||||
to uint32: -1 (INVALID)
|
||||
to uint64: -1 (INVALID)
|
||||
from single: f32(nan:0x7fc00000)
|
||||
to double: f64(nan:0x007ff8000000000000) (OK)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
from single: f32(nan:0x7fa00000)
|
||||
to double: f64(nan:0x007ffc000000000000) (INVALID)
|
||||
to int32: 0 (INVALID)
|
||||
to int64: 0 (INVALID)
|
||||
to uint32: 0 (INVALID)
|
||||
to uint64: 0 (INVALID)
|
||||
768
tests/tcg/arm/float_madds.ref
Normal file
768
tests/tcg/arm/float_madds.ref
Normal file
@ -0,0 +1,768 @@
|
||||
### Rounding to nearest
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/0)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/1)
|
||||
op : f32(-inf:0xff800000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/2)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/0)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/1)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/2)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/0)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-inf:0xff800000)
|
||||
res: f32(-inf:0xff800000) flags=OK (2/1)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/2)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (3/0)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (3/1)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (3/2)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (4/0)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(-0x1.1874b200000000000000p+103:0xf30c3a59) flags=INEXACT (4/1)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) flags=INEXACT (4/2)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(0x1.0c27fa00000000000000p+60:0x5d8613fd) flags=INEXACT (5/0)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) flags=INEXACT (5/1)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(0x1.26c46200000000000000p+34:0x50936231) flags=INEXACT (5/2)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(0x1.91f94000000000000000p-106:0x0ac8fca0) flags=INEXACT (6/0)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(-0x1.31f75000000000000000p-40:0xab98fba8) flags=INEXACT (6/1)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544400000000000000p-66:0x9ea82a22) flags=INEXACT (6/2)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=UNDERFLOW INEXACT (7/0)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544400000000000000p-66:0x9ea82a22) flags=OK (7/1)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (7/2)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (8/0)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (8/1)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(-0x0.00000000000000000000p+0:0x80000000) flags=UNDERFLOW INEXACT (8/2)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000000000000000000p-25:0x33000000) flags=OK (9/0)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=UNDERFLOW INEXACT (9/1)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (9/2)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.ffffe600000000000000p-25:0x337ffff3) flags=INEXACT (10/0)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.ffffe600000000000000p-50:0x26fffff3) flags=INEXACT (10/1)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000000000000000000p-25:0x33000000) flags=INEXACT (10/2)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801a00000000000000p-15:0x387fc00d) flags=INEXACT (11/0)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.0007fe00000000000000p-25:0x330003ff) flags=INEXACT (11/1)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0001f200000000000000p-24:0x338000f9) flags=INEXACT (11/2)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00000c00000000000000p-14:0x38800006) flags=INEXACT (12/0)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0ffbf400000000000000p-24:0x3387fdfa) flags=INEXACT (12/1)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801c00000000000000p-15:0x387fc00e) flags=INEXACT (12/2)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00000000000000000000p+0:0x3f800000) flags=INEXACT (13/0)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ffc01800000000000000p-14:0x38ffe00c) flags=INEXACT (13/1)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.ffc01800000000000000p-14:0x38ffe00c) flags=INEXACT (13/2)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.00440000000000000000p+0:0x3f802200) flags=INEXACT (14/0)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00440000000000000000p+0:0x3f802200) flags=INEXACT (14/1)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00040200000000000000p+0:0x3f800201) flags=INEXACT (14/2)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/0)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.80400000000000000000p+1:0x40402000) flags=OK (15/1)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/2)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.2e185400000000000000p+2:0x40970c2a) flags=OK (16/0)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.9c00a800000000000000p+2:0x40ce0054) flags=OK (16/1)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.2e23d200000000000000p+2:0x409711e9) flags=INEXACT (16/2)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.12804200000000000000p+3:0x41094021) flags=INEXACT (17/0)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.51458000000000000000p+3:0x4128a2c0) flags=INEXACT (17/1)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.200c0400000000000000p+3:0x41100602) flags=INEXACT (17/2)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ffcf1400000000000000p+15:0x477fe78a) flags=INEXACT (18/0)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.91ed3c00000000000000p+17:0x4848f69e) flags=INEXACT (18/1)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.5bc56000000000000000p+17:0x482de2b0) flags=INEXACT (18/2)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.08edf000000000000000p+18:0x488476f8) flags=INEXACT (19/0)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.ff7e0800000000000000p+31:0x4f7fbf04) flags=INEXACT (19/1)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.08ee7a00000000000000p+18:0x4884773d) flags=INEXACT (19/2)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800800000000000000p+31:0x4f7fc004) flags=INEXACT (20/0)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ff840800000000000000p+31:0x4f7fc204) flags=INEXACT (20/1)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820800000000000000p+31:0x4f7fc104) flags=INEXACT (20/2)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff860800000000000000p+31:0x4f7fc304) flags=INEXACT (21/0)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820800000000000000p+32:0x4fffc104) flags=INEXACT (21/1)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800800000000000000p+32:0x4fffc004) flags=INEXACT (21/2)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff830800000000000000p+32:0x4fffc184) flags=INEXACT (22/0)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff7f8800000000000000p+33:0x507fbfc4) flags=INEXACT (22/1)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff840800000000000000p+32:0x4fffc204) flags=INEXACT (22/2)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.ff800800000000000000p+33:0x507fc004) flags=INEXACT (23/0)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff820800000000000000p+33:0x507fc104) flags=INEXACT (23/1)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff810800000000000000p+33:0x507fc084) flags=INEXACT (23/2)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(0x1.c0bab600000000000000p+99:0x71605d5b) flags=INEXACT (24/0)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.c0838000000000000000p+116:0x79e041c0) flags=INEXACT (24/1)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.c0829e00000000000000p+116:0x79e0414f) flags=INEXACT (24/2)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (25/0)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (25/1)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (25/2)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/0)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/1)
|
||||
op : f32(inf:0x7f800000) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/2)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/0)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/1)
|
||||
op : f32(nan:0x7fc00000) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/2)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/0)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/1)
|
||||
op : f32(nan:0x7fa00000) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/2)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (29/0)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/1)
|
||||
op : f32(-nan:0xffa00000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/2)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/0)
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/1)
|
||||
op : f32(-nan:0xffc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (30/2)
|
||||
# LP184149
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-1:0x3f000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=OK (31/0)
|
||||
op : f32(0x1.00000000000000000000p-149:0x00000001) * f32(0x1.00000000000000000000p-149:0x00000001) + f32(0x1.00000000000000000000p-149:0x00000001)
|
||||
res: f32(0x1.00000000000000000000p-149:0x00000001) flags=UNDERFLOW INEXACT (32/0)
|
||||
### Rounding upwards
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/0)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/1)
|
||||
op : f32(-inf:0xff800000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/2)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/0)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/1)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/2)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/0)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-inf:0xff800000)
|
||||
res: f32(-inf:0xff800000) flags=OK (2/1)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/2)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (3/0)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (3/1)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (3/2)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (4/0)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(-0x1.1874b000000000000000p+103:0xf30c3a58) flags=INEXACT (4/1)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab400000000000000p+99:0xf1605d5a) flags=INEXACT (4/2)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(0x1.0c27fa00000000000000p+60:0x5d8613fd) flags=INEXACT (5/0)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab400000000000000p+99:0xf1605d5a) flags=INEXACT (5/1)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(0x1.26c46200000000000000p+34:0x50936231) flags=INEXACT (5/2)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(0x1.91f94000000000000000p-106:0x0ac8fca0) flags=INEXACT (6/0)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(-0x1.31f74e00000000000000p-40:0xab98fba7) flags=INEXACT (6/1)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544200000000000000p-66:0x9ea82a21) flags=INEXACT (6/2)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x1.00000000000000000000p-149:0x00000001) flags=UNDERFLOW INEXACT (7/0)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544400000000000000p-66:0x9ea82a22) flags=OK (7/1)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (7/2)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (8/0)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (8/1)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(-0x0.00000000000000000000p+0:0x80000000) flags=UNDERFLOW INEXACT (8/2)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000000000000000000p-25:0x33000000) flags=OK (9/0)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x1.00000000000000000000p-149:0x00000001) flags=UNDERFLOW INEXACT (9/1)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (9/2)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.ffffe800000000000000p-25:0x337ffff4) flags=INEXACT (10/0)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.ffffe800000000000000p-50:0x26fffff4) flags=INEXACT (10/1)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000200000000000000p-25:0x33000001) flags=INEXACT (10/2)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801c00000000000000p-15:0x387fc00e) flags=INEXACT (11/0)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00080000000000000000p-25:0x33000400) flags=INEXACT (11/1)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0001f400000000000000p-24:0x338000fa) flags=INEXACT (11/2)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00000e00000000000000p-14:0x38800007) flags=INEXACT (12/0)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0ffbf600000000000000p-24:0x3387fdfb) flags=INEXACT (12/1)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801c00000000000000p-15:0x387fc00e) flags=INEXACT (12/2)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00000200000000000000p+0:0x3f800001) flags=INEXACT (13/0)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ffc01a00000000000000p-14:0x38ffe00d) flags=INEXACT (13/1)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.ffc01a00000000000000p-14:0x38ffe00d) flags=INEXACT (13/2)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.00440200000000000000p+0:0x3f802201) flags=INEXACT (14/0)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00440200000000000000p+0:0x3f802201) flags=INEXACT (14/1)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00040200000000000000p+0:0x3f800201) flags=INEXACT (14/2)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/0)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.80400000000000000000p+1:0x40402000) flags=OK (15/1)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/2)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.2e185400000000000000p+2:0x40970c2a) flags=OK (16/0)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.9c00a800000000000000p+2:0x40ce0054) flags=OK (16/1)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.2e23d400000000000000p+2:0x409711ea) flags=INEXACT (16/2)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.12804200000000000000p+3:0x41094021) flags=INEXACT (17/0)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.51458200000000000000p+3:0x4128a2c1) flags=INEXACT (17/1)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.200c0600000000000000p+3:0x41100603) flags=INEXACT (17/2)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ffcf1600000000000000p+15:0x477fe78b) flags=INEXACT (18/0)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.91ed3c00000000000000p+17:0x4848f69e) flags=INEXACT (18/1)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.5bc56200000000000000p+17:0x482de2b1) flags=INEXACT (18/2)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.08edf000000000000000p+18:0x488476f8) flags=INEXACT (19/0)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.ff7e0a00000000000000p+31:0x4f7fbf05) flags=INEXACT (19/1)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.08ee7a00000000000000p+18:0x4884773d) flags=INEXACT (19/2)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800a00000000000000p+31:0x4f7fc005) flags=INEXACT (20/0)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ff840800000000000000p+31:0x4f7fc204) flags=INEXACT (20/1)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820800000000000000p+31:0x4f7fc104) flags=INEXACT (20/2)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff860800000000000000p+31:0x4f7fc304) flags=INEXACT (21/0)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820800000000000000p+32:0x4fffc104) flags=INEXACT (21/1)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800a00000000000000p+32:0x4fffc005) flags=INEXACT (21/2)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff830800000000000000p+32:0x4fffc184) flags=INEXACT (22/0)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff7f8a00000000000000p+33:0x507fbfc5) flags=INEXACT (22/1)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff840800000000000000p+32:0x4fffc204) flags=INEXACT (22/2)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.ff800a00000000000000p+33:0x507fc005) flags=INEXACT (23/0)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff820800000000000000p+33:0x507fc104) flags=INEXACT (23/1)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff810800000000000000p+33:0x507fc084) flags=INEXACT (23/2)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(0x1.c0bab800000000000000p+99:0x71605d5c) flags=INEXACT (24/0)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.c0838000000000000000p+116:0x79e041c0) flags=INEXACT (24/1)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.c082a000000000000000p+116:0x79e04150) flags=INEXACT (24/2)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (25/0)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (25/1)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OVERFLOW INEXACT (25/2)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/0)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/1)
|
||||
op : f32(inf:0x7f800000) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/2)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/0)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/1)
|
||||
op : f32(nan:0x7fc00000) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/2)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/0)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/1)
|
||||
op : f32(nan:0x7fa00000) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/2)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (29/0)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/1)
|
||||
op : f32(-nan:0xffa00000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/2)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/0)
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/1)
|
||||
op : f32(-nan:0xffc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (30/2)
|
||||
# LP184149
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-1:0x3f000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=OK (31/0)
|
||||
op : f32(0x1.00000000000000000000p-149:0x00000001) * f32(0x1.00000000000000000000p-149:0x00000001) + f32(0x1.00000000000000000000p-149:0x00000001)
|
||||
res: f32(0x1.00000000000000000000p-148:0x00000002) flags=UNDERFLOW INEXACT (32/0)
|
||||
### Rounding downwards
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/0)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/1)
|
||||
op : f32(-inf:0xff800000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/2)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/0)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/1)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/2)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/0)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-inf:0xff800000)
|
||||
res: f32(-inf:0xff800000) flags=OK (2/1)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/2)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (3/0)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (3/1)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (3/2)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (4/0)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(-0x1.1874b200000000000000p+103:0xf30c3a59) flags=INEXACT (4/1)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) flags=INEXACT (4/2)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(0x1.0c27f800000000000000p+60:0x5d8613fc) flags=INEXACT (5/0)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) flags=INEXACT (5/1)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(0x1.26c46000000000000000p+34:0x50936230) flags=INEXACT (5/2)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(0x1.91f93e00000000000000p-106:0x0ac8fc9f) flags=INEXACT (6/0)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(-0x1.31f75000000000000000p-40:0xab98fba8) flags=INEXACT (6/1)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544400000000000000p-66:0x9ea82a22) flags=INEXACT (6/2)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=UNDERFLOW INEXACT (7/0)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544400000000000000p-66:0x9ea82a22) flags=OK (7/1)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (7/2)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (8/0)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (8/1)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(-0x1.00000000000000000000p-149:0x80000001) flags=UNDERFLOW INEXACT (8/2)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000000000000000000p-25:0x33000000) flags=OK (9/0)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=UNDERFLOW INEXACT (9/1)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (9/2)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.ffffe600000000000000p-25:0x337ffff3) flags=INEXACT (10/0)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.ffffe600000000000000p-50:0x26fffff3) flags=INEXACT (10/1)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000000000000000000p-25:0x33000000) flags=INEXACT (10/2)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801a00000000000000p-15:0x387fc00d) flags=INEXACT (11/0)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.0007fe00000000000000p-25:0x330003ff) flags=INEXACT (11/1)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0001f200000000000000p-24:0x338000f9) flags=INEXACT (11/2)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00000c00000000000000p-14:0x38800006) flags=INEXACT (12/0)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0ffbf400000000000000p-24:0x3387fdfa) flags=INEXACT (12/1)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801a00000000000000p-15:0x387fc00d) flags=INEXACT (12/2)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00000000000000000000p+0:0x3f800000) flags=INEXACT (13/0)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ffc01800000000000000p-14:0x38ffe00c) flags=INEXACT (13/1)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.ffc01800000000000000p-14:0x38ffe00c) flags=INEXACT (13/2)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.00440000000000000000p+0:0x3f802200) flags=INEXACT (14/0)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00440000000000000000p+0:0x3f802200) flags=INEXACT (14/1)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00040000000000000000p+0:0x3f800200) flags=INEXACT (14/2)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/0)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.80400000000000000000p+1:0x40402000) flags=OK (15/1)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/2)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.2e185400000000000000p+2:0x40970c2a) flags=OK (16/0)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.9c00a800000000000000p+2:0x40ce0054) flags=OK (16/1)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.2e23d200000000000000p+2:0x409711e9) flags=INEXACT (16/2)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.12804000000000000000p+3:0x41094020) flags=INEXACT (17/0)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.51458000000000000000p+3:0x4128a2c0) flags=INEXACT (17/1)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.200c0400000000000000p+3:0x41100602) flags=INEXACT (17/2)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ffcf1400000000000000p+15:0x477fe78a) flags=INEXACT (18/0)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.91ed3a00000000000000p+17:0x4848f69d) flags=INEXACT (18/1)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.5bc56000000000000000p+17:0x482de2b0) flags=INEXACT (18/2)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.08edee00000000000000p+18:0x488476f7) flags=INEXACT (19/0)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.ff7e0800000000000000p+31:0x4f7fbf04) flags=INEXACT (19/1)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.08ee7800000000000000p+18:0x4884773c) flags=INEXACT (19/2)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800800000000000000p+31:0x4f7fc004) flags=INEXACT (20/0)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ff840600000000000000p+31:0x4f7fc203) flags=INEXACT (20/1)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820600000000000000p+31:0x4f7fc103) flags=INEXACT (20/2)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff860600000000000000p+31:0x4f7fc303) flags=INEXACT (21/0)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820600000000000000p+32:0x4fffc103) flags=INEXACT (21/1)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800800000000000000p+32:0x4fffc004) flags=INEXACT (21/2)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff830600000000000000p+32:0x4fffc183) flags=INEXACT (22/0)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff7f8800000000000000p+33:0x507fbfc4) flags=INEXACT (22/1)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff840600000000000000p+32:0x4fffc203) flags=INEXACT (22/2)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.ff800800000000000000p+33:0x507fc004) flags=INEXACT (23/0)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff820600000000000000p+33:0x507fc103) flags=INEXACT (23/1)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff810600000000000000p+33:0x507fc083) flags=INEXACT (23/2)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(0x1.c0bab600000000000000p+99:0x71605d5b) flags=INEXACT (24/0)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.c0837e00000000000000p+116:0x79e041bf) flags=INEXACT (24/1)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.c0829e00000000000000p+116:0x79e0414f) flags=INEXACT (24/2)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (25/0)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (25/1)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (25/2)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/0)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/1)
|
||||
op : f32(inf:0x7f800000) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/2)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/0)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/1)
|
||||
op : f32(nan:0x7fc00000) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/2)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/0)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/1)
|
||||
op : f32(nan:0x7fa00000) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/2)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (29/0)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/1)
|
||||
op : f32(-nan:0xffa00000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/2)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/0)
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/1)
|
||||
op : f32(-nan:0xffc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (30/2)
|
||||
# LP184149
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-1:0x3f000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=OK (31/0)
|
||||
op : f32(0x1.00000000000000000000p-149:0x00000001) * f32(0x1.00000000000000000000p-149:0x00000001) + f32(0x1.00000000000000000000p-149:0x00000001)
|
||||
res: f32(0x1.00000000000000000000p-149:0x00000001) flags=UNDERFLOW INEXACT (32/0)
|
||||
### Rounding to zero
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/0)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/1)
|
||||
op : f32(-inf:0xff800000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (0/2)
|
||||
op : f32(-nan:0xffc00000) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/0)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-nan:0xffc00000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/1)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-nan:0xffc00000) + f32(-inf:0xff800000)
|
||||
res: f32(-nan:0xffc00000) flags=OK (1/2)
|
||||
op : f32(-inf:0xff800000) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/0)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-inf:0xff800000)
|
||||
res: f32(-inf:0xff800000) flags=OK (2/1)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-inf:0xff800000) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (2/2)
|
||||
op : f32(-0x1.fffffe00000000000000p+127:0xff7fffff) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (3/0)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.fffffe00000000000000p+127:0xff7fffff)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (3/1)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.fffffe00000000000000p+127:0xff7fffff) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (3/2)
|
||||
op : f32(-0x1.1874b200000000000000p+103:0xf30c3a59) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (4/0)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.1874b200000000000000p+103:0xf30c3a59)
|
||||
res: f32(-0x1.1874b000000000000000p+103:0xf30c3a58) flags=INEXACT (4/1)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.1874b200000000000000p+103:0xf30c3a59) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab400000000000000p+99:0xf1605d5a) flags=INEXACT (4/2)
|
||||
op : f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(0x1.0c27f800000000000000p+60:0x5d8613fc) flags=INEXACT (5/0)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.c0bab600000000000000p+99:0xf1605d5b)
|
||||
res: f32(-0x1.c0bab400000000000000p+99:0xf1605d5a) flags=INEXACT (5/1)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.c0bab600000000000000p+99:0xf1605d5b) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(0x1.26c46000000000000000p+34:0x50936230) flags=INEXACT (5/2)
|
||||
op : f32(-0x1.31f75000000000000000p-40:0xab98fba8) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(0x1.91f93e00000000000000p-106:0x0ac8fc9f) flags=INEXACT (6/0)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(-0x1.31f75000000000000000p-40:0xab98fba8)
|
||||
res: f32(-0x1.31f74e00000000000000p-40:0xab98fba7) flags=INEXACT (6/1)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(-0x1.31f75000000000000000p-40:0xab98fba8) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544200000000000000p-66:0x9ea82a21) flags=INEXACT (6/2)
|
||||
op : f32(-0x1.50544400000000000000p-66:0x9ea82a22) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=UNDERFLOW INEXACT (7/0)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(-0x1.50544400000000000000p-66:0x9ea82a22)
|
||||
res: f32(-0x1.50544400000000000000p-66:0x9ea82a22) flags=OK (7/1)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(-0x1.50544400000000000000p-66:0x9ea82a22) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (7/2)
|
||||
op : f32(-0x1.00000000000000000000p-126:0x80800000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (8/0)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(-0x1.00000000000000000000p-126:0x80800000)
|
||||
res: f32(-0x1.00000000000000000000p-126:0x80800000) flags=OK (8/1)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(-0x1.00000000000000000000p-126:0x80800000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(-0x0.00000000000000000000p+0:0x80000000) flags=UNDERFLOW INEXACT (8/2)
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000000000000000000p-25:0x33000000) flags=OK (9/0)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=UNDERFLOW INEXACT (9/1)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x0.00000000000000000000p+0:0000000000) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.00000000000000000000p-126:0x00800000) flags=OK (9/2)
|
||||
op : f32(0x1.00000000000000000000p-126:0x00800000) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.ffffe600000000000000p-25:0x337ffff3) flags=INEXACT (10/0)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.00000000000000000000p-126:0x00800000)
|
||||
res: f32(0x1.ffffe600000000000000p-50:0x26fffff3) flags=INEXACT (10/1)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.00000000000000000000p-126:0x00800000) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.00000000000000000000p-25:0x33000000) flags=INEXACT (10/2)
|
||||
op : f32(0x1.00000000000000000000p-25:0x33000000) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801a00000000000000p-15:0x387fc00d) flags=INEXACT (11/0)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000000000000000000p-25:0x33000000)
|
||||
res: f32(0x1.0007fe00000000000000p-25:0x330003ff) flags=INEXACT (11/1)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000000000000000000p-25:0x33000000) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0001f200000000000000p-24:0x338000f9) flags=INEXACT (11/2)
|
||||
op : f32(0x1.ffffe600000000000000p-25:0x337ffff3) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00000c00000000000000p-14:0x38800006) flags=INEXACT (12/0)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.ffffe600000000000000p-25:0x337ffff3)
|
||||
res: f32(0x1.0ffbf400000000000000p-24:0x3387fdfa) flags=INEXACT (12/1)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.ffffe600000000000000p-25:0x337ffff3) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ff801a00000000000000p-15:0x387fc00d) flags=INEXACT (12/2)
|
||||
op : f32(0x1.ff801a00000000000000p-15:0x387fc00d) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00000000000000000000p+0:0x3f800000) flags=INEXACT (13/0)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.ff801a00000000000000p-15:0x387fc00d)
|
||||
res: f32(0x1.ffc01800000000000000p-14:0x38ffe00c) flags=INEXACT (13/1)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.ff801a00000000000000p-15:0x387fc00d) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.ffc01800000000000000p-14:0x38ffe00c) flags=INEXACT (13/2)
|
||||
op : f32(0x1.00000c00000000000000p-14:0x38800006) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.00440000000000000000p+0:0x3f802200) flags=INEXACT (14/0)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000c00000000000000p-14:0x38800006)
|
||||
res: f32(0x1.00440000000000000000p+0:0x3f802200) flags=INEXACT (14/1)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000c00000000000000p-14:0x38800006) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.00040000000000000000p+0:0x3f800200) flags=INEXACT (14/2)
|
||||
op : f32(0x1.00000000000000000000p+0:0x3f800000) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/0)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.00000000000000000000p+0:0x3f800000)
|
||||
res: f32(0x1.80400000000000000000p+1:0x40402000) flags=OK (15/1)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.00000000000000000000p+0:0x3f800000) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.80200000000000000000p+1:0x40401000) flags=OK (15/2)
|
||||
op : f32(0x1.00400000000000000000p+0:0x3f802000) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.2e185400000000000000p+2:0x40970c2a) flags=OK (16/0)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.00400000000000000000p+0:0x3f802000)
|
||||
res: f32(0x1.9c00a800000000000000p+2:0x40ce0054) flags=OK (16/1)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.00400000000000000000p+0:0x3f802000) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.2e23d200000000000000p+2:0x409711e9) flags=INEXACT (16/2)
|
||||
op : f32(0x1.00000000000000000000p+1:0x40000000) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.12804000000000000000p+3:0x41094020) flags=INEXACT (17/0)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.00000000000000000000p+1:0x40000000)
|
||||
res: f32(0x1.51458000000000000000p+3:0x4128a2c0) flags=INEXACT (17/1)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.00000000000000000000p+1:0x40000000) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.200c0400000000000000p+3:0x41100602) flags=INEXACT (17/2)
|
||||
op : f32(0x1.5bf0a800000000000000p+1:0x402df854) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ffcf1400000000000000p+15:0x477fe78a) flags=INEXACT (18/0)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.5bf0a800000000000000p+1:0x402df854)
|
||||
res: f32(0x1.91ed3a00000000000000p+17:0x4848f69d) flags=INEXACT (18/1)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.5bf0a800000000000000p+1:0x402df854) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.5bc56000000000000000p+17:0x482de2b0) flags=INEXACT (18/2)
|
||||
op : f32(0x1.921fb600000000000000p+1:0x40490fdb) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.08edee00000000000000p+18:0x488476f7) flags=INEXACT (19/0)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.921fb600000000000000p+1:0x40490fdb)
|
||||
res: f32(0x1.ff7e0800000000000000p+31:0x4f7fbf04) flags=INEXACT (19/1)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.921fb600000000000000p+1:0x40490fdb) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.08ee7800000000000000p+18:0x4884773c) flags=INEXACT (19/2)
|
||||
op : f32(0x1.ffbe0000000000000000p+15:0x477fdf00) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800800000000000000p+31:0x4f7fc004) flags=INEXACT (20/0)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbe0000000000000000p+15:0x477fdf00)
|
||||
res: f32(0x1.ff840600000000000000p+31:0x4f7fc203) flags=INEXACT (20/1)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbe0000000000000000p+15:0x477fdf00) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820600000000000000p+31:0x4f7fc103) flags=INEXACT (20/2)
|
||||
op : f32(0x1.ffc00000000000000000p+15:0x477fe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff860600000000000000p+31:0x4f7fc303) flags=INEXACT (21/0)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+15:0x477fe000)
|
||||
res: f32(0x1.ff820600000000000000p+32:0x4fffc103) flags=INEXACT (21/1)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+15:0x477fe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff800800000000000000p+32:0x4fffc004) flags=INEXACT (21/2)
|
||||
op : f32(0x1.ffc20000000000000000p+15:0x477fe100) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff830600000000000000p+32:0x4fffc183) flags=INEXACT (22/0)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc20000000000000000p+15:0x477fe100)
|
||||
res: f32(0x1.ff7f8800000000000000p+33:0x507fbfc4) flags=INEXACT (22/1)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc20000000000000000p+15:0x477fe100) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff840600000000000000p+32:0x4fffc203) flags=INEXACT (22/2)
|
||||
op : f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.ff800800000000000000p+33:0x507fc004) flags=INEXACT (23/0)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.ffbf0000000000000000p+16:0x47ffdf80)
|
||||
res: f32(0x1.ff820600000000000000p+33:0x507fc103) flags=INEXACT (23/1)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.ffbf0000000000000000p+16:0x47ffdf80) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.ff810600000000000000p+33:0x507fc083) flags=INEXACT (23/2)
|
||||
op : f32(0x1.ffc00000000000000000p+16:0x47ffe000) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(0x1.c0bab600000000000000p+99:0x71605d5b) flags=INEXACT (24/0)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.ffc00000000000000000p+16:0x47ffe000)
|
||||
res: f32(0x1.c0837e00000000000000p+116:0x79e041bf) flags=INEXACT (24/1)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.ffc00000000000000000p+16:0x47ffe000) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.c0829e00000000000000p+116:0x79e0414f) flags=INEXACT (24/2)
|
||||
op : f32(0x1.ffc10000000000000000p+16:0x47ffe080) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (25/0)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(0x1.ffc10000000000000000p+16:0x47ffe080)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (25/1)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(0x1.ffc10000000000000000p+16:0x47ffe080) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(0x1.fffffe00000000000000p+127:0x7f7fffff) flags=OVERFLOW INEXACT (25/2)
|
||||
op : f32(0x1.c0bab600000000000000p+99:0x71605d5b) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/0)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(0x1.c0bab600000000000000p+99:0x71605d5b)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/1)
|
||||
op : f32(inf:0x7f800000) * f32(0x1.c0bab600000000000000p+99:0x71605d5b) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(inf:0x7f800000) flags=OK (26/2)
|
||||
op : f32(0x1.fffffe00000000000000p+127:0x7f7fffff) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/0)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(0x1.fffffe00000000000000p+127:0x7f7fffff)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/1)
|
||||
op : f32(nan:0x7fc00000) * f32(0x1.fffffe00000000000000p+127:0x7f7fffff) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fc00000) flags=OK (27/2)
|
||||
op : f32(inf:0x7f800000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/0)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(inf:0x7f800000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/1)
|
||||
op : f32(nan:0x7fa00000) * f32(inf:0x7f800000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (28/2)
|
||||
op : f32(nan:0x7fc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (29/0)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(nan:0x7fc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/1)
|
||||
op : f32(-nan:0xffa00000) * f32(nan:0x7fc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (29/2)
|
||||
op : f32(nan:0x7fa00000) * f32(-nan:0xffa00000) + f32(-nan:0xffc00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/0)
|
||||
op : f32(-nan:0xffa00000) * f32(-nan:0xffc00000) + f32(nan:0x7fa00000)
|
||||
res: f32(nan:0x7fe00000) flags=INVALID (30/1)
|
||||
op : f32(-nan:0xffc00000) * f32(nan:0x7fa00000) + f32(-nan:0xffa00000)
|
||||
res: f32(-nan:0xffe00000) flags=INVALID (30/2)
|
||||
# LP184149
|
||||
op : f32(0x0.00000000000000000000p+0:0000000000) * f32(0x1.00000000000000000000p-1:0x3f000000) + f32(0x0.00000000000000000000p+0:0000000000)
|
||||
res: f32(0x0.00000000000000000000p+0:0000000000) flags=OK (31/0)
|
||||
op : f32(0x1.00000000000000000000p-149:0x00000001) * f32(0x1.00000000000000000000p-149:0x00000001) + f32(0x1.00000000000000000000p-149:0x00000001)
|
||||
res: f32(0x1.00000000000000000000p-149:0x00000001) flags=UNDERFLOW INEXACT (32/0)
|
||||
@ -10,20 +10,22 @@ MULTIARCH_SRC=$(SRC_PATH)/tests/tcg/multiarch
|
||||
# Set search path for all sources
|
||||
VPATH += $(MULTIARCH_SRC)
|
||||
MULTIARCH_SRCS =$(notdir $(wildcard $(MULTIARCH_SRC)/*.c))
|
||||
MULTIARCH_TESTS =$(MULTIARCH_SRCS:.c=)
|
||||
|
||||
# FIXME: ppc64abi32 linux-test seems to have issues but the other basic tests work
|
||||
ifeq ($(TARGET_NAME),ppc64abi32)
|
||||
BROKEN_TESTS = linux-test
|
||||
endif
|
||||
|
||||
# Update TESTS
|
||||
TESTS += $(filter-out $(BROKEN_TESTS), $(MULTIARCH_TESTS))
|
||||
MULTIARCH_TESTS =$(filter-out float_helpers, $(MULTIARCH_SRCS:.c=))
|
||||
|
||||
#
|
||||
# The following are any additional rules needed to build things
|
||||
#
|
||||
|
||||
|
||||
float_%: LDFLAGS+=-lm
|
||||
float_%: float_%.c float_helpers.c
|
||||
$(CC) $(CFLAGS) $(EXTRA_CFLAGS) $< $(MULTIARCH_SRC)/float_helpers.c -o $@ $(LDFLAGS)
|
||||
|
||||
run-float_%: float_%
|
||||
$(call run-test,$<, $(QEMU) $(QEMU_OPTS) $<,"$< on $(TARGET_NAME)")
|
||||
$(call conditional-diff-out,$<,$(SRC_PATH)/tests/tcg/$(TARGET_NAME)/$<.ref)
|
||||
|
||||
|
||||
testthread: LDFLAGS+=-lpthread
|
||||
|
||||
# We define the runner for test-mmap after the individual
|
||||
@ -39,3 +41,6 @@ run-test-mmap: test-mmap
|
||||
run-test-mmap-%: test-mmap
|
||||
$(call run-test, test-mmap-$*, $(QEMU) -p $* $<,\
|
||||
"$< ($* byte pages) on $(TARGET_NAME)")
|
||||
|
||||
# Update TESTS
|
||||
TESTS += $(MULTIARCH_TESTS)
|
||||
|
||||
105
tests/tcg/multiarch/float_convs.c
Normal file
105
tests/tcg/multiarch/float_convs.c
Normal file
@ -0,0 +1,105 @@
|
||||
/*
|
||||
* Floating Point Convert Single to Various
|
||||
*
|
||||
* Copyright (c) 2019 Linaro
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <float.h>
|
||||
#include <fenv.h>
|
||||
|
||||
|
||||
#include "float_helpers.h"
|
||||
|
||||
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
|
||||
|
||||
typedef struct {
|
||||
int flag;
|
||||
char *desc;
|
||||
} float_mapping;
|
||||
|
||||
float_mapping round_flags[] = {
|
||||
{ FE_TONEAREST, "to nearest" },
|
||||
#ifdef FE_UPWARD
|
||||
{ FE_UPWARD, "upwards" },
|
||||
#endif
|
||||
#ifdef FE_DOWNWARD
|
||||
{ FE_DOWNWARD, "downwards" },
|
||||
#endif
|
||||
{ FE_TOWARDZERO, "to zero" }
|
||||
};
|
||||
|
||||
static void print_input(float input)
|
||||
{
|
||||
char *in_fmt = fmt_f32(input);
|
||||
printf("from single: %s\n", in_fmt);
|
||||
free(in_fmt);
|
||||
}
|
||||
|
||||
static void convert_single_to_double(float input)
|
||||
{
|
||||
double output;
|
||||
char *out_fmt, *flag_fmt;
|
||||
|
||||
feclearexcept(FE_ALL_EXCEPT);
|
||||
|
||||
output = input;
|
||||
|
||||
out_fmt = fmt_f64(output);
|
||||
flag_fmt = fmt_flags();
|
||||
printf(" to double: %s (%s)\n", out_fmt, flag_fmt);
|
||||
free(out_fmt);
|
||||
free(flag_fmt);
|
||||
}
|
||||
|
||||
#define xstr(a) str(a)
|
||||
#define str(a) #a
|
||||
|
||||
#define CONVERT_SINGLE_TO_INT(TYPE, FMT) \
|
||||
static void convert_single_to_ ## TYPE(float input) \
|
||||
{ \
|
||||
TYPE ## _t output; \
|
||||
char *flag_fmt; \
|
||||
const char to[] = "to " xstr(TYPE); \
|
||||
feclearexcept(FE_ALL_EXCEPT); \
|
||||
output = input; \
|
||||
flag_fmt = fmt_flags(); \
|
||||
printf("%11s: %" FMT " (%s)\n", to, output, flag_fmt); \
|
||||
free(flag_fmt); \
|
||||
}
|
||||
|
||||
CONVERT_SINGLE_TO_INT( int32, PRId32)
|
||||
CONVERT_SINGLE_TO_INT(uint32, PRId32)
|
||||
CONVERT_SINGLE_TO_INT( int64, PRId64)
|
||||
CONVERT_SINGLE_TO_INT(uint64, PRId64)
|
||||
|
||||
int main(int argc, char *argv[argc])
|
||||
{
|
||||
int i, j, nums;
|
||||
|
||||
nums = get_num_f32();
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(round_flags); ++i) {
|
||||
if (fesetround(round_flags[i].flag) != 0) {
|
||||
printf("### Rounding %s skipped\n", round_flags[i].desc);
|
||||
continue;
|
||||
}
|
||||
printf("### Rounding %s\n", round_flags[i].desc);
|
||||
for (j = 0; j < nums; j++) {
|
||||
float input = get_f32(j);
|
||||
print_input(input);
|
||||
/* convert_single_to_half(input); */
|
||||
convert_single_to_double(input);
|
||||
convert_single_to_int32(input);
|
||||
convert_single_to_int64(input);
|
||||
convert_single_to_uint32(input);
|
||||
convert_single_to_uint64(input);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
230
tests/tcg/multiarch/float_helpers.c
Normal file
230
tests/tcg/multiarch/float_helpers.c
Normal file
@ -0,0 +1,230 @@
|
||||
/*
|
||||
* Common Float Helpers
|
||||
*
|
||||
* This contains a series of useful utility routines and a set of
|
||||
* floating point constants useful for exercising the edge cases in
|
||||
* floating point tests.
|
||||
*
|
||||
* Copyright (c) 2019 Linaro
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*/
|
||||
|
||||
/* we want additional float type definitions */
|
||||
#define __STDC_WANT_IEC_60559_BFP_EXT__
|
||||
#define __STDC_WANT_IEC_60559_TYPES_EXT__
|
||||
|
||||
#define _GNU_SOURCE
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <inttypes.h>
|
||||
#include <math.h>
|
||||
#include <float.h>
|
||||
#include <fenv.h>
|
||||
|
||||
#include "float_helpers.h"
|
||||
|
||||
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
|
||||
|
||||
/*
|
||||
* Half Precision Numbers
|
||||
*
|
||||
* Not yet well standardised so we return a plain uint16_t for now.
|
||||
*/
|
||||
|
||||
/* no handy defines for these numbers */
|
||||
static uint16_t f16_numbers[] = {
|
||||
0xffff, /* -NaN / AHP -Max */
|
||||
0xfcff, /* -NaN / AHP */
|
||||
0xfc01, /* -NaN / AHP */
|
||||
0xfc00, /* -Inf */
|
||||
0xfbff, /* -Max */
|
||||
0xc000, /* -2 */
|
||||
0xbc00, /* -1 */
|
||||
0x8001, /* -MIN subnormal */
|
||||
0x8000, /* -0 */
|
||||
0x0000, /* +0 */
|
||||
0x0001, /* MIN subnormal */
|
||||
0x3c00, /* 1 */
|
||||
0x7bff, /* Max */
|
||||
0x7c00, /* Inf */
|
||||
0x7c01, /* NaN / AHP */
|
||||
0x7cff, /* NaN / AHP */
|
||||
0x7fff, /* NaN / AHP +Max*/
|
||||
};
|
||||
|
||||
static const int num_f16 = ARRAY_SIZE(f16_numbers);
|
||||
|
||||
int get_num_f16(void)
|
||||
{
|
||||
return num_f16;
|
||||
}
|
||||
|
||||
uint16_t get_f16(int i)
|
||||
{
|
||||
return f16_numbers[i % num_f16];
|
||||
}
|
||||
|
||||
/* only display as hex */
|
||||
char *fmt_16(uint16_t num)
|
||||
{
|
||||
char *fmt;
|
||||
asprintf(&fmt, "f16(%#04x)", num);
|
||||
return fmt;
|
||||
}
|
||||
|
||||
/*
|
||||
* Single Precision Numbers
|
||||
*/
|
||||
|
||||
#ifndef SNANF
|
||||
/* Signaling NaN macros, if supported. */
|
||||
# if __GNUC_PREREQ(3, 3)
|
||||
# define SNANF (__builtin_nansf (""))
|
||||
# define SNAN (__builtin_nans (""))
|
||||
# define SNANL (__builtin_nansl (""))
|
||||
# endif
|
||||
#endif
|
||||
|
||||
static float f32_numbers[] = {
|
||||
-SNANF,
|
||||
-NAN,
|
||||
-INFINITY,
|
||||
-FLT_MAX,
|
||||
-0x1.1874b2p+103,
|
||||
-0x1.c0bab6p+99,
|
||||
-0x1.31f75p-40,
|
||||
-0x1.505444p-66,
|
||||
-FLT_MIN,
|
||||
0.0,
|
||||
FLT_MIN,
|
||||
0x1p-25,
|
||||
0x1.ffffe6p-25, /* min positive FP16 subnormal */
|
||||
0x1.ff801ap-15, /* max subnormal FP16 */
|
||||
0x1.00000cp-14, /* min positive normal FP16 */
|
||||
1.0,
|
||||
0x1.004p+0, /* smallest float after 1.0 FP16 */
|
||||
2.0,
|
||||
M_E, M_PI,
|
||||
0x1.ffbep+15,
|
||||
0x1.ffcp+15, /* max FP16 */
|
||||
0x1.ffc2p+15,
|
||||
0x1.ffbfp+16,
|
||||
0x1.ffcp+16, /* max AFP */
|
||||
0x1.ffc1p+16,
|
||||
0x1.c0bab6p+99,
|
||||
FLT_MAX,
|
||||
INFINITY,
|
||||
NAN,
|
||||
SNANF
|
||||
};
|
||||
|
||||
static const int num_f32 = ARRAY_SIZE(f32_numbers);
|
||||
|
||||
int get_num_f32(void)
|
||||
{
|
||||
return num_f32;
|
||||
}
|
||||
|
||||
float get_f32(int i)
|
||||
{
|
||||
return f32_numbers[i % num_f32];
|
||||
}
|
||||
|
||||
char *fmt_f32(float num)
|
||||
{
|
||||
uint32_t single_as_hex = *(uint32_t *) #
|
||||
char *fmt;
|
||||
asprintf(&fmt, "f32(%02.20a:%#010x)", num, single_as_hex);
|
||||
return fmt;
|
||||
}
|
||||
|
||||
|
||||
/* This allows us to initialise some doubles as pure hex */
|
||||
typedef union {
|
||||
double d;
|
||||
uint64_t h;
|
||||
} test_doubles;
|
||||
|
||||
static test_doubles f64_numbers[] = {
|
||||
{SNAN},
|
||||
{-NAN},
|
||||
{-INFINITY},
|
||||
{-DBL_MAX},
|
||||
{-FLT_MAX-1.0},
|
||||
{-FLT_MAX},
|
||||
{-1.111E+31},
|
||||
{-1.111E+30}, /* half prec */
|
||||
{-2.0}, {-1.0},
|
||||
{-DBL_MIN},
|
||||
{-FLT_MIN},
|
||||
{0.0},
|
||||
{FLT_MIN},
|
||||
{2.98023224e-08},
|
||||
{5.96046E-8}, /* min positive FP16 subnormal */
|
||||
{6.09756E-5}, /* max subnormal FP16 */
|
||||
{6.10352E-5}, /* min positive normal FP16 */
|
||||
{1.0},
|
||||
{1.0009765625}, /* smallest float after 1.0 FP16 */
|
||||
{DBL_MIN},
|
||||
{1.3789972848607228e-308},
|
||||
{1.4914738736681624e-308},
|
||||
{1.0}, {2.0},
|
||||
{M_E}, {M_PI},
|
||||
{65503.0},
|
||||
{65504.0}, /* max FP16 */
|
||||
{65505.0},
|
||||
{131007.0},
|
||||
{131008.0}, /* max AFP */
|
||||
{131009.0},
|
||||
{.h = 0x41dfffffffc00000 }, /* to int = 0x7fffffff */
|
||||
{FLT_MAX},
|
||||
{FLT_MAX + 1.0},
|
||||
{DBL_MAX},
|
||||
{INFINITY},
|
||||
{NAN},
|
||||
{.h = 0x7ff0000000000001}, /* SNAN */
|
||||
{SNAN},
|
||||
};
|
||||
|
||||
static const int num_f64 = ARRAY_SIZE(f64_numbers);
|
||||
|
||||
int get_num_f64(void)
|
||||
{
|
||||
return num_f64;
|
||||
}
|
||||
|
||||
double get_f64(int i)
|
||||
{
|
||||
return f64_numbers[i % num_f64].d;
|
||||
}
|
||||
|
||||
char *fmt_f64(double num)
|
||||
{
|
||||
uint64_t double_as_hex = *(uint64_t *) #
|
||||
char *fmt;
|
||||
asprintf(&fmt, "f64(%02.20a:%#020" PRIx64 ")", num, double_as_hex);
|
||||
return fmt;
|
||||
}
|
||||
|
||||
/*
|
||||
* Float flags
|
||||
*/
|
||||
char *fmt_flags(void)
|
||||
{
|
||||
int flags = fetestexcept(FE_ALL_EXCEPT);
|
||||
char *fmt;
|
||||
|
||||
if (flags) {
|
||||
asprintf(&fmt, "%s%s%s%s%s",
|
||||
flags & FE_OVERFLOW ? "OVERFLOW " : "",
|
||||
flags & FE_UNDERFLOW ? "UNDERFLOW " : "",
|
||||
flags & FE_DIVBYZERO ? "DIV0 " : "",
|
||||
flags & FE_INEXACT ? "INEXACT " : "",
|
||||
flags & FE_INVALID ? "INVALID" : "");
|
||||
} else {
|
||||
asprintf(&fmt, "OK");
|
||||
}
|
||||
|
||||
return fmt;
|
||||
}
|
||||
26
tests/tcg/multiarch/float_helpers.h
Normal file
26
tests/tcg/multiarch/float_helpers.h
Normal file
@ -0,0 +1,26 @@
|
||||
/*
|
||||
* Common Float Helpers
|
||||
*
|
||||
* Copyright (c) 2019 Linaro
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*/
|
||||
|
||||
#include <inttypes.h>
|
||||
|
||||
/* Number of constants in each table */
|
||||
int get_num_f16(void);
|
||||
int get_num_f32(void);
|
||||
int get_num_f64(void);
|
||||
|
||||
/* Accessor helpers, overflows will automatically wrap */
|
||||
uint16_t get_f16(int i); /* use _Float16 when we can */
|
||||
float get_f32(int i);
|
||||
double get_f64(int i);
|
||||
|
||||
/* Return format strings, free after use */
|
||||
char * fmt_f16(uint16_t);
|
||||
char * fmt_f32(float);
|
||||
char * fmt_f64(double);
|
||||
/* exception flags */
|
||||
char * fmt_flags(void);
|
||||
103
tests/tcg/multiarch/float_madds.c
Normal file
103
tests/tcg/multiarch/float_madds.c
Normal file
@ -0,0 +1,103 @@
|
||||
/*
|
||||
* Fused Multiply Add (Single)
|
||||
*
|
||||
* Copyright (c) 2019 Linaro
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <float.h>
|
||||
#include <fenv.h>
|
||||
|
||||
#include "float_helpers.h"
|
||||
|
||||
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
|
||||
|
||||
typedef struct {
|
||||
int flag;
|
||||
char *desc;
|
||||
} float_mapping;
|
||||
|
||||
float_mapping round_flags[] = {
|
||||
{ FE_TONEAREST, "to nearest" },
|
||||
#ifdef FE_UPWARD
|
||||
{ FE_UPWARD, "upwards" },
|
||||
#endif
|
||||
#ifdef FE_DOWNWARD
|
||||
{ FE_DOWNWARD, "downwards" },
|
||||
#endif
|
||||
{ FE_TOWARDZERO, "to zero" }
|
||||
};
|
||||
|
||||
|
||||
static void print_inputs(float a, float b, float c)
|
||||
{
|
||||
char *a_fmt, *b_fmt, *c_fmt;
|
||||
|
||||
a_fmt = fmt_f32(a);
|
||||
b_fmt = fmt_f32(b);
|
||||
c_fmt = fmt_f32(c);
|
||||
|
||||
printf("op : %s * %s + %s\n", a_fmt, b_fmt, c_fmt);
|
||||
|
||||
free(a_fmt);
|
||||
free(b_fmt);
|
||||
free(c_fmt);
|
||||
}
|
||||
|
||||
static void print_result(float r, int j, int k)
|
||||
{
|
||||
char *r_fmt, *flag_fmt;
|
||||
|
||||
r_fmt = fmt_f32(r);
|
||||
flag_fmt = fmt_flags();
|
||||
|
||||
printf("res: %s flags=%s (%d/%d)\n", r_fmt, flag_fmt, j, k);
|
||||
|
||||
free(r_fmt);
|
||||
free(flag_fmt);
|
||||
}
|
||||
|
||||
static void do_madds(float a, float b, float c, int j, int k)
|
||||
{
|
||||
float r;
|
||||
|
||||
print_inputs(a, b, c);
|
||||
|
||||
feclearexcept(FE_ALL_EXCEPT);
|
||||
r = __builtin_fmaf(a, b, c);
|
||||
|
||||
print_result(r, j, k);
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[argc])
|
||||
{
|
||||
int i, j, k, nums = get_num_f32();
|
||||
float a, b, c;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(round_flags); ++i) {
|
||||
if (fesetround(round_flags[i].flag) != 0) {
|
||||
printf("### Rounding %s skipped\n", round_flags[i].desc);
|
||||
continue;
|
||||
}
|
||||
printf("### Rounding %s\n", round_flags[i].desc);
|
||||
for (j = 0; j < nums; j++) {
|
||||
for (k = 0; k < 3; k++) {
|
||||
a = get_f32(j + ((k)%3));
|
||||
b = get_f32(j + ((k+1)%3));
|
||||
c = get_f32(j + ((k+2)%3));
|
||||
do_madds(a, b, c, j, k);
|
||||
}
|
||||
}
|
||||
|
||||
/* From https://bugs.launchpad.net/qemu/+bug/1841491 */
|
||||
printf("# LP184149\n");
|
||||
do_madds(0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x0.0000000000001p-1022, j, 0);
|
||||
do_madds(0x8p-152, 0x8p-152, 0x8p-152, j+1, 0);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user