ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Updates for testing, plugins, gdbstub 

- restore some 32 bit host builds and testing
   - move some physmem tracepoint definitions
   - use --userns keep-id for podman builds
   - cleanup check-tcg compiler flag checking for Arm
   - fix some casting in fcvt test
   - tweak check-tcg inline asm for clang
   - suppress some invalid clang warnings
   - disable KVM for the TCI builds
   - improve the insn tracking plugin
   - cleanups to the lockstep plugin
   - free plugin data on cpu finalise
   - assert cpu->index assigned
   - move qemu_plugin_vcpu_init__async into plugin code
   - add support for dynamic gdb command tables
   - allow targets to extend gdb capabilities
   - enable user-mode MTE support
 -----BEGIN PGP SIGNATURE-----
 
 iQEzBAABCgAdFiEEZoWumedRZ7yvyN81+9DbCVqeKkQFAmaH3bEACgkQ+9DbCVqe
 KkTnvwf9HS68sTICEJqBfY663hjcfdFGsSV/h3q7SN3fhKm/3JHGNK+kumgqdnaC
 ykd7tx0AtBGgKm83B7G6MPywsVMIosMeV3mFeJTVHhKsFwGNjSiGkr3j4R2qxjFt
 nYQ977FqBKyhvhSplR2wwhwi+JpuGWFGlnQTvdF2Z7ni4YCDFcbl4eiMyGwsjbWm
 0VBP+wCSSMIIbS9Qb7DrhZlfu0+wKZK/q0FLzVVofcLSXGou+Mse/qhtG+yAU/FI
 qqqV+7J4PU9E4BqFaklxyRtBrpXNDgpo77pu6ZR7oDXD7HNMuIAuEIlkxMJjarNM
 xN64WOOzw15R2RMVyXdYx6ccxWft2Q==
 =9Gmk
 -----END PGP SIGNATURE-----

Merge tag 'pull-maintainer-july24-050724-1' of https://gitlab.com/stsquad/qemu into staging

Updates for testing, plugins, gdbstub

  - restore some 32 bit host builds and testing
  - move some physmem tracepoint definitions
  - use --userns keep-id for podman builds
  - cleanup check-tcg compiler flag checking for Arm
  - fix some casting in fcvt test
  - tweak check-tcg inline asm for clang
  - suppress some invalid clang warnings
  - disable KVM for the TCI builds
  - improve the insn tracking plugin
  - cleanups to the lockstep plugin
  - free plugin data on cpu finalise
  - assert cpu->index assigned
  - move qemu_plugin_vcpu_init__async into plugin code
  - add support for dynamic gdb command tables
  - allow targets to extend gdb capabilities
  - enable user-mode MTE support

# -----BEGIN PGP SIGNATURE-----
#
# iQEzBAABCgAdFiEEZoWumedRZ7yvyN81+9DbCVqeKkQFAmaH3bEACgkQ+9DbCVqe
# KkTnvwf9HS68sTICEJqBfY663hjcfdFGsSV/h3q7SN3fhKm/3JHGNK+kumgqdnaC
# ykd7tx0AtBGgKm83B7G6MPywsVMIosMeV3mFeJTVHhKsFwGNjSiGkr3j4R2qxjFt
# nYQ977FqBKyhvhSplR2wwhwi+JpuGWFGlnQTvdF2Z7ni4YCDFcbl4eiMyGwsjbWm
# 0VBP+wCSSMIIbS9Qb7DrhZlfu0+wKZK/q0FLzVVofcLSXGou+Mse/qhtG+yAU/FI
# qqqV+7J4PU9E4BqFaklxyRtBrpXNDgpo77pu6ZR7oDXD7HNMuIAuEIlkxMJjarNM
# xN64WOOzw15R2RMVyXdYx6ccxWft2Q==
# =9Gmk
# -----END PGP SIGNATURE-----
# gpg: Signature made Fri 05 Jul 2024 04:49:05 AM PDT
# gpg:                using RSA key 6685AE99E75167BCAFC8DF35FBD0DB095A9E2A44
# gpg: Good signature from "Alex Bennée (Master Work Key) <alex.bennee@linaro.org>" [full]

* tag 'pull-maintainer-july24-050724-1' of https://gitlab.com/stsquad/qemu: (40 commits)
  tests/tcg/aarch64: Add MTE gdbstub tests
  gdbstub: Add support for MTE in user mode
  gdbstub: Use true to set cmd_startswith
  gdbstub: Pass CPU context to command handler
  gdbstub: Make hex conversion function non-internal
  target/arm: Factor out code for setting MTE TCF0 field
  target/arm: Make some MTE helpers widely available
  target/arm: Fix exception case in allocation_tag_mem_probe
  gdbstub: Add support for target-specific stubs
  gdbstub: Move GdbCmdParseEntry into a new header file
  gdbstub: Clean up process_string_cmd
  accel/tcg: Move qemu_plugin_vcpu_init__async() to plugins/
  plugins: Free CPUPluginState before destroying vCPU state
  plugins: Ensure vCPU index is assigned in init/exit hooks
  plugins/lockstep: clean-up output
  plugins/lockstep: mention the one-insn-per-tb option
  plugins/lockstep: make mixed-mode safe
  plugins/lockstep: preserve sock_path
  test/plugins: preserve the instruction record over translations
  test/plugin: make insn plugin less noisy by default
  ...

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
This commit is contained in:
Richard Henderson 2024-07-05 09:15:48 -07:00
parent 5915139aba 340ca46b68
commit f2cb4026fc
50 changed files with 1771 additions and 946 deletions

2
.gitlab-ci.d/buildtest.yml
View File

@ -635,7 +635,7 @@ build-tci:
- TARGETS="aarch64 arm hppa m68k microblaze ppc64 s390x x86_64"
- mkdir build
- cd build
- ../configure --enable-tcg-interpreter --disable-docs --disable-gtk --disable-vnc
- ../configure --enable-tcg-interpreter --disable-kvm --disable-docs --disable-gtk --disable-vnc
--target-list="$(for tg in $TARGETS; do echo -n ${tg}'-softmmu '; done)"
|| { cat config.log meson-logs/meson-log.txt && exit 1; }
- make -j"$JOBS"

13
.gitlab-ci.d/crossbuilds.yml
View File

@ -37,6 +37,17 @@ cross-arm64-kvm-only:
IMAGE: debian-arm64-cross
EXTRA_CONFIGURE_OPTS: --disable-tcg --without-default-features
cross-i686-system:
extends:
- .cross_system_build_job
- .cross_test_artifacts
needs:
job: i686-debian-cross-container
variables:
IMAGE: debian-i686-cross
EXTRA_CONFIGURE_OPTS: --disable-kvm
MAKE_CHECK_ARGS: check-qtest
cross-i686-user:
extends:
- .cross_user_build_job
@ -57,7 +68,7 @@ cross-i686-tci:
variables:
IMAGE: debian-i686-cross
ACCEL: tcg-interpreter
EXTRA_CONFIGURE_OPTS: --target-list=i386-softmmu,i386-linux-user,aarch64-softmmu,aarch64-linux-user,ppc-softmmu,ppc-linux-user --disable-plugins
EXTRA_CONFIGURE_OPTS: --target-list=i386-softmmu,i386-linux-user,aarch64-softmmu,aarch64-linux-user,ppc-softmmu,ppc-linux-user --disable-plugins --disable-kvm
MAKE_CHECK_ARGS: check check-tcg
cross-mipsel-system:

2
configs/targets/aarch64-linux-user.mak
View File

@ -1,6 +1,6 @@
TARGET_ARCH=aarch64
TARGET_BASE_ARCH=arm
TARGET_XML_FILES= gdb-xml/aarch64-core.xml gdb-xml/aarch64-fpu.xml gdb-xml/aarch64-pauth.xml
TARGET_XML_FILES= gdb-xml/aarch64-core.xml gdb-xml/aarch64-fpu.xml gdb-xml/aarch64-pauth.xml gdb-xml/aarch64-mte.xml
TARGET_HAS_BFLT=y
CONFIG_SEMIHOSTING=y
CONFIG_ARM_COMPATIBLE_SEMIHOSTING=y

4
configure vendored
View File

@ -1673,6 +1673,10 @@ for target in $target_list; do
echo "GDB=$gdb_bin" >> $config_target_mak
fi
if test "${arch}" = "aarch64" && version_ge ${gdb_version##* } 15.0; then
echo "GDB_HAS_MTE=y" >> $config_target_mak
fi
echo "run-tcg-tests-$target: $qemu\$(EXESUF)" >> Makefile.prereqs
tcg_tests_targets="$tcg_tests_targets $target"
fi

23
contrib/plugins/lockstep.c
View File

@ -14,7 +14,8 @@
* particular run may execute the exact same sequence of blocks. An
* asynchronous event (for example X11 graphics update) may cause a
* block to end early and a new partial block to start. This means
* serial only test cases are a better bet. -d nochain may also help.
* serial only test cases are a better bet. -d nochain may also help
* as well as -accel tcg,one-insn-per-tb=on
*
* This code is not thread safe!
*
@ -57,7 +58,7 @@ typedef struct {
/* The execution state we compare */
typedef struct {
uint64_t pc;
unsigned long insn_count;
uint64_t insn_count;
} ExecState;
typedef struct {
@ -134,10 +135,13 @@ static void report_divergance(ExecState *us, ExecState *them)
/* Output short log entry of going out of sync... */
if (verbose || divrec.distance == 1 || diverged) {
g_string_printf(out,
"@ 0x%016" PRIx64 " vs 0x%016" PRIx64
g_string_printf(out, "@ "
"0x%016" PRIx64 " (%" PRId64 ") vs "
"0x%016" PRIx64 " (%" PRId64 ")"
" (%d/%d since last)\n",
us->pc, them->pc, g_slist_length(divergence_log),
us->pc, us->insn_count,
them->pc, them->insn_count,
g_slist_length(divergence_log),
divrec.distance);
qemu_plugin_outs(out->str);
}
@ -146,10 +150,7 @@ static void report_divergance(ExecState *us, ExecState *them)
int i;
GSList *entry;
g_string_printf(out,
"Δ insn_count @ 0x%016" PRIx64
" (%ld) vs 0x%016" PRIx64 " (%ld)\n",
us->pc, us->insn_count, them->pc, them->insn_count);
g_string_printf(out, "Δ too high, we have diverged, previous insns\n");
for (entry = log, i = 0;
g_slist_next(entry) && i < 5;
@ -162,7 +163,7 @@ static void report_divergance(ExecState *us, ExecState *them)
prev->insn_count);
}
qemu_plugin_outs(out->str);
qemu_plugin_outs("too much divergence... giving up.");
qemu_plugin_outs("giving up\n");
qemu_plugin_uninstall(our_id, plugin_cleanup);
}
}
@ -347,7 +348,7 @@ QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id,
return -1;
}
} else if (g_strcmp0(tokens[0], "sockpath") == 0) {
sock_path = tokens[1];
sock_path = g_strdup(tokens[1]);
} else {
fprintf(stderr, "option parsing failed: %s\n", p);
return -1;

11
gdb-xml/aarch64-mte.xml Normal file
View File

@ -0,0 +1,11 @@
<?xml version="1.0"?>
<!-- Copyright (C) 2021-2023 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. -->
<!DOCTYPE feature SYSTEM "gdb-target.dtd">
<feature name="org.gnu.gdb.aarch64.mte">
<reg name="tag_ctl" bitsize="64" type="uint64" group="system" save-restore="no"/>
</feature>

341
gdbstub/gdbstub.c
View File

@ -30,6 +30,7 @@
#include "qemu/error-report.h"
#include "trace.h"
#include "exec/gdbstub.h"
#include "gdbstub/commands.h"
#include "gdbstub/syscalls.h"
#ifdef CONFIG_USER_ONLY
#include "accel/tcg/vcpu-state.h"
@ -920,60 +921,24 @@ static int cmd_parse_params(const char *data, const char *schema,
return 0;
}
typedef void (*GdbCmdHandler)(GArray *params, void *user_ctx);
/*
* cmd_startswith -> cmd is compared using startswith
*
* allow_stop_reply -> true iff the gdbstub can respond to this command with a
* "stop reply" packet. The list of commands that accept such response is
* defined at the GDB Remote Serial Protocol documentation. see:
* https://sourceware.org/gdb/onlinedocs/gdb/Stop-Reply-Packets.html#Stop-Reply-Packets.
*
* schema definitions:
* Each schema parameter entry consists of 2 chars,
* the first char represents the parameter type handling
* the second char represents the delimiter for the next parameter
*
* Currently supported schema types:
* 'l' -> unsigned long (stored in .val_ul)
* 'L' -> unsigned long long (stored in .val_ull)
* 's' -> string (stored in .data)
* 'o' -> single char (stored in .opcode)
* 't' -> thread id (stored in .thread_id)
* '?' -> skip according to delimiter
*
* Currently supported delimiters:
* '?' -> Stop at any delimiter (",;:=\0")
* '0' -> Stop at "\0"
* '.' -> Skip 1 char unless reached "\0"
* Any other value is treated as the delimiter value itself
*/
typedef struct GdbCmdParseEntry {
GdbCmdHandler handler;
const char *cmd;
bool cmd_startswith;
const char *schema;
bool allow_stop_reply;
} GdbCmdParseEntry;
static inline int startswith(const char *string, const char *pattern)
{
return !strncmp(string, pattern, strlen(pattern));
}
static int process_string_cmd(const char *data,
const GdbCmdParseEntry *cmds, int num_cmds)
static bool process_string_cmd(const char *data,
const GdbCmdParseEntry *cmds, int num_cmds)
{
int i;
g_autoptr(GArray) params = g_array_new(false, true, sizeof(GdbCmdVariant));
if (!cmds) {
return -1;
return false;
}
for (i = 0; i < num_cmds; i++) {
const GdbCmdParseEntry *cmd = &cmds[i];
void *user_ctx = NULL;
g_assert(cmd->handler && cmd->cmd);
if ((cmd->cmd_startswith && !startswith(data, cmd->cmd)) ||
@ -984,16 +949,20 @@ static int process_string_cmd(const char *data,
if (cmd->schema) {
if (cmd_parse_params(&data[strlen(cmd->cmd)],
cmd->schema, params)) {
return -1;
return false;
}
}
if (cmd->need_cpu_context) {
user_ctx = (void *)gdbserver_state.g_cpu;
}
gdbserver_state.allow_stop_reply = cmd->allow_stop_reply;
cmd->handler(params, NULL);
return 0;
cmd->handler(params, user_ctx);
return true;
}
return -1;
return false;
}
static void run_cmd_parser(const char *data, const GdbCmdParseEntry *cmd)
@ -1007,7 +976,7 @@ static void run_cmd_parser(const char *data, const GdbCmdParseEntry *cmd)
/* In case there was an error during the command parsing we must
* send a NULL packet to indicate the command is not supported */
if (process_string_cmd(data, cmd, 1)) {
if (!process_string_cmd(data, cmd, 1)) {
gdb_put_packet("");
}
}
@ -1023,7 +992,7 @@ static void handle_detach(GArray *params, void *user_ctx)
return;
}
pid = get_param(params, 0)->val_ul;
pid = gdb_get_cmd_param(params, 0)->val_ul;
}
#ifdef CONFIG_USER_ONLY
@ -1061,13 +1030,13 @@ static void handle_thread_alive(GArray *params, void *user_ctx)
return;
}
if (get_param(params, 0)->thread_id.kind == GDB_READ_THREAD_ERR) {
if (gdb_get_cmd_param(params, 0)->thread_id.kind == GDB_READ_THREAD_ERR) {
gdb_put_packet("E22");
return;
}
cpu = gdb_get_cpu(get_param(params, 0)->thread_id.pid,
get_param(params, 0)->thread_id.tid);
cpu = gdb_get_cpu(gdb_get_cmd_param(params, 0)->thread_id.pid,
gdb_get_cmd_param(params, 0)->thread_id.tid);
if (!cpu) {
gdb_put_packet("E22");
return;
@ -1079,7 +1048,7 @@ static void handle_thread_alive(GArray *params, void *user_ctx)
static void handle_continue(GArray *params, void *user_ctx)
{
if (params->len) {
gdb_set_cpu_pc(get_param(params, 0)->val_ull);
gdb_set_cpu_pc(gdb_get_cmd_param(params, 0)->val_ull);
}
gdbserver_state.signal = 0;
@ -1095,7 +1064,7 @@ static void handle_cont_with_sig(GArray *params, void *user_ctx)
* omit the addr parameter
*/
if (params->len) {
signal = get_param(params, 0)->val_ul;
signal = gdb_get_cmd_param(params, 0)->val_ul;
}
gdbserver_state.signal = gdb_signal_to_target(signal);
@ -1115,18 +1084,18 @@ static void handle_set_thread(GArray *params, void *user_ctx)
return;
}
if (get_param(params, 1)->thread_id.kind == GDB_READ_THREAD_ERR) {
if (gdb_get_cmd_param(params, 1)->thread_id.kind == GDB_READ_THREAD_ERR) {
gdb_put_packet("E22");
return;
}
if (get_param(params, 1)->thread_id.kind != GDB_ONE_THREAD) {
if (gdb_get_cmd_param(params, 1)->thread_id.kind != GDB_ONE_THREAD) {
gdb_put_packet("OK");
return;
}
pid = get_param(params, 1)->thread_id.pid;
tid = get_param(params, 1)->thread_id.tid;
pid = gdb_get_cmd_param(params, 1)->thread_id.pid;
tid = gdb_get_cmd_param(params, 1)->thread_id.tid;
#ifdef CONFIG_USER_ONLY
if (gdb_handle_set_thread_user(pid, tid)) {
return;
@ -1142,7 +1111,7 @@ static void handle_set_thread(GArray *params, void *user_ctx)
* Note: This command is deprecated and modern gdb's will be using the
* vCont command instead.
*/
switch (get_param(params, 0)->opcode) {
switch (gdb_get_cmd_param(params, 0)->opcode) {
case 'c':
gdbserver_state.c_cpu = cpu;
gdb_put_packet("OK");
@ -1167,9 +1136,9 @@ static void handle_insert_bp(GArray *params, void *user_ctx)
}
res = gdb_breakpoint_insert(gdbserver_state.c_cpu,
get_param(params, 0)->val_ul,
get_param(params, 1)->val_ull,
get_param(params, 2)->val_ull);
gdb_get_cmd_param(params, 0)->val_ul,
gdb_get_cmd_param(params, 1)->val_ull,
gdb_get_cmd_param(params, 2)->val_ull);
if (res >= 0) {
gdb_put_packet("OK");
return;
@ -1191,9 +1160,9 @@ static void handle_remove_bp(GArray *params, void *user_ctx)
}
res = gdb_breakpoint_remove(gdbserver_state.c_cpu,
get_param(params, 0)->val_ul,
get_param(params, 1)->val_ull,
get_param(params, 2)->val_ull);
gdb_get_cmd_param(params, 0)->val_ul,
gdb_get_cmd_param(params, 1)->val_ull,
gdb_get_cmd_param(params, 2)->val_ull);
if (res >= 0) {
gdb_put_packet("OK");
return;
@ -1225,10 +1194,10 @@ static void handle_set_reg(GArray *params, void *user_ctx)
return;
}
reg_size = strlen(get_param(params, 1)->data) / 2;
gdb_hextomem(gdbserver_state.mem_buf, get_param(params, 1)->data, reg_size);
reg_size = strlen(gdb_get_cmd_param(params, 1)->data) / 2;
gdb_hextomem(gdbserver_state.mem_buf, gdb_get_cmd_param(params, 1)->data, reg_size);
gdb_write_register(gdbserver_state.g_cpu, gdbserver_state.mem_buf->data,
get_param(params, 0)->val_ull);
gdb_get_cmd_param(params, 0)->val_ull);
gdb_put_packet("OK");
}
@ -1243,7 +1212,7 @@ static void handle_get_reg(GArray *params, void *user_ctx)
reg_size = gdb_read_register(gdbserver_state.g_cpu,
gdbserver_state.mem_buf,
get_param(params, 0)->val_ull);
gdb_get_cmd_param(params, 0)->val_ull);
if (!reg_size) {
gdb_put_packet("E14");
return;
@ -1264,16 +1233,16 @@ static void handle_write_mem(GArray *params, void *user_ctx)
}
/* gdb_hextomem() reads 2*len bytes */
if (get_param(params, 1)->val_ull >
strlen(get_param(params, 2)->data) / 2) {
if (gdb_get_cmd_param(params, 1)->val_ull >
strlen(gdb_get_cmd_param(params, 2)->data) / 2) {
gdb_put_packet("E22");
return;
}
gdb_hextomem(gdbserver_state.mem_buf, get_param(params, 2)->data,
get_param(params, 1)->val_ull);
gdb_hextomem(gdbserver_state.mem_buf, gdb_get_cmd_param(params, 2)->data,
gdb_get_cmd_param(params, 1)->val_ull);
if (gdb_target_memory_rw_debug(gdbserver_state.g_cpu,
get_param(params, 0)->val_ull,
gdb_get_cmd_param(params, 0)->val_ull,
gdbserver_state.mem_buf->data,
gdbserver_state.mem_buf->len, true)) {
gdb_put_packet("E14");
@ -1291,16 +1260,16 @@ static void handle_read_mem(GArray *params, void *user_ctx)
}
/* gdb_memtohex() doubles the required space */
if (get_param(params, 1)->val_ull > MAX_PACKET_LENGTH / 2) {
if (gdb_get_cmd_param(params, 1)->val_ull > MAX_PACKET_LENGTH / 2) {
gdb_put_packet("E22");
return;
}
g_byte_array_set_size(gdbserver_state.mem_buf,
get_param(params, 1)->val_ull);
gdb_get_cmd_param(params, 1)->val_ull);
if (gdb_target_memory_rw_debug(gdbserver_state.g_cpu,
get_param(params, 0)->val_ull,
gdb_get_cmd_param(params, 0)->val_ull,
gdbserver_state.mem_buf->data,
gdbserver_state.mem_buf->len, false)) {
gdb_put_packet("E14");
@ -1324,8 +1293,8 @@ static void handle_write_all_regs(GArray *params, void *user_ctx)
}
cpu_synchronize_state(gdbserver_state.g_cpu);
len = strlen(get_param(params, 0)->data) / 2;
gdb_hextomem(gdbserver_state.mem_buf, get_param(params, 0)->data, len);
len = strlen(gdb_get_cmd_param(params, 0)->data) / 2;
gdb_hextomem(gdbserver_state.mem_buf, gdb_get_cmd_param(params, 0)->data, len);
registers = gdbserver_state.mem_buf->data;
for (reg_id = 0;
reg_id < gdbserver_state.g_cpu->gdb_num_g_regs && len > 0;
@ -1360,7 +1329,7 @@ static void handle_read_all_regs(GArray *params, void *user_ctx)
static void handle_step(GArray *params, void *user_ctx)
{
if (params->len) {
gdb_set_cpu_pc(get_param(params, 0)->val_ull);
gdb_set_cpu_pc(gdb_get_cmd_param(params, 0)->val_ull);
}
cpu_single_step(gdbserver_state.c_cpu, gdbserver_state.sstep_flags);
@ -1373,7 +1342,7 @@ static void handle_backward(GArray *params, void *user_ctx)
gdb_put_packet("E22");
}
if (params->len == 1) {
switch (get_param(params, 0)->opcode) {
switch (gdb_get_cmd_param(params, 0)->opcode) {
case 's':
if (replay_reverse_step()) {
gdb_continue();
@ -1408,7 +1377,7 @@ static void handle_v_cont(GArray *params, void *user_ctx)
return;
}
res = gdb_handle_vcont(get_param(params, 0)->data);
res = gdb_handle_vcont(gdb_get_cmd_param(params, 0)->data);
if ((res == -EINVAL) || (res == -ERANGE)) {
gdb_put_packet("E22");
} else if (res) {
@ -1426,7 +1395,7 @@ static void handle_v_attach(GArray *params, void *user_ctx)
goto cleanup;
}
process = gdb_get_process(get_param(params, 0)->val_ul);
process = gdb_get_process(gdb_get_cmd_param(params, 0)->val_ul);
if (!process) {
goto cleanup;
}
@ -1464,26 +1433,26 @@ static const GdbCmdParseEntry gdb_v_commands_table[] = {
{
.handler = handle_v_cont_query,
.cmd = "Cont?",
.cmd_startswith = 1
.cmd_startswith = true
},
{
.handler = handle_v_cont,
.cmd = "Cont",
.cmd_startswith = 1,
.cmd_startswith = true,
.allow_stop_reply = true,
.schema = "s0"
},
{
.handler = handle_v_attach,
.cmd = "Attach;",
.cmd_startswith = 1,
.cmd_startswith = true,
.allow_stop_reply = true,
.schema = "l0"
},
{
.handler = handle_v_kill,
.cmd = "Kill;",
.cmd_startswith = 1
.cmd_startswith = true
},
#ifdef CONFIG_USER_ONLY
/*
@ -1493,25 +1462,25 @@ static const GdbCmdParseEntry gdb_v_commands_table[] = {
{
.handler = gdb_handle_v_file_open,
.cmd = "File:open:",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "s,L,L0"
},
{
.handler = gdb_handle_v_file_close,
.cmd = "File:close:",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "l0"
},
{
.handler = gdb_handle_v_file_pread,
.cmd = "File:pread:",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "l,L,L0"
},
{
.handler = gdb_handle_v_file_readlink,
.cmd = "File:readlink:",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "s0"
},
#endif
@ -1523,9 +1492,9 @@ static void handle_v_commands(GArray *params, void *user_ctx)
return;
}
if (process_string_cmd(get_param(params, 0)->data,
gdb_v_commands_table,
ARRAY_SIZE(gdb_v_commands_table))) {
if (!process_string_cmd(gdb_get_cmd_param(params, 0)->data,
gdb_v_commands_table,
ARRAY_SIZE(gdb_v_commands_table))) {
gdb_put_packet("");
}
}
@ -1555,7 +1524,7 @@ static void handle_set_qemu_sstep(GArray *params, void *user_ctx)
return;
}
new_sstep_flags = get_param(params, 0)->val_ul;
new_sstep_flags = gdb_get_cmd_param(params, 0)->val_ul;
if (new_sstep_flags & ~gdbserver_state.supported_sstep_flags) {
gdb_put_packet("E22");
@ -1615,13 +1584,13 @@ static void handle_query_thread_extra(GArray *params, void *user_ctx)
CPUState *cpu;
if (!params->len ||
get_param(params, 0)->thread_id.kind == GDB_READ_THREAD_ERR) {
gdb_get_cmd_param(params, 0)->thread_id.kind == GDB_READ_THREAD_ERR) {
gdb_put_packet("E22");
return;
}
cpu = gdb_get_cpu(get_param(params, 0)->thread_id.pid,
get_param(params, 0)->thread_id.tid);
cpu = gdb_get_cpu(gdb_get_cmd_param(params, 0)->thread_id.pid,
gdb_get_cmd_param(params, 0)->thread_id.tid);
if (!cpu) {
return;
}
@ -1645,6 +1614,20 @@ static void handle_query_thread_extra(GArray *params, void *user_ctx)
gdb_put_strbuf();
}
static char *extended_qsupported_features;
void gdb_extend_qsupported_features(char *qsupported_features)
{
/*
* We don't support different sets of CPU gdb features on different CPUs yet
* so assert the feature strings are the same on all CPUs, or is set only
* once (1 CPU).
*/
g_assert(extended_qsupported_features == NULL ||
g_strcmp0(extended_qsupported_features, qsupported_features) == 0);
extended_qsupported_features = qsupported_features;
}
static void handle_query_supported(GArray *params, void *user_ctx)
{
CPUClass *cc;
@ -1673,7 +1656,7 @@ static void handle_query_supported(GArray *params, void *user_ctx)
#endif
if (params->len) {
const char *gdb_supported = get_param(params, 0)->data;
const char *gdb_supported = gdb_get_cmd_param(params, 0)->data;
if (strstr(gdb_supported, "multiprocess+")) {
gdbserver_state.multiprocess = true;
@ -1684,6 +1667,11 @@ static void handle_query_supported(GArray *params, void *user_ctx)
}
g_string_append(gdbserver_state.str_buf, ";vContSupported+;multiprocess+");
if (extended_qsupported_features) {
g_string_append(gdbserver_state.str_buf, extended_qsupported_features);
}
gdb_put_strbuf();
}
@ -1707,15 +1695,15 @@ static void handle_query_xfer_features(GArray *params, void *user_ctx)
return;
}
p = get_param(params, 0)->data;
p = gdb_get_cmd_param(params, 0)->data;
xml = get_feature_xml(p, &p, process);
if (!xml) {
gdb_put_packet("E00");
return;
}
addr = get_param(params, 1)->val_ul;
len = get_param(params, 2)->val_ul;
addr = gdb_get_cmd_param(params, 1)->val_ul;
len = gdb_get_cmd_param(params, 2)->val_ul;
total_len = strlen(xml);
if (addr > total_len) {
gdb_put_packet("E00");
@ -1760,11 +1748,46 @@ static const GdbCmdParseEntry gdb_gen_query_set_common_table[] = {
{
.handler = handle_set_qemu_sstep,
.cmd = "qemu.sstep=",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "l0"
},
};
/* Compares if a set of command parsers is equal to another set of parsers. */
static bool cmp_cmds(GdbCmdParseEntry *c, GdbCmdParseEntry *d, int size)
{
for (int i = 0; i < size; i++) {
if (!(c[i].handler == d[i].handler &&
g_strcmp0(c[i].cmd, d[i].cmd) == 0 &&
c[i].cmd_startswith == d[i].cmd_startswith &&
g_strcmp0(c[i].schema, d[i].schema) == 0)) {
/* Sets are different. */
return false;
}
}
/* Sets are equal, i.e. contain the same command parsers. */
return true;
}
static GdbCmdParseEntry *extended_query_table;
static int extended_query_table_size;
void gdb_extend_query_table(GdbCmdParseEntry *table, int size)
{
/*
* We don't support different sets of CPU gdb features on different CPUs yet
* so assert query table is the same on all CPUs, or is set only once
* (1 CPU).
*/
g_assert(extended_query_table == NULL ||
(extended_query_table_size == size &&
cmp_cmds(extended_query_table, table, size)));
extended_query_table = table;
extended_query_table_size = size;
}
static const GdbCmdParseEntry gdb_gen_query_table[] = {
{
.handler = handle_query_curr_tid,
@ -1781,7 +1804,7 @@ static const GdbCmdParseEntry gdb_gen_query_table[] = {
{
.handler = handle_query_thread_extra,
.cmd = "ThreadExtraInfo,",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "t0"
},
#ifdef CONFIG_USER_ONLY
@ -1793,14 +1816,14 @@ static const GdbCmdParseEntry gdb_gen_query_table[] = {
{
.handler = gdb_handle_query_rcmd,
.cmd = "Rcmd,",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "s0"
},
#endif
{
.handler = handle_query_supported,
.cmd = "Supported:",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "s0"
},
{
@ -1811,7 +1834,7 @@ static const GdbCmdParseEntry gdb_gen_query_table[] = {
{
.handler = handle_query_xfer_features,
.cmd = "Xfer:features:read:",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "s:l,l0"
},
#if defined(CONFIG_USER_ONLY)
@ -1819,27 +1842,27 @@ static const GdbCmdParseEntry gdb_gen_query_table[] = {
{
.handler = gdb_handle_query_xfer_auxv,
.cmd = "Xfer:auxv:read::",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "l,l0"
},
{
.handler = gdb_handle_query_xfer_siginfo,
.cmd = "Xfer:siginfo:read::",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "l,l0"
},
#endif
{
.handler = gdb_handle_query_xfer_exec_file,
.cmd = "Xfer:exec-file:read:",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "l:l,l0"
},
#endif
{
.handler = gdb_handle_query_attached,
.cmd = "Attached:",
.cmd_startswith = 1
.cmd_startswith = true
},
{
.handler = gdb_handle_query_attached,
@ -1857,19 +1880,35 @@ static const GdbCmdParseEntry gdb_gen_query_table[] = {
#endif
};
static GdbCmdParseEntry *extended_set_table;
static int extended_set_table_size;
void gdb_extend_set_table(GdbCmdParseEntry *table, int size)
{
/*
* We don't support different sets of CPU gdb features on different CPUs yet
* so assert set table is the same on all CPUs, or is set only once (1 CPU).
*/
g_assert(extended_set_table == NULL ||
(extended_set_table_size == size &&
cmp_cmds(extended_set_table, table, size)));
extended_set_table = table;
extended_set_table_size = size;
}
static const GdbCmdParseEntry gdb_gen_set_table[] = {
/* Order is important if has same prefix */
{
.handler = handle_set_qemu_sstep,
.cmd = "qemu.sstep:",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "l0"
},
#ifndef CONFIG_USER_ONLY
{
.handler = gdb_handle_set_qemu_phy_mem_mode,
.cmd = "qemu.PhyMemMode:",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "l0"
},
#endif
@ -1877,7 +1916,7 @@ static const GdbCmdParseEntry gdb_gen_set_table[] = {
{
.handler = gdb_handle_set_catch_syscalls,
.cmd = "CatchSyscalls:",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "s0",
},
#endif
@ -1889,17 +1928,27 @@ static void handle_gen_query(GArray *params, void *user_ctx)
return;
}
if (!process_string_cmd(get_param(params, 0)->data,
gdb_gen_query_set_common_table,
ARRAY_SIZE(gdb_gen_query_set_common_table))) {
if (process_string_cmd(gdb_get_cmd_param(params, 0)->data,
gdb_gen_query_set_common_table,
ARRAY_SIZE(gdb_gen_query_set_common_table))) {
return;
}
if (process_string_cmd(get_param(params, 0)->data,
if (process_string_cmd(gdb_get_cmd_param(params, 0)->data,
gdb_gen_query_table,
ARRAY_SIZE(gdb_gen_query_table))) {
gdb_put_packet("");
return;
}
if (extended_query_table &&
process_string_cmd(gdb_get_cmd_param(params, 0)->data,
extended_query_table,
extended_query_table_size)) {
return;
}
/* Can't handle query, return Empty response. */
gdb_put_packet("");
}
static void handle_gen_set(GArray *params, void *user_ctx)
@ -1908,17 +1957,27 @@ static void handle_gen_set(GArray *params, void *user_ctx)
return;
}
if (!process_string_cmd(get_param(params, 0)->data,
gdb_gen_query_set_common_table,
ARRAY_SIZE(gdb_gen_query_set_common_table))) {
if (process_string_cmd(gdb_get_cmd_param(params, 0)->data,
gdb_gen_query_set_common_table,
ARRAY_SIZE(gdb_gen_query_set_common_table))) {
return;
}
if (process_string_cmd(get_param(params, 0)->data,
if (process_string_cmd(gdb_get_cmd_param(params, 0)->data,
gdb_gen_set_table,
ARRAY_SIZE(gdb_gen_set_table))) {
gdb_put_packet("");
return;
}
if (extended_set_table &&
process_string_cmd(gdb_get_cmd_param(params, 0)->data,
extended_set_table,
extended_set_table_size)) {
return;
}
/* Can't handle set, return Empty response. */
gdb_put_packet("");
}
static void handle_target_halt(GArray *params, void *user_ctx)
@ -1953,7 +2012,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry target_halted_cmd_desc = {
.handler = handle_target_halt,
.cmd = "?",
.cmd_startswith = 1,
.cmd_startswith = true,
.allow_stop_reply = true,
};
cmd_parser = &target_halted_cmd_desc;
@ -1964,7 +2023,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry continue_cmd_desc = {
.handler = handle_continue,
.cmd = "c",
.cmd_startswith = 1,
.cmd_startswith = true,
.allow_stop_reply = true,
.schema = "L0"
};
@ -1976,7 +2035,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry cont_with_sig_cmd_desc = {
.handler = handle_cont_with_sig,
.cmd = "C",
.cmd_startswith = 1,
.cmd_startswith = true,
.allow_stop_reply = true,
.schema = "l0"
};
@ -1988,7 +2047,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry v_cmd_desc = {
.handler = handle_v_commands,
.cmd = "v",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "s0"
};
cmd_parser = &v_cmd_desc;
@ -2005,7 +2064,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry detach_cmd_desc = {
.handler = handle_detach,
.cmd = "D",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "?.l0"
};
cmd_parser = &detach_cmd_desc;
@ -2016,7 +2075,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry step_cmd_desc = {
.handler = handle_step,
.cmd = "s",
.cmd_startswith = 1,
.cmd_startswith = true,
.allow_stop_reply = true,
.schema = "L0"
};
@ -2028,7 +2087,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry backward_cmd_desc = {
.handler = handle_backward,
.cmd = "b",
.cmd_startswith = 1,
.cmd_startswith = true,
.allow_stop_reply = true,
.schema = "o0"
};
@ -2040,7 +2099,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry file_io_cmd_desc = {
.handler = gdb_handle_file_io,
.cmd = "F",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "L,L,o0"
};
cmd_parser = &file_io_cmd_desc;
@ -2051,7 +2110,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry read_all_regs_cmd_desc = {
.handler = handle_read_all_regs,
.cmd = "g",
.cmd_startswith = 1
.cmd_startswith = true
};
cmd_parser = &read_all_regs_cmd_desc;
}
@ -2061,7 +2120,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry write_all_regs_cmd_desc = {
.handler = handle_write_all_regs,
.cmd = "G",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "s0"
};
cmd_parser = &write_all_regs_cmd_desc;
@ -2072,7 +2131,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry read_mem_cmd_desc = {
.handler = handle_read_mem,
.cmd = "m",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "L,L0"
};
cmd_parser = &read_mem_cmd_desc;
@ -2083,7 +2142,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry write_mem_cmd_desc = {
.handler = handle_write_mem,
.cmd = "M",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "L,L:s0"
};
cmd_parser = &write_mem_cmd_desc;
@ -2094,7 +2153,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry get_reg_cmd_desc = {
.handler = handle_get_reg,
.cmd = "p",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "L0"
};
cmd_parser = &get_reg_cmd_desc;
@ -2105,7 +2164,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry set_reg_cmd_desc = {
.handler = handle_set_reg,
.cmd = "P",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "L?s0"
};
cmd_parser = &set_reg_cmd_desc;
@ -2116,7 +2175,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry insert_bp_cmd_desc = {
.handler = handle_insert_bp,
.cmd = "Z",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "l?L?L0"
};
cmd_parser = &insert_bp_cmd_desc;
@ -2127,7 +2186,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry remove_bp_cmd_desc = {
.handler = handle_remove_bp,
.cmd = "z",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "l?L?L0"
};
cmd_parser = &remove_bp_cmd_desc;
@ -2138,7 +2197,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry set_thread_cmd_desc = {
.handler = handle_set_thread,
.cmd = "H",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "o.t0"
};
cmd_parser = &set_thread_cmd_desc;
@ -2149,7 +2208,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry thread_alive_cmd_desc = {
.handler = handle_thread_alive,
.cmd = "T",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "t0"
};
cmd_parser = &thread_alive_cmd_desc;
@ -2160,7 +2219,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry gen_query_cmd_desc = {
.handler = handle_gen_query,
.cmd = "q",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "s0"
};
cmd_parser = &gen_query_cmd_desc;
@ -2171,7 +2230,7 @@ static int gdb_handle_packet(const char *line_buf)
static const GdbCmdParseEntry gen_set_cmd_desc = {
.handler = handle_gen_set,
.cmd = "Q",
.cmd_startswith = 1,
.cmd_startswith = true,
.schema = "s0"
};
cmd_parser = &gen_set_cmd_desc;

23
gdbstub/internals.h
View File

@ -106,9 +106,7 @@ static inline int tohex(int v)
*/
void gdb_put_strbuf(void);
int gdb_put_packet(const char *buf);
int gdb_put_packet_binary(const char *buf, int len, bool dump);
void gdb_hextomem(GByteArray *mem, const char *buf, int len);
void gdb_memtohex(GString *buf, const uint8_t *mem, int len);
void gdb_memtox(GString *buf, const char *mem, int len);
void gdb_read_byte(uint8_t ch);
@ -166,27 +164,6 @@ void gdb_put_buffer(const uint8_t *buf, int len);
*/
void gdb_init_gdbserver_state(void);
typedef enum GDBThreadIdKind {
GDB_ONE_THREAD = 0,
GDB_ALL_THREADS, /* One process, all threads */
GDB_ALL_PROCESSES,
GDB_READ_THREAD_ERR
} GDBThreadIdKind;
typedef union GdbCmdVariant {
const char *data;
uint8_t opcode;
unsigned long val_ul;
unsigned long long val_ull;
struct {
GDBThreadIdKind kind;
uint32_t pid;
uint32_t tid;
} thread_id;
} GdbCmdVariant;
#define get_param(p, i) (&g_array_index(p, GdbCmdVariant, i))
void gdb_handle_query_rcmd(GArray *params, void *ctx); /* system */
void gdb_handle_query_offsets(GArray *params, void *user_ctx); /* user */
void gdb_handle_query_xfer_auxv(GArray *params, void *user_ctx); /*user */

7
gdbstub/syscalls.c
View File

@ -16,6 +16,7 @@
#include "sysemu/runstate.h"
#include "gdbstub/user.h"
#include "gdbstub/syscalls.h"
#include "gdbstub/commands.h"
#include "trace.h"
#include "internals.h"
@ -154,9 +155,9 @@ void gdb_handle_file_io(GArray *params, void *user_ctx)
uint64_t ret;
int err;
ret = get_param(params, 0)->val_ull;
ret = gdb_get_cmd_param(params, 0)->val_ull;
if (params->len >= 2) {
err = get_param(params, 1)->val_ull;
err = gdb_get_cmd_param(params, 1)->val_ull;
} else {
err = 0;
}
@ -196,7 +197,7 @@ void gdb_handle_file_io(GArray *params, void *user_ctx)
gdbserver_syscall_state.current_syscall_cb = NULL;
}
if (params->len >= 3 && get_param(params, 2)->opcode == (uint8_t)'C') {
if (params->len >= 3 && gdb_get_cmd_param(params, 2)->opcode == (uint8_t)'C') {
gdb_put_packet("T02");
return;
}

7
gdbstub/system.c
View File

@ -16,6 +16,7 @@
#include "qemu/cutils.h"
#include "exec/gdbstub.h"
#include "gdbstub/syscalls.h"
#include "gdbstub/commands.h"
#include "exec/hwaddr.h"
#include "exec/tb-flush.h"
#include "sysemu/cpus.h"
@ -501,7 +502,7 @@ void gdb_handle_set_qemu_phy_mem_mode(GArray *params, void *ctx)
return;
}
if (!get_param(params, 0)->val_ul) {
if (!gdb_get_cmd_param(params, 0)->val_ul) {
phy_memory_mode = 0;
} else {
phy_memory_mode = 1;
@ -519,7 +520,7 @@ void gdb_handle_query_rcmd(GArray *params, void *ctx)
return;
}
len = strlen(get_param(params, 0)->data);
len = strlen(gdb_get_cmd_param(params, 0)->data);
if (len % 2) {
gdb_put_packet("E01");
return;
@ -527,7 +528,7 @@ void gdb_handle_query_rcmd(GArray *params, void *ctx)
g_assert(gdbserver_state.mem_buf->len == 0);
len = len / 2;
gdb_hextomem(gdbserver_state.mem_buf, get_param(params, 0)->data, len);
gdb_hextomem(gdbserver_state.mem_buf, gdb_get_cmd_param(params, 0)->data, len);
g_byte_array_append(gdbserver_state.mem_buf, &zero, 1);
qemu_chr_be_write(gdbserver_system_state.mon_chr,
gdbserver_state.mem_buf->data,

25
gdbstub/user-target.c
View File

@ -9,6 +9,7 @@
#include "qemu/osdep.h"
#include "exec/gdbstub.h"
#include "gdbstub/commands.h"
#include "qemu.h"
#include "internals.h"
#ifdef CONFIG_LINUX
@ -250,8 +251,8 @@ void gdb_handle_query_xfer_auxv(GArray *params, void *user_ctx)
return;
}
offset = get_param(params, 0)->val_ul;
len = get_param(params, 1)->val_ul;
offset = gdb_get_cmd_param(params, 0)->val_ul;
len = gdb_get_cmd_param(params, 1)->val_ul;
ts = get_task_state(gdbserver_state.c_cpu);
saved_auxv = ts->info->saved_auxv;
auxv_len = ts->info->auxv_len;
@ -288,7 +289,7 @@ void gdb_handle_query_xfer_auxv(GArray *params, void *user_ctx)
static const char *get_filename_param(GArray *params, int i)
{
const char *hex_filename = get_param(params, i)->data;
const char *hex_filename = gdb_get_cmd_param(params, i)->data;
gdb_hextomem(gdbserver_state.mem_buf, hex_filename,
strlen(hex_filename) / 2);
g_byte_array_append(gdbserver_state.mem_buf, (const guint8 *)"", 1);
@ -306,8 +307,8 @@ static void hostio_reply_with_data(const void *buf, size_t n)
void gdb_handle_v_file_open(GArray *params, void *user_ctx)
{
const char *filename = get_filename_param(params, 0);
uint64_t flags = get_param(params, 1)->val_ull;
uint64_t mode = get_param(params, 2)->val_ull;
uint64_t flags = gdb_get_cmd_param(params, 1)->val_ull;
uint64_t mode = gdb_get_cmd_param(params, 2)->val_ull;
#ifdef CONFIG_LINUX
int fd = do_guest_openat(cpu_env(gdbserver_state.g_cpu), 0, filename,
@ -325,7 +326,7 @@ void gdb_handle_v_file_open(GArray *params, void *user_ctx)
void gdb_handle_v_file_close(GArray *params, void *user_ctx)
{
int fd = get_param(params, 0)->val_ul;
int fd = gdb_get_cmd_param(params, 0)->val_ul;
if (close(fd) == -1) {
g_string_printf(gdbserver_state.str_buf, "F-1,%d", errno);
@ -338,9 +339,9 @@ void gdb_handle_v_file_close(GArray *params, void *user_ctx)
void gdb_handle_v_file_pread(GArray *params, void *user_ctx)
{
int fd = get_param(params, 0)->val_ul;
size_t count = get_param(params, 1)->val_ull;
off_t offset = get_param(params, 2)->val_ull;
int fd = gdb_get_cmd_param(params, 0)->val_ul;
size_t count = gdb_get_cmd_param(params, 1)->val_ull;
off_t offset = gdb_get_cmd_param(params, 2)->val_ull;
size_t bufsiz = MIN(count, BUFSIZ);
g_autofree char *buf = g_try_malloc(bufsiz);
@ -383,9 +384,9 @@ void gdb_handle_v_file_readlink(GArray *params, void *user_ctx)
void gdb_handle_query_xfer_exec_file(GArray *params, void *user_ctx)
{
uint32_t pid = get_param(params, 0)->val_ul;
uint32_t offset = get_param(params, 1)->val_ul;
uint32_t length = get_param(params, 2)->val_ul;
uint32_t pid = gdb_get_cmd_param(params, 0)->val_ul;
uint32_t offset = gdb_get_cmd_param(params, 1)->val_ul;
uint32_t length = gdb_get_cmd_param(params, 2)->val_ul;
GDBProcess *process = gdb_get_process(pid);
if (!process) {

7
gdbstub/user.c
View File

@ -16,6 +16,7 @@
#include "exec/hwaddr.h"
#include "exec/tb-flush.h"
#include "exec/gdbstub.h"
#include "gdbstub/commands.h"
#include "gdbstub/syscalls.h"
#include "gdbstub/user.h"
#include "gdbstub/enums.h"
@ -793,7 +794,7 @@ void gdb_syscall_return(CPUState *cs, int num)
void gdb_handle_set_catch_syscalls(GArray *params, void *user_ctx)
{
const char *param = get_param(params, 0)->data;
const char *param = gdb_get_cmd_param(params, 0)->data;
GDBSyscallsMask catch_syscalls_mask;
bool catch_all_syscalls;
unsigned int num;
@ -858,8 +859,8 @@ void gdb_handle_query_xfer_siginfo(GArray *params, void *user_ctx)
unsigned long offset, len;
uint8_t *siginfo_offset;
offset = get_param(params, 0)->val_ul;
len = get_param(params, 1)->val_ul;
offset = gdb_get_cmd_param(params, 0)->val_ul;
len = gdb_get_cmd_param(params, 1)->val_ul;
if (offset + len > gdbserver_user_state.siginfo_len) {
/* Invalid offset and/or requested length. */

14
hw/core/cpu-common.c
View File

@ -192,13 +192,6 @@ static void cpu_common_parse_features(const char *typename, char *features,
}
}
#ifdef CONFIG_PLUGIN
static void qemu_plugin_vcpu_init__async(CPUState *cpu, run_on_cpu_data unused)
{
qemu_plugin_vcpu_init_hook(cpu);
}
#endif
static void cpu_common_realizefn(DeviceState *dev, Error **errp)
{
CPUState *cpu = CPU(dev);
@ -274,7 +267,7 @@ static void cpu_common_initfn(Object *obj)
#ifdef CONFIG_PLUGIN
if (tcg_enabled()) {
cpu->plugin_state = qemu_plugin_create_vcpu_state();
async_run_on_cpu(cpu, qemu_plugin_vcpu_init__async, RUN_ON_CPU_NULL);
qemu_plugin_vcpu_init_hook(cpu);
}
#endif
}
@ -283,6 +276,11 @@ static void cpu_common_finalize(Object *obj)
{
CPUState *cpu = CPU(obj);
#ifdef CONFIG_PLUGIN
if (tcg_enabled()) {
g_free(cpu->plugin_state);
}
#endif
g_array_free(cpu->gdb_regs, TRUE);
qemu_lockcnt_destroy(&cpu->in_ioctl_lock);
qemu_mutex_destroy(&cpu->work_mutex);

2
hw/core/loader-fit.c
View File

@ -267,7 +267,7 @@ int load_fit(const struct fit_loader *ldr, const char *filename, void *opaque)
const char *def_cfg_name;
char path[FIT_LOADER_MAX_PATH];
int itb_size, configs, cfg_off, off;
hwaddr kernel_end;
hwaddr kernel_end = 0;
int ret;
itb = load_device_tree(filename, &itb_size);

103
include/gdbstub/commands.h Normal file
View File

@ -0,0 +1,103 @@
#ifndef GDBSTUB_COMMANDS_H
#define GDBSTUB
typedef void (*GdbCmdHandler)(GArray *params, void *user_ctx);
typedef enum GDBThreadIdKind {
GDB_ONE_THREAD = 0,
GDB_ALL_THREADS, /* One process, all threads */
GDB_ALL_PROCESSES,
GDB_READ_THREAD_ERR
} GDBThreadIdKind;
typedef union GdbCmdVariant {
const char *data;
uint8_t opcode;
unsigned long val_ul;
unsigned long long val_ull;
struct {
GDBThreadIdKind kind;
uint32_t pid;
uint32_t tid;
} thread_id;
} GdbCmdVariant;
#define gdb_get_cmd_param(p, i) (&g_array_index(p, GdbCmdVariant, i))
/**
* typedef GdbCmdParseEntry - gdb command parser
*
* This structure keeps the information necessary to match a gdb command,
* parse it (extract its parameters), and select the correct handler for it.
*
* @cmd: The command to be matched
* @cmd_startswith: If true, @cmd is compared using startswith
* @schema: Each schema for the command parameter entry consists of 2 chars,
* the first char represents the parameter type handling the second char
* represents the delimiter for the next parameter.
*
* Currently supported schema types:
* 'l' -> unsigned long (stored in .val_ul)
* 'L' -> unsigned long long (stored in .val_ull)
* 's' -> string (stored in .data)
* 'o' -> single char (stored in .opcode)
* 't' -> thread id (stored in .thread_id)
* '?' -> skip according to delimiter
*
* Currently supported delimiters:
* '?' -> Stop at any delimiter (",;:=\0")
* '0' -> Stop at "\0"
* '.' -> Skip 1 char unless reached "\0"
* Any other value is treated as the delimiter value itself
*
* @allow_stop_reply: True iff the gdbstub can respond to this command with a
* "stop reply" packet. The list of commands that accept such response is
* defined at the GDB Remote Serial Protocol documentation. See:
* https://sourceware.org/gdb/onlinedocs/gdb/Stop-Reply-Packets.html#Stop-Reply-Packets.
*
* @need_cpu_context: Pass current CPU context to command handler via user_ctx.
*/
typedef struct GdbCmdParseEntry {
GdbCmdHandler handler;
const char *cmd;
bool cmd_startswith;
const char *schema;
bool allow_stop_reply;
bool need_cpu_context;
} GdbCmdParseEntry;
/**
* gdb_put_packet() - put string into gdb server's buffer so it is sent
* to the client
*/
int gdb_put_packet(const char *buf);
/**
* gdb_extend_query_table() - Extend query table.
* @table: The table with the additional query packet handlers.
* @size: The number of handlers to be added.
*/
void gdb_extend_query_table(GdbCmdParseEntry *table, int size);
/**
* gdb_extend_set_table() - Extend set table.
* @table: The table with the additional set packet handlers.
* @size: The number of handlers to be added.
*/
void gdb_extend_set_table(GdbCmdParseEntry *table, int size);
/**
* gdb_extend_qsupported_features() - Extend the qSupported features string.
* @qsupported_features: The additional qSupported feature(s) string. The string
* should start with a semicolon and, if there are more than one feature, the
* features should be separate by a semiocolon.
*/
void gdb_extend_qsupported_features(char *qsupported_features);
/**
* Convert a hex string to bytes. Conversion is done per byte, so 2 hex digits
* are converted to 1 byte. Invalid hex digits are treated as 0 digits.
*/
void gdb_hextomem(GByteArray *mem, const char *buf, int len);
#endif /* GDBSTUB_COMMANDS_H */

3
include/qemu/plugin.h
View File

@ -149,6 +149,9 @@ struct CPUPluginState {
/**
* qemu_plugin_create_vcpu_state: allocate plugin state
*
* The returned data must be released with g_free()
* when no longer required.
*/
CPUPluginState *qemu_plugin_create_vcpu_state(void);

2
linux-user/aarch64/meson.build
View File

@ -9,3 +9,5 @@ vdso_le_inc = gen_vdso.process('vdso-le.so',
extra_args: ['-r', '__kernel_rt_sigreturn'])
linux_user_ss.add(when: 'TARGET_AARCH64', if_true: [vdso_be_inc, vdso_le_inc])
linux_user_ss.add(when: 'TARGET_AARCH64', if_true: [files('mte_user_helper.c')])

35
linux-user/aarch64/mte_user_helper.c Normal file
View File

@ -0,0 +1,35 @@
/*
* ARM MemTag convenience functions.
*
* This code is licensed under the GNU GPL v2 or later.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
#include "qemu/osdep.h"
#include "qemu.h"
#include "mte_user_helper.h"
void arm_set_mte_tcf0(CPUArchState *env, abi_long value)
{
/*
* Write PR_MTE_TCF to SCTLR_EL1[TCF0].
*
* The kernel has a per-cpu configuration for the sysadmin,
* /sys/devices/system/cpu/cpu<N>/mte_tcf_preferred,
* which qemu does not implement.
*
* Because there is no performance difference between the modes, and
* because SYNC is most useful for debugging MTE errors, choose SYNC
* as the preferred mode. With this preference, and the way the API
* uses only two bits, there is no way for the program to select
* ASYMM mode.
*/
unsigned tcf = 0;
if (value & PR_MTE_TCF_SYNC) {
tcf = 1;
} else if (value & PR_MTE_TCF_ASYNC) {
tcf = 2;
}
env->cp15.sctlr_el[1] = deposit64(env->cp15.sctlr_el[1], 38, 2, tcf);
}

32
linux-user/aarch64/mte_user_helper.h Normal file
View File

@ -0,0 +1,32 @@
/*
* ARM MemTag convenience functions.
*
* This code is licensed under the GNU GPL v2 or later.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
#ifndef AARCH64_MTE_USER_HELPER_H
#define AARCH64_MTE USER_HELPER_H
#ifndef PR_MTE_TCF_SHIFT
# define PR_MTE_TCF_SHIFT 1
# define PR_MTE_TCF_NONE (0UL << PR_MTE_TCF_SHIFT)
# define PR_MTE_TCF_SYNC (1UL << PR_MTE_TCF_SHIFT)
# define PR_MTE_TCF_ASYNC (2UL << PR_MTE_TCF_SHIFT)
# define PR_MTE_TCF_MASK (3UL << PR_MTE_TCF_SHIFT)
# define PR_MTE_TAG_SHIFT 3
# define PR_MTE_TAG_MASK (0xffffUL << PR_MTE_TAG_SHIFT)
#endif
/**
* arm_set_mte_tcf0 - Set TCF0 field in SCTLR_EL1 register
* @env: The CPU environment
* @value: The value to be set for the Tag Check Fault in EL0 field.
*
* Only SYNC and ASYNC modes can be selected. If ASYMM mode is given, the SYNC
* mode is selected instead. So, there is no way to set the ASYMM mode.
*/
void arm_set_mte_tcf0(CPUArchState *env, abi_long value);
#endif /* AARCH64_MTE_USER_HELPER_H */

22
linux-user/aarch64/target_prctl.h
View File

@ -7,6 +7,7 @@
#define AARCH64_TARGET_PRCTL_H
#include "target/arm/cpu-features.h"
#include "mte_user_helper.h"
static abi_long do_prctl_sve_get_vl(CPUArchState *env)
{
@ -173,26 +174,7 @@ static abi_long do_prctl_set_tagged_addr_ctrl(CPUArchState *env, abi_long arg2)
env->tagged_addr_enable = arg2 & PR_TAGGED_ADDR_ENABLE;
if (cpu_isar_feature(aa64_mte, cpu)) {
/*
* Write PR_MTE_TCF to SCTLR_EL1[TCF0].
*
* The kernel has a per-cpu configuration for the sysadmin,
* /sys/devices/system/cpu/cpu<N>/mte_tcf_preferred,
* which qemu does not implement.
*
* Because there is no performance difference between the modes, and
* because SYNC is most useful for debugging MTE errors, choose SYNC
* as the preferred mode. With this preference, and the way the API
* uses only two bits, there is no way for the program to select
* ASYMM mode.
*/
unsigned tcf = 0;
if (arg2 & PR_MTE_TCF_SYNC) {
tcf = 1;
} else if (arg2 & PR_MTE_TCF_ASYNC) {
tcf = 2;
}
env->cp15.sctlr_el[1] = deposit64(env->cp15.sctlr_el[1], 38, 2, tcf);
arm_set_mte_tcf0(env, arg2);
/*
* Write PR_MTE_TAG to GCR_EL1[Exclude].

1
linux-user/main.c
View File

@ -843,6 +843,7 @@ int main(int argc, char **argv, char **envp)
*/
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits"
#pragma GCC diagnostic ignored "-Wtautological-compare"
/*
* Select an initial value for task_unmapped_base that is in range.

9
linux-user/syscall.c
View File

@ -6281,15 +6281,6 @@ abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr)
# define PR_GET_TAGGED_ADDR_CTRL 56
# define PR_TAGGED_ADDR_ENABLE (1UL << 0)
#endif
#ifndef PR_MTE_TCF_SHIFT
# define PR_MTE_TCF_SHIFT 1
# define PR_MTE_TCF_NONE (0UL << PR_MTE_TCF_SHIFT)
# define PR_MTE_TCF_SYNC (1UL << PR_MTE_TCF_SHIFT)
# define PR_MTE_TCF_ASYNC (2UL << PR_MTE_TCF_SHIFT)
# define PR_MTE_TCF_MASK (3UL << PR_MTE_TCF_SHIFT)
# define PR_MTE_TAG_SHIFT 3
# define PR_MTE_TAG_MASK (0xffffUL << PR_MTE_TAG_SHIFT)
#endif
#ifndef PR_SET_IO_FLUSHER
# define PR_SET_IO_FLUSHER 57
# define PR_GET_IO_FLUSHER 58

10
plugins/core.c
View File

@ -241,10 +241,11 @@ static void plugin_grow_scoreboards__locked(CPUState *cpu)
end_exclusive();
}
void qemu_plugin_vcpu_init_hook(CPUState *cpu)
static void qemu_plugin_vcpu_init__async(CPUState *cpu, run_on_cpu_data unused)
{
bool success;
assert(cpu->cpu_index != UNASSIGNED_CPU_INDEX);
qemu_rec_mutex_lock(&plugin.lock);
plugin.num_vcpus = MAX(plugin.num_vcpus, cpu->cpu_index + 1);
plugin_cpu_update__locked(&cpu->cpu_index, NULL, NULL);
@ -257,12 +258,19 @@ void qemu_plugin_vcpu_init_hook(CPUState *cpu)
plugin_vcpu_cb__simple(cpu, QEMU_PLUGIN_EV_VCPU_INIT);
}
void qemu_plugin_vcpu_init_hook(CPUState *cpu)
{
/* Plugin initialization must wait until the cpu start executing code */
async_run_on_cpu(cpu, qemu_plugin_vcpu_init__async, RUN_ON_CPU_NULL);
}
void qemu_plugin_vcpu_exit_hook(CPUState *cpu)
{
bool success;
plugin_vcpu_cb__simple(cpu, QEMU_PLUGIN_EV_VCPU_EXIT);
assert(cpu->cpu_index != UNASSIGNED_CPU_INDEX);
qemu_rec_mutex_lock(&plugin.lock);
success = g_hash_table_remove(plugin.cpu_ht, &cpu->cpu_index);
g_assert(success);

4
system/physmem.c
View File

@ -53,7 +53,7 @@
#include "sysemu/hostmem.h"
#include "sysemu/hw_accel.h"
#include "sysemu/xen-mapcache.h"
#include "trace/trace-root.h"
#include "trace.h"
#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
#include <linux/falloc.h>
@ -3193,6 +3193,8 @@ void *address_space_map(AddressSpace *as,
MemoryRegion *mr;
FlatView *fv;
trace_address_space_map(as, addr, len, is_write, *(uint32_t *) &attrs);
if (len == 0) {
return NULL;
}

6
system/trace-events
View File

@ -21,6 +21,12 @@ flatview_destroy(void *view, void *root) "%p (root %p)"
flatview_destroy_rcu(void *view, void *root) "%p (root %p)"
global_dirty_changed(unsigned int bitmask) "bitmask 0x%"PRIx32
# physmem.c
address_space_map(void *as, uint64_t addr, uint64_t len, bool is_write, uint32_t attrs) "as:%p addr 0x%"PRIx64":%"PRIx64" write:%d attrs:0x%x"
find_ram_offset(uint64_t size, uint64_t offset) "size: 0x%" PRIx64 " @ 0x%" PRIx64
find_ram_offset_loop(uint64_t size, uint64_t candidate, uint64_t offset, uint64_t next, uint64_t mingap) "trying size: 0x%" PRIx64 " @ 0x%" PRIx64 ", offset: 0x%" PRIx64" next: 0x%" PRIx64 " mingap: 0x%" PRIx64
ram_block_discard_range(const char *rbname, void *hva, size_t length, bool need_madvise, bool need_fallocate, int ret) "%s@%p + 0x%zx: madvise: %d fallocate: %d ret: %d"
# cpus.c
vm_stop_flush_all(int ret) "ret %d"

1
target/arm/cpu.c
View File

@ -2518,6 +2518,7 @@ static void arm_cpu_realizefn(DeviceState *dev, Error **errp)
register_cp_regs_for_features(cpu);
arm_cpu_register_gdb_regs_for_features(cpu);
arm_cpu_register_gdb_commands(cpu);
init_cpreg_list(cpu);

46
target/arm/gdbstub.c
View File

@ -21,6 +21,7 @@
#include "cpu.h"
#include "exec/gdbstub.h"
#include "gdbstub/helpers.h"
#include "gdbstub/commands.h"
#include "sysemu/tcg.h"
#include "internals.h"
#include "cpu-features.h"
@ -474,6 +475,41 @@ static GDBFeature *arm_gen_dynamic_m_secextreg_feature(CPUState *cs,
#endif
#endif /* CONFIG_TCG */
void arm_cpu_register_gdb_commands(ARMCPU *cpu)
{
GArray *query_table =
g_array_new(FALSE, FALSE, sizeof(GdbCmdParseEntry));
GArray *set_table =
g_array_new(FALSE, FALSE, sizeof(GdbCmdParseEntry));
GString *qsupported_features = g_string_new(NULL);
if (arm_feature(&cpu->env, ARM_FEATURE_AARCH64)) {
#ifdef TARGET_AARCH64
aarch64_cpu_register_gdb_commands(cpu, qsupported_features, query_table,
set_table);
#endif
}
/* Set arch-specific handlers for 'q' commands. */
if (query_table->len) {
gdb_extend_query_table(&g_array_index(query_table,
GdbCmdParseEntry, 0),
query_table->len);
}
/* Set arch-specific handlers for 'Q' commands. */
if (set_table->len) {
gdb_extend_set_table(&g_array_index(set_table,
GdbCmdParseEntry, 0),
set_table->len);
}
/* Set arch-specific qSupported feature. */
if (qsupported_features->len) {
gdb_extend_qsupported_features(qsupported_features->str);
}
}
void arm_cpu_register_gdb_regs_for_features(ARMCPU *cpu)
{
CPUState *cs = CPU(cpu);
@ -507,6 +543,16 @@ void arm_cpu_register_gdb_regs_for_features(ARMCPU *cpu)
gdb_find_static_feature("aarch64-pauth.xml"),
0);
}
#ifdef CONFIG_USER_ONLY
/* Memory Tagging Extension (MTE) 'tag_ctl' pseudo-register. */
if (cpu_isar_feature(aa64_mte, cpu)) {
gdb_register_coprocessor(cs, aarch64_gdb_get_tag_ctl_reg,
aarch64_gdb_set_tag_ctl_reg,
gdb_find_static_feature("aarch64-mte.xml"),
0);
}
#endif
#endif
} else {
if (arm_feature(env, ARM_FEATURE_NEON)) {

223
target/arm/gdbstub64.c
View File

@ -21,6 +21,12 @@
#include "cpu.h"
#include "internals.h"
#include "gdbstub/helpers.h"
#include "gdbstub/commands.h"
#include "tcg/mte_helper.h"
#if defined(CONFIG_USER_ONLY) && defined(CONFIG_LINUX)
#include <sys/prctl.h>
#include "mte_user_helper.h"
#endif
int aarch64_cpu_gdb_read_register(CPUState *cs, GByteArray *mem_buf, int n)
{
@ -381,3 +387,220 @@ GDBFeature *arm_gen_dynamic_svereg_feature(CPUState *cs, int base_reg)
return &cpu->dyn_svereg_feature.desc;
}
#ifdef CONFIG_USER_ONLY
int aarch64_gdb_get_tag_ctl_reg(CPUState *cs, GByteArray *buf, int reg)
{
ARMCPU *cpu = ARM_CPU(cs);
CPUARMState *env = &cpu->env;
uint64_t tcf0;
assert(reg == 0);
tcf0 = extract64(env->cp15.sctlr_el[1], 38, 2);
return gdb_get_reg64(buf, tcf0);
}
int aarch64_gdb_set_tag_ctl_reg(CPUState *cs, uint8_t *buf, int reg)
{
ARMCPU *cpu = ARM_CPU(cs);
CPUARMState *env = &cpu->env;
uint8_t tcf;
assert(reg == 0);
tcf = *buf << PR_MTE_TCF_SHIFT;
if (!tcf) {
return 0;
}
/*
* 'tag_ctl' register is actually a "pseudo-register" provided by GDB to
* expose options regarding the type of MTE fault that can be controlled at
* runtime.
*/
arm_set_mte_tcf0(env, tcf);
return 1;
}
static void handle_q_memtag(GArray *params, void *user_ctx)
{
ARMCPU *cpu = ARM_CPU(user_ctx);
CPUARMState *env = &cpu->env;
uint64_t addr = gdb_get_cmd_param(params, 0)->val_ull;
uint64_t len = gdb_get_cmd_param(params, 1)->val_ul;
int type = gdb_get_cmd_param(params, 2)->val_ul;
uint8_t *tags;
uint8_t addr_tag;
g_autoptr(GString) str_buf = g_string_new(NULL);
/*
* GDB does not query multiple tags for a memory range on remote targets, so
* that's not supported either by gdbstub.
*/
if (len != 1) {
gdb_put_packet("E02");
}
/* GDB never queries a tag different from an allocation tag (type 1). */
if (type != 1) {
gdb_put_packet("E03");
}
/* Note that tags are packed here (2 tags packed in one byte). */
tags = allocation_tag_mem_probe(env, 0, addr, MMU_DATA_LOAD, 8 /* 64-bit */,
MMU_DATA_LOAD, true, 0);
if (!tags) {
/* Address is not in a tagged region. */
gdb_put_packet("E04");
return;
}
/* Unpack tag from byte. */
addr_tag = load_tag1(addr, tags);
g_string_printf(str_buf, "m%.2x", addr_tag);
gdb_put_packet(str_buf->str);
}
static void handle_q_isaddresstagged(GArray *params, void *user_ctx)
{
ARMCPU *cpu = ARM_CPU(user_ctx);
CPUARMState *env = &cpu->env;
uint64_t addr = gdb_get_cmd_param(params, 0)->val_ull;
uint8_t *tags;
const char *reply;
tags = allocation_tag_mem_probe(env, 0, addr, MMU_DATA_LOAD, 8 /* 64-bit */,
MMU_DATA_LOAD, true, 0);
reply = tags ? "01" : "00";
gdb_put_packet(reply);
}
static void handle_Q_memtag(GArray *params, void *user_ctx)
{
ARMCPU *cpu = ARM_CPU(user_ctx);
CPUARMState *env = &cpu->env;
uint64_t start_addr = gdb_get_cmd_param(params, 0)->val_ull;
uint64_t len = gdb_get_cmd_param(params, 1)->val_ul;
int type = gdb_get_cmd_param(params, 2)->val_ul;
char const *new_tags_str = gdb_get_cmd_param(params, 3)->data;
uint64_t end_addr;
int num_new_tags;
uint8_t *tags;
g_autoptr(GByteArray) new_tags = g_byte_array_new();
/*
* Only the allocation tag (i.e. type 1) can be set at the stub side.
*/
if (type != 1) {
gdb_put_packet("E02");
return;
}
end_addr = start_addr + (len - 1); /* 'len' is always >= 1 */
/* Check if request's memory range does not cross page boundaries. */
if ((start_addr ^ end_addr) & TARGET_PAGE_MASK) {
gdb_put_packet("E03");
return;
}
/*
* Get all tags in the page starting from the tag of the start address.
* Note that there are two tags packed into a single byte here.
*/
tags = allocation_tag_mem_probe(env, 0, start_addr, MMU_DATA_STORE,
8 /* 64-bit */, MMU_DATA_STORE, true, 0);
if (!tags) {
/* Address is not in a tagged region. */
gdb_put_packet("E04");
return;
}
/* Convert tags provided by GDB, 2 hex digits per tag. */
num_new_tags = strlen(new_tags_str) / 2;
gdb_hextomem(new_tags, new_tags_str, num_new_tags);
uint64_t address = start_addr;
int new_tag_index = 0;
while (address <= end_addr) {
uint8_t new_tag;
int packed_index;
/*
* Find packed tag index from unpacked tag index. There are two tags
* in one packed index (one tag per nibble).
*/
packed_index = new_tag_index / 2;
new_tag = new_tags->data[new_tag_index % num_new_tags];
store_tag1(address, tags + packed_index, new_tag);
address += TAG_GRANULE;
new_tag_index++;
}
gdb_put_packet("OK");
}
enum Command {
qMemTags,
qIsAddressTagged,
QMemTags,
NUM_CMDS
};
static GdbCmdParseEntry cmd_handler_table[NUM_CMDS] = {
[qMemTags] = {
.handler = handle_q_memtag,
.cmd_startswith = true,
.cmd = "MemTags:",
.schema = "L,l:l0",
.need_cpu_context = true
},
[qIsAddressTagged] = {
.handler = handle_q_isaddresstagged,
.cmd_startswith = true,
.cmd = "IsAddressTagged:",
.schema = "L0",
.need_cpu_context = true
},
[QMemTags] = {
.handler = handle_Q_memtag,
.cmd_startswith = true,
.cmd = "MemTags:",
.schema = "L,l:l:s0",
.need_cpu_context = true
},
};
#endif /* CONFIG_USER_ONLY */
void aarch64_cpu_register_gdb_commands(ARMCPU *cpu, GString *qsupported,
GArray *qtable, GArray *stable)
{
#ifdef CONFIG_USER_ONLY
/* MTE */
if (cpu_isar_feature(aa64_mte, cpu)) {
g_string_append(qsupported, ";memory-tagging+");
g_array_append_val(qtable, cmd_handler_table[qMemTags]);
g_array_append_val(qtable, cmd_handler_table[qIsAddressTagged]);
g_array_append_val(stable, cmd_handler_table[QMemTags]);
}
#endif
}

6
target/arm/internals.h
View File

@ -358,6 +358,10 @@ void init_cpreg_list(ARMCPU *cpu);
void arm_cpu_register_gdb_regs_for_features(ARMCPU *cpu);
void arm_translate_init(void);
void arm_cpu_register_gdb_commands(ARMCPU *cpu);
void aarch64_cpu_register_gdb_commands(ARMCPU *cpu, GString *, GArray *,
GArray *);
void arm_restore_state_to_opc(CPUState *cs,
const TranslationBlock *tb,
const uint64_t *data);
@ -1640,6 +1644,8 @@ int aarch64_gdb_get_fpu_reg(CPUState *cs, GByteArray *buf, int reg);
int aarch64_gdb_set_fpu_reg(CPUState *cs, uint8_t *buf, int reg);
int aarch64_gdb_get_pauth_reg(CPUState *cs, GByteArray *buf, int reg);
int aarch64_gdb_set_pauth_reg(CPUState *cs, uint8_t *buf, int reg);
int aarch64_gdb_get_tag_ctl_reg(CPUState *cs, GByteArray *buf, int reg);
int aarch64_gdb_set_tag_ctl_reg(CPUState *cs, uint8_t *buf, int reg);
void arm_cpu_sve_finalize(ARMCPU *cpu, Error **errp);
void arm_cpu_sme_finalize(ARMCPU *cpu, Error **errp);
void arm_cpu_pauth_finalize(ARMCPU *cpu, Error **errp);

48
target/arm/tcg/mte_helper.c
View File

@ -29,6 +29,7 @@
#include "hw/core/tcg-cpu-ops.h"
#include "qapi/error.h"
#include "qemu/guest-random.h"
#include "mte_helper.h"
static int choose_nonexcluded_tag(int tag, int offset, uint16_t exclude)
@ -50,42 +51,10 @@ static int choose_nonexcluded_tag(int tag, int offset, uint16_t exclude)
return tag;
}
/**
* allocation_tag_mem_probe:
* @env: the cpu environment
* @ptr_mmu_idx: the addressing regime to use for the virtual address
* @ptr: the virtual address for which to look up tag memory
* @ptr_access: the access to use for the virtual address
* @ptr_size: the number of bytes in the normal memory access
* @tag_access: the access to use for the tag memory
* @probe: true to merely probe, never taking an exception
* @ra: the return address for exception handling
*
* Our tag memory is formatted as a sequence of little-endian nibbles.
* That is, the byte at (addr >> (LOG2_TAG_GRANULE + 1)) contains two
* tags, with the tag at [3:0] for the lower addr and the tag at [7:4]
* for the higher addr.
*
* Here, resolve the physical address from the virtual address, and return
* a pointer to the corresponding tag byte.
*
* If there is no tag storage corresponding to @ptr, return NULL.
*
* If the page is inaccessible for @ptr_access, or has a watchpoint, there are
* three options:
* (1) probe = true, ra = 0 : pure probe -- we return NULL if the page is not
* accessible, and do not take watchpoint traps. The calling code must
* handle those cases in the right priority compared to MTE traps.
* (2) probe = false, ra = 0 : probe, no fault expected -- the caller guarantees
* that the page is going to be accessible. We will take watchpoint traps.
* (3) probe = false, ra != 0 : non-probe -- we will take both memory access
* traps and watchpoint traps.
* (probe = true, ra != 0 is invalid and will assert.)
*/
static uint8_t *allocation_tag_mem_probe(CPUARMState *env, int ptr_mmu_idx,
uint64_t ptr, MMUAccessType ptr_access,
int ptr_size, MMUAccessType tag_access,
bool probe, uintptr_t ra)
uint8_t *allocation_tag_mem_probe(CPUARMState *env, int ptr_mmu_idx,
uint64_t ptr, MMUAccessType ptr_access,
int ptr_size, MMUAccessType tag_access,
bool probe, uintptr_t ra)
{
#ifdef CONFIG_USER_ONLY
uint64_t clean_ptr = useronly_clean_ptr(ptr);
@ -96,6 +65,9 @@ static uint8_t *allocation_tag_mem_probe(CPUARMState *env, int ptr_mmu_idx,
assert(!(probe && ra));
if (!(flags & (ptr_access == MMU_DATA_STORE ? PAGE_WRITE_ORG : PAGE_READ))) {
if (probe) {
return NULL;
}
cpu_loop_exit_sigsegv(env_cpu(env), ptr, ptr_access,
!(flags & PAGE_VALID), ra);
}
@ -284,7 +256,7 @@ uint64_t HELPER(addsubg)(CPUARMState *env, uint64_t ptr,
return address_with_allocation_tag(ptr + offset, rtag);
}
static int load_tag1(uint64_t ptr, uint8_t *mem)
int load_tag1(uint64_t ptr, uint8_t *mem)
{
int ofs = extract32(ptr, LOG2_TAG_GRANULE, 1) * 4;
return extract32(*mem, ofs, 4);
@ -318,7 +290,7 @@ static void check_tag_aligned(CPUARMState *env, uint64_t ptr, uintptr_t ra)
}
/* For use in a non-parallel context, store to the given nibble. */
static void store_tag1(uint64_t ptr, uint8_t *mem, int tag)
void store_tag1(uint64_t ptr, uint8_t *mem, int tag)
{
int ofs = extract32(ptr, LOG2_TAG_GRANULE, 1) * 4;
*mem = deposit32(*mem, ofs, 4, tag);

66
target/arm/tcg/mte_helper.h Normal file
View File

@ -0,0 +1,66 @@
/*
* ARM MemTag operation helpers.
*
* This code is licensed under the GNU GPL v2 or later.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
#ifndef TARGET_ARM_MTE_H
#define TARGET_ARM_MTE_H
#include "exec/mmu-access-type.h"
/**
* allocation_tag_mem_probe:
* @env: the cpu environment
* @ptr_mmu_idx: the addressing regime to use for the virtual address
* @ptr: the virtual address for which to look up tag memory
* @ptr_access: the access to use for the virtual address
* @ptr_size: the number of bytes in the normal memory access
* @tag_access: the access to use for the tag memory
* @probe: true to merely probe, never taking an exception
* @ra: the return address for exception handling
*
* Our tag memory is formatted as a sequence of little-endian nibbles.
* That is, the byte at (addr >> (LOG2_TAG_GRANULE + 1)) contains two
* tags, with the tag at [3:0] for the lower addr and the tag at [7:4]
* for the higher addr.
*
* Here, resolve the physical address from the virtual address, and return
* a pointer to the corresponding tag byte.
*
* If there is no tag storage corresponding to @ptr, return NULL.
*
* If the page is inaccessible for @ptr_access, or has a watchpoint, there are
* three options:
* (1) probe = true, ra = 0 : pure probe -- we return NULL if the page is not
* accessible, and do not take watchpoint traps. The calling code must
* handle those cases in the right priority compared to MTE traps.
* (2) probe = false, ra = 0 : probe, no fault expected -- the caller guarantees
* that the page is going to be accessible. We will take watchpoint traps.
* (3) probe = false, ra != 0 : non-probe -- we will take both memory access
* traps and watchpoint traps.
* (probe = true, ra != 0 is invalid and will assert.)
*/
uint8_t *allocation_tag_mem_probe(CPUARMState *env, int ptr_mmu_idx,
uint64_t ptr, MMUAccessType ptr_access,
int ptr_size, MMUAccessType tag_access,
bool probe, uintptr_t ra);
/**
* load_tag1 - Load 1 tag (nibble) from byte
* @ptr: The tagged address
* @mem: The tag address (packed, 2 tags in byte)
*/
int load_tag1(uint64_t ptr, uint8_t *mem);
/**
* store_tag1 - Store 1 tag (nibble) into byte
* @ptr: The tagged address
* @mem: The tag address (packed, 2 tags in byte)
* @tag: The tag to be stored in the nibble
*/
void store_tag1(uint64_t ptr, uint8_t *mem, int tag);
#endif /* TARGET_ARM_MTE_H */

7
tests/docker/Makefile.include
View File

@ -207,7 +207,12 @@ docker-run: docker-qemu-src
$(call quiet-command, \
$(RUNC) run \
--rm \
$(if $(NOUSER),,-u $(UID)) \
$(if $(NOUSER),, \
$(if $(filter docker,$(RUNC)), \
-u $(UID), \
--userns keep-id \
) \
) \
--security-opt seccomp=unconfined \
$(if $(DEBUG),-ti,) \
$(if $(NETWORK),$(if $(subst $(NETWORK),,1),--net=$(NETWORK)),--net=none) \

2
tests/docker/dockerfiles/debian-i686-cross.docker
View File

@ -169,7 +169,7 @@ endian = 'little'\n" > /usr/local/share/meson/cross/i686-linux-gnu && \
ENV ABI "i686-linux-gnu"
ENV MESON_OPTS "--cross-file=i686-linux-gnu"
ENV QEMU_CONFIGURE_OPTS --cross-prefix=x86_64-linux-gnu-
ENV QEMU_CONFIGURE_OPTS --cross-prefix=i686-linux-gnu-
ENV DEF_TARGET_LIST x86_64-softmmu,x86_64-linux-user,i386-softmmu,i386-linux-user
# As a final step configure the user (if env is defined)
ARG USER

2
tests/lcitool/refresh
View File

@ -167,7 +167,7 @@ try:
generate_dockerfile("debian-i686-cross", "debian-11",
cross="i686",
trailer=cross_build("x86_64-linux-gnu-",
trailer=cross_build("i686-linux-gnu-",
"x86_64-softmmu,"
"x86_64-linux-user,"
"i386-softmmu,i386-linux-user"))

112
tests/plugin/insn.c
View File

@ -20,6 +20,7 @@ static qemu_plugin_u64 insn_count;
static bool do_inline;
static bool do_size;
static bool do_trace;
static GArray *sizes;
typedef struct {
@ -42,6 +43,44 @@ typedef struct {
char *disas;
} Instruction;
/* A hash table to hold matched instructions */
static GHashTable *match_insn_records;
static GMutex match_hash_lock;
static Instruction * get_insn_record(const char *disas, uint64_t vaddr, Match *m)
{
g_autofree char *str_hash = g_strdup_printf("%"PRIx64" %s", vaddr, disas);
Instruction *record;
g_mutex_lock(&match_hash_lock);
if (!match_insn_records) {
match_insn_records = g_hash_table_new(g_str_hash, g_str_equal);
}
record = g_hash_table_lookup(match_insn_records, str_hash);
if (!record) {
g_autoptr(GString) ts = g_string_new(str_hash);
record = g_new0(Instruction, 1);
record->disas = g_strdup(disas);
record->vaddr = vaddr;
record->match = m;
g_hash_table_insert(match_insn_records, str_hash, record);
g_string_prepend(ts, "Created record for: ");
g_string_append(ts, "\n");
qemu_plugin_outs(ts->str);
}
g_mutex_unlock(&match_hash_lock);
return record;
}
/*
* Initialise a new vcpu with reading the register list
*/
@ -73,30 +112,30 @@ static void vcpu_insn_matched_exec_before(unsigned int cpu_index, void *udata)
MatchCount *match = qemu_plugin_scoreboard_find(insn_match->counts,
cpu_index);
g_autoptr(GString) ts = g_string_new("");
insn->hits++;
g_string_append_printf(ts, "0x%" PRIx64 ", '%s', %"PRId64 " hits",
insn->vaddr, insn->disas, insn->hits);
uint64_t icount = qemu_plugin_u64_get(insn_count, cpu_index);
uint64_t delta = icount - match->last_hit;
match->hits++;
match->total_delta += delta;
g_string_append_printf(ts,
" , cpu %u,"
" %"PRId64" match hits,"
" Δ+%"PRId64 " since last match,"
" %"PRId64 " avg insns/match\n",
cpu_index,
match->hits, delta,
match->total_delta / match->hits);
match->last_hit = icount;
qemu_plugin_outs(ts->str);
if (do_trace) {
g_autoptr(GString) ts = g_string_new("");
g_string_append_printf(ts, "0x%" PRIx64 ", '%s', %"PRId64 " hits",
insn->vaddr, insn->disas, insn->hits);
g_string_append_printf(ts,
" , cpu %u,"
" %"PRId64" match hits,"
" Δ+%"PRId64 " since last match,"
" %"PRId64 " avg insns/match\n",
cpu_index,
match->hits, delta,
match->total_delta / match->hits);
qemu_plugin_outs(ts->str);
}
}
static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
@ -130,16 +169,19 @@ static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
* If we are tracking certain instructions we will need more
* information about the instruction which we also need to
* save if there is a hit.
*
* We only want one record for each occurrence of the matched
* instruction.
*/
if (matches->len) {
char *insn_disas = qemu_plugin_insn_disas(insn);
for (int j = 0; j < matches->len; j++) {
Match *m = &g_array_index(matches, Match, j);
if (g_str_has_prefix(insn_disas, m->match_string)) {
Instruction *rec = g_new0(Instruction, 1);
rec->disas = g_strdup(insn_disas);
rec->vaddr = qemu_plugin_insn_vaddr(insn);
rec->match = m;
Instruction *rec = get_insn_record(insn_disas,
qemu_plugin_insn_vaddr(insn),
m);
qemu_plugin_register_vcpu_insn_exec_cb(
insn, vcpu_insn_matched_exec_before,
QEMU_PLUGIN_CB_NO_REGS, rec);
@ -172,13 +214,38 @@ static void plugin_exit(qemu_plugin_id_t id, void *p)
qemu_plugin_u64_sum(insn_count));
}
qemu_plugin_outs(out->str);
qemu_plugin_scoreboard_free(insn_count.score);
g_mutex_lock(&match_hash_lock);
for (i = 0; i < matches->len; ++i) {
Match *m = &g_array_index(matches, Match, i);
GHashTableIter iter;
Instruction *record;
qemu_plugin_u64 hit_e = qemu_plugin_scoreboard_u64_in_struct(m->counts, MatchCount, hits);
uint64_t hits = qemu_plugin_u64_sum(hit_e);
g_string_printf(out, "Match: %s, hits %"PRId64"\n", m->match_string, hits);
qemu_plugin_outs(out->str);
g_hash_table_iter_init(&iter, match_insn_records);
while (g_hash_table_iter_next(&iter, NULL, (void **)&record)) {
if (record->match == m) {
g_string_printf(out,
" %"PRIx64": %s (hits %"PRId64")\n",
record->vaddr,
record->disas,
record->hits);
qemu_plugin_outs(out->str);
}
}
g_free(m->match_string);
qemu_plugin_scoreboard_free(m->counts);
}
g_mutex_unlock(&match_hash_lock);
g_array_free(matches, TRUE);
g_array_free(sizes, TRUE);
}
@ -216,6 +283,11 @@ QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id,
}
} else if (g_strcmp0(tokens[0], "match") == 0) {
parse_match(tokens[1]);
} else if (g_strcmp0(tokens[0], "trace") == 0) {
if (!qemu_plugin_bool_parse(tokens[0], tokens[1], &do_trace)) {
fprintf(stderr, "boolean argument parsing failed: %s\n", opt);
return -1;
}
} else {
fprintf(stderr, "option parsing failed: %s\n", opt);
return -1;

2
tests/tcg/Makefile.target
View File

@ -49,7 +49,7 @@ quiet-command = $(call quiet-@,$2,$3)$1
cc-test = $(CC) -Werror $1 -c -o /dev/null -xc /dev/null >/dev/null 2>&1
cc-option = if $(call cc-test, $1); then \
echo "$(TARGET_PREFIX)$1 detected" && echo "$(strip $2)=y" >&3; else \
echo "$(TARGET_PREFIX)$1 detected" && echo "$(strip $2)=$(strip $1)" >&3; else \
echo "$(TARGET_PREFIX)$1 not detected"; fi
# $1 = test name, $2 = cmd, $3 = desc

4
tests/tcg/aarch64/Makefile.softmmu-target
View File

@ -39,7 +39,7 @@ memory: CFLAGS+=-DCHECK_UNALIGNED=1
memory-sve: memory.c $(LINK_SCRIPT) $(CRT_OBJS) $(MINILIB_OBJS)
$(CC) $(CFLAGS) $(EXTRA_CFLAGS) $< -o $@ $(LDFLAGS)
memory-sve: CFLAGS+=-DCHECK_UNALIGNED=1 -march=armv8.1-a+sve -O3 -fno-tree-loop-distribute-patterns
memory-sve: CFLAGS+=-DCHECK_UNALIGNED=1 -march=armv8.1-a+sve -O3
TESTS+=memory-sve
@ -81,7 +81,7 @@ run-memory-replay: memory-replay run-memory-record
EXTRA_RUNS+=run-memory-replay
ifneq ($(CROSS_CC_HAS_ARMV8_3),)
pauth-3: CFLAGS += -march=armv8.3-a
pauth-3: CFLAGS += $(CROSS_CC_HAS_ARMV8_3)
else
pauth-3:
$(call skip-test, "BUILD of $@", "missing compiler support")

32
tests/tcg/aarch64/Makefile.target
View File

@ -20,6 +20,7 @@ run-fcvt: fcvt
config-cc.mak: Makefile
$(quiet-@)( \
fnia=`$(call cc-test,-fno-integrated-as) && echo -fno-integrated-as`; \
$(call cc-option,-march=armv8.1-a+sve, CROSS_CC_HAS_SVE); \
$(call cc-option,-march=armv8.1-a+sve2, CROSS_CC_HAS_SVE2); \
$(call cc-option,-march=armv8.2-a, CROSS_CC_HAS_ARMV8_2); \
@ -27,22 +28,22 @@ config-cc.mak: Makefile
$(call cc-option,-march=armv8.5-a, CROSS_CC_HAS_ARMV8_5); \
$(call cc-option,-mbranch-protection=standard, CROSS_CC_HAS_ARMV8_BTI); \
$(call cc-option,-march=armv8.5-a+memtag, CROSS_CC_HAS_ARMV8_MTE); \
$(call cc-option,-Wa$(COMMA)-march=armv9-a+sme, CROSS_AS_HAS_ARMV9_SME)) 3> config-cc.mak
$(call cc-option,-Wa$(COMMA)-march=armv9-a+sme $$fnia, CROSS_AS_HAS_ARMV9_SME)) 3> config-cc.mak
-include config-cc.mak
ifneq ($(CROSS_CC_HAS_ARMV8_2),)
AARCH64_TESTS += dcpop
dcpop: CFLAGS += -march=armv8.2-a
dcpop: CFLAGS += $(CROSS_CC_HAS_ARMV8_2)
endif
ifneq ($(CROSS_CC_HAS_ARMV8_5),)
AARCH64_TESTS += dcpodp
dcpodp: CFLAGS += -march=armv8.5-a
dcpodp: CFLAGS += $(CROSS_CC_HAS_ARMV8_5)
endif
# Pauth Tests
ifneq ($(CROSS_CC_HAS_ARMV8_3),)
AARCH64_TESTS += pauth-1 pauth-2 pauth-4 pauth-5 test-2375
pauth-%: CFLAGS += -march=armv8.3-a
pauth-%: CFLAGS += $(CROSS_CC_HAS_ARMV8_3)
test-2375: CFLAGS += -march=armv8.3-a
run-pauth-1: QEMU_OPTS += -cpu max
run-pauth-2: QEMU_OPTS += -cpu max
@ -55,7 +56,7 @@ endif
# bti-1 tests the elf notes, so we require special compiler support.
ifneq ($(CROSS_CC_HAS_ARMV8_BTI),)
AARCH64_TESTS += bti-1 bti-3
bti-1 bti-3: CFLAGS += -fno-stack-protector -mbranch-protection=standard
bti-1 bti-3: CFLAGS += -fno-stack-protector $(CROSS_CC_HAS_ARMV8_BTI)
bti-1 bti-3: LDFLAGS += -nostdlib
endif
# bti-2 tests PROT_BTI, so no special compiler support required.
@ -63,13 +64,14 @@ AARCH64_TESTS += bti-2
# MTE Tests
ifneq ($(CROSS_CC_HAS_ARMV8_MTE),)
AARCH64_TESTS += mte-1 mte-2 mte-3 mte-4 mte-5 mte-6 mte-7
mte-%: CFLAGS += -march=armv8.5-a+memtag
AARCH64_TESTS += mte-1 mte-2 mte-3 mte-4 mte-5 mte-6 mte-7 mte-8
mte-%: CFLAGS += $(CROSS_CC_HAS_ARMV8_MTE)
endif
# SME Tests
ifneq ($(CROSS_AS_HAS_ARMV9_SME),)
AARCH64_TESTS += sme-outprod1 sme-smopa-1 sme-smopa-2
sme-outprod1 sme-smopa-1 sme-smopa-2: CFLAGS += $(CROSS_AS_HAS_ARMV9_SME)
endif
# System Registers Tests
@ -99,7 +101,7 @@ TESTS += sha512-vector
ifneq ($(CROSS_CC_HAS_SVE),)
# SVE ioctl test
AARCH64_TESTS += sve-ioctls
sve-ioctls: CFLAGS+=-march=armv8.1-a+sve
sve-ioctls: CFLAGS += $(CROSS_CC_HAS_SVE)
sha512-sve: CFLAGS=-O3 -march=armv8.1-a+sve
sha512-sve: sha512.c
@ -129,12 +131,24 @@ run-gdbstub-sve-ioctls: sve-ioctls
basic gdbstub SVE ZLEN support)
EXTRA_RUNS += run-gdbstub-sysregs run-gdbstub-sve-ioctls
ifeq ($(GDB_HAS_MTE),y)
run-gdbstub-mte: mte-8
$(call run-test, $@, $(GDB_SCRIPT) \
--gdb $(GDB) \
--qemu $(QEMU) --qargs "$(QEMU_OPTS)" \
--bin $< --test $(AARCH64_SRC)/gdbstub/test-mte.py, \
gdbstub MTE support)
EXTRA_RUNS += run-gdbstub-mte
endif
endif
endif
ifneq ($(CROSS_CC_HAS_SVE2),)
AARCH64_TESTS += test-826
test-826: CFLAGS+=-march=armv8.1-a+sve2
test-826: CFLAGS += $(CROSS_CC_HAS_SVE2)
endif
TESTS += $(AARCH64_TESTS)

6
tests/tcg/aarch64/bti-1.c
View File

@ -17,15 +17,15 @@ static void skip2_sigill(int sig, siginfo_t *info, ucontext_t *uc)
#define BTI_JC "hint #38"
#define BTYPE_1(DEST) \
asm("mov %0,#1; adr x16, 1f; br x16; 1: " DEST "; mov %0,#0" \
asm("mov %w0,#1; adr x16, 1f; br x16; 1: " DEST "; mov %w0,#0" \
: "=r"(skipped) : : "x16")
#define BTYPE_2(DEST) \
asm("mov %0,#1; adr x16, 1f; blr x16; 1: " DEST "; mov %0,#0" \
asm("mov %w0,#1; adr x16, 1f; blr x16; 1: " DEST "; mov %w0,#0" \
: "=r"(skipped) : : "x16", "x30")
#define BTYPE_3(DEST) \
asm("mov %0,#1; adr x15, 1f; br x15; 1: " DEST "; mov %0,#0" \
asm("mov %w0,#1; adr x15, 1f; br x15; 1: " DEST "; mov %w0,#0" \
: "=r"(skipped) : : "x15")
#define TEST(WHICH, DEST, EXPECT) \

6
tests/tcg/aarch64/bti-3.c
View File

@ -11,15 +11,15 @@ static void skip2_sigill(int sig, siginfo_t *info, ucontext_t *uc)
}
#define BTYPE_1() \
asm("mov %0,#1; adr x16, 1f; br x16; 1: hint #25; mov %0,#0" \
asm("mov %w0,#1; adr x16, 1f; br x16; 1: hint #25; mov %w0,#0" \
: "=r"(skipped) : : "x16", "x30")
#define BTYPE_2() \
asm("mov %0,#1; adr x16, 1f; blr x16; 1: hint #25; mov %0,#0" \
asm("mov %w0,#1; adr x16, 1f; blr x16; 1: hint #25; mov %w0,#0" \
: "=r"(skipped) : : "x16", "x30")
#define BTYPE_3() \
asm("mov %0,#1; adr x15, 1f; br x15; 1: hint #25; mov %0,#0" \
asm("mov %w0,#1; adr x15, 1f; br x15; 1: hint #25; mov %w0,#0" \
: "=r"(skipped) : : "x15", "x30")
#define TEST(WHICH, EXPECT) \

604
tests/tcg/aarch64/fcvt.ref
View File

@ -211,45 +211,45 @@ Converting double-precision to half-precision
40 HALF: 0x7f00 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570815e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x14 => OVERFLOW INEXACT )
03 SINGLE: -inf / 0xff800000 (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007529e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766476800000000000e+09 / 0x4f730c3a (0x10 => INEXACT )
06 SINGLE: -1.11100004769645909791e+31 / 0xf30c3a59 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999085e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962432000000000000e+09 / 0x4f71605d (0x10 => INEXACT )
07 SINGLE: -1.11100003258488635273e+30 / 0xf1605d5b (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138309e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -0.00000000000000000000e+00 / 0x80000000 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750797e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750797e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750797e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750797e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013061e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638016000000000000e+08 / 0x4e4c0000 (0x10 => INEXACT )
14 SINGLE: 2.98023223876953125000e-08 / 0x33000000 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015661e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026624000000000000e+08 / 0x4e4e0000 (0x10 => INEXACT )
15 SINGLE: 5.96045985901128005935e-08 / 0x337ffff3 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994299e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896320000000000000e+08 / 0x4e61ff00 (0x10 => INEXACT )
16 SINGLE: 6.09755988989491015673e-05 / 0x387fc00d (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013665e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912704000000000000e+08 / 0x4e620000 (0x10 => INEXACT )
17 SINGLE: 6.10351999057456851006e-05 / 0x38800006 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138309e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282843e-308 / 0x000009ea82a2287680 (0 => OK)
@ -257,41 +257,41 @@ Converting double-precision to single-precision
22 DOUBLE: 1.49147387366816238763e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509080e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675456000000000000e+09 / 0x4e805bf1 (0x10 => INEXACT )
25 SINGLE: 2.71828174591064453125e+00 / 0x402df854 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311600e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07853004800000000000e+09 / 0x4e809220 (0x10 => INEXACT )
26 SINGLE: 3.14159274101257324219e+00 / 0x40490fdb (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32540006400000000000e+09 / 0x4e9e0000 (0x10 => INEXACT )
33 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570815e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x14 => OVERFLOW INEXACT )
36 SINGLE: inf / 0x7f800000 (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -nan / 0xffffe000 (0 => OK)
@ -574,87 +574,87 @@ Converting double-precision to half-precision
40 HALF: 0x7f00 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570814e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x14 => OVERFLOW INEXACT )
03 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007529e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766502400000000000e+09 / 0x4f730c3b (0x10 => INEXACT )
06 SINGLE: -1.11099992680387713644e+31 / 0xf30c3a58 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999084e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962457600000000000e+09 / 0x4f71605e (0x10 => INEXACT )
07 SINGLE: -1.11099995702702262681e+30 / 0xf1605d5a (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138309e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -0.00000000000000000000e+00 / 0x80000000 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750796e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750796e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750797e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750797e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013061e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638080000000000000e+08 / 0x4e4c0001 (0x10 => INEXACT )
14 SINGLE: 2.98023259404089913006e-08 / 0x33000001 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015662e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026624000000000000e+08 / 0x4e4e0000 (0x10 => INEXACT )
15 SINGLE: 5.96046021428264793940e-08 / 0x337ffff4 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994299e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896384000000000000e+08 / 0x4e61ff01 (0x10 => INEXACT )
16 SINGLE: 6.09756025369279086590e-05 / 0x387fc00e (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013665e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912768000000000000e+08 / 0x4e620001 (0x10 => INEXACT )
17 SINGLE: 6.10352071817032992840e-05 / 0x38800007 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138310e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0x18 => UNDERFLOW INEXACT )
20 SINGLE: 1.40129846432481707093e-45 / 0x00000001 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282844e-308 / 0x000009ea82a2287680 (0 => OK)
21 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0x18 => UNDERFLOW INEXACT )
21 SINGLE: 1.40129846432481707093e-45 / 0x00000001 (0x18 => UNDERFLOW INEXACT )
22 DOUBLE: 1.49147387366816238764e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0x18 => UNDERFLOW INEXACT )
22 SINGLE: 1.40129846432481707093e-45 / 0x00000001 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509080e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675456000000000000e+09 / 0x4e805bf1 (0x10 => INEXACT )
25 SINGLE: 2.71828198432922363282e+00 / 0x402df855 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311600e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07853004800000000000e+09 / 0x4e809220 (0x10 => INEXACT )
26 SINGLE: 3.14159274101257324219e+00 / 0x40490fdb (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32540006400000000000e+09 / 0x4e9e0000 (0x10 => INEXACT )
33 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570815e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x14 => OVERFLOW INEXACT )
36 SINGLE: inf / 0x7f800000 (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -nan / 0xffffe000 (0 => OK)
@ -937,45 +937,45 @@ Converting double-precision to half-precision
40 HALF: 0x7f00 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570815e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x14 => OVERFLOW INEXACT )
03 SINGLE: -inf / 0xff800000 (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007530e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766476800000000000e+09 / 0x4f730c3a (0x10 => INEXACT )
06 SINGLE: -1.11100004769645909791e+31 / 0xf30c3a59 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999085e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962432000000000000e+09 / 0x4f71605d (0x10 => INEXACT )
07 SINGLE: -1.11100003258488635273e+30 / 0xf1605d5b (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138310e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -1.40129846432481707093e-45 / 0x80000001 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750797e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750797e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750796e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750796e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013060e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638016000000000000e+08 / 0x4e4c0000 (0x10 => INEXACT )
14 SINGLE: 2.98023223876953125000e-08 / 0x33000000 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015661e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026560000000000000e+08 / 0x4e4dffff (0x10 => INEXACT )
15 SINGLE: 5.96045985901128005934e-08 / 0x337ffff3 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994298e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896320000000000000e+08 / 0x4e61ff00 (0x10 => INEXACT )
16 SINGLE: 6.09755988989491015672e-05 / 0x387fc00d (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013664e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912704000000000000e+08 / 0x4e620000 (0x10 => INEXACT )
17 SINGLE: 6.10351999057456851005e-05 / 0x38800006 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138309e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282843e-308 / 0x000009ea82a2287680 (0 => OK)
@ -983,41 +983,41 @@ Converting double-precision to single-precision
22 DOUBLE: 1.49147387366816238763e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509079e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675443200000000000e+09 / 0x4e805bf0 (0x10 => INEXACT )
25 SINGLE: 2.71828174591064453125e+00 / 0x402df854 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311599e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07852992000000000000e+09 / 0x4e80921f (0x10 => INEXACT )
26 SINGLE: 3.14159250259399414062e+00 / 0x40490fda (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32539993600000000000e+09 / 0x4e9dffff (0x10 => INEXACT )
33 SINGLE: 2.14748352000000000000e+09 / 0x4effffff (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570814e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x14 => OVERFLOW INEXACT )
36 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -nan / 0xffffe000 (0 => OK)
@ -1300,45 +1300,45 @@ Converting double-precision to half-precision
40 HALF: 0x7f00 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570814e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x14 => OVERFLOW INEXACT )
03 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007529e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766476800000000000e+09 / 0x4f730c3a (0x10 => INEXACT )
06 SINGLE: -1.11099992680387713644e+31 / 0xf30c3a58 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999084e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962432000000000000e+09 / 0x4f71605d (0x10 => INEXACT )
07 SINGLE: -1.11099995702702262681e+30 / 0xf1605d5a (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138309e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -0.00000000000000000000e+00 / 0x80000000 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750796e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750796e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750796e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750796e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013060e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638016000000000000e+08 / 0x4e4c0000 (0x10 => INEXACT )
14 SINGLE: 2.98023223876953125000e-08 / 0x33000000 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015661e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026560000000000000e+08 / 0x4e4dffff (0x10 => INEXACT )
15 SINGLE: 5.96045985901128005934e-08 / 0x337ffff3 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994298e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896320000000000000e+08 / 0x4e61ff00 (0x10 => INEXACT )
16 SINGLE: 6.09755988989491015672e-05 / 0x387fc00d (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013664e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912704000000000000e+08 / 0x4e620000 (0x10 => INEXACT )
17 SINGLE: 6.10351999057456851005e-05 / 0x38800006 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138309e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282843e-308 / 0x000009ea82a2287680 (0 => OK)
@ -1346,41 +1346,41 @@ Converting double-precision to single-precision
22 DOUBLE: 1.49147387366816238763e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509079e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675443200000000000e+09 / 0x4e805bf0 (0x10 => INEXACT )
25 SINGLE: 2.71828174591064453125e+00 / 0x402df854 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311599e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07852992000000000000e+09 / 0x4e80921f (0x10 => INEXACT )
26 SINGLE: 3.14159250259399414062e+00 / 0x40490fda (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32539993600000000000e+09 / 0x4e9dffff (0x10 => INEXACT )
33 SINGLE: 2.14748352000000000000e+09 / 0x4effffff (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570814e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x14 => OVERFLOW INEXACT )
36 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -nan / 0xffffe000 (0 => OK)
@ -1845,45 +1845,45 @@ Converting double-precision to half-precision
40 HALF: 0000 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570815e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x14 => OVERFLOW INEXACT )
03 SINGLE: -inf / 0xff800000 (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007529e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766476800000000000e+09 / 0x4f730c3a (0x10 => INEXACT )
06 SINGLE: -1.11100004769645909791e+31 / 0xf30c3a59 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999085e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962432000000000000e+09 / 0x4f71605d (0x10 => INEXACT )
07 SINGLE: -1.11100003258488635273e+30 / 0xf1605d5b (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138309e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -0.00000000000000000000e+00 / 0x80000000 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750797e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750797e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750797e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750797e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013061e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638016000000000000e+08 / 0x4e4c0000 (0x10 => INEXACT )
14 SINGLE: 2.98023223876953125000e-08 / 0x33000000 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015661e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026624000000000000e+08 / 0x4e4e0000 (0x10 => INEXACT )
15 SINGLE: 5.96045985901128005935e-08 / 0x337ffff3 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994299e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896320000000000000e+08 / 0x4e61ff00 (0x10 => INEXACT )
16 SINGLE: 6.09755988989491015673e-05 / 0x387fc00d (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013665e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912704000000000000e+08 / 0x4e620000 (0x10 => INEXACT )
17 SINGLE: 6.10351999057456851006e-05 / 0x38800006 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138309e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282843e-308 / 0x000009ea82a2287680 (0 => OK)
@ -1891,41 +1891,41 @@ Converting double-precision to single-precision
22 DOUBLE: 1.49147387366816238763e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509080e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675456000000000000e+09 / 0x4e805bf1 (0x10 => INEXACT )
25 SINGLE: 2.71828174591064453125e+00 / 0x402df854 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311600e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07853004800000000000e+09 / 0x4e809220 (0x10 => INEXACT )
26 SINGLE: 3.14159274101257324219e+00 / 0x40490fdb (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32540006400000000000e+09 / 0x4e9e0000 (0x10 => INEXACT )
33 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570815e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x14 => OVERFLOW INEXACT )
36 SINGLE: inf / 0x7f800000 (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -1.31008000000000000000e+05 / 0xc7ffe000 (0 => OK)
@ -2208,87 +2208,87 @@ Converting double-precision to half-precision
40 HALF: 0000 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570814e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x14 => OVERFLOW INEXACT )
03 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007529e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766502400000000000e+09 / 0x4f730c3b (0x10 => INEXACT )
06 SINGLE: -1.11099992680387713644e+31 / 0xf30c3a58 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999084e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962457600000000000e+09 / 0x4f71605e (0x10 => INEXACT )
07 SINGLE: -1.11099995702702262681e+30 / 0xf1605d5a (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138309e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -0.00000000000000000000e+00 / 0x80000000 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750796e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750796e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750797e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750797e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013061e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638080000000000000e+08 / 0x4e4c0001 (0x10 => INEXACT )
14 SINGLE: 2.98023259404089913006e-08 / 0x33000001 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015662e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026624000000000000e+08 / 0x4e4e0000 (0x10 => INEXACT )
15 SINGLE: 5.96046021428264793940e-08 / 0x337ffff4 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994299e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896384000000000000e+08 / 0x4e61ff01 (0x10 => INEXACT )
16 SINGLE: 6.09756025369279086590e-05 / 0x387fc00e (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013665e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912768000000000000e+08 / 0x4e620001 (0x10 => INEXACT )
17 SINGLE: 6.10352071817032992840e-05 / 0x38800007 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138310e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0x18 => UNDERFLOW INEXACT )
20 SINGLE: 1.40129846432481707093e-45 / 0x00000001 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282844e-308 / 0x000009ea82a2287680 (0 => OK)
21 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0x18 => UNDERFLOW INEXACT )
21 SINGLE: 1.40129846432481707093e-45 / 0x00000001 (0x18 => UNDERFLOW INEXACT )
22 DOUBLE: 1.49147387366816238764e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0x18 => UNDERFLOW INEXACT )
22 SINGLE: 1.40129846432481707093e-45 / 0x00000001 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509080e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675456000000000000e+09 / 0x4e805bf1 (0x10 => INEXACT )
25 SINGLE: 2.71828198432922363282e+00 / 0x402df855 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311600e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07853004800000000000e+09 / 0x4e809220 (0x10 => INEXACT )
26 SINGLE: 3.14159274101257324219e+00 / 0x40490fdb (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32540006400000000000e+09 / 0x4e9e0000 (0x10 => INEXACT )
33 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570815e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x14 => OVERFLOW INEXACT )
36 SINGLE: inf / 0x7f800000 (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -1.31008000000000000000e+05 / 0xc7ffe000 (0 => OK)
@ -2571,45 +2571,45 @@ Converting double-precision to half-precision
40 HALF: 0000 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570815e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x14 => OVERFLOW INEXACT )
03 SINGLE: -inf / 0xff800000 (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007530e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766476800000000000e+09 / 0x4f730c3a (0x10 => INEXACT )
06 SINGLE: -1.11100004769645909791e+31 / 0xf30c3a59 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999085e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962432000000000000e+09 / 0x4f71605d (0x10 => INEXACT )
07 SINGLE: -1.11100003258488635273e+30 / 0xf1605d5b (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138310e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -1.40129846432481707093e-45 / 0x80000001 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750797e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750797e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750796e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750796e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013060e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638016000000000000e+08 / 0x4e4c0000 (0x10 => INEXACT )
14 SINGLE: 2.98023223876953125000e-08 / 0x33000000 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015661e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026560000000000000e+08 / 0x4e4dffff (0x10 => INEXACT )
15 SINGLE: 5.96045985901128005934e-08 / 0x337ffff3 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994298e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896320000000000000e+08 / 0x4e61ff00 (0x10 => INEXACT )
16 SINGLE: 6.09755988989491015672e-05 / 0x387fc00d (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013664e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912704000000000000e+08 / 0x4e620000 (0x10 => INEXACT )
17 SINGLE: 6.10351999057456851005e-05 / 0x38800006 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138309e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282843e-308 / 0x000009ea82a2287680 (0 => OK)
@ -2617,41 +2617,41 @@ Converting double-precision to single-precision
22 DOUBLE: 1.49147387366816238763e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509079e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675443200000000000e+09 / 0x4e805bf0 (0x10 => INEXACT )
25 SINGLE: 2.71828174591064453125e+00 / 0x402df854 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311599e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07852992000000000000e+09 / 0x4e80921f (0x10 => INEXACT )
26 SINGLE: 3.14159250259399414062e+00 / 0x40490fda (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32539993600000000000e+09 / 0x4e9dffff (0x10 => INEXACT )
33 SINGLE: 2.14748352000000000000e+09 / 0x4effffff (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570814e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x14 => OVERFLOW INEXACT )
36 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -1.31008000000000000000e+05 / 0xc7ffe000 (0 => OK)
@ -2934,45 +2934,45 @@ Converting double-precision to half-precision
40 HALF: 0000 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570814e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x14 => OVERFLOW INEXACT )
03 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007529e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766476800000000000e+09 / 0x4f730c3a (0x10 => INEXACT )
06 SINGLE: -1.11099992680387713644e+31 / 0xf30c3a58 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999084e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962432000000000000e+09 / 0x4f71605d (0x10 => INEXACT )
07 SINGLE: -1.11099995702702262681e+30 / 0xf1605d5a (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138309e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -0.00000000000000000000e+00 / 0x80000000 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750796e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750796e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750796e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750796e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013060e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638016000000000000e+08 / 0x4e4c0000 (0x10 => INEXACT )
14 SINGLE: 2.98023223876953125000e-08 / 0x33000000 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015661e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026560000000000000e+08 / 0x4e4dffff (0x10 => INEXACT )
15 SINGLE: 5.96045985901128005934e-08 / 0x337ffff3 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994298e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896320000000000000e+08 / 0x4e61ff00 (0x10 => INEXACT )
16 SINGLE: 6.09755988989491015672e-05 / 0x387fc00d (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013664e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912704000000000000e+08 / 0x4e620000 (0x10 => INEXACT )
17 SINGLE: 6.10351999057456851005e-05 / 0x38800006 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138309e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282843e-308 / 0x000009ea82a2287680 (0 => OK)
@ -2980,41 +2980,41 @@ Converting double-precision to single-precision
22 DOUBLE: 1.49147387366816238763e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509079e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675443200000000000e+09 / 0x4e805bf0 (0x10 => INEXACT )
25 SINGLE: 2.71828174591064453125e+00 / 0x402df854 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311599e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07852992000000000000e+09 / 0x4e80921f (0x10 => INEXACT )
26 SINGLE: 3.14159250259399414062e+00 / 0x40490fda (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32539993600000000000e+09 / 0x4e9dffff (0x10 => INEXACT )
33 SINGLE: 2.14748352000000000000e+09 / 0x4effffff (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570814e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x14 => OVERFLOW INEXACT )
36 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -1.31008000000000000000e+05 / 0xc7ffe000 (0 => OK)

86
tests/tcg/aarch64/gdbstub/test-mte.py Normal file
View File

@ -0,0 +1,86 @@
from __future__ import print_function
#
# Test GDB memory-tag commands that exercise the stubs for the qIsAddressTagged,
# qMemTag, and QMemTag packets. Logical tag-only commands rely on local
# operations, hence don't exercise any stub.
#
# The test consists in breaking just after a atag() call (which sets the
# allocation tag -- see mte-8.c for details) and setting/getting tags in
# different memory locations and ranges starting at the address of the array
# 'a'.
#
# This is launched via tests/guest-debug/run-test.py
#
import gdb
import re
from test_gdbstub import main, report
PATTERN_0 = "Memory tags for address 0x[0-9a-f]+ match \(0x[0-9a-f]+\)."
PATTERN_1 = ".*(0x[0-9a-f]+)"
def run_test():
gdb.execute("break 95", False, True)
gdb.execute("continue", False, True)
try:
# Test if we can check correctly that the allocation tag for
# array 'a' matches the logical tag after atag() is called.
co = gdb.execute("memory-tag check a", False, True)
tags_match = re.findall(PATTERN_0, co, re.MULTILINE)
if tags_match:
report(True, f"{tags_match[0]}")
else:
report(False, "Logical and allocation tags don't match!")
# Test allocation tag 'set and print' commands. Commands on logical
# tags rely on local operation and so don't exercise any stub.
# Set the allocation tag for the first granule (16 bytes) of
# address starting at 'a' address to a known value, i.e. 0x04.
gdb.execute("memory-tag set-allocation-tag a 1 04", False, True)
# Then set the allocation tag for the second granule to a known
# value, i.e. 0x06. This tests that contiguous tag granules are
# set correct and don't run over each other.
gdb.execute("memory-tag set-allocation-tag a+16 1 06", False, True)
# Read the known values back and check if they remain the same.
co = gdb.execute("memory-tag print-allocation-tag a", False, True)
first_tag = re.match(PATTERN_1, co)[1]
co = gdb.execute("memory-tag print-allocation-tag a+16", False, True)
second_tag = re.match(PATTERN_1, co)[1]
if first_tag == "0x4" and second_tag == "0x6":
report(True, "Allocation tags are correctly set/printed.")
else:
report(False, "Can't set/print allocation tags!")
# Now test fill pattern by setting a whole page with a pattern.
gdb.execute("memory-tag set-allocation-tag a 4096 0a0b", False, True)
# And read back the tags of the last two granules in page so
# we also test if the pattern is set correctly up to the end of
# the page.
co = gdb.execute("memory-tag print-allocation-tag a+4096-32", False, True)
tag = re.match(PATTERN_1, co)[1]
co = gdb.execute("memory-tag print-allocation-tag a+4096-16", False, True)
last_tag = re.match(PATTERN_1, co)[1]
if tag == "0xa" and last_tag == "0xb":
report(True, "Fill pattern is ok.")
else:
report(False, "Fill pattern failed!")
except gdb.error:
# This usually happens because a GDB version that does not
# support memory tagging was used to run the test.
report(False, "'memory-tag' command failed!")
main(run_test, expected_arch="aarch64")

2
tests/tcg/aarch64/mte-1.c
View File

@ -15,7 +15,7 @@ int main(int ac, char **av)
enable_mte(PR_MTE_TCF_NONE);
p0 = alloc_mte_mem(sizeof(*p0));
asm("irg %0,%1,%2" : "=r"(p1) : "r"(p0), "r"(1));
asm("irg %0,%1,%2" : "=r"(p1) : "r"(p0), "r"(1l));
assert(p1 != p0);
asm("subp %0,%1,%2" : "=r"(c) : "r"(p0), "r"(p1));
assert(c == 0);

99
tests/tcg/aarch64/mte-8.c Normal file
View File

@ -0,0 +1,99 @@
/*
* To be compiled with -march=armv8.5-a+memtag
*
* This test is adapted from a Linux test. Please see:
*
* https://www.kernel.org/doc/html/next/arch/arm64/memory-tagging-extension.html#example-of-correct-usage
*/
#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/auxv.h>
#include <sys/mman.h>
#include <sys/prctl.h>
#include <string.h>
/*
* From arch/arm64/include/uapi/asm/hwcap.h
*/
#define HWCAP2_MTE (1 << 18)
/*
* From arch/arm64/include/uapi/asm/mman.h
*/
#define PROT_MTE 0x20
/*
* Insert a random logical tag into the given pointer.
*/
#define insert_random_tag(ptr) ({ \
uint64_t __val; \
asm("irg %0, %1" : "=r" (__val) : "r" (ptr)); \
__val; \
})
/*
* Set the allocation tag on the destination address.
*/
#define set_tag(tagged_addr) do { \
asm volatile("stg %0, [%0]" : : "r" (tagged_addr) : "memory"); \
} while (0)
int main(int argc, char *argv[])
{
unsigned char *a;
unsigned long page_sz = sysconf(_SC_PAGESIZE);
unsigned long hwcap2 = getauxval(AT_HWCAP2);
/* check if MTE is present */
if (!(hwcap2 & HWCAP2_MTE)) {
return EXIT_FAILURE;
}
/*
* Enable the tagged address ABI, synchronous or asynchronous MTE
* tag check faults (based on per-CPU preference) and allow all
* non-zero tags in the randomly generated set.
*/
if (prctl(PR_SET_TAGGED_ADDR_CTRL,
PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC | PR_MTE_TCF_ASYNC |
(0xfffe << PR_MTE_TAG_SHIFT),
0, 0, 0)) {
perror("prctl() failed");
return EXIT_FAILURE;
}
a = mmap(0, page_sz, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (a == MAP_FAILED) {
perror("mmap() failed");
return EXIT_FAILURE;
}
printf("a[] address is %p\n", a);
/*
* Enable MTE on the above anonymous mmap. The flag could be passed
* directly to mmap() and skip this step.
*/
if (mprotect(a, page_sz, PROT_READ | PROT_WRITE | PROT_MTE)) {
perror("mprotect() failed");
return EXIT_FAILURE;
}
/* access with the default tag (0) */
a[0] = 1;
a[1] = 2;
printf("a[0] = %hhu a[1] = %hhu\n", a[0], a[1]);
/* set the logical and allocation tags */
a = (unsigned char *)insert_random_tag(a);
set_tag(a);
printf("%p\n", a);
return 0;
}

4
tests/tcg/arm/Makefile.softmmu-target
View File

@ -13,7 +13,7 @@ VPATH += $(ARM_SRC)
test-armv6m-undef: test-armv6m-undef.S
$(CC) -mcpu=cortex-m0 -mfloat-abi=soft \
-Wl,--build-id=none -x assembler-with-cpp \
$< -o $@ -nostdlib -N -static \
$< -o $@ -nostdlib -static \
-T $(ARM_SRC)/$@.ld
run-test-armv6m-undef: QEMU_OPTS=-semihosting-config enable=on,target=native,chardev=output -M microbit -kernel
@ -30,7 +30,7 @@ CRT_PATH=$(ARM_SRC)
LINK_SCRIPT=$(ARM_SRC)/kernel.ld
LDFLAGS=-Wl,-T$(LINK_SCRIPT)
CFLAGS+=-nostdlib -ggdb -O0 $(MINILIB_INC)
LDFLAGS+=-static -nostdlib -N $(CRT_OBJS) $(MINILIB_OBJS) -lgcc
LDFLAGS+=-static -nostdlib $(CRT_OBJS) $(MINILIB_OBJS) -lgcc
# building head blobs
.PRECIOUS: $(CRT_OBJS)

12
tests/tcg/arm/Makefile.target
View File

@ -8,6 +8,11 @@ ARM_SRC=$(SRC_PATH)/tests/tcg/arm
# Set search path for all sources
VPATH += $(ARM_SRC)
config-cc.mak: Makefile
$(quiet-@)( \
$(call cc-option,-fno-integrated-as, CROSS_CC_HAS_FNIA)) 3> config-cc.mak
-include config-cc.mak
float_madds: CFLAGS+=-mfpu=neon-vfpv4
# Basic Hello World
@ -17,14 +22,15 @@ 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
# Clang assembler does not support IWMXT, so use the external assembler.
test-arm-iwmmxt: CFLAGS += -marm -march=iwmmxt -mabi=aapcs -mfpu=fpv4-sp-d16 $(CROSS_CC_HAS_FNIA)
test-arm-iwmmxt: test-arm-iwmmxt.S
$(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)
# Float-convert Tests
ARM_TESTS += fcvt
fcvt: LDFLAGS+=-lm
# fcvt: CFLAGS+=-march=armv8.2-a+fp16 -mfpu=neon-fp-armv8
fcvt: LDFLAGS += -lm
fcvt: CFLAGS += -march=armv8.2-a+fp16 -mfpu=neon-fp-armv8
run-fcvt: fcvt
$(call run-test,fcvt,$(QEMU) $<)
$(call diff-out,fcvt,$(ARM_SRC)/fcvt.ref)

28
tests/tcg/arm/fcvt.c
View File

@ -126,7 +126,7 @@ static void convert_single_to_half(void)
asm("vcvtb.f16.f32 %0, %1" : "=t" (output) : "x" (input));
#else
uint16_t output;
asm("fcvt %h0, %s1" : "=w" (output) : "x" (input));
asm("fcvt %h0, %s1" : "=w" (output) : "w" (input));
#endif
print_half_number(i, output);
}
@ -149,7 +149,7 @@ static void convert_single_to_double(void)
#if defined(__arm__)
asm("vcvt.f64.f32 %P0, %1" : "=w" (output) : "t" (input));
#else
asm("fcvt %d0, %s1" : "=w" (output) : "x" (input));
asm("fcvt %d0, %s1" : "=w" (output) : "w" (input));
#endif
print_double_number(i, output);
}
@ -244,7 +244,7 @@ static void convert_double_to_half(void)
/* asm("vcvtb.f16.f64 %0, %P1" : "=t" (output) : "x" (input)); */
output = input;
#else
asm("fcvt %h0, %d1" : "=w" (output) : "x" (input));
asm("fcvt %h0, %d1" : "=w" (output) : "w" (input));
#endif
print_half_number(i, output);
}
@ -258,7 +258,7 @@ static void convert_double_to_single(void)
for (i = 0; i < ARRAY_SIZE(double_numbers); ++i) {
double input = double_numbers[i].d;
uint32_t output;
float output;
feclearexcept(FE_ALL_EXCEPT);
@ -267,7 +267,7 @@ static void convert_double_to_single(void)
#if defined(__arm__)
asm("vcvt.f32.f64 %0, %P1" : "=w" (output) : "x" (input));
#else
asm("fcvt %s0, %d1" : "=w" (output) : "x" (input));
asm("fcvt %s0, %d1" : "=w" (output) : "w" (input));
#endif
print_single_number(i, output);
@ -335,7 +335,7 @@ static void convert_half_to_double(void)
/* asm("vcvtb.f64.f16 %P0, %1" : "=w" (output) : "t" (input)); */
output = input;
#else
asm("fcvt %d0, %h1" : "=w" (output) : "x" (input));
asm("fcvt %d0, %h1" : "=w" (output) : "w" (input));
#endif
print_double_number(i, output);
}
@ -355,9 +355,14 @@ static void convert_half_to_single(void)
print_half_number(i, input);
#if defined(__arm__)
asm("vcvtb.f32.f16 %0, %1" : "=w" (output) : "x" ((uint32_t)input));
/*
* Clang refuses to allocate an integer to a fp register.
* Perform the move from a general register by hand.
*/
asm("vmov %0, %1\n\t"
"vcvtb.f32.f16 %0, %0" : "=w" (output) : "r" (input));
#else
asm("fcvt %s0, %h1" : "=w" (output) : "x" (input));
asm("fcvt %s0, %h1" : "=w" (output) : "w" (input));
#endif
print_single_number(i, output);
}
@ -380,7 +385,7 @@ static void convert_half_to_integer(void)
/* asm("vcvt.s32.f16 %0, %1" : "=t" (output) : "t" (input)); v8.2*/
output = input;
#else
asm("fcvt %s0, %h1" : "=w" (output) : "x" (input));
asm("fcvt %s0, %h1" : "=w" (output) : "w" (input));
#endif
print_int64(i, output);
}
@ -422,10 +427,9 @@ int main(int argc, char *argv[argc])
/* And now with ARM alternative FP16 */
#if defined(__arm__)
/* See glibc sysdeps/arm/fpu_control.h */
asm("mrc p10, 7, r1, cr1, cr0, 0\n\t"
asm("vmrs r1, fpscr\n\t"
"orr r1, r1, %[flags]\n\t"
"mcr p10, 7, r1, cr1, cr0, 0\n\t"
"vmsr fpscr, r1"
: /* no output */ : [flags] "n" (1 << 26) : "r1" );
#else
asm("mrs x1, fpcr\n\t"

604
tests/tcg/arm/fcvt.ref
View File

@ -211,45 +211,45 @@ Converting double-precision to half-precision
40 HALF: 0000 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570815e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x14 => OVERFLOW INEXACT )
03 SINGLE: -inf / 0xff800000 (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007529e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766476800000000000e+09 / 0x4f730c3a (0x10 => INEXACT )
06 SINGLE: -1.11100004769645909791e+31 / 0xf30c3a59 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999085e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962432000000000000e+09 / 0x4f71605d (0x10 => INEXACT )
07 SINGLE: -1.11100003258488635273e+30 / 0xf1605d5b (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138309e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -0.00000000000000000000e+00 / 0x80000000 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750797e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750797e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750797e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750797e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013061e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638016000000000000e+08 / 0x4e4c0000 (0x10 => INEXACT )
14 SINGLE: 2.98023223876953125000e-08 / 0x33000000 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015661e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026624000000000000e+08 / 0x4e4e0000 (0x10 => INEXACT )
15 SINGLE: 5.96045985901128005935e-08 / 0x337ffff3 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994299e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896320000000000000e+08 / 0x4e61ff00 (0x10 => INEXACT )
16 SINGLE: 6.09755988989491015673e-05 / 0x387fc00d (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013665e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912704000000000000e+08 / 0x4e620000 (0x10 => INEXACT )
17 SINGLE: 6.10351999057456851006e-05 / 0x38800006 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138309e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282843e-308 / 0x000009ea82a2287680 (0 => OK)
@ -257,41 +257,41 @@ Converting double-precision to single-precision
22 DOUBLE: 1.49147387366816238763e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509080e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675456000000000000e+09 / 0x4e805bf1 (0x10 => INEXACT )
25 SINGLE: 2.71828174591064453125e+00 / 0x402df854 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311600e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07853004800000000000e+09 / 0x4e809220 (0x10 => INEXACT )
26 SINGLE: 3.14159274101257324219e+00 / 0x40490fdb (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32540006400000000000e+09 / 0x4e9e0000 (0x10 => INEXACT )
33 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570815e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x14 => OVERFLOW INEXACT )
36 SINGLE: inf / 0x7f800000 (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -nan / 0xffffe000 (0 => OK)
@ -574,87 +574,87 @@ Converting double-precision to half-precision
40 HALF: 0000 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570814e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x14 => OVERFLOW INEXACT )
03 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007529e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766502400000000000e+09 / 0x4f730c3b (0x10 => INEXACT )
06 SINGLE: -1.11099992680387713644e+31 / 0xf30c3a58 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999084e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962457600000000000e+09 / 0x4f71605e (0x10 => INEXACT )
07 SINGLE: -1.11099995702702262681e+30 / 0xf1605d5a (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138309e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -0.00000000000000000000e+00 / 0x80000000 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750796e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750796e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750797e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750797e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013061e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638080000000000000e+08 / 0x4e4c0001 (0x10 => INEXACT )
14 SINGLE: 2.98023259404089913006e-08 / 0x33000001 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015662e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026624000000000000e+08 / 0x4e4e0000 (0x10 => INEXACT )
15 SINGLE: 5.96046021428264793940e-08 / 0x337ffff4 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994299e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896384000000000000e+08 / 0x4e61ff01 (0x10 => INEXACT )
16 SINGLE: 6.09756025369279086590e-05 / 0x387fc00e (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013665e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912768000000000000e+08 / 0x4e620001 (0x10 => INEXACT )
17 SINGLE: 6.10352071817032992840e-05 / 0x38800007 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138310e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0x18 => UNDERFLOW INEXACT )
20 SINGLE: 1.40129846432481707093e-45 / 0x00000001 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282844e-308 / 0x000009ea82a2287680 (0 => OK)
21 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0x18 => UNDERFLOW INEXACT )
21 SINGLE: 1.40129846432481707093e-45 / 0x00000001 (0x18 => UNDERFLOW INEXACT )
22 DOUBLE: 1.49147387366816238764e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0x18 => UNDERFLOW INEXACT )
22 SINGLE: 1.40129846432481707093e-45 / 0x00000001 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509080e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675456000000000000e+09 / 0x4e805bf1 (0x10 => INEXACT )
25 SINGLE: 2.71828198432922363282e+00 / 0x402df855 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311600e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07853004800000000000e+09 / 0x4e809220 (0x10 => INEXACT )
26 SINGLE: 3.14159274101257324219e+00 / 0x40490fdb (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32540006400000000000e+09 / 0x4e9e0000 (0x10 => INEXACT )
33 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570815e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x14 => OVERFLOW INEXACT )
36 SINGLE: inf / 0x7f800000 (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -nan / 0xffffe000 (0 => OK)
@ -937,45 +937,45 @@ Converting double-precision to half-precision
40 HALF: 0000 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570815e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x14 => OVERFLOW INEXACT )
03 SINGLE: -inf / 0xff800000 (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007530e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766476800000000000e+09 / 0x4f730c3a (0x10 => INEXACT )
06 SINGLE: -1.11100004769645909791e+31 / 0xf30c3a59 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999085e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962432000000000000e+09 / 0x4f71605d (0x10 => INEXACT )
07 SINGLE: -1.11100003258488635273e+30 / 0xf1605d5b (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138310e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -1.40129846432481707093e-45 / 0x80000001 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750797e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750797e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750796e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750796e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013060e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638016000000000000e+08 / 0x4e4c0000 (0x10 => INEXACT )
14 SINGLE: 2.98023223876953125000e-08 / 0x33000000 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015661e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026560000000000000e+08 / 0x4e4dffff (0x10 => INEXACT )
15 SINGLE: 5.96045985901128005934e-08 / 0x337ffff3 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994298e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896320000000000000e+08 / 0x4e61ff00 (0x10 => INEXACT )
16 SINGLE: 6.09755988989491015672e-05 / 0x387fc00d (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013664e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912704000000000000e+08 / 0x4e620000 (0x10 => INEXACT )
17 SINGLE: 6.10351999057456851005e-05 / 0x38800006 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138309e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282843e-308 / 0x000009ea82a2287680 (0 => OK)
@ -983,41 +983,41 @@ Converting double-precision to single-precision
22 DOUBLE: 1.49147387366816238763e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509079e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675443200000000000e+09 / 0x4e805bf0 (0x10 => INEXACT )
25 SINGLE: 2.71828174591064453125e+00 / 0x402df854 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311599e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07852992000000000000e+09 / 0x4e80921f (0x10 => INEXACT )
26 SINGLE: 3.14159250259399414062e+00 / 0x40490fda (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32539993600000000000e+09 / 0x4e9dffff (0x10 => INEXACT )
33 SINGLE: 2.14748352000000000000e+09 / 0x4effffff (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570814e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x14 => OVERFLOW INEXACT )
36 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -nan / 0xffffe000 (0 => OK)
@ -1300,45 +1300,45 @@ Converting double-precision to half-precision
40 HALF: 0000 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570814e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x14 => OVERFLOW INEXACT )
03 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007529e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766476800000000000e+09 / 0x4f730c3a (0x10 => INEXACT )
06 SINGLE: -1.11099992680387713644e+31 / 0xf30c3a58 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999084e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962432000000000000e+09 / 0x4f71605d (0x10 => INEXACT )
07 SINGLE: -1.11099995702702262681e+30 / 0xf1605d5a (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138309e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -0.00000000000000000000e+00 / 0x80000000 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750796e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750796e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750796e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750796e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013060e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638016000000000000e+08 / 0x4e4c0000 (0x10 => INEXACT )
14 SINGLE: 2.98023223876953125000e-08 / 0x33000000 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015661e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026560000000000000e+08 / 0x4e4dffff (0x10 => INEXACT )
15 SINGLE: 5.96045985901128005934e-08 / 0x337ffff3 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994298e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896320000000000000e+08 / 0x4e61ff00 (0x10 => INEXACT )
16 SINGLE: 6.09755988989491015672e-05 / 0x387fc00d (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013664e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912704000000000000e+08 / 0x4e620000 (0x10 => INEXACT )
17 SINGLE: 6.10351999057456851005e-05 / 0x38800006 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138309e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282843e-308 / 0x000009ea82a2287680 (0 => OK)
@ -1346,41 +1346,41 @@ Converting double-precision to single-precision
22 DOUBLE: 1.49147387366816238763e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509079e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675443200000000000e+09 / 0x4e805bf0 (0x10 => INEXACT )
25 SINGLE: 2.71828174591064453125e+00 / 0x402df854 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311599e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07852992000000000000e+09 / 0x4e80921f (0x10 => INEXACT )
26 SINGLE: 3.14159250259399414062e+00 / 0x40490fda (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32539993600000000000e+09 / 0x4e9dffff (0x10 => INEXACT )
33 SINGLE: 2.14748352000000000000e+09 / 0x4effffff (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570814e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x14 => OVERFLOW INEXACT )
36 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -nan / 0xffffe000 (0 => OK)
@ -1845,45 +1845,45 @@ Converting double-precision to half-precision
40 HALF: 0000 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570815e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x14 => OVERFLOW INEXACT )
03 SINGLE: -inf / 0xff800000 (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007529e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766476800000000000e+09 / 0x4f730c3a (0x10 => INEXACT )
06 SINGLE: -1.11100004769645909791e+31 / 0xf30c3a59 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999085e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962432000000000000e+09 / 0x4f71605d (0x10 => INEXACT )
07 SINGLE: -1.11100003258488635273e+30 / 0xf1605d5b (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138309e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -0.00000000000000000000e+00 / 0x80000000 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750797e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750797e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750797e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750797e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013061e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638016000000000000e+08 / 0x4e4c0000 (0x10 => INEXACT )
14 SINGLE: 2.98023223876953125000e-08 / 0x33000000 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015661e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026624000000000000e+08 / 0x4e4e0000 (0x10 => INEXACT )
15 SINGLE: 5.96045985901128005935e-08 / 0x337ffff3 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994299e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896320000000000000e+08 / 0x4e61ff00 (0x10 => INEXACT )
16 SINGLE: 6.09755988989491015673e-05 / 0x387fc00d (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013665e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912704000000000000e+08 / 0x4e620000 (0x10 => INEXACT )
17 SINGLE: 6.10351999057456851006e-05 / 0x38800006 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138309e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282843e-308 / 0x000009ea82a2287680 (0 => OK)
@ -1891,41 +1891,41 @@ Converting double-precision to single-precision
22 DOUBLE: 1.49147387366816238763e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509080e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675456000000000000e+09 / 0x4e805bf1 (0x10 => INEXACT )
25 SINGLE: 2.71828174591064453125e+00 / 0x402df854 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311600e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07853004800000000000e+09 / 0x4e809220 (0x10 => INEXACT )
26 SINGLE: 3.14159274101257324219e+00 / 0x40490fdb (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32540006400000000000e+09 / 0x4e9e0000 (0x10 => INEXACT )
33 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570815e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x14 => OVERFLOW INEXACT )
36 SINGLE: inf / 0x7f800000 (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -1.31008000000000000000e+05 / 0xc7ffe000 (0 => OK)
@ -2208,87 +2208,87 @@ Converting double-precision to half-precision
40 HALF: 0000 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570814e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x14 => OVERFLOW INEXACT )
03 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007529e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766502400000000000e+09 / 0x4f730c3b (0x10 => INEXACT )
06 SINGLE: -1.11099992680387713644e+31 / 0xf30c3a58 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999084e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962457600000000000e+09 / 0x4f71605e (0x10 => INEXACT )
07 SINGLE: -1.11099995702702262681e+30 / 0xf1605d5a (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138309e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -0.00000000000000000000e+00 / 0x80000000 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750796e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750796e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750797e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750797e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013061e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638080000000000000e+08 / 0x4e4c0001 (0x10 => INEXACT )
14 SINGLE: 2.98023259404089913006e-08 / 0x33000001 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015662e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026624000000000000e+08 / 0x4e4e0000 (0x10 => INEXACT )
15 SINGLE: 5.96046021428264793940e-08 / 0x337ffff4 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994299e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896384000000000000e+08 / 0x4e61ff01 (0x10 => INEXACT )
16 SINGLE: 6.09756025369279086590e-05 / 0x387fc00e (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013665e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912768000000000000e+08 / 0x4e620001 (0x10 => INEXACT )
17 SINGLE: 6.10352071817032992840e-05 / 0x38800007 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138310e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0x18 => UNDERFLOW INEXACT )
20 SINGLE: 1.40129846432481707093e-45 / 0x00000001 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282844e-308 / 0x000009ea82a2287680 (0 => OK)
21 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0x18 => UNDERFLOW INEXACT )
21 SINGLE: 1.40129846432481707093e-45 / 0x00000001 (0x18 => UNDERFLOW INEXACT )
22 DOUBLE: 1.49147387366816238764e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0x18 => UNDERFLOW INEXACT )
22 SINGLE: 1.40129846432481707093e-45 / 0x00000001 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509080e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675456000000000000e+09 / 0x4e805bf1 (0x10 => INEXACT )
25 SINGLE: 2.71828198432922363282e+00 / 0x402df855 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311600e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07853004800000000000e+09 / 0x4e809220 (0x10 => INEXACT )
26 SINGLE: 3.14159274101257324219e+00 / 0x40490fdb (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32540006400000000000e+09 / 0x4e9e0000 (0x10 => INEXACT )
33 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859812e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859812e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570815e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0x14 => OVERFLOW INEXACT )
36 SINGLE: inf / 0x7f800000 (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -1.31008000000000000000e+05 / 0xc7ffe000 (0 => OK)
@ -2571,45 +2571,45 @@ Converting double-precision to half-precision
40 HALF: 0000 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570815e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0x14 => OVERFLOW INEXACT )
03 SINGLE: -inf / 0xff800000 (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859812e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859812e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007530e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766476800000000000e+09 / 0x4f730c3a (0x10 => INEXACT )
06 SINGLE: -1.11100004769645909791e+31 / 0xf30c3a59 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999085e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962432000000000000e+09 / 0x4f71605d (0x10 => INEXACT )
07 SINGLE: -1.11100003258488635273e+30 / 0xf1605d5b (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138310e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -1.40129846432481707093e-45 / 0x80000001 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750797e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750797e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750796e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750796e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013060e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638016000000000000e+08 / 0x4e4c0000 (0x10 => INEXACT )
14 SINGLE: 2.98023223876953125000e-08 / 0x33000000 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015661e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026560000000000000e+08 / 0x4e4dffff (0x10 => INEXACT )
15 SINGLE: 5.96045985901128005934e-08 / 0x337ffff3 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994298e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896320000000000000e+08 / 0x4e61ff00 (0x10 => INEXACT )
16 SINGLE: 6.09755988989491015672e-05 / 0x387fc00d (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013664e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912704000000000000e+08 / 0x4e620000 (0x10 => INEXACT )
17 SINGLE: 6.10351999057456851005e-05 / 0x38800006 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138309e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282843e-308 / 0x000009ea82a2287680 (0 => OK)
@ -2617,41 +2617,41 @@ Converting double-precision to single-precision
22 DOUBLE: 1.49147387366816238763e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509079e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675443200000000000e+09 / 0x4e805bf0 (0x10 => INEXACT )
25 SINGLE: 2.71828174591064453125e+00 / 0x402df854 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311599e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07852992000000000000e+09 / 0x4e80921f (0x10 => INEXACT )
26 SINGLE: 3.14159250259399414062e+00 / 0x40490fda (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32539993600000000000e+09 / 0x4e9dffff (0x10 => INEXACT )
33 SINGLE: 2.14748352000000000000e+09 / 0x4effffff (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570814e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x14 => OVERFLOW INEXACT )
36 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -1.31008000000000000000e+05 / 0xc7ffe000 (0 => OK)
@ -2934,45 +2934,45 @@ Converting double-precision to half-precision
40 HALF: 0000 (0x1 => INVALID)
Converting double-precision to single-precision
00 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
00 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
00 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
01 DOUBLE: -nan / 0x00fff8000000000000 (0 => OK)
01 SINGLE: 4.29077299200000000000e+09 / 0x4f7fc000 (0 => OK)
01 SINGLE: -nan / 0xffc00000 (0 => OK)
02 DOUBLE: -inf / 0x00fff0000000000000 (0 => OK)
02 SINGLE: 4.28657868800000000000e+09 / 0x4f7f8000 (0 => OK)
02 SINGLE: -inf / 0xff800000 (0 => OK)
03 DOUBLE: -1.79769313486231570814e+308 / 0x00ffefffffffffffff (0 => OK)
03 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x14 => OVERFLOW INEXACT )
03 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0x14 => OVERFLOW INEXACT )
04 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
04 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
04 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
05 DOUBLE: -3.40282346638528859811e+38 / 0x00c7efffffe0000000 (0 => OK)
05 SINGLE: 4.28657843200000000000e+09 / 0x4f7f7fff (0x10 => INEXACT )
05 SINGLE: -3.40282346638528859811e+38 / 0xff7fffff (0 => OK)
06 DOUBLE: -1.11100000000000007529e+31 / 0x00c661874b135ff654 (0 => OK)
06 SINGLE: 4.07766476800000000000e+09 / 0x4f730c3a (0x10 => INEXACT )
06 SINGLE: -1.11099992680387713644e+31 / 0xf30c3a58 (0x10 => INEXACT )
07 DOUBLE: -1.11099999999999999084e+30 / 0x00c62c0bab523323b9 (0 => OK)
07 SINGLE: 4.04962432000000000000e+09 / 0x4f71605d (0x10 => INEXACT )
07 SINGLE: -1.11099995702702262681e+30 / 0xf1605d5a (0x10 => INEXACT )
08 DOUBLE: -2.00000000000000000000e+00 / 0x00c000000000000000 (0 => OK)
08 SINGLE: 3.22122547200000000000e+09 / 0x4f400000 (0 => OK)
08 SINGLE: -2.00000000000000000000e+00 / 0xc0000000 (0 => OK)
09 DOUBLE: -1.00000000000000000000e+00 / 0x00bff0000000000000 (0 => OK)
09 SINGLE: 3.21283686400000000000e+09 / 0x4f3f8000 (0 => OK)
09 SINGLE: -1.00000000000000000000e+00 / 0xbf800000 (0 => OK)
10 DOUBLE: -2.22507385850720138309e-308 / 0x008010000000000000 (0 => OK)
10 SINGLE: 2.14748364800000000000e+09 / 0x4f000000 (0x18 => UNDERFLOW INEXACT )
10 SINGLE: -0.00000000000000000000e+00 / 0x80000000 (0x18 => UNDERFLOW INEXACT )
11 DOUBLE: -1.17549435082228750796e-38 / 0x00b810000000000000 (0 => OK)
11 SINGLE: 2.15587225600000000000e+09 / 0x4f008000 (0 => OK)
11 SINGLE: -1.17549435082228750796e-38 / 0x80800000 (0 => OK)
12 DOUBLE: 0.00000000000000000000e+00 / 00000000000000000000 (0 => OK)
12 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0 => OK)
13 DOUBLE: 1.17549435082228750796e-38 / 0x003810000000000000 (0 => OK)
13 SINGLE: 8.38860800000000000000e+06 / 0x4b000000 (0 => OK)
13 SINGLE: 1.17549435082228750796e-38 / 0x00800000 (0 => OK)
14 DOUBLE: 2.98023224000000013060e-08 / 0x003e600000001c5f68 (0 => OK)
14 SINGLE: 8.55638016000000000000e+08 / 0x4e4c0000 (0x10 => INEXACT )
14 SINGLE: 2.98023223876953125000e-08 / 0x33000000 (0x10 => INEXACT )
15 DOUBLE: 5.96046000000000015661e-08 / 0x003e6ffffe6cb2fa82 (0 => OK)
15 SINGLE: 8.64026560000000000000e+08 / 0x4e4dffff (0x10 => INEXACT )
15 SINGLE: 5.96045985901128005934e-08 / 0x337ffff3 (0x10 => INEXACT )
16 DOUBLE: 6.09755999999999994298e-05 / 0x003f0ff801a9af58a1 (0 => OK)
16 SINGLE: 9.47896320000000000000e+08 / 0x4e61ff00 (0x10 => INEXACT )
16 SINGLE: 6.09755988989491015672e-05 / 0x387fc00d (0x10 => INEXACT )
17 DOUBLE: 6.10352000000000013664e-05 / 0x003f100000c06a1ef5 (0 => OK)
17 SINGLE: 9.47912704000000000000e+08 / 0x4e620000 (0x10 => INEXACT )
17 SINGLE: 6.10351999057456851005e-05 / 0x38800006 (0x10 => INEXACT )
18 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
18 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
18 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
19 DOUBLE: 1.00097656250000000000e+00 / 0x003ff0040000000000 (0 => OK)
19 SINGLE: 1.06536140800000000000e+09 / 0x4e7e0080 (0 => OK)
19 SINGLE: 1.00097656250000000000e+00 / 0x3f802000 (0 => OK)
20 DOUBLE: 2.22507385850720138309e-308 / 0x000010000000000000 (0 => OK)
20 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
21 DOUBLE: 1.37899728486072282843e-308 / 0x000009ea82a2287680 (0 => OK)
@ -2980,41 +2980,41 @@ Converting double-precision to single-precision
22 DOUBLE: 1.49147387366816238763e-308 / 0x00000ab98fba843210 (0 => OK)
22 SINGLE: 0.00000000000000000000e+00 / 0000000000 (0x18 => UNDERFLOW INEXACT )
23 DOUBLE: 1.00000000000000000000e+00 / 0x003ff0000000000000 (0 => OK)
23 SINGLE: 1.06535321600000000000e+09 / 0x4e7e0000 (0 => OK)
23 SINGLE: 1.00000000000000000000e+00 / 0x3f800000 (0 => OK)
24 DOUBLE: 2.00000000000000000000e+00 / 0x004000000000000000 (0 => OK)
24 SINGLE: 1.07374182400000000000e+09 / 0x4e800000 (0 => OK)
24 SINGLE: 2.00000000000000000000e+00 / 0x40000000 (0 => OK)
25 DOUBLE: 2.71828182845904509079e+00 / 0x004005bf0a8b145769 (0 => OK)
25 SINGLE: 1.07675443200000000000e+09 / 0x4e805bf0 (0x10 => INEXACT )
25 SINGLE: 2.71828174591064453125e+00 / 0x402df854 (0x10 => INEXACT )
26 DOUBLE: 3.14159265358979311599e+00 / 0x00400921fb54442d18 (0 => OK)
26 SINGLE: 1.07852992000000000000e+09 / 0x4e80921f (0x10 => INEXACT )
26 SINGLE: 3.14159250259399414062e+00 / 0x40490fda (0x10 => INEXACT )
27 DOUBLE: 6.55030000000000000000e+04 / 0x0040effbe000000000 (0 => OK)
27 SINGLE: 1.19956249600000000000e+09 / 0x4e8effbe (0 => OK)
27 SINGLE: 6.55030000000000000000e+04 / 0x477fdf00 (0 => OK)
28 DOUBLE: 6.55040000000000000000e+04 / 0x0040effc0000000000 (0 => OK)
28 SINGLE: 1.19956275200000000000e+09 / 0x4e8effc0 (0 => OK)
28 SINGLE: 6.55040000000000000000e+04 / 0x477fe000 (0 => OK)
29 DOUBLE: 6.55050000000000000000e+04 / 0x0040effc2000000000 (0 => OK)
29 SINGLE: 1.19956300800000000000e+09 / 0x4e8effc2 (0 => OK)
29 SINGLE: 6.55050000000000000000e+04 / 0x477fe100 (0 => OK)
30 DOUBLE: 1.31007000000000000000e+05 / 0x0040fffbf000000000 (0 => OK)
30 SINGLE: 1.20795123200000000000e+09 / 0x4e8fffbf (0 => OK)
30 SINGLE: 1.31007000000000000000e+05 / 0x47ffdf80 (0 => OK)
31 DOUBLE: 1.31008000000000000000e+05 / 0x0040fffc0000000000 (0 => OK)
31 SINGLE: 1.20795136000000000000e+09 / 0x4e8fffc0 (0 => OK)
31 SINGLE: 1.31008000000000000000e+05 / 0x47ffe000 (0 => OK)
32 DOUBLE: 1.31009000000000000000e+05 / 0x0040fffc1000000000 (0 => OK)
32 SINGLE: 1.20795148800000000000e+09 / 0x4e8fffc1 (0 => OK)
32 SINGLE: 1.31009000000000000000e+05 / 0x47ffe080 (0 => OK)
33 DOUBLE: 2.14748364700000000000e+09 / 0x0041dfffffffc00000 (0 => OK)
33 SINGLE: 1.32539993600000000000e+09 / 0x4e9dffff (0x10 => INEXACT )
33 SINGLE: 2.14748352000000000000e+09 / 0x4effffff (0x10 => INEXACT )
34 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
34 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
34 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
35 DOUBLE: 3.40282346638528859811e+38 / 0x0047efffffe0000000 (0 => OK)
35 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x10 => INEXACT )
35 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0 => OK)
36 DOUBLE: 1.79769313486231570814e+308 / 0x007fefffffffffffff (0 => OK)
36 SINGLE: 2.13909491200000000000e+09 / 0x4efeffff (0x14 => OVERFLOW INEXACT )
36 SINGLE: 3.40282346638528859811e+38 / 0x7f7fffff (0x14 => OVERFLOW INEXACT )
37 DOUBLE: inf / 0x007ff0000000000000 (0 => OK)
37 SINGLE: 2.13909504000000000000e+09 / 0x4eff0000 (0 => OK)
37 SINGLE: inf / 0x7f800000 (0 => OK)
38 DOUBLE: nan / 0x007ff8000000000000 (0 => OK)
38 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0 => OK)
38 SINGLE: nan / 0x7fc00000 (0 => OK)
39 DOUBLE: nan / 0x007ff0000000000001 (0 => OK)
39 SINGLE: 2.14328934400000000000e+09 / 0x4eff8000 (0x1 => INVALID)
39 SINGLE: nan / 0x7fc00000 (0x1 => INVALID)
40 DOUBLE: nan / 0x007ff4000000000000 (0 => OK)
40 SINGLE: 2.14538649600000000000e+09 / 0x4effc000 (0x1 => INVALID)
40 SINGLE: nan / 0x7fe00000 (0x1 => INVALID)
Converting half-precision to single-precision
00 HALF: 0xffff (0 => OK)
00 SINGLE: -1.31008000000000000000e+05 / 0xc7ffe000 (0 => OK)

2
tests/tcg/minilib/printf.c
View File

@ -27,7 +27,7 @@ static void print_str(char *s)
static void print_num(unsigned long long value, int base)
{
char digits[] = "0123456789abcdef";
static const char digits[] = "0123456789abcdef";
char buf[32];
int i = sizeof(buf) - 2, j;

5
trace-events
View File

@ -37,11 +37,6 @@ dma_complete(void *dbs, int ret, void *cb) "dbs=%p ret=%d cb=%p"
dma_blk_cb(void *dbs, int ret) "dbs=%p ret=%d"
dma_map_wait(void *dbs) "dbs=%p"
# exec.c
find_ram_offset(uint64_t size, uint64_t offset) "size: 0x%" PRIx64 " @ 0x%" PRIx64
find_ram_offset_loop(uint64_t size, uint64_t candidate, uint64_t offset, uint64_t next, uint64_t mingap) "trying size: 0x%" PRIx64 " @ 0x%" PRIx64 ", offset: 0x%" PRIx64" next: 0x%" PRIx64 " mingap: 0x%" PRIx64
ram_block_discard_range(const char *rbname, void *hva, size_t length, bool need_madvise, bool need_fallocate, int ret) "%s@%p + 0x%zx: madvise: %d fallocate: %d ret: %d"
# job.c
job_state_transition(void *job, int ret, const char *legal, const char *s0, const char *s1) "job %p (ret: %d) attempting %s transition (%s-->%s)"
job_apply_verb(void *job, const char *state, const char *verb, const char *legal) "job %p in state %s; applying verb %s (%s)"