Various fixes for rc2:
- get shippable working again - semihosting bug fixes - tweak tb-size handling for low memory machines - i386 compound literal float fix - linux-user MAP_FIXED->MAP_NOREPLACE on fallback - docker binfmt_misc fixes - linux-user nanosleep fix - tests/vm drain console fixes -----BEGIN PGP SIGNATURE----- iQEzBAABCgAdFiEEZoWumedRZ7yvyN81+9DbCVqeKkQFAl8elCsACgkQ+9DbCVqe KkS8Sgf+KM+1J2cuCTb6r+/Rxwvo1JWIufhLArK8ZQfsdGVZpyfXAeG3b6wYbf9S YiSvFeGaeyCn5h4IrUgwOZ974rOdxsvm3hfQXDjnUj1RhlwJUgtJp3HZR0gFtrFj nVAZH4onvg4UFZcgWkXp1MIc1Uca8MulX7g8VdgO1Jy+ngLVIxT+DCsupXrvCkoC A5yppEQZ6TQhN/NEEumE4JlELf+XQZbSNT5TJp22TOJ2s/ujo/Qgq0Kj3CA+gwUa 02hSG3NLORpZ1n0n+a2vPERfiG0fPc7XwTPQcWOvne/t5XUU3bRrYPyqckDcs03q LKEZkNmaIWyv7gM4DmqGzJUQgKIqnw== =KvQo -----END PGP SIGNATURE----- Merge remote-tracking branch 'remotes/stsquad/tags/pull-fixes-for-rc2-270720-1' into staging Various fixes for rc2: - get shippable working again - semihosting bug fixes - tweak tb-size handling for low memory machines - i386 compound literal float fix - linux-user MAP_FIXED->MAP_NOREPLACE on fallback - docker binfmt_misc fixes - linux-user nanosleep fix - tests/vm drain console fixes # gpg: Signature made Mon 27 Jul 2020 09:45:31 BST # gpg: using RSA key 6685AE99E75167BCAFC8DF35FBD0DB095A9E2A44 # gpg: Good signature from "Alex Bennée (Master Work Key) <alex.bennee@linaro.org>" [full] # Primary key fingerprint: 6685 AE99 E751 67BC AFC8 DF35 FBD0 DB09 5A9E 2A44 * remotes/stsquad/tags/pull-fixes-for-rc2-270720-1: tests/vm: add shutdown timeout in basevm.py python/qemu: Change ConsoleSocket to optionally drain socket. python/qemu: Cleanup changes to ConsoleSocket linux-user, ppc: fix clock_nanosleep() for linux-user-ppc linux-user: fix clock_nanosleep() tests/docker: add support for DEB_KEYRING tests/docker: fix binfmt_misc image building tests/docker: fix update command due to python3 str/bytes distinction linux-user: don't use MAP_FIXED in pgd_find_hole_fallback target/i386: floatx80: avoid compound literals in static initializers accel/tcg: better handle memory constrained systems util/oslib-win32: add qemu_get_host_physmem implementation util: add qemu_get_host_physmem utility function semihosting: don't send the trailing '\0' semihosting: defer connect_chardevs a little more to use serialx shippable: add one more qemu to registry url Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell
commit
cb320a07e6
@ -27,7 +27,7 @@ env:
|
||||
TARGET_LIST=ppc64-softmmu,ppc64-linux-user,ppc64abi32-linux-user
|
||||
build:
|
||||
pre_ci_boot:
|
||||
image_name: registry.gitlab.com/qemu-project/qemu/${IMAGE}
|
||||
image_name: registry.gitlab.com/qemu-project/qemu/qemu/${IMAGE}
|
||||
image_tag: latest
|
||||
pull: true
|
||||
options: "-e HOME=/root"
|
||||
|
||||
@ -976,7 +976,12 @@ static inline size_t size_code_gen_buffer(size_t tb_size)
|
||||
{
|
||||
/* Size the buffer. */
|
||||
if (tb_size == 0) {
|
||||
tb_size = DEFAULT_CODE_GEN_BUFFER_SIZE;
|
||||
size_t phys_mem = qemu_get_host_physmem();
|
||||
if (phys_mem == 0) {
|
||||
tb_size = DEFAULT_CODE_GEN_BUFFER_SIZE;
|
||||
} else {
|
||||
tb_size = MIN(DEFAULT_CODE_GEN_BUFFER_SIZE, phys_mem / 8);
|
||||
}
|
||||
}
|
||||
if (tb_size < MIN_CODE_GEN_BUFFER_SIZE) {
|
||||
tb_size = MIN_CODE_GEN_BUFFER_SIZE;
|
||||
|
||||
@ -52,7 +52,9 @@ static GString *copy_user_string(CPUArchState *env, target_ulong addr)
|
||||
|
||||
do {
|
||||
if (cpu_memory_rw_debug(cpu, addr++, &c, 1, 0) == 0) {
|
||||
s = g_string_append_c(s, c);
|
||||
if (c) {
|
||||
s = g_string_append_c(s, c);
|
||||
}
|
||||
} else {
|
||||
qemu_log_mask(LOG_GUEST_ERROR,
|
||||
"%s: passed inaccessible address " TARGET_FMT_lx,
|
||||
|
||||
@ -822,6 +822,7 @@ static inline bool floatx80_invalid_encoding(floatx80 a)
|
||||
}
|
||||
|
||||
#define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL)
|
||||
#define floatx80_zero_init make_floatx80_init(0x0000, 0x0000000000000000LL)
|
||||
#define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL)
|
||||
#define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL)
|
||||
#define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL)
|
||||
|
||||
@ -173,6 +173,9 @@ extern int daemon(int, int);
|
||||
#ifndef MAP_ANONYMOUS
|
||||
#define MAP_ANONYMOUS MAP_ANON
|
||||
#endif
|
||||
#ifndef MAP_FIXED_NOREPLACE
|
||||
#define MAP_FIXED_NOREPLACE 0
|
||||
#endif
|
||||
#ifndef ENOMEDIUM
|
||||
#define ENOMEDIUM ENODEV
|
||||
#endif
|
||||
@ -668,4 +671,16 @@ static inline void qemu_reset_optind(void)
|
||||
*/
|
||||
char *qemu_get_host_name(Error **errp);
|
||||
|
||||
/**
|
||||
* qemu_get_host_physmem:
|
||||
*
|
||||
* Operating system agnostic way of querying host memory.
|
||||
*
|
||||
* Returns amount of physical memory on the system. This is purely
|
||||
* advisery and may return 0 if we can't work it out. At the other
|
||||
* end we saturate to SIZE_MAX if you are lucky enough to have that
|
||||
* much memory.
|
||||
*/
|
||||
size_t qemu_get_host_physmem(void);
|
||||
|
||||
#endif
|
||||
|
||||
@ -2134,12 +2134,15 @@ static uintptr_t pgd_find_hole_fallback(uintptr_t guest_size, uintptr_t brk,
|
||||
/* we have run out of space */
|
||||
return -1;
|
||||
} else {
|
||||
int flags = MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE | MAP_FIXED;
|
||||
int flags = MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE |
|
||||
MAP_FIXED_NOREPLACE;
|
||||
void * mmap_start = mmap((void *) align_start, guest_size,
|
||||
PROT_NONE, flags, -1, 0);
|
||||
if (mmap_start != MAP_FAILED) {
|
||||
munmap((void *) align_start, guest_size);
|
||||
return (uintptr_t) mmap_start + offset;
|
||||
if (MAP_FIXED_NOREPLACE || mmap_start == (void *) align_start) {
|
||||
return (uintptr_t) mmap_start + offset;
|
||||
}
|
||||
}
|
||||
base += qemu_host_page_size;
|
||||
}
|
||||
@ -2307,9 +2310,8 @@ static void pgb_reserved_va(const char *image_name, abi_ulong guest_loaddr,
|
||||
/* Widen the "image" to the entire reserved address space. */
|
||||
pgb_static(image_name, 0, reserved_va, align);
|
||||
|
||||
#ifdef MAP_FIXED_NOREPLACE
|
||||
/* osdep.h defines this as 0 if it's missing */
|
||||
flags |= MAP_FIXED_NOREPLACE;
|
||||
#endif
|
||||
|
||||
/* Reserve the memory on the host. */
|
||||
assert(guest_base != 0);
|
||||
|
||||
@ -11831,16 +11831,15 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
|
||||
target_to_host_timespec(&ts, arg3);
|
||||
ret = get_errno(safe_clock_nanosleep(arg1, arg2,
|
||||
&ts, arg4 ? &ts : NULL));
|
||||
if (arg4)
|
||||
/*
|
||||
* if the call is interrupted by a signal handler, it fails
|
||||
* with error -TARGET_EINTR and if arg4 is not NULL and arg2 is not
|
||||
* TIMER_ABSTIME, it returns the remaining unslept time in arg4.
|
||||
*/
|
||||
if (ret == -TARGET_EINTR && arg4 && arg2 != TIMER_ABSTIME) {
|
||||
host_to_target_timespec(arg4, &ts);
|
||||
|
||||
#if defined(TARGET_PPC)
|
||||
/* clock_nanosleep is odd in that it returns positive errno values.
|
||||
* On PPC, CR0 bit 3 should be set in such a situation. */
|
||||
if (ret && ret != -TARGET_ERESTARTSYS) {
|
||||
((CPUPPCState *)cpu_env)->crf[0] |= 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -1,12 +1,9 @@
|
||||
#!/usr/bin/env python3
|
||||
#
|
||||
# This python module implements a ConsoleSocket object which is
|
||||
# designed always drain the socket itself, and place
|
||||
# the bytes into a in memory buffer for later processing.
|
||||
#
|
||||
# Optionally a file path can be passed in and we will also
|
||||
# dump the characters to this file for debug.
|
||||
#
|
||||
"""
|
||||
QEMU Console Socket Module:
|
||||
|
||||
This python module implements a ConsoleSocket object,
|
||||
which can drain a socket and optionally dump the bytes to file.
|
||||
"""
|
||||
# Copyright 2020 Linaro
|
||||
#
|
||||
# Authors:
|
||||
@ -15,96 +12,118 @@
|
||||
# This code is licensed under the GPL version 2 or later. See
|
||||
# the COPYING file in the top-level directory.
|
||||
#
|
||||
import asyncore
|
||||
|
||||
import socket
|
||||
import threading
|
||||
import io
|
||||
import os
|
||||
import sys
|
||||
from collections import deque
|
||||
import time
|
||||
import traceback
|
||||
|
||||
class ConsoleSocket(asyncore.dispatcher):
|
||||
|
||||
def __init__(self, address, file=None):
|
||||
class ConsoleSocket(socket.socket):
|
||||
"""
|
||||
ConsoleSocket represents a socket attached to a char device.
|
||||
|
||||
Optionally (if drain==True), drains the socket and places the bytes
|
||||
into an in memory buffer for later processing.
|
||||
|
||||
Optionally a file path can be passed in and we will also
|
||||
dump the characters to this file for debugging purposes.
|
||||
"""
|
||||
def __init__(self, address, file=None, drain=False):
|
||||
self._recv_timeout_sec = 300
|
||||
self._sleep_time = 0.5
|
||||
self._buffer = deque()
|
||||
self._asyncore_thread = None
|
||||
self._sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
|
||||
self._sock.connect(address)
|
||||
socket.socket.__init__(self, socket.AF_UNIX, socket.SOCK_STREAM)
|
||||
self.connect(address)
|
||||
self._logfile = None
|
||||
if file:
|
||||
self._logfile = open(file, "w")
|
||||
asyncore.dispatcher.__init__(self, sock=self._sock)
|
||||
self._open = True
|
||||
self._thread_start()
|
||||
if drain:
|
||||
self._drain_thread = self._thread_start()
|
||||
else:
|
||||
self._drain_thread = None
|
||||
|
||||
def _drain_fn(self):
|
||||
"""Drains the socket and runs while the socket is open."""
|
||||
while self._open:
|
||||
try:
|
||||
self._drain_socket()
|
||||
except socket.timeout:
|
||||
# The socket is expected to timeout since we set a
|
||||
# short timeout to allow the thread to exit when
|
||||
# self._open is set to False.
|
||||
time.sleep(self._sleep_time)
|
||||
|
||||
def _thread_start(self):
|
||||
"""Kick off a thread to wait on the asyncore.loop"""
|
||||
if self._asyncore_thread is not None:
|
||||
return
|
||||
self._asyncore_thread = threading.Thread(target=asyncore.loop,
|
||||
kwargs={'timeout':1})
|
||||
self._asyncore_thread.daemon = True
|
||||
self._asyncore_thread.start()
|
||||
|
||||
def handle_close(self):
|
||||
"""redirect close to base class"""
|
||||
# Call the base class close, but not self.close() since
|
||||
# handle_close() occurs in the context of the thread which
|
||||
# self.close() attempts to join.
|
||||
asyncore.dispatcher.close(self)
|
||||
"""Kick off a thread to drain the socket."""
|
||||
# Configure socket to not block and timeout.
|
||||
# This allows our drain thread to not block
|
||||
# on recieve and exit smoothly.
|
||||
socket.socket.setblocking(self, False)
|
||||
socket.socket.settimeout(self, 1)
|
||||
drain_thread = threading.Thread(target=self._drain_fn)
|
||||
drain_thread.daemon = True
|
||||
drain_thread.start()
|
||||
return drain_thread
|
||||
|
||||
def close(self):
|
||||
"""Close the base object and wait for the thread to terminate"""
|
||||
if self._open:
|
||||
self._open = False
|
||||
asyncore.dispatcher.close(self)
|
||||
if self._asyncore_thread is not None:
|
||||
thread, self._asyncore_thread = self._asyncore_thread, None
|
||||
if self._drain_thread is not None:
|
||||
thread, self._drain_thread = self._drain_thread, None
|
||||
thread.join()
|
||||
socket.socket.close(self)
|
||||
if self._logfile:
|
||||
self._logfile.close()
|
||||
self._logfile = None
|
||||
|
||||
def handle_read(self):
|
||||
def _drain_socket(self):
|
||||
"""process arriving characters into in memory _buffer"""
|
||||
try:
|
||||
data = asyncore.dispatcher.recv(self, 1)
|
||||
# latin1 is needed since there are some chars
|
||||
# we are receiving that cannot be encoded to utf-8
|
||||
# such as 0xe2, 0x80, 0xA6.
|
||||
string = data.decode("latin1")
|
||||
except:
|
||||
print("Exception seen.")
|
||||
traceback.print_exc()
|
||||
return
|
||||
data = socket.socket.recv(self, 1)
|
||||
# latin1 is needed since there are some chars
|
||||
# we are receiving that cannot be encoded to utf-8
|
||||
# such as 0xe2, 0x80, 0xA6.
|
||||
string = data.decode("latin1")
|
||||
if self._logfile:
|
||||
self._logfile.write("{}".format(string))
|
||||
self._logfile.flush()
|
||||
for c in string:
|
||||
self._buffer.extend(c)
|
||||
|
||||
def recv(self, n=1, sleep_delay_s=0.1):
|
||||
"""Return chars from in memory buffer"""
|
||||
def recv(self, bufsize=1):
|
||||
"""Return chars from in memory buffer.
|
||||
Maintains the same API as socket.socket.recv.
|
||||
"""
|
||||
if self._drain_thread is None:
|
||||
# Not buffering the socket, pass thru to socket.
|
||||
return socket.socket.recv(self, bufsize)
|
||||
start_time = time.time()
|
||||
while len(self._buffer) < n:
|
||||
time.sleep(sleep_delay_s)
|
||||
while len(self._buffer) < bufsize:
|
||||
time.sleep(self._sleep_time)
|
||||
elapsed_sec = time.time() - start_time
|
||||
if elapsed_sec > self._recv_timeout_sec:
|
||||
raise socket.timeout
|
||||
chars = ''.join([self._buffer.popleft() for i in range(n)])
|
||||
chars = ''.join([self._buffer.popleft() for i in range(bufsize)])
|
||||
# We choose to use latin1 to remain consistent with
|
||||
# handle_read() and give back the same data as the user would
|
||||
# receive if they were reading directly from the
|
||||
# socket w/o our intervention.
|
||||
return chars.encode("latin1")
|
||||
|
||||
def set_blocking(self):
|
||||
"""Maintain compatibility with socket API"""
|
||||
pass
|
||||
def setblocking(self, value):
|
||||
"""When not draining we pass thru to the socket,
|
||||
since when draining we control socket blocking.
|
||||
"""
|
||||
if self._drain_thread is None:
|
||||
socket.socket.setblocking(self, value)
|
||||
|
||||
def settimeout(self, seconds):
|
||||
"""Set current timeout on recv"""
|
||||
self._recv_timeout_sec = seconds
|
||||
"""When not draining we pass thru to the socket,
|
||||
since when draining we control the timeout.
|
||||
"""
|
||||
if seconds is not None:
|
||||
self._recv_timeout_sec = seconds
|
||||
if self._drain_thread is None:
|
||||
socket.socket.settimeout(self, seconds)
|
||||
|
||||
@ -23,11 +23,10 @@ import os
|
||||
import subprocess
|
||||
import shutil
|
||||
import signal
|
||||
import socket
|
||||
import tempfile
|
||||
from typing import Optional, Type
|
||||
from types import TracebackType
|
||||
from qemu.console_socket import ConsoleSocket
|
||||
from . import console_socket
|
||||
|
||||
from . import qmp
|
||||
|
||||
@ -673,11 +672,8 @@ class QEMUMachine:
|
||||
Returns a socket connected to the console
|
||||
"""
|
||||
if self._console_socket is None:
|
||||
if self._drain_console:
|
||||
self._console_socket = ConsoleSocket(self._console_address,
|
||||
file=self._console_log_path)
|
||||
else:
|
||||
self._console_socket = socket.socket(socket.AF_UNIX,
|
||||
socket.SOCK_STREAM)
|
||||
self._console_socket.connect(self._console_address)
|
||||
self._console_socket = console_socket.ConsoleSocket(
|
||||
self._console_address,
|
||||
file=self._console_log_path,
|
||||
drain=self._drain_console)
|
||||
return self._console_socket
|
||||
|
||||
@ -33,7 +33,7 @@ good-names=i,
|
||||
Run,
|
||||
_,
|
||||
fd,
|
||||
|
||||
c,
|
||||
[VARIABLES]
|
||||
|
||||
[STRING]
|
||||
|
||||
@ -4127,8 +4127,6 @@ void qemu_init(int argc, char **argv, char **envp)
|
||||
|
||||
qemu_opts_foreach(qemu_find_opts("chardev"),
|
||||
chardev_init_func, NULL, &error_fatal);
|
||||
/* now chardevs have been created we may have semihosting to connect */
|
||||
qemu_semihosting_connect_chardevs();
|
||||
|
||||
#ifdef CONFIG_VIRTFS
|
||||
qemu_opts_foreach(qemu_find_opts("fsdev"),
|
||||
@ -4279,6 +4277,9 @@ void qemu_init(int argc, char **argv, char **envp)
|
||||
if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
|
||||
exit(1);
|
||||
|
||||
/* now chardevs have been created we may have semihosting to connect */
|
||||
qemu_semihosting_connect_chardevs();
|
||||
|
||||
/* If no default VGA is requested, the default is "none". */
|
||||
if (default_vga) {
|
||||
vga_model = get_default_vga_model(machine_class);
|
||||
|
||||
@ -868,201 +868,201 @@ struct f2xm1_data {
|
||||
};
|
||||
|
||||
static const struct f2xm1_data f2xm1_table[65] = {
|
||||
{ make_floatx80(0xbfff, 0x8000000000000000ULL),
|
||||
make_floatx80(0x3ffe, 0x8000000000000000ULL),
|
||||
make_floatx80(0xbffe, 0x8000000000000000ULL) },
|
||||
{ make_floatx80(0xbffe, 0xf800000000002e7eULL),
|
||||
make_floatx80(0x3ffe, 0x82cd8698ac2b9160ULL),
|
||||
make_floatx80(0xbffd, 0xfa64f2cea7a8dd40ULL) },
|
||||
{ make_floatx80(0xbffe, 0xefffffffffffe960ULL),
|
||||
make_floatx80(0x3ffe, 0x85aac367cc488345ULL),
|
||||
make_floatx80(0xbffd, 0xf4aa7930676ef976ULL) },
|
||||
{ make_floatx80(0xbffe, 0xe800000000006f10ULL),
|
||||
make_floatx80(0x3ffe, 0x88980e8092da5c14ULL),
|
||||
make_floatx80(0xbffd, 0xeecfe2feda4b47d8ULL) },
|
||||
{ make_floatx80(0xbffe, 0xe000000000008a45ULL),
|
||||
make_floatx80(0x3ffe, 0x8b95c1e3ea8ba2a5ULL),
|
||||
make_floatx80(0xbffd, 0xe8d47c382ae8bab6ULL) },
|
||||
{ make_floatx80(0xbffe, 0xd7ffffffffff8a9eULL),
|
||||
make_floatx80(0x3ffe, 0x8ea4398b45cd8116ULL),
|
||||
make_floatx80(0xbffd, 0xe2b78ce97464fdd4ULL) },
|
||||
{ make_floatx80(0xbffe, 0xd0000000000019a0ULL),
|
||||
make_floatx80(0x3ffe, 0x91c3d373ab11b919ULL),
|
||||
make_floatx80(0xbffd, 0xdc785918a9dc8dceULL) },
|
||||
{ make_floatx80(0xbffe, 0xc7ffffffffff14dfULL),
|
||||
make_floatx80(0x3ffe, 0x94f4efa8fef76836ULL),
|
||||
make_floatx80(0xbffd, 0xd61620ae02112f94ULL) },
|
||||
{ make_floatx80(0xbffe, 0xc000000000006530ULL),
|
||||
make_floatx80(0x3ffe, 0x9837f0518db87fbbULL),
|
||||
make_floatx80(0xbffd, 0xcf901f5ce48f008aULL) },
|
||||
{ make_floatx80(0xbffe, 0xb7ffffffffff1723ULL),
|
||||
make_floatx80(0x3ffe, 0x9b8d39b9d54eb74cULL),
|
||||
make_floatx80(0xbffd, 0xc8e58c8c55629168ULL) },
|
||||
{ make_floatx80(0xbffe, 0xb00000000000b5e1ULL),
|
||||
make_floatx80(0x3ffe, 0x9ef5326091a0c366ULL),
|
||||
make_floatx80(0xbffd, 0xc2159b3edcbe7934ULL) },
|
||||
{ make_floatx80(0xbffe, 0xa800000000006f8aULL),
|
||||
make_floatx80(0x3ffe, 0xa27043030c49370aULL),
|
||||
make_floatx80(0xbffd, 0xbb1f79f9e76d91ecULL) },
|
||||
{ make_floatx80(0xbffe, 0x9fffffffffff816aULL),
|
||||
make_floatx80(0x3ffe, 0xa5fed6a9b15171cfULL),
|
||||
make_floatx80(0xbffd, 0xb40252ac9d5d1c62ULL) },
|
||||
{ make_floatx80(0xbffe, 0x97ffffffffffb621ULL),
|
||||
make_floatx80(0x3ffe, 0xa9a15ab4ea7c30e6ULL),
|
||||
make_floatx80(0xbffd, 0xacbd4a962b079e34ULL) },
|
||||
{ make_floatx80(0xbffe, 0x8fffffffffff162bULL),
|
||||
make_floatx80(0x3ffe, 0xad583eea42a1b886ULL),
|
||||
make_floatx80(0xbffd, 0xa54f822b7abc8ef4ULL) },
|
||||
{ make_floatx80(0xbffe, 0x87ffffffffff4d34ULL),
|
||||
make_floatx80(0x3ffe, 0xb123f581d2ac7b51ULL),
|
||||
make_floatx80(0xbffd, 0x9db814fc5aa7095eULL) },
|
||||
{ make_floatx80(0xbffe, 0x800000000000227dULL),
|
||||
make_floatx80(0x3ffe, 0xb504f333f9de539dULL),
|
||||
make_floatx80(0xbffd, 0x95f619980c4358c6ULL) },
|
||||
{ make_floatx80(0xbffd, 0xefffffffffff3978ULL),
|
||||
make_floatx80(0x3ffe, 0xb8fbaf4762fbd0a1ULL),
|
||||
make_floatx80(0xbffd, 0x8e08a1713a085ebeULL) },
|
||||
{ make_floatx80(0xbffd, 0xe00000000000df81ULL),
|
||||
make_floatx80(0x3ffe, 0xbd08a39f580bfd8cULL),
|
||||
make_floatx80(0xbffd, 0x85eeb8c14fe804e8ULL) },
|
||||
{ make_floatx80(0xbffd, 0xd00000000000bccfULL),
|
||||
make_floatx80(0x3ffe, 0xc12c4cca667062f6ULL),
|
||||
make_floatx80(0xbffc, 0xfb4eccd6663e7428ULL) },
|
||||
{ make_floatx80(0xbffd, 0xc00000000000eff0ULL),
|
||||
make_floatx80(0x3ffe, 0xc5672a1155069abeULL),
|
||||
make_floatx80(0xbffc, 0xea6357baabe59508ULL) },
|
||||
{ make_floatx80(0xbffd, 0xb000000000000fe6ULL),
|
||||
make_floatx80(0x3ffe, 0xc9b9bd866e2f234bULL),
|
||||
make_floatx80(0xbffc, 0xd91909e6474372d4ULL) },
|
||||
{ make_floatx80(0xbffd, 0x9fffffffffff2172ULL),
|
||||
make_floatx80(0x3ffe, 0xce248c151f84bf00ULL),
|
||||
make_floatx80(0xbffc, 0xc76dcfab81ed0400ULL) },
|
||||
{ make_floatx80(0xbffd, 0x8fffffffffffafffULL),
|
||||
make_floatx80(0x3ffe, 0xd2a81d91f12afb2bULL),
|
||||
make_floatx80(0xbffc, 0xb55f89b83b541354ULL) },
|
||||
{ make_floatx80(0xbffc, 0xffffffffffff81a3ULL),
|
||||
make_floatx80(0x3ffe, 0xd744fccad69d7d5eULL),
|
||||
make_floatx80(0xbffc, 0xa2ec0cd4a58a0a88ULL) },
|
||||
{ make_floatx80(0xbffc, 0xdfffffffffff1568ULL),
|
||||
make_floatx80(0x3ffe, 0xdbfbb797daf25a44ULL),
|
||||
make_floatx80(0xbffc, 0x901121a0943696f0ULL) },
|
||||
{ make_floatx80(0xbffc, 0xbfffffffffff68daULL),
|
||||
make_floatx80(0x3ffe, 0xe0ccdeec2a94f811ULL),
|
||||
make_floatx80(0xbffb, 0xf999089eab583f78ULL) },
|
||||
{ make_floatx80(0xbffc, 0x9fffffffffff4690ULL),
|
||||
make_floatx80(0x3ffe, 0xe5b906e77c83657eULL),
|
||||
make_floatx80(0xbffb, 0xd237c8c41be4d410ULL) },
|
||||
{ make_floatx80(0xbffb, 0xffffffffffff8aeeULL),
|
||||
make_floatx80(0x3ffe, 0xeac0c6e7dd24427cULL),
|
||||
make_floatx80(0xbffb, 0xa9f9c8c116ddec20ULL) },
|
||||
{ make_floatx80(0xbffb, 0xbfffffffffff2d18ULL),
|
||||
make_floatx80(0x3ffe, 0xefe4b99bdcdb06ebULL),
|
||||
make_floatx80(0xbffb, 0x80da33211927c8a8ULL) },
|
||||
{ make_floatx80(0xbffa, 0xffffffffffff8ccbULL),
|
||||
make_floatx80(0x3ffe, 0xf5257d152486d0f4ULL),
|
||||
make_floatx80(0xbffa, 0xada82eadb792f0c0ULL) },
|
||||
{ make_floatx80(0xbff9, 0xffffffffffff11feULL),
|
||||
make_floatx80(0x3ffe, 0xfa83b2db722a0846ULL),
|
||||
make_floatx80(0xbff9, 0xaf89a491babef740ULL) },
|
||||
{ floatx80_zero,
|
||||
make_floatx80(0x3fff, 0x8000000000000000ULL),
|
||||
floatx80_zero },
|
||||
{ make_floatx80(0x3ff9, 0xffffffffffff2680ULL),
|
||||
make_floatx80(0x3fff, 0x82cd8698ac2b9f6fULL),
|
||||
make_floatx80(0x3ff9, 0xb361a62b0ae7dbc0ULL) },
|
||||
{ make_floatx80(0x3ffb, 0x800000000000b500ULL),
|
||||
make_floatx80(0x3fff, 0x85aac367cc488345ULL),
|
||||
make_floatx80(0x3ffa, 0xb5586cf9891068a0ULL) },
|
||||
{ make_floatx80(0x3ffb, 0xbfffffffffff4b67ULL),
|
||||
make_floatx80(0x3fff, 0x88980e8092da7cceULL),
|
||||
make_floatx80(0x3ffb, 0x8980e8092da7cce0ULL) },
|
||||
{ make_floatx80(0x3ffb, 0xffffffffffffff57ULL),
|
||||
make_floatx80(0x3fff, 0x8b95c1e3ea8bd6dfULL),
|
||||
make_floatx80(0x3ffb, 0xb95c1e3ea8bd6df0ULL) },
|
||||
{ make_floatx80(0x3ffc, 0x9fffffffffff811fULL),
|
||||
make_floatx80(0x3fff, 0x8ea4398b45cd4780ULL),
|
||||
make_floatx80(0x3ffb, 0xea4398b45cd47800ULL) },
|
||||
{ make_floatx80(0x3ffc, 0xbfffffffffff9980ULL),
|
||||
make_floatx80(0x3fff, 0x91c3d373ab11b919ULL),
|
||||
make_floatx80(0x3ffc, 0x8e1e9b9d588dc8c8ULL) },
|
||||
{ make_floatx80(0x3ffc, 0xdffffffffffff631ULL),
|
||||
make_floatx80(0x3fff, 0x94f4efa8fef70864ULL),
|
||||
make_floatx80(0x3ffc, 0xa7a77d47f7b84320ULL) },
|
||||
{ make_floatx80(0x3ffc, 0xffffffffffff2499ULL),
|
||||
make_floatx80(0x3fff, 0x9837f0518db892d4ULL),
|
||||
make_floatx80(0x3ffc, 0xc1bf828c6dc496a0ULL) },
|
||||
{ make_floatx80(0x3ffd, 0x8fffffffffff80fbULL),
|
||||
make_floatx80(0x3fff, 0x9b8d39b9d54e3a79ULL),
|
||||
make_floatx80(0x3ffc, 0xdc69cdceaa71d3c8ULL) },
|
||||
{ make_floatx80(0x3ffd, 0x9fffffffffffbc23ULL),
|
||||
make_floatx80(0x3fff, 0x9ef5326091a10313ULL),
|
||||
make_floatx80(0x3ffc, 0xf7a993048d081898ULL) },
|
||||
{ make_floatx80(0x3ffd, 0xafffffffffff20ecULL),
|
||||
make_floatx80(0x3fff, 0xa27043030c49370aULL),
|
||||
make_floatx80(0x3ffd, 0x89c10c0c3124dc28ULL) },
|
||||
{ make_floatx80(0x3ffd, 0xc00000000000fd2cULL),
|
||||
make_floatx80(0x3fff, 0xa5fed6a9b15171cfULL),
|
||||
make_floatx80(0x3ffd, 0x97fb5aa6c545c73cULL) },
|
||||
{ make_floatx80(0x3ffd, 0xd0000000000093beULL),
|
||||
make_floatx80(0x3fff, 0xa9a15ab4ea7c30e6ULL),
|
||||
make_floatx80(0x3ffd, 0xa6856ad3a9f0c398ULL) },
|
||||
{ make_floatx80(0x3ffd, 0xe00000000000c2aeULL),
|
||||
make_floatx80(0x3fff, 0xad583eea42a17876ULL),
|
||||
make_floatx80(0x3ffd, 0xb560fba90a85e1d8ULL) },
|
||||
{ make_floatx80(0x3ffd, 0xefffffffffff1e3fULL),
|
||||
make_floatx80(0x3fff, 0xb123f581d2abef6cULL),
|
||||
make_floatx80(0x3ffd, 0xc48fd6074aafbdb0ULL) },
|
||||
{ make_floatx80(0x3ffd, 0xffffffffffff1c23ULL),
|
||||
make_floatx80(0x3fff, 0xb504f333f9de2cadULL),
|
||||
make_floatx80(0x3ffd, 0xd413cccfe778b2b4ULL) },
|
||||
{ make_floatx80(0x3ffe, 0x8800000000006344ULL),
|
||||
make_floatx80(0x3fff, 0xb8fbaf4762fbd0a1ULL),
|
||||
make_floatx80(0x3ffd, 0xe3eebd1d8bef4284ULL) },
|
||||
{ make_floatx80(0x3ffe, 0x9000000000005d67ULL),
|
||||
make_floatx80(0x3fff, 0xbd08a39f580c668dULL),
|
||||
make_floatx80(0x3ffd, 0xf4228e7d60319a34ULL) },
|
||||
{ make_floatx80(0x3ffe, 0x9800000000009127ULL),
|
||||
make_floatx80(0x3fff, 0xc12c4cca6670e042ULL),
|
||||
make_floatx80(0x3ffe, 0x82589994cce1c084ULL) },
|
||||
{ make_floatx80(0x3ffe, 0x9fffffffffff06f9ULL),
|
||||
make_floatx80(0x3fff, 0xc5672a11550655c3ULL),
|
||||
make_floatx80(0x3ffe, 0x8ace5422aa0cab86ULL) },
|
||||
{ make_floatx80(0x3ffe, 0xa7fffffffffff80dULL),
|
||||
make_floatx80(0x3fff, 0xc9b9bd866e2f234bULL),
|
||||
make_floatx80(0x3ffe, 0x93737b0cdc5e4696ULL) },
|
||||
{ make_floatx80(0x3ffe, 0xafffffffffff1470ULL),
|
||||
make_floatx80(0x3fff, 0xce248c151f83fd69ULL),
|
||||
make_floatx80(0x3ffe, 0x9c49182a3f07fad2ULL) },
|
||||
{ make_floatx80(0x3ffe, 0xb800000000000e0aULL),
|
||||
make_floatx80(0x3fff, 0xd2a81d91f12aec5cULL),
|
||||
make_floatx80(0x3ffe, 0xa5503b23e255d8b8ULL) },
|
||||
{ make_floatx80(0x3ffe, 0xc00000000000b7faULL),
|
||||
make_floatx80(0x3fff, 0xd744fccad69dd630ULL),
|
||||
make_floatx80(0x3ffe, 0xae89f995ad3bac60ULL) },
|
||||
{ make_floatx80(0x3ffe, 0xc800000000003aa6ULL),
|
||||
make_floatx80(0x3fff, 0xdbfbb797daf25a44ULL),
|
||||
make_floatx80(0x3ffe, 0xb7f76f2fb5e4b488ULL) },
|
||||
{ make_floatx80(0x3ffe, 0xd00000000000a6aeULL),
|
||||
make_floatx80(0x3fff, 0xe0ccdeec2a954685ULL),
|
||||
make_floatx80(0x3ffe, 0xc199bdd8552a8d0aULL) },
|
||||
{ make_floatx80(0x3ffe, 0xd800000000004165ULL),
|
||||
make_floatx80(0x3fff, 0xe5b906e77c837155ULL),
|
||||
make_floatx80(0x3ffe, 0xcb720dcef906e2aaULL) },
|
||||
{ make_floatx80(0x3ffe, 0xe00000000000582cULL),
|
||||
make_floatx80(0x3fff, 0xeac0c6e7dd24713aULL),
|
||||
make_floatx80(0x3ffe, 0xd5818dcfba48e274ULL) },
|
||||
{ make_floatx80(0x3ffe, 0xe800000000001a5dULL),
|
||||
make_floatx80(0x3fff, 0xefe4b99bdcdb06ebULL),
|
||||
make_floatx80(0x3ffe, 0xdfc97337b9b60dd6ULL) },
|
||||
{ make_floatx80(0x3ffe, 0xefffffffffffc1efULL),
|
||||
make_floatx80(0x3fff, 0xf5257d152486a2faULL),
|
||||
make_floatx80(0x3ffe, 0xea4afa2a490d45f4ULL) },
|
||||
{ make_floatx80(0x3ffe, 0xf800000000001069ULL),
|
||||
make_floatx80(0x3fff, 0xfa83b2db722a0e5cULL),
|
||||
make_floatx80(0x3ffe, 0xf50765b6e4541cb8ULL) },
|
||||
{ make_floatx80(0x3fff, 0x8000000000000000ULL),
|
||||
make_floatx80(0x4000, 0x8000000000000000ULL),
|
||||
make_floatx80(0x3fff, 0x8000000000000000ULL) },
|
||||
{ make_floatx80_init(0xbfff, 0x8000000000000000ULL),
|
||||
make_floatx80_init(0x3ffe, 0x8000000000000000ULL),
|
||||
make_floatx80_init(0xbffe, 0x8000000000000000ULL) },
|
||||
{ make_floatx80_init(0xbffe, 0xf800000000002e7eULL),
|
||||
make_floatx80_init(0x3ffe, 0x82cd8698ac2b9160ULL),
|
||||
make_floatx80_init(0xbffd, 0xfa64f2cea7a8dd40ULL) },
|
||||
{ make_floatx80_init(0xbffe, 0xefffffffffffe960ULL),
|
||||
make_floatx80_init(0x3ffe, 0x85aac367cc488345ULL),
|
||||
make_floatx80_init(0xbffd, 0xf4aa7930676ef976ULL) },
|
||||
{ make_floatx80_init(0xbffe, 0xe800000000006f10ULL),
|
||||
make_floatx80_init(0x3ffe, 0x88980e8092da5c14ULL),
|
||||
make_floatx80_init(0xbffd, 0xeecfe2feda4b47d8ULL) },
|
||||
{ make_floatx80_init(0xbffe, 0xe000000000008a45ULL),
|
||||
make_floatx80_init(0x3ffe, 0x8b95c1e3ea8ba2a5ULL),
|
||||
make_floatx80_init(0xbffd, 0xe8d47c382ae8bab6ULL) },
|
||||
{ make_floatx80_init(0xbffe, 0xd7ffffffffff8a9eULL),
|
||||
make_floatx80_init(0x3ffe, 0x8ea4398b45cd8116ULL),
|
||||
make_floatx80_init(0xbffd, 0xe2b78ce97464fdd4ULL) },
|
||||
{ make_floatx80_init(0xbffe, 0xd0000000000019a0ULL),
|
||||
make_floatx80_init(0x3ffe, 0x91c3d373ab11b919ULL),
|
||||
make_floatx80_init(0xbffd, 0xdc785918a9dc8dceULL) },
|
||||
{ make_floatx80_init(0xbffe, 0xc7ffffffffff14dfULL),
|
||||
make_floatx80_init(0x3ffe, 0x94f4efa8fef76836ULL),
|
||||
make_floatx80_init(0xbffd, 0xd61620ae02112f94ULL) },
|
||||
{ make_floatx80_init(0xbffe, 0xc000000000006530ULL),
|
||||
make_floatx80_init(0x3ffe, 0x9837f0518db87fbbULL),
|
||||
make_floatx80_init(0xbffd, 0xcf901f5ce48f008aULL) },
|
||||
{ make_floatx80_init(0xbffe, 0xb7ffffffffff1723ULL),
|
||||
make_floatx80_init(0x3ffe, 0x9b8d39b9d54eb74cULL),
|
||||
make_floatx80_init(0xbffd, 0xc8e58c8c55629168ULL) },
|
||||
{ make_floatx80_init(0xbffe, 0xb00000000000b5e1ULL),
|
||||
make_floatx80_init(0x3ffe, 0x9ef5326091a0c366ULL),
|
||||
make_floatx80_init(0xbffd, 0xc2159b3edcbe7934ULL) },
|
||||
{ make_floatx80_init(0xbffe, 0xa800000000006f8aULL),
|
||||
make_floatx80_init(0x3ffe, 0xa27043030c49370aULL),
|
||||
make_floatx80_init(0xbffd, 0xbb1f79f9e76d91ecULL) },
|
||||
{ make_floatx80_init(0xbffe, 0x9fffffffffff816aULL),
|
||||
make_floatx80_init(0x3ffe, 0xa5fed6a9b15171cfULL),
|
||||
make_floatx80_init(0xbffd, 0xb40252ac9d5d1c62ULL) },
|
||||
{ make_floatx80_init(0xbffe, 0x97ffffffffffb621ULL),
|
||||
make_floatx80_init(0x3ffe, 0xa9a15ab4ea7c30e6ULL),
|
||||
make_floatx80_init(0xbffd, 0xacbd4a962b079e34ULL) },
|
||||
{ make_floatx80_init(0xbffe, 0x8fffffffffff162bULL),
|
||||
make_floatx80_init(0x3ffe, 0xad583eea42a1b886ULL),
|
||||
make_floatx80_init(0xbffd, 0xa54f822b7abc8ef4ULL) },
|
||||
{ make_floatx80_init(0xbffe, 0x87ffffffffff4d34ULL),
|
||||
make_floatx80_init(0x3ffe, 0xb123f581d2ac7b51ULL),
|
||||
make_floatx80_init(0xbffd, 0x9db814fc5aa7095eULL) },
|
||||
{ make_floatx80_init(0xbffe, 0x800000000000227dULL),
|
||||
make_floatx80_init(0x3ffe, 0xb504f333f9de539dULL),
|
||||
make_floatx80_init(0xbffd, 0x95f619980c4358c6ULL) },
|
||||
{ make_floatx80_init(0xbffd, 0xefffffffffff3978ULL),
|
||||
make_floatx80_init(0x3ffe, 0xb8fbaf4762fbd0a1ULL),
|
||||
make_floatx80_init(0xbffd, 0x8e08a1713a085ebeULL) },
|
||||
{ make_floatx80_init(0xbffd, 0xe00000000000df81ULL),
|
||||
make_floatx80_init(0x3ffe, 0xbd08a39f580bfd8cULL),
|
||||
make_floatx80_init(0xbffd, 0x85eeb8c14fe804e8ULL) },
|
||||
{ make_floatx80_init(0xbffd, 0xd00000000000bccfULL),
|
||||
make_floatx80_init(0x3ffe, 0xc12c4cca667062f6ULL),
|
||||
make_floatx80_init(0xbffc, 0xfb4eccd6663e7428ULL) },
|
||||
{ make_floatx80_init(0xbffd, 0xc00000000000eff0ULL),
|
||||
make_floatx80_init(0x3ffe, 0xc5672a1155069abeULL),
|
||||
make_floatx80_init(0xbffc, 0xea6357baabe59508ULL) },
|
||||
{ make_floatx80_init(0xbffd, 0xb000000000000fe6ULL),
|
||||
make_floatx80_init(0x3ffe, 0xc9b9bd866e2f234bULL),
|
||||
make_floatx80_init(0xbffc, 0xd91909e6474372d4ULL) },
|
||||
{ make_floatx80_init(0xbffd, 0x9fffffffffff2172ULL),
|
||||
make_floatx80_init(0x3ffe, 0xce248c151f84bf00ULL),
|
||||
make_floatx80_init(0xbffc, 0xc76dcfab81ed0400ULL) },
|
||||
{ make_floatx80_init(0xbffd, 0x8fffffffffffafffULL),
|
||||
make_floatx80_init(0x3ffe, 0xd2a81d91f12afb2bULL),
|
||||
make_floatx80_init(0xbffc, 0xb55f89b83b541354ULL) },
|
||||
{ make_floatx80_init(0xbffc, 0xffffffffffff81a3ULL),
|
||||
make_floatx80_init(0x3ffe, 0xd744fccad69d7d5eULL),
|
||||
make_floatx80_init(0xbffc, 0xa2ec0cd4a58a0a88ULL) },
|
||||
{ make_floatx80_init(0xbffc, 0xdfffffffffff1568ULL),
|
||||
make_floatx80_init(0x3ffe, 0xdbfbb797daf25a44ULL),
|
||||
make_floatx80_init(0xbffc, 0x901121a0943696f0ULL) },
|
||||
{ make_floatx80_init(0xbffc, 0xbfffffffffff68daULL),
|
||||
make_floatx80_init(0x3ffe, 0xe0ccdeec2a94f811ULL),
|
||||
make_floatx80_init(0xbffb, 0xf999089eab583f78ULL) },
|
||||
{ make_floatx80_init(0xbffc, 0x9fffffffffff4690ULL),
|
||||
make_floatx80_init(0x3ffe, 0xe5b906e77c83657eULL),
|
||||
make_floatx80_init(0xbffb, 0xd237c8c41be4d410ULL) },
|
||||
{ make_floatx80_init(0xbffb, 0xffffffffffff8aeeULL),
|
||||
make_floatx80_init(0x3ffe, 0xeac0c6e7dd24427cULL),
|
||||
make_floatx80_init(0xbffb, 0xa9f9c8c116ddec20ULL) },
|
||||
{ make_floatx80_init(0xbffb, 0xbfffffffffff2d18ULL),
|
||||
make_floatx80_init(0x3ffe, 0xefe4b99bdcdb06ebULL),
|
||||
make_floatx80_init(0xbffb, 0x80da33211927c8a8ULL) },
|
||||
{ make_floatx80_init(0xbffa, 0xffffffffffff8ccbULL),
|
||||
make_floatx80_init(0x3ffe, 0xf5257d152486d0f4ULL),
|
||||
make_floatx80_init(0xbffa, 0xada82eadb792f0c0ULL) },
|
||||
{ make_floatx80_init(0xbff9, 0xffffffffffff11feULL),
|
||||
make_floatx80_init(0x3ffe, 0xfa83b2db722a0846ULL),
|
||||
make_floatx80_init(0xbff9, 0xaf89a491babef740ULL) },
|
||||
{ floatx80_zero_init,
|
||||
make_floatx80_init(0x3fff, 0x8000000000000000ULL),
|
||||
floatx80_zero_init },
|
||||
{ make_floatx80_init(0x3ff9, 0xffffffffffff2680ULL),
|
||||
make_floatx80_init(0x3fff, 0x82cd8698ac2b9f6fULL),
|
||||
make_floatx80_init(0x3ff9, 0xb361a62b0ae7dbc0ULL) },
|
||||
{ make_floatx80_init(0x3ffb, 0x800000000000b500ULL),
|
||||
make_floatx80_init(0x3fff, 0x85aac367cc488345ULL),
|
||||
make_floatx80_init(0x3ffa, 0xb5586cf9891068a0ULL) },
|
||||
{ make_floatx80_init(0x3ffb, 0xbfffffffffff4b67ULL),
|
||||
make_floatx80_init(0x3fff, 0x88980e8092da7cceULL),
|
||||
make_floatx80_init(0x3ffb, 0x8980e8092da7cce0ULL) },
|
||||
{ make_floatx80_init(0x3ffb, 0xffffffffffffff57ULL),
|
||||
make_floatx80_init(0x3fff, 0x8b95c1e3ea8bd6dfULL),
|
||||
make_floatx80_init(0x3ffb, 0xb95c1e3ea8bd6df0ULL) },
|
||||
{ make_floatx80_init(0x3ffc, 0x9fffffffffff811fULL),
|
||||
make_floatx80_init(0x3fff, 0x8ea4398b45cd4780ULL),
|
||||
make_floatx80_init(0x3ffb, 0xea4398b45cd47800ULL) },
|
||||
{ make_floatx80_init(0x3ffc, 0xbfffffffffff9980ULL),
|
||||
make_floatx80_init(0x3fff, 0x91c3d373ab11b919ULL),
|
||||
make_floatx80_init(0x3ffc, 0x8e1e9b9d588dc8c8ULL) },
|
||||
{ make_floatx80_init(0x3ffc, 0xdffffffffffff631ULL),
|
||||
make_floatx80_init(0x3fff, 0x94f4efa8fef70864ULL),
|
||||
make_floatx80_init(0x3ffc, 0xa7a77d47f7b84320ULL) },
|
||||
{ make_floatx80_init(0x3ffc, 0xffffffffffff2499ULL),
|
||||
make_floatx80_init(0x3fff, 0x9837f0518db892d4ULL),
|
||||
make_floatx80_init(0x3ffc, 0xc1bf828c6dc496a0ULL) },
|
||||
{ make_floatx80_init(0x3ffd, 0x8fffffffffff80fbULL),
|
||||
make_floatx80_init(0x3fff, 0x9b8d39b9d54e3a79ULL),
|
||||
make_floatx80_init(0x3ffc, 0xdc69cdceaa71d3c8ULL) },
|
||||
{ make_floatx80_init(0x3ffd, 0x9fffffffffffbc23ULL),
|
||||
make_floatx80_init(0x3fff, 0x9ef5326091a10313ULL),
|
||||
make_floatx80_init(0x3ffc, 0xf7a993048d081898ULL) },
|
||||
{ make_floatx80_init(0x3ffd, 0xafffffffffff20ecULL),
|
||||
make_floatx80_init(0x3fff, 0xa27043030c49370aULL),
|
||||
make_floatx80_init(0x3ffd, 0x89c10c0c3124dc28ULL) },
|
||||
{ make_floatx80_init(0x3ffd, 0xc00000000000fd2cULL),
|
||||
make_floatx80_init(0x3fff, 0xa5fed6a9b15171cfULL),
|
||||
make_floatx80_init(0x3ffd, 0x97fb5aa6c545c73cULL) },
|
||||
{ make_floatx80_init(0x3ffd, 0xd0000000000093beULL),
|
||||
make_floatx80_init(0x3fff, 0xa9a15ab4ea7c30e6ULL),
|
||||
make_floatx80_init(0x3ffd, 0xa6856ad3a9f0c398ULL) },
|
||||
{ make_floatx80_init(0x3ffd, 0xe00000000000c2aeULL),
|
||||
make_floatx80_init(0x3fff, 0xad583eea42a17876ULL),
|
||||
make_floatx80_init(0x3ffd, 0xb560fba90a85e1d8ULL) },
|
||||
{ make_floatx80_init(0x3ffd, 0xefffffffffff1e3fULL),
|
||||
make_floatx80_init(0x3fff, 0xb123f581d2abef6cULL),
|
||||
make_floatx80_init(0x3ffd, 0xc48fd6074aafbdb0ULL) },
|
||||
{ make_floatx80_init(0x3ffd, 0xffffffffffff1c23ULL),
|
||||
make_floatx80_init(0x3fff, 0xb504f333f9de2cadULL),
|
||||
make_floatx80_init(0x3ffd, 0xd413cccfe778b2b4ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0x8800000000006344ULL),
|
||||
make_floatx80_init(0x3fff, 0xb8fbaf4762fbd0a1ULL),
|
||||
make_floatx80_init(0x3ffd, 0xe3eebd1d8bef4284ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0x9000000000005d67ULL),
|
||||
make_floatx80_init(0x3fff, 0xbd08a39f580c668dULL),
|
||||
make_floatx80_init(0x3ffd, 0xf4228e7d60319a34ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0x9800000000009127ULL),
|
||||
make_floatx80_init(0x3fff, 0xc12c4cca6670e042ULL),
|
||||
make_floatx80_init(0x3ffe, 0x82589994cce1c084ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0x9fffffffffff06f9ULL),
|
||||
make_floatx80_init(0x3fff, 0xc5672a11550655c3ULL),
|
||||
make_floatx80_init(0x3ffe, 0x8ace5422aa0cab86ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0xa7fffffffffff80dULL),
|
||||
make_floatx80_init(0x3fff, 0xc9b9bd866e2f234bULL),
|
||||
make_floatx80_init(0x3ffe, 0x93737b0cdc5e4696ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0xafffffffffff1470ULL),
|
||||
make_floatx80_init(0x3fff, 0xce248c151f83fd69ULL),
|
||||
make_floatx80_init(0x3ffe, 0x9c49182a3f07fad2ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0xb800000000000e0aULL),
|
||||
make_floatx80_init(0x3fff, 0xd2a81d91f12aec5cULL),
|
||||
make_floatx80_init(0x3ffe, 0xa5503b23e255d8b8ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0xc00000000000b7faULL),
|
||||
make_floatx80_init(0x3fff, 0xd744fccad69dd630ULL),
|
||||
make_floatx80_init(0x3ffe, 0xae89f995ad3bac60ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0xc800000000003aa6ULL),
|
||||
make_floatx80_init(0x3fff, 0xdbfbb797daf25a44ULL),
|
||||
make_floatx80_init(0x3ffe, 0xb7f76f2fb5e4b488ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0xd00000000000a6aeULL),
|
||||
make_floatx80_init(0x3fff, 0xe0ccdeec2a954685ULL),
|
||||
make_floatx80_init(0x3ffe, 0xc199bdd8552a8d0aULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0xd800000000004165ULL),
|
||||
make_floatx80_init(0x3fff, 0xe5b906e77c837155ULL),
|
||||
make_floatx80_init(0x3ffe, 0xcb720dcef906e2aaULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0xe00000000000582cULL),
|
||||
make_floatx80_init(0x3fff, 0xeac0c6e7dd24713aULL),
|
||||
make_floatx80_init(0x3ffe, 0xd5818dcfba48e274ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0xe800000000001a5dULL),
|
||||
make_floatx80_init(0x3fff, 0xefe4b99bdcdb06ebULL),
|
||||
make_floatx80_init(0x3ffe, 0xdfc97337b9b60dd6ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0xefffffffffffc1efULL),
|
||||
make_floatx80_init(0x3fff, 0xf5257d152486a2faULL),
|
||||
make_floatx80_init(0x3ffe, 0xea4afa2a490d45f4ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0xf800000000001069ULL),
|
||||
make_floatx80_init(0x3fff, 0xfa83b2db722a0e5cULL),
|
||||
make_floatx80_init(0x3ffe, 0xf50765b6e4541cb8ULL) },
|
||||
{ make_floatx80_init(0x3fff, 0x8000000000000000ULL),
|
||||
make_floatx80_init(0x4000, 0x8000000000000000ULL),
|
||||
make_floatx80_init(0x3fff, 0x8000000000000000ULL) },
|
||||
};
|
||||
|
||||
void helper_f2xm1(CPUX86State *env)
|
||||
@ -1275,24 +1275,24 @@ struct fpatan_data {
|
||||
};
|
||||
|
||||
static const struct fpatan_data fpatan_table[9] = {
|
||||
{ floatx80_zero,
|
||||
floatx80_zero },
|
||||
{ make_floatx80(0x3ffb, 0xfeadd4d5617b6e33ULL),
|
||||
make_floatx80(0xbfb9, 0xdda19d8305ddc420ULL) },
|
||||
{ make_floatx80(0x3ffc, 0xfadbafc96406eb15ULL),
|
||||
make_floatx80(0x3fbb, 0xdb8f3debef442fccULL) },
|
||||
{ make_floatx80(0x3ffd, 0xb7b0ca0f26f78474ULL),
|
||||
make_floatx80(0xbfbc, 0xeab9bdba460376faULL) },
|
||||
{ make_floatx80(0x3ffd, 0xed63382b0dda7b45ULL),
|
||||
make_floatx80(0x3fbc, 0xdfc88bd978751a06ULL) },
|
||||
{ make_floatx80(0x3ffe, 0x8f005d5ef7f59f9bULL),
|
||||
make_floatx80(0x3fbd, 0xb906bc2ccb886e90ULL) },
|
||||
{ make_floatx80(0x3ffe, 0xa4bc7d1934f70924ULL),
|
||||
make_floatx80(0x3fbb, 0xcd43f9522bed64f8ULL) },
|
||||
{ make_floatx80(0x3ffe, 0xb8053e2bc2319e74ULL),
|
||||
make_floatx80(0xbfbc, 0xd3496ab7bd6eef0cULL) },
|
||||
{ make_floatx80(0x3ffe, 0xc90fdaa22168c235ULL),
|
||||
make_floatx80(0xbfbc, 0xece675d1fc8f8cbcULL) },
|
||||
{ floatx80_zero_init,
|
||||
floatx80_zero_init },
|
||||
{ make_floatx80_init(0x3ffb, 0xfeadd4d5617b6e33ULL),
|
||||
make_floatx80_init(0xbfb9, 0xdda19d8305ddc420ULL) },
|
||||
{ make_floatx80_init(0x3ffc, 0xfadbafc96406eb15ULL),
|
||||
make_floatx80_init(0x3fbb, 0xdb8f3debef442fccULL) },
|
||||
{ make_floatx80_init(0x3ffd, 0xb7b0ca0f26f78474ULL),
|
||||
make_floatx80_init(0xbfbc, 0xeab9bdba460376faULL) },
|
||||
{ make_floatx80_init(0x3ffd, 0xed63382b0dda7b45ULL),
|
||||
make_floatx80_init(0x3fbc, 0xdfc88bd978751a06ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0x8f005d5ef7f59f9bULL),
|
||||
make_floatx80_init(0x3fbd, 0xb906bc2ccb886e90ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0xa4bc7d1934f70924ULL),
|
||||
make_floatx80_init(0x3fbb, 0xcd43f9522bed64f8ULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0xb8053e2bc2319e74ULL),
|
||||
make_floatx80_init(0xbfbc, 0xd3496ab7bd6eef0cULL) },
|
||||
{ make_floatx80_init(0x3ffe, 0xc90fdaa22168c235ULL),
|
||||
make_floatx80_init(0xbfbc, 0xece675d1fc8f8cbcULL) },
|
||||
};
|
||||
|
||||
void helper_fpatan(CPUX86State *env)
|
||||
|
||||
@ -78,7 +78,7 @@ docker-binfmt-image-debian-%: $(DOCKER_FILES_DIR)/debian-bootstrap.docker
|
||||
DEB_ARCH=$(DEB_ARCH) \
|
||||
DEB_TYPE=$(DEB_TYPE) \
|
||||
$(if $(DEB_URL),DEB_URL=$(DEB_URL),) \
|
||||
$(DOCKER_SCRIPT) build qemu/debian-$* $< \
|
||||
$(DOCKER_SCRIPT) build -t qemu/debian-$* -f $< \
|
||||
$(if $V,,--quiet) $(if $(NOCACHE),--no-cache) \
|
||||
$(if $(NOUSER),,--add-current-user) \
|
||||
$(if $(EXTRA_FILES),--extra-files $(EXTRA_FILES)) \
|
||||
|
||||
@ -24,7 +24,7 @@ import tempfile
|
||||
import re
|
||||
import signal
|
||||
from tarfile import TarFile, TarInfo
|
||||
from io import StringIO
|
||||
from io import StringIO, BytesIO
|
||||
from shutil import copy, rmtree
|
||||
from pwd import getpwuid
|
||||
from datetime import datetime, timedelta
|
||||
@ -541,13 +541,14 @@ class UpdateCommand(SubCommand):
|
||||
|
||||
# Create a Docker buildfile
|
||||
df = StringIO()
|
||||
df.write("FROM %s\n" % args.tag)
|
||||
df.write("ADD . /\n")
|
||||
df.seek(0)
|
||||
df.write(u"FROM %s\n" % args.tag)
|
||||
df.write(u"ADD . /\n")
|
||||
|
||||
df_bytes = BytesIO(bytes(df.getvalue(), "UTF-8"))
|
||||
|
||||
df_tar = TarInfo(name="Dockerfile")
|
||||
df_tar.size = len(df.buf)
|
||||
tmp_tar.addfile(df_tar, fileobj=df)
|
||||
df_tar.size = df_bytes.getbuffer().nbytes
|
||||
tmp_tar.addfile(df_tar, fileobj=df_bytes)
|
||||
|
||||
tmp_tar.close()
|
||||
|
||||
|
||||
@ -79,6 +79,13 @@ else
|
||||
fi
|
||||
fi
|
||||
|
||||
#
|
||||
# Add optional args
|
||||
#
|
||||
if [ -n "${DEB_KEYRING}" ]; then
|
||||
DEBOOTSTRAP="${DEBOOTSTRAP} --keyring=${DEB_KEYRING}"
|
||||
fi
|
||||
|
||||
#
|
||||
# Finally check to see if any qemu's are installed
|
||||
#
|
||||
|
||||
@ -80,6 +80,8 @@ class BaseVM(object):
|
||||
arch = "#arch"
|
||||
# command to halt the guest, can be overridden by subclasses
|
||||
poweroff = "poweroff"
|
||||
# Time to wait for shutdown to finish.
|
||||
shutdown_timeout_default = 30
|
||||
# enable IPv6 networking
|
||||
ipv6 = True
|
||||
# This is the timeout on the wait for console bytes.
|
||||
@ -87,7 +89,7 @@ class BaseVM(object):
|
||||
# Scale up some timeouts under TCG.
|
||||
# 4 is arbitrary, but greater than 2,
|
||||
# since we found we need to wait more than twice as long.
|
||||
tcg_ssh_timeout_multiplier = 4
|
||||
tcg_timeout_multiplier = 4
|
||||
def __init__(self, args, config=None):
|
||||
self._guest = None
|
||||
self._genisoimage = args.genisoimage
|
||||
@ -141,9 +143,12 @@ class BaseVM(object):
|
||||
if args.jobs and args.jobs > 1:
|
||||
self._args += ["-smp", "%d" % args.jobs]
|
||||
if kvm_available(self.arch):
|
||||
self._shutdown_timeout = self.shutdown_timeout_default
|
||||
self._args += ["-enable-kvm"]
|
||||
else:
|
||||
logging.info("KVM not available, not using -enable-kvm")
|
||||
self._shutdown_timeout = \
|
||||
self.shutdown_timeout_default * self.tcg_timeout_multiplier
|
||||
self._data_args = []
|
||||
|
||||
if self._config['qemu_args'] != None:
|
||||
@ -423,7 +428,7 @@ class BaseVM(object):
|
||||
def wait_ssh(self, wait_root=False, seconds=300, cmd="exit 0"):
|
||||
# Allow more time for VM to boot under TCG.
|
||||
if not kvm_available(self.arch):
|
||||
seconds *= self.tcg_ssh_timeout_multiplier
|
||||
seconds *= self.tcg_timeout_multiplier
|
||||
starttime = datetime.datetime.now()
|
||||
endtime = starttime + datetime.timedelta(seconds=seconds)
|
||||
cmd_success = False
|
||||
@ -441,14 +446,14 @@ class BaseVM(object):
|
||||
raise Exception("Timeout while waiting for guest ssh")
|
||||
|
||||
def shutdown(self):
|
||||
self._guest.shutdown()
|
||||
self._guest.shutdown(timeout=self._shutdown_timeout)
|
||||
|
||||
def wait(self):
|
||||
self._guest.wait()
|
||||
self._guest.wait(timeout=self._shutdown_timeout)
|
||||
|
||||
def graceful_shutdown(self):
|
||||
self.ssh_root(self.poweroff)
|
||||
self._guest.wait()
|
||||
self._guest.wait(timeout=self._shutdown_timeout)
|
||||
|
||||
def qmp(self, *args, **kwargs):
|
||||
return self._guest.qmp(*args, **kwargs)
|
||||
|
||||
@ -841,3 +841,18 @@ char *qemu_get_host_name(Error **errp)
|
||||
|
||||
return g_steal_pointer(&hostname);
|
||||
}
|
||||
|
||||
size_t qemu_get_host_physmem(void)
|
||||
{
|
||||
#ifdef _SC_PHYS_PAGES
|
||||
long pages = sysconf(_SC_PHYS_PAGES);
|
||||
if (pages > 0) {
|
||||
if (pages > SIZE_MAX / qemu_real_host_page_size) {
|
||||
return SIZE_MAX;
|
||||
} else {
|
||||
return pages * qemu_real_host_page_size;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -828,3 +828,14 @@ char *qemu_get_host_name(Error **errp)
|
||||
|
||||
return g_utf16_to_utf8(tmp, size, NULL, NULL, NULL);
|
||||
}
|
||||
|
||||
size_t qemu_get_host_physmem(void)
|
||||
{
|
||||
MEMORYSTATUSEX statex;
|
||||
statex.dwLength = sizeof(statex);
|
||||
|
||||
if (GlobalMemoryStatusEx(&statex)) {
|
||||
return statex.ullTotalPhys;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user