mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Various fixes for rc2:

Browse Source 
- 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 2020-07-27 15:55:56 +01:00
commit cb320a07e6
18 changed files with 390 additions and 311 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.shippable.yml
View File

@ -27,7 +27,7 @@ env:
TARGET_LIST=ppc64-softmmu,ppc64-linux-user,ppc64abi32-linux-user TARGET_LIST=ppc64-softmmu,ppc64-linux-user,ppc64abi32-linux-user
build: build:
pre_ci_boot: 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 image_tag: latest
pull: true pull: true
options: "-e HOME=/root" options: "-e HOME=/root"

7
accel/tcg/translate-all.c
View File

@ -976,7 +976,12 @@ static inline size_t size_code_gen_buffer(size_t tb_size)
{ {
/* Size the buffer. */ /* Size the buffer. */
if (tb_size == 0) { 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) { if (tb_size < MIN_CODE_GEN_BUFFER_SIZE) {
tb_size = MIN_CODE_GEN_BUFFER_SIZE; tb_size = MIN_CODE_GEN_BUFFER_SIZE;

4
hw/semihosting/console.c
View File

@ -52,7 +52,9 @@ static GString *copy_user_string(CPUArchState *env, target_ulong addr)
do { do {
if (cpu_memory_rw_debug(cpu, addr++, &c, 1, 0) == 0) { 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 { } else {
qemu_log_mask(LOG_GUEST_ERROR, qemu_log_mask(LOG_GUEST_ERROR,
"%s: passed inaccessible address " TARGET_FMT_lx, "%s: passed inaccessible address " TARGET_FMT_lx,

1
include/fpu/softfloat.h
View File

@ -822,6 +822,7 @@ static inline bool floatx80_invalid_encoding(floatx80 a)
} }
#define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL) #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_one make_floatx80(0x3fff, 0x8000000000000000LL)
#define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL) #define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL)
#define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL) #define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL)

15
include/qemu/osdep.h
View File

@ -173,6 +173,9 @@ extern int daemon(int, int);
#ifndef MAP_ANONYMOUS #ifndef MAP_ANONYMOUS
#define MAP_ANONYMOUS MAP_ANON #define MAP_ANONYMOUS MAP_ANON
#endif #endif
#ifndef MAP_FIXED_NOREPLACE
#define MAP_FIXED_NOREPLACE 0
#endif
#ifndef ENOMEDIUM #ifndef ENOMEDIUM
#define ENOMEDIUM ENODEV #define ENOMEDIUM ENODEV
#endif #endif
@ -668,4 +671,16 @@ static inline void qemu_reset_optind(void)
*/ */
char *qemu_get_host_name(Error **errp); 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 #endif

10
linux-user/elfload.c
View File

@ -2134,12 +2134,15 @@ static uintptr_t pgd_find_hole_fallback(uintptr_t guest_size, uintptr_t brk,
/* we have run out of space */ /* we have run out of space */
return -1; return -1;
} else { } 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, void * mmap_start = mmap((void *) align_start, guest_size,
PROT_NONE, flags, -1, 0); PROT_NONE, flags, -1, 0);
if (mmap_start != MAP_FAILED) { if (mmap_start != MAP_FAILED) {
munmap((void *) align_start, guest_size); 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; 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. */ /* Widen the "image" to the entire reserved address space. */
pgb_static(image_name, 0, reserved_va, align); 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; flags |= MAP_FIXED_NOREPLACE;
#endif
/* Reserve the memory on the host. */ /* Reserve the memory on the host. */
assert(guest_base != 0); assert(guest_base != 0);

15
linux-user/syscall.c
View File

@ -11831,16 +11831,15 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
target_to_host_timespec(&ts, arg3); target_to_host_timespec(&ts, arg3);
ret = get_errno(safe_clock_nanosleep(arg1, arg2, ret = get_errno(safe_clock_nanosleep(arg1, arg2,
&ts, arg4 ? &ts : NULL)); &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); 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; return ret;
} }
#endif #endif

137
python/qemu/console_socket.py
View File

@ -1,12 +1,9 @@
#!/usr/bin/env python3 """
# QEMU Console Socket Module:
# This python module implements a ConsoleSocket object which is
# designed always drain the socket itself, and place This python module implements a ConsoleSocket object,
# the bytes into a in memory buffer for later processing. which can drain a socket and optionally dump the bytes to file.
# """
# Optionally a file path can be passed in and we will also
# dump the characters to this file for debug.
#
# Copyright 2020 Linaro # Copyright 2020 Linaro
# #
# Authors: # Authors:
@ -15,96 +12,118 @@
# This code is licensed under the GPL version 2 or later. See # This code is licensed under the GPL version 2 or later. See
# the COPYING file in the top-level directory. # the COPYING file in the top-level directory.
# #
import asyncore
import socket import socket
import threading import threading
import io
import os
import sys
from collections import deque from collections import deque
import time 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._recv_timeout_sec = 300
self._sleep_time = 0.5
self._buffer = deque() self._buffer = deque()
self._asyncore_thread = None socket.socket.__init__(self, socket.AF_UNIX, socket.SOCK_STREAM)
self._sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) self.connect(address)
self._sock.connect(address)
self._logfile = None self._logfile = None
if file: if file:
self._logfile = open(file, "w") self._logfile = open(file, "w")
asyncore.dispatcher.__init__(self, sock=self._sock)
self._open = True 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): def _thread_start(self):
"""Kick off a thread to wait on the asyncore.loop""" """Kick off a thread to drain the socket."""
if self._asyncore_thread is not None: # Configure socket to not block and timeout.
return # This allows our drain thread to not block
self._asyncore_thread = threading.Thread(target=asyncore.loop, # on recieve and exit smoothly.
kwargs={'timeout':1}) socket.socket.setblocking(self, False)
self._asyncore_thread.daemon = True socket.socket.settimeout(self, 1)
self._asyncore_thread.start() drain_thread = threading.Thread(target=self._drain_fn)
drain_thread.daemon = True
def handle_close(self): drain_thread.start()
"""redirect close to base class""" return drain_thread
# 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)
def close(self): def close(self):
"""Close the base object and wait for the thread to terminate""" """Close the base object and wait for the thread to terminate"""
if self._open: if self._open:
self._open = False self._open = False
asyncore.dispatcher.close(self) if self._drain_thread is not None:
if self._asyncore_thread is not None: thread, self._drain_thread = self._drain_thread, None
thread, self._asyncore_thread = self._asyncore_thread, None
thread.join() thread.join()
socket.socket.close(self)
if self._logfile: if self._logfile:
self._logfile.close() self._logfile.close()
self._logfile = None self._logfile = None
def handle_read(self): def _drain_socket(self):
"""process arriving characters into in memory _buffer""" """process arriving characters into in memory _buffer"""
try: data = socket.socket.recv(self, 1)
data = asyncore.dispatcher.recv(self, 1) # latin1 is needed since there are some chars
# latin1 is needed since there are some chars # we are receiving that cannot be encoded to utf-8
# we are receiving that cannot be encoded to utf-8 # such as 0xe2, 0x80, 0xA6.
# such as 0xe2, 0x80, 0xA6. string = data.decode("latin1")
string = data.decode("latin1")
except:
print("Exception seen.")
traceback.print_exc()
return
if self._logfile: if self._logfile:
self._logfile.write("{}".format(string)) self._logfile.write("{}".format(string))
self._logfile.flush() self._logfile.flush()
for c in string: for c in string:
self._buffer.extend(c) self._buffer.extend(c)
def recv(self, n=1, sleep_delay_s=0.1): def recv(self, bufsize=1):
"""Return chars from in memory buffer""" """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() start_time = time.time()
while len(self._buffer) < n: while len(self._buffer) < bufsize:
time.sleep(sleep_delay_s) time.sleep(self._sleep_time)
elapsed_sec = time.time() - start_time elapsed_sec = time.time() - start_time
if elapsed_sec > self._recv_timeout_sec: if elapsed_sec > self._recv_timeout_sec:
raise socket.timeout 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 # We choose to use latin1 to remain consistent with
# handle_read() and give back the same data as the user would # handle_read() and give back the same data as the user would
# receive if they were reading directly from the # receive if they were reading directly from the
# socket w/o our intervention. # socket w/o our intervention.
return chars.encode("latin1") return chars.encode("latin1")
def set_blocking(self): def setblocking(self, value):
"""Maintain compatibility with socket API""" """When not draining we pass thru to the socket,
pass since when draining we control socket blocking.
"""
if self._drain_thread is None:
socket.socket.setblocking(self, value)
def settimeout(self, seconds): def settimeout(self, seconds):
"""Set current timeout on recv""" """When not draining we pass thru to the socket,
self._recv_timeout_sec = seconds 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)

14
python/qemu/machine.py
View File

@ -23,11 +23,10 @@ import os
import subprocess import subprocess
import shutil import shutil
import signal import signal
import socket
import tempfile import tempfile
from typing import Optional, Type from typing import Optional, Type
from types import TracebackType from types import TracebackType
from qemu.console_socket import ConsoleSocket from . import console_socket
from . import qmp from . import qmp
@ -673,11 +672,8 @@ class QEMUMachine:
Returns a socket connected to the console Returns a socket connected to the console
""" """
if self._console_socket is None: if self._console_socket is None:
if self._drain_console: self._console_socket = console_socket.ConsoleSocket(
self._console_socket = ConsoleSocket(self._console_address, self._console_address,
file=self._console_log_path) file=self._console_log_path,
else: drain=self._drain_console)
self._console_socket = socket.socket(socket.AF_UNIX,
socket.SOCK_STREAM)
self._console_socket.connect(self._console_address)
return self._console_socket return self._console_socket

2
python/qemu/pylintrc
View File

@ -33,7 +33,7 @@ good-names=i,
Run, Run,
_, _,
fd, fd,
c,
[VARIABLES] [VARIABLES]
[STRING] [STRING]

5
softmmu/vl.c
View File

@ -4127,8 +4127,6 @@ void qemu_init(int argc, char **argv, char **envp)
qemu_opts_foreach(qemu_find_opts("chardev"), qemu_opts_foreach(qemu_find_opts("chardev"),
chardev_init_func, NULL, &error_fatal); chardev_init_func, NULL, &error_fatal);
/* now chardevs have been created we may have semihosting to connect */
qemu_semihosting_connect_chardevs();
#ifdef CONFIG_VIRTFS #ifdef CONFIG_VIRTFS
qemu_opts_foreach(qemu_find_opts("fsdev"), 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) if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
exit(1); 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 no default VGA is requested, the default is "none". */
if (default_vga) { if (default_vga) {
vga_model = get_default_vga_model(machine_class); vga_model = get_default_vga_model(machine_class);

426
target/i386/fpu_helper.c
View File

@ -868,201 +868,201 @@ struct f2xm1_data {
}; };
static const struct f2xm1_data f2xm1_table[65] = { static const struct f2xm1_data f2xm1_table[65] = {
{ make_floatx80(0xbfff, 0x8000000000000000ULL), { make_floatx80_init(0xbfff, 0x8000000000000000ULL),
make_floatx80(0x3ffe, 0x8000000000000000ULL), make_floatx80_init(0x3ffe, 0x8000000000000000ULL),
make_floatx80(0xbffe, 0x8000000000000000ULL) }, make_floatx80_init(0xbffe, 0x8000000000000000ULL) },
{ make_floatx80(0xbffe, 0xf800000000002e7eULL), { make_floatx80_init(0xbffe, 0xf800000000002e7eULL),
make_floatx80(0x3ffe, 0x82cd8698ac2b9160ULL), make_floatx80_init(0x3ffe, 0x82cd8698ac2b9160ULL),
make_floatx80(0xbffd, 0xfa64f2cea7a8dd40ULL) }, make_floatx80_init(0xbffd, 0xfa64f2cea7a8dd40ULL) },
{ make_floatx80(0xbffe, 0xefffffffffffe960ULL), { make_floatx80_init(0xbffe, 0xefffffffffffe960ULL),
make_floatx80(0x3ffe, 0x85aac367cc488345ULL), make_floatx80_init(0x3ffe, 0x85aac367cc488345ULL),
make_floatx80(0xbffd, 0xf4aa7930676ef976ULL) }, make_floatx80_init(0xbffd, 0xf4aa7930676ef976ULL) },
{ make_floatx80(0xbffe, 0xe800000000006f10ULL), { make_floatx80_init(0xbffe, 0xe800000000006f10ULL),
make_floatx80(0x3ffe, 0x88980e8092da5c14ULL), make_floatx80_init(0x3ffe, 0x88980e8092da5c14ULL),
make_floatx80(0xbffd, 0xeecfe2feda4b47d8ULL) }, make_floatx80_init(0xbffd, 0xeecfe2feda4b47d8ULL) },
{ make_floatx80(0xbffe, 0xe000000000008a45ULL), { make_floatx80_init(0xbffe, 0xe000000000008a45ULL),
make_floatx80(0x3ffe, 0x8b95c1e3ea8ba2a5ULL), make_floatx80_init(0x3ffe, 0x8b95c1e3ea8ba2a5ULL),
make_floatx80(0xbffd, 0xe8d47c382ae8bab6ULL) }, make_floatx80_init(0xbffd, 0xe8d47c382ae8bab6ULL) },
{ make_floatx80(0xbffe, 0xd7ffffffffff8a9eULL), { make_floatx80_init(0xbffe, 0xd7ffffffffff8a9eULL),
make_floatx80(0x3ffe, 0x8ea4398b45cd8116ULL), make_floatx80_init(0x3ffe, 0x8ea4398b45cd8116ULL),
make_floatx80(0xbffd, 0xe2b78ce97464fdd4ULL) }, make_floatx80_init(0xbffd, 0xe2b78ce97464fdd4ULL) },
{ make_floatx80(0xbffe, 0xd0000000000019a0ULL), { make_floatx80_init(0xbffe, 0xd0000000000019a0ULL),
make_floatx80(0x3ffe, 0x91c3d373ab11b919ULL), make_floatx80_init(0x3ffe, 0x91c3d373ab11b919ULL),
make_floatx80(0xbffd, 0xdc785918a9dc8dceULL) }, make_floatx80_init(0xbffd, 0xdc785918a9dc8dceULL) },
{ make_floatx80(0xbffe, 0xc7ffffffffff14dfULL), { make_floatx80_init(0xbffe, 0xc7ffffffffff14dfULL),
make_floatx80(0x3ffe, 0x94f4efa8fef76836ULL), make_floatx80_init(0x3ffe, 0x94f4efa8fef76836ULL),
make_floatx80(0xbffd, 0xd61620ae02112f94ULL) }, make_floatx80_init(0xbffd, 0xd61620ae02112f94ULL) },
{ make_floatx80(0xbffe, 0xc000000000006530ULL), { make_floatx80_init(0xbffe, 0xc000000000006530ULL),
make_floatx80(0x3ffe, 0x9837f0518db87fbbULL), make_floatx80_init(0x3ffe, 0x9837f0518db87fbbULL),
make_floatx80(0xbffd, 0xcf901f5ce48f008aULL) }, make_floatx80_init(0xbffd, 0xcf901f5ce48f008aULL) },
{ make_floatx80(0xbffe, 0xb7ffffffffff1723ULL), { make_floatx80_init(0xbffe, 0xb7ffffffffff1723ULL),
make_floatx80(0x3ffe, 0x9b8d39b9d54eb74cULL), make_floatx80_init(0x3ffe, 0x9b8d39b9d54eb74cULL),
make_floatx80(0xbffd, 0xc8e58c8c55629168ULL) }, make_floatx80_init(0xbffd, 0xc8e58c8c55629168ULL) },
{ make_floatx80(0xbffe, 0xb00000000000b5e1ULL), { make_floatx80_init(0xbffe, 0xb00000000000b5e1ULL),
make_floatx80(0x3ffe, 0x9ef5326091a0c366ULL), make_floatx80_init(0x3ffe, 0x9ef5326091a0c366ULL),
make_floatx80(0xbffd, 0xc2159b3edcbe7934ULL) }, make_floatx80_init(0xbffd, 0xc2159b3edcbe7934ULL) },
{ make_floatx80(0xbffe, 0xa800000000006f8aULL), { make_floatx80_init(0xbffe, 0xa800000000006f8aULL),
make_floatx80(0x3ffe, 0xa27043030c49370aULL), make_floatx80_init(0x3ffe, 0xa27043030c49370aULL),
make_floatx80(0xbffd, 0xbb1f79f9e76d91ecULL) }, make_floatx80_init(0xbffd, 0xbb1f79f9e76d91ecULL) },
{ make_floatx80(0xbffe, 0x9fffffffffff816aULL), { make_floatx80_init(0xbffe, 0x9fffffffffff816aULL),
make_floatx80(0x3ffe, 0xa5fed6a9b15171cfULL), make_floatx80_init(0x3ffe, 0xa5fed6a9b15171cfULL),
make_floatx80(0xbffd, 0xb40252ac9d5d1c62ULL) }, make_floatx80_init(0xbffd, 0xb40252ac9d5d1c62ULL) },
{ make_floatx80(0xbffe, 0x97ffffffffffb621ULL), { make_floatx80_init(0xbffe, 0x97ffffffffffb621ULL),
make_floatx80(0x3ffe, 0xa9a15ab4ea7c30e6ULL), make_floatx80_init(0x3ffe, 0xa9a15ab4ea7c30e6ULL),
make_floatx80(0xbffd, 0xacbd4a962b079e34ULL) }, make_floatx80_init(0xbffd, 0xacbd4a962b079e34ULL) },
{ make_floatx80(0xbffe, 0x8fffffffffff162bULL), { make_floatx80_init(0xbffe, 0x8fffffffffff162bULL),
make_floatx80(0x3ffe, 0xad583eea42a1b886ULL), make_floatx80_init(0x3ffe, 0xad583eea42a1b886ULL),
make_floatx80(0xbffd, 0xa54f822b7abc8ef4ULL) }, make_floatx80_init(0xbffd, 0xa54f822b7abc8ef4ULL) },
{ make_floatx80(0xbffe, 0x87ffffffffff4d34ULL), { make_floatx80_init(0xbffe, 0x87ffffffffff4d34ULL),
make_floatx80(0x3ffe, 0xb123f581d2ac7b51ULL), make_floatx80_init(0x3ffe, 0xb123f581d2ac7b51ULL),
make_floatx80(0xbffd, 0x9db814fc5aa7095eULL) }, make_floatx80_init(0xbffd, 0x9db814fc5aa7095eULL) },
{ make_floatx80(0xbffe, 0x800000000000227dULL), { make_floatx80_init(0xbffe, 0x800000000000227dULL),
make_floatx80(0x3ffe, 0xb504f333f9de539dULL), make_floatx80_init(0x3ffe, 0xb504f333f9de539dULL),
make_floatx80(0xbffd, 0x95f619980c4358c6ULL) }, make_floatx80_init(0xbffd, 0x95f619980c4358c6ULL) },
{ make_floatx80(0xbffd, 0xefffffffffff3978ULL), { make_floatx80_init(0xbffd, 0xefffffffffff3978ULL),
make_floatx80(0x3ffe, 0xb8fbaf4762fbd0a1ULL), make_floatx80_init(0x3ffe, 0xb8fbaf4762fbd0a1ULL),
make_floatx80(0xbffd, 0x8e08a1713a085ebeULL) }, make_floatx80_init(0xbffd, 0x8e08a1713a085ebeULL) },
{ make_floatx80(0xbffd, 0xe00000000000df81ULL), { make_floatx80_init(0xbffd, 0xe00000000000df81ULL),
make_floatx80(0x3ffe, 0xbd08a39f580bfd8cULL), make_floatx80_init(0x3ffe, 0xbd08a39f580bfd8cULL),
make_floatx80(0xbffd, 0x85eeb8c14fe804e8ULL) }, make_floatx80_init(0xbffd, 0x85eeb8c14fe804e8ULL) },
{ make_floatx80(0xbffd, 0xd00000000000bccfULL), { make_floatx80_init(0xbffd, 0xd00000000000bccfULL),
make_floatx80(0x3ffe, 0xc12c4cca667062f6ULL), make_floatx80_init(0x3ffe, 0xc12c4cca667062f6ULL),
make_floatx80(0xbffc, 0xfb4eccd6663e7428ULL) }, make_floatx80_init(0xbffc, 0xfb4eccd6663e7428ULL) },
{ make_floatx80(0xbffd, 0xc00000000000eff0ULL), { make_floatx80_init(0xbffd, 0xc00000000000eff0ULL),
make_floatx80(0x3ffe, 0xc5672a1155069abeULL), make_floatx80_init(0x3ffe, 0xc5672a1155069abeULL),
make_floatx80(0xbffc, 0xea6357baabe59508ULL) }, make_floatx80_init(0xbffc, 0xea6357baabe59508ULL) },
{ make_floatx80(0xbffd, 0xb000000000000fe6ULL), { make_floatx80_init(0xbffd, 0xb000000000000fe6ULL),
make_floatx80(0x3ffe, 0xc9b9bd866e2f234bULL), make_floatx80_init(0x3ffe, 0xc9b9bd866e2f234bULL),
make_floatx80(0xbffc, 0xd91909e6474372d4ULL) }, make_floatx80_init(0xbffc, 0xd91909e6474372d4ULL) },
{ make_floatx80(0xbffd, 0x9fffffffffff2172ULL), { make_floatx80_init(0xbffd, 0x9fffffffffff2172ULL),
make_floatx80(0x3ffe, 0xce248c151f84bf00ULL), make_floatx80_init(0x3ffe, 0xce248c151f84bf00ULL),
make_floatx80(0xbffc, 0xc76dcfab81ed0400ULL) }, make_floatx80_init(0xbffc, 0xc76dcfab81ed0400ULL) },
{ make_floatx80(0xbffd, 0x8fffffffffffafffULL), { make_floatx80_init(0xbffd, 0x8fffffffffffafffULL),
make_floatx80(0x3ffe, 0xd2a81d91f12afb2bULL), make_floatx80_init(0x3ffe, 0xd2a81d91f12afb2bULL),
make_floatx80(0xbffc, 0xb55f89b83b541354ULL) }, make_floatx80_init(0xbffc, 0xb55f89b83b541354ULL) },
{ make_floatx80(0xbffc, 0xffffffffffff81a3ULL), { make_floatx80_init(0xbffc, 0xffffffffffff81a3ULL),
make_floatx80(0x3ffe, 0xd744fccad69d7d5eULL), make_floatx80_init(0x3ffe, 0xd744fccad69d7d5eULL),
make_floatx80(0xbffc, 0xa2ec0cd4a58a0a88ULL) }, make_floatx80_init(0xbffc, 0xa2ec0cd4a58a0a88ULL) },
{ make_floatx80(0xbffc, 0xdfffffffffff1568ULL), { make_floatx80_init(0xbffc, 0xdfffffffffff1568ULL),
make_floatx80(0x3ffe, 0xdbfbb797daf25a44ULL), make_floatx80_init(0x3ffe, 0xdbfbb797daf25a44ULL),
make_floatx80(0xbffc, 0x901121a0943696f0ULL) }, make_floatx80_init(0xbffc, 0x901121a0943696f0ULL) },
{ make_floatx80(0xbffc, 0xbfffffffffff68daULL), { make_floatx80_init(0xbffc, 0xbfffffffffff68daULL),
make_floatx80(0x3ffe, 0xe0ccdeec2a94f811ULL), make_floatx80_init(0x3ffe, 0xe0ccdeec2a94f811ULL),
make_floatx80(0xbffb, 0xf999089eab583f78ULL) }, make_floatx80_init(0xbffb, 0xf999089eab583f78ULL) },
{ make_floatx80(0xbffc, 0x9fffffffffff4690ULL), { make_floatx80_init(0xbffc, 0x9fffffffffff4690ULL),
make_floatx80(0x3ffe, 0xe5b906e77c83657eULL), make_floatx80_init(0x3ffe, 0xe5b906e77c83657eULL),
make_floatx80(0xbffb, 0xd237c8c41be4d410ULL) }, make_floatx80_init(0xbffb, 0xd237c8c41be4d410ULL) },
{ make_floatx80(0xbffb, 0xffffffffffff8aeeULL), { make_floatx80_init(0xbffb, 0xffffffffffff8aeeULL),
make_floatx80(0x3ffe, 0xeac0c6e7dd24427cULL), make_floatx80_init(0x3ffe, 0xeac0c6e7dd24427cULL),
make_floatx80(0xbffb, 0xa9f9c8c116ddec20ULL) }, make_floatx80_init(0xbffb, 0xa9f9c8c116ddec20ULL) },
{ make_floatx80(0xbffb, 0xbfffffffffff2d18ULL), { make_floatx80_init(0xbffb, 0xbfffffffffff2d18ULL),
make_floatx80(0x3ffe, 0xefe4b99bdcdb06ebULL), make_floatx80_init(0x3ffe, 0xefe4b99bdcdb06ebULL),
make_floatx80(0xbffb, 0x80da33211927c8a8ULL) }, make_floatx80_init(0xbffb, 0x80da33211927c8a8ULL) },
{ make_floatx80(0xbffa, 0xffffffffffff8ccbULL), { make_floatx80_init(0xbffa, 0xffffffffffff8ccbULL),
make_floatx80(0x3ffe, 0xf5257d152486d0f4ULL), make_floatx80_init(0x3ffe, 0xf5257d152486d0f4ULL),
make_floatx80(0xbffa, 0xada82eadb792f0c0ULL) }, make_floatx80_init(0xbffa, 0xada82eadb792f0c0ULL) },
{ make_floatx80(0xbff9, 0xffffffffffff11feULL), { make_floatx80_init(0xbff9, 0xffffffffffff11feULL),
make_floatx80(0x3ffe, 0xfa83b2db722a0846ULL), make_floatx80_init(0x3ffe, 0xfa83b2db722a0846ULL),
make_floatx80(0xbff9, 0xaf89a491babef740ULL) }, make_floatx80_init(0xbff9, 0xaf89a491babef740ULL) },
{ floatx80_zero, { floatx80_zero_init,
make_floatx80(0x3fff, 0x8000000000000000ULL), make_floatx80_init(0x3fff, 0x8000000000000000ULL),
floatx80_zero }, floatx80_zero_init },
{ make_floatx80(0x3ff9, 0xffffffffffff2680ULL), { make_floatx80_init(0x3ff9, 0xffffffffffff2680ULL),
make_floatx80(0x3fff, 0x82cd8698ac2b9f6fULL), make_floatx80_init(0x3fff, 0x82cd8698ac2b9f6fULL),
make_floatx80(0x3ff9, 0xb361a62b0ae7dbc0ULL) }, make_floatx80_init(0x3ff9, 0xb361a62b0ae7dbc0ULL) },
{ make_floatx80(0x3ffb, 0x800000000000b500ULL), { make_floatx80_init(0x3ffb, 0x800000000000b500ULL),
make_floatx80(0x3fff, 0x85aac367cc488345ULL), make_floatx80_init(0x3fff, 0x85aac367cc488345ULL),
make_floatx80(0x3ffa, 0xb5586cf9891068a0ULL) }, make_floatx80_init(0x3ffa, 0xb5586cf9891068a0ULL) },
{ make_floatx80(0x3ffb, 0xbfffffffffff4b67ULL), { make_floatx80_init(0x3ffb, 0xbfffffffffff4b67ULL),
make_floatx80(0x3fff, 0x88980e8092da7cceULL), make_floatx80_init(0x3fff, 0x88980e8092da7cceULL),
make_floatx80(0x3ffb, 0x8980e8092da7cce0ULL) }, make_floatx80_init(0x3ffb, 0x8980e8092da7cce0ULL) },
{ make_floatx80(0x3ffb, 0xffffffffffffff57ULL), { make_floatx80_init(0x3ffb, 0xffffffffffffff57ULL),
make_floatx80(0x3fff, 0x8b95c1e3ea8bd6dfULL), make_floatx80_init(0x3fff, 0x8b95c1e3ea8bd6dfULL),
make_floatx80(0x3ffb, 0xb95c1e3ea8bd6df0ULL) }, make_floatx80_init(0x3ffb, 0xb95c1e3ea8bd6df0ULL) },
{ make_floatx80(0x3ffc, 0x9fffffffffff811fULL), { make_floatx80_init(0x3ffc, 0x9fffffffffff811fULL),
make_floatx80(0x3fff, 0x8ea4398b45cd4780ULL), make_floatx80_init(0x3fff, 0x8ea4398b45cd4780ULL),
make_floatx80(0x3ffb, 0xea4398b45cd47800ULL) }, make_floatx80_init(0x3ffb, 0xea4398b45cd47800ULL) },
{ make_floatx80(0x3ffc, 0xbfffffffffff9980ULL), { make_floatx80_init(0x3ffc, 0xbfffffffffff9980ULL),
make_floatx80(0x3fff, 0x91c3d373ab11b919ULL), make_floatx80_init(0x3fff, 0x91c3d373ab11b919ULL),
make_floatx80(0x3ffc, 0x8e1e9b9d588dc8c8ULL) }, make_floatx80_init(0x3ffc, 0x8e1e9b9d588dc8c8ULL) },
{ make_floatx80(0x3ffc, 0xdffffffffffff631ULL), { make_floatx80_init(0x3ffc, 0xdffffffffffff631ULL),
make_floatx80(0x3fff, 0x94f4efa8fef70864ULL), make_floatx80_init(0x3fff, 0x94f4efa8fef70864ULL),
make_floatx80(0x3ffc, 0xa7a77d47f7b84320ULL) }, make_floatx80_init(0x3ffc, 0xa7a77d47f7b84320ULL) },
{ make_floatx80(0x3ffc, 0xffffffffffff2499ULL), { make_floatx80_init(0x3ffc, 0xffffffffffff2499ULL),
make_floatx80(0x3fff, 0x9837f0518db892d4ULL), make_floatx80_init(0x3fff, 0x9837f0518db892d4ULL),
make_floatx80(0x3ffc, 0xc1bf828c6dc496a0ULL) }, make_floatx80_init(0x3ffc, 0xc1bf828c6dc496a0ULL) },
{ make_floatx80(0x3ffd, 0x8fffffffffff80fbULL), { make_floatx80_init(0x3ffd, 0x8fffffffffff80fbULL),
make_floatx80(0x3fff, 0x9b8d39b9d54e3a79ULL), make_floatx80_init(0x3fff, 0x9b8d39b9d54e3a79ULL),
make_floatx80(0x3ffc, 0xdc69cdceaa71d3c8ULL) }, make_floatx80_init(0x3ffc, 0xdc69cdceaa71d3c8ULL) },
{ make_floatx80(0x3ffd, 0x9fffffffffffbc23ULL), { make_floatx80_init(0x3ffd, 0x9fffffffffffbc23ULL),
make_floatx80(0x3fff, 0x9ef5326091a10313ULL), make_floatx80_init(0x3fff, 0x9ef5326091a10313ULL),
make_floatx80(0x3ffc, 0xf7a993048d081898ULL) }, make_floatx80_init(0x3ffc, 0xf7a993048d081898ULL) },
{ make_floatx80(0x3ffd, 0xafffffffffff20ecULL), { make_floatx80_init(0x3ffd, 0xafffffffffff20ecULL),
make_floatx80(0x3fff, 0xa27043030c49370aULL), make_floatx80_init(0x3fff, 0xa27043030c49370aULL),
make_floatx80(0x3ffd, 0x89c10c0c3124dc28ULL) }, make_floatx80_init(0x3ffd, 0x89c10c0c3124dc28ULL) },
{ make_floatx80(0x3ffd, 0xc00000000000fd2cULL), { make_floatx80_init(0x3ffd, 0xc00000000000fd2cULL),
make_floatx80(0x3fff, 0xa5fed6a9b15171cfULL), make_floatx80_init(0x3fff, 0xa5fed6a9b15171cfULL),
make_floatx80(0x3ffd, 0x97fb5aa6c545c73cULL) }, make_floatx80_init(0x3ffd, 0x97fb5aa6c545c73cULL) },
{ make_floatx80(0x3ffd, 0xd0000000000093beULL), { make_floatx80_init(0x3ffd, 0xd0000000000093beULL),
make_floatx80(0x3fff, 0xa9a15ab4ea7c30e6ULL), make_floatx80_init(0x3fff, 0xa9a15ab4ea7c30e6ULL),
make_floatx80(0x3ffd, 0xa6856ad3a9f0c398ULL) }, make_floatx80_init(0x3ffd, 0xa6856ad3a9f0c398ULL) },
{ make_floatx80(0x3ffd, 0xe00000000000c2aeULL), { make_floatx80_init(0x3ffd, 0xe00000000000c2aeULL),
make_floatx80(0x3fff, 0xad583eea42a17876ULL), make_floatx80_init(0x3fff, 0xad583eea42a17876ULL),
make_floatx80(0x3ffd, 0xb560fba90a85e1d8ULL) }, make_floatx80_init(0x3ffd, 0xb560fba90a85e1d8ULL) },
{ make_floatx80(0x3ffd, 0xefffffffffff1e3fULL), { make_floatx80_init(0x3ffd, 0xefffffffffff1e3fULL),
make_floatx80(0x3fff, 0xb123f581d2abef6cULL), make_floatx80_init(0x3fff, 0xb123f581d2abef6cULL),
make_floatx80(0x3ffd, 0xc48fd6074aafbdb0ULL) }, make_floatx80_init(0x3ffd, 0xc48fd6074aafbdb0ULL) },
{ make_floatx80(0x3ffd, 0xffffffffffff1c23ULL), { make_floatx80_init(0x3ffd, 0xffffffffffff1c23ULL),
make_floatx80(0x3fff, 0xb504f333f9de2cadULL), make_floatx80_init(0x3fff, 0xb504f333f9de2cadULL),
make_floatx80(0x3ffd, 0xd413cccfe778b2b4ULL) }, make_floatx80_init(0x3ffd, 0xd413cccfe778b2b4ULL) },
{ make_floatx80(0x3ffe, 0x8800000000006344ULL), { make_floatx80_init(0x3ffe, 0x8800000000006344ULL),
make_floatx80(0x3fff, 0xb8fbaf4762fbd0a1ULL), make_floatx80_init(0x3fff, 0xb8fbaf4762fbd0a1ULL),
make_floatx80(0x3ffd, 0xe3eebd1d8bef4284ULL) }, make_floatx80_init(0x3ffd, 0xe3eebd1d8bef4284ULL) },
{ make_floatx80(0x3ffe, 0x9000000000005d67ULL), { make_floatx80_init(0x3ffe, 0x9000000000005d67ULL),
make_floatx80(0x3fff, 0xbd08a39f580c668dULL), make_floatx80_init(0x3fff, 0xbd08a39f580c668dULL),
make_floatx80(0x3ffd, 0xf4228e7d60319a34ULL) }, make_floatx80_init(0x3ffd, 0xf4228e7d60319a34ULL) },
{ make_floatx80(0x3ffe, 0x9800000000009127ULL), { make_floatx80_init(0x3ffe, 0x9800000000009127ULL),
make_floatx80(0x3fff, 0xc12c4cca6670e042ULL), make_floatx80_init(0x3fff, 0xc12c4cca6670e042ULL),
make_floatx80(0x3ffe, 0x82589994cce1c084ULL) }, make_floatx80_init(0x3ffe, 0x82589994cce1c084ULL) },
{ make_floatx80(0x3ffe, 0x9fffffffffff06f9ULL), { make_floatx80_init(0x3ffe, 0x9fffffffffff06f9ULL),
make_floatx80(0x3fff, 0xc5672a11550655c3ULL), make_floatx80_init(0x3fff, 0xc5672a11550655c3ULL),
make_floatx80(0x3ffe, 0x8ace5422aa0cab86ULL) }, make_floatx80_init(0x3ffe, 0x8ace5422aa0cab86ULL) },
{ make_floatx80(0x3ffe, 0xa7fffffffffff80dULL), { make_floatx80_init(0x3ffe, 0xa7fffffffffff80dULL),
make_floatx80(0x3fff, 0xc9b9bd866e2f234bULL), make_floatx80_init(0x3fff, 0xc9b9bd866e2f234bULL),
make_floatx80(0x3ffe, 0x93737b0cdc5e4696ULL) }, make_floatx80_init(0x3ffe, 0x93737b0cdc5e4696ULL) },
{ make_floatx80(0x3ffe, 0xafffffffffff1470ULL), { make_floatx80_init(0x3ffe, 0xafffffffffff1470ULL),
make_floatx80(0x3fff, 0xce248c151f83fd69ULL), make_floatx80_init(0x3fff, 0xce248c151f83fd69ULL),
make_floatx80(0x3ffe, 0x9c49182a3f07fad2ULL) }, make_floatx80_init(0x3ffe, 0x9c49182a3f07fad2ULL) },
{ make_floatx80(0x3ffe, 0xb800000000000e0aULL), { make_floatx80_init(0x3ffe, 0xb800000000000e0aULL),
make_floatx80(0x3fff, 0xd2a81d91f12aec5cULL), make_floatx80_init(0x3fff, 0xd2a81d91f12aec5cULL),
make_floatx80(0x3ffe, 0xa5503b23e255d8b8ULL) }, make_floatx80_init(0x3ffe, 0xa5503b23e255d8b8ULL) },
{ make_floatx80(0x3ffe, 0xc00000000000b7faULL), { make_floatx80_init(0x3ffe, 0xc00000000000b7faULL),
make_floatx80(0x3fff, 0xd744fccad69dd630ULL), make_floatx80_init(0x3fff, 0xd744fccad69dd630ULL),
make_floatx80(0x3ffe, 0xae89f995ad3bac60ULL) }, make_floatx80_init(0x3ffe, 0xae89f995ad3bac60ULL) },
{ make_floatx80(0x3ffe, 0xc800000000003aa6ULL), { make_floatx80_init(0x3ffe, 0xc800000000003aa6ULL),
make_floatx80(0x3fff, 0xdbfbb797daf25a44ULL), make_floatx80_init(0x3fff, 0xdbfbb797daf25a44ULL),
make_floatx80(0x3ffe, 0xb7f76f2fb5e4b488ULL) }, make_floatx80_init(0x3ffe, 0xb7f76f2fb5e4b488ULL) },
{ make_floatx80(0x3ffe, 0xd00000000000a6aeULL), { make_floatx80_init(0x3ffe, 0xd00000000000a6aeULL),
make_floatx80(0x3fff, 0xe0ccdeec2a954685ULL), make_floatx80_init(0x3fff, 0xe0ccdeec2a954685ULL),
make_floatx80(0x3ffe, 0xc199bdd8552a8d0aULL) }, make_floatx80_init(0x3ffe, 0xc199bdd8552a8d0aULL) },
{ make_floatx80(0x3ffe, 0xd800000000004165ULL), { make_floatx80_init(0x3ffe, 0xd800000000004165ULL),
make_floatx80(0x3fff, 0xe5b906e77c837155ULL), make_floatx80_init(0x3fff, 0xe5b906e77c837155ULL),
make_floatx80(0x3ffe, 0xcb720dcef906e2aaULL) }, make_floatx80_init(0x3ffe, 0xcb720dcef906e2aaULL) },
{ make_floatx80(0x3ffe, 0xe00000000000582cULL), { make_floatx80_init(0x3ffe, 0xe00000000000582cULL),
make_floatx80(0x3fff, 0xeac0c6e7dd24713aULL), make_floatx80_init(0x3fff, 0xeac0c6e7dd24713aULL),
make_floatx80(0x3ffe, 0xd5818dcfba48e274ULL) }, make_floatx80_init(0x3ffe, 0xd5818dcfba48e274ULL) },
{ make_floatx80(0x3ffe, 0xe800000000001a5dULL), { make_floatx80_init(0x3ffe, 0xe800000000001a5dULL),
make_floatx80(0x3fff, 0xefe4b99bdcdb06ebULL), make_floatx80_init(0x3fff, 0xefe4b99bdcdb06ebULL),
make_floatx80(0x3ffe, 0xdfc97337b9b60dd6ULL) }, make_floatx80_init(0x3ffe, 0xdfc97337b9b60dd6ULL) },
{ make_floatx80(0x3ffe, 0xefffffffffffc1efULL), { make_floatx80_init(0x3ffe, 0xefffffffffffc1efULL),
make_floatx80(0x3fff, 0xf5257d152486a2faULL), make_floatx80_init(0x3fff, 0xf5257d152486a2faULL),
make_floatx80(0x3ffe, 0xea4afa2a490d45f4ULL) }, make_floatx80_init(0x3ffe, 0xea4afa2a490d45f4ULL) },
{ make_floatx80(0x3ffe, 0xf800000000001069ULL), { make_floatx80_init(0x3ffe, 0xf800000000001069ULL),
make_floatx80(0x3fff, 0xfa83b2db722a0e5cULL), make_floatx80_init(0x3fff, 0xfa83b2db722a0e5cULL),
make_floatx80(0x3ffe, 0xf50765b6e4541cb8ULL) }, make_floatx80_init(0x3ffe, 0xf50765b6e4541cb8ULL) },
{ make_floatx80(0x3fff, 0x8000000000000000ULL), { make_floatx80_init(0x3fff, 0x8000000000000000ULL),
make_floatx80(0x4000, 0x8000000000000000ULL), make_floatx80_init(0x4000, 0x8000000000000000ULL),
make_floatx80(0x3fff, 0x8000000000000000ULL) }, make_floatx80_init(0x3fff, 0x8000000000000000ULL) },
}; };
void helper_f2xm1(CPUX86State *env) void helper_f2xm1(CPUX86State *env)
@ -1275,24 +1275,24 @@ struct fpatan_data {
}; };
static const struct fpatan_data fpatan_table[9] = { static const struct fpatan_data fpatan_table[9] = {
{ floatx80_zero, { floatx80_zero_init,
floatx80_zero }, floatx80_zero_init },
{ make_floatx80(0x3ffb, 0xfeadd4d5617b6e33ULL), { make_floatx80_init(0x3ffb, 0xfeadd4d5617b6e33ULL),
make_floatx80(0xbfb9, 0xdda19d8305ddc420ULL) }, make_floatx80_init(0xbfb9, 0xdda19d8305ddc420ULL) },
{ make_floatx80(0x3ffc, 0xfadbafc96406eb15ULL), { make_floatx80_init(0x3ffc, 0xfadbafc96406eb15ULL),
make_floatx80(0x3fbb, 0xdb8f3debef442fccULL) }, make_floatx80_init(0x3fbb, 0xdb8f3debef442fccULL) },
{ make_floatx80(0x3ffd, 0xb7b0ca0f26f78474ULL), { make_floatx80_init(0x3ffd, 0xb7b0ca0f26f78474ULL),
make_floatx80(0xbfbc, 0xeab9bdba460376faULL) }, make_floatx80_init(0xbfbc, 0xeab9bdba460376faULL) },
{ make_floatx80(0x3ffd, 0xed63382b0dda7b45ULL), { make_floatx80_init(0x3ffd, 0xed63382b0dda7b45ULL),
make_floatx80(0x3fbc, 0xdfc88bd978751a06ULL) }, make_floatx80_init(0x3fbc, 0xdfc88bd978751a06ULL) },
{ make_floatx80(0x3ffe, 0x8f005d5ef7f59f9bULL), { make_floatx80_init(0x3ffe, 0x8f005d5ef7f59f9bULL),
make_floatx80(0x3fbd, 0xb906bc2ccb886e90ULL) }, make_floatx80_init(0x3fbd, 0xb906bc2ccb886e90ULL) },
{ make_floatx80(0x3ffe, 0xa4bc7d1934f70924ULL), { make_floatx80_init(0x3ffe, 0xa4bc7d1934f70924ULL),
make_floatx80(0x3fbb, 0xcd43f9522bed64f8ULL) }, make_floatx80_init(0x3fbb, 0xcd43f9522bed64f8ULL) },
{ make_floatx80(0x3ffe, 0xb8053e2bc2319e74ULL), { make_floatx80_init(0x3ffe, 0xb8053e2bc2319e74ULL),
make_floatx80(0xbfbc, 0xd3496ab7bd6eef0cULL) }, make_floatx80_init(0xbfbc, 0xd3496ab7bd6eef0cULL) },
{ make_floatx80(0x3ffe, 0xc90fdaa22168c235ULL), { make_floatx80_init(0x3ffe, 0xc90fdaa22168c235ULL),
make_floatx80(0xbfbc, 0xece675d1fc8f8cbcULL) }, make_floatx80_init(0xbfbc, 0xece675d1fc8f8cbcULL) },
}; };
void helper_fpatan(CPUX86State *env) void helper_fpatan(CPUX86State *env)

2
tests/docker/Makefile.include
View File

@ -78,7 +78,7 @@ docker-binfmt-image-debian-%: $(DOCKER_FILES_DIR)/debian-bootstrap.docker
DEB_ARCH=$(DEB_ARCH) \ DEB_ARCH=$(DEB_ARCH) \
DEB_TYPE=$(DEB_TYPE) \ DEB_TYPE=$(DEB_TYPE) \
$(if $(DEB_URL),DEB_URL=$(DEB_URL),) \ $(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 $V,,--quiet) $(if $(NOCACHE),--no-cache) \
$(if $(NOUSER),,--add-current-user) \ $(if $(NOUSER),,--add-current-user) \
$(if $(EXTRA_FILES),--extra-files $(EXTRA_FILES)) \ $(if $(EXTRA_FILES),--extra-files $(EXTRA_FILES)) \

13
tests/docker/docker.py
View File

@ -24,7 +24,7 @@ import tempfile
import re import re
import signal import signal
from tarfile import TarFile, TarInfo from tarfile import TarFile, TarInfo
from io import StringIO from io import StringIO, BytesIO
from shutil import copy, rmtree from shutil import copy, rmtree
from pwd import getpwuid from pwd import getpwuid
from datetime import datetime, timedelta from datetime import datetime, timedelta
@ -541,13 +541,14 @@ class UpdateCommand(SubCommand):
# Create a Docker buildfile # Create a Docker buildfile
df = StringIO() df = StringIO()
df.write("FROM %s\n" % args.tag) df.write(u"FROM %s\n" % args.tag)
df.write("ADD . /\n") df.write(u"ADD . /\n")
df.seek(0)
df_bytes = BytesIO(bytes(df.getvalue(), "UTF-8"))
df_tar = TarInfo(name="Dockerfile") df_tar = TarInfo(name="Dockerfile")
df_tar.size = len(df.buf) df_tar.size = df_bytes.getbuffer().nbytes
tmp_tar.addfile(df_tar, fileobj=df) tmp_tar.addfile(df_tar, fileobj=df_bytes)
tmp_tar.close() tmp_tar.close()

7
tests/docker/dockerfiles/debian-bootstrap.pre
View File

@ -79,6 +79,13 @@ else
fi fi
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 # Finally check to see if any qemu's are installed
# #

15
tests/vm/basevm.py
View File

@ -80,6 +80,8 @@ class BaseVM(object):
arch = "#arch" arch = "#arch"
# command to halt the guest, can be overridden by subclasses # command to halt the guest, can be overridden by subclasses
poweroff = "poweroff" poweroff = "poweroff"
# Time to wait for shutdown to finish.
shutdown_timeout_default = 30
# enable IPv6 networking # enable IPv6 networking
ipv6 = True ipv6 = True
# This is the timeout on the wait for console bytes. # This is the timeout on the wait for console bytes.
@ -87,7 +89,7 @@ class BaseVM(object):
# Scale up some timeouts under TCG. # Scale up some timeouts under TCG.
# 4 is arbitrary, but greater than 2, # 4 is arbitrary, but greater than 2,
# since we found we need to wait more than twice as long. # 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): def __init__(self, args, config=None):
self._guest = None self._guest = None
self._genisoimage = args.genisoimage self._genisoimage = args.genisoimage
@ -141,9 +143,12 @@ class BaseVM(object):
if args.jobs and args.jobs > 1: if args.jobs and args.jobs > 1:
self._args += ["-smp", "%d" % args.jobs] self._args += ["-smp", "%d" % args.jobs]
if kvm_available(self.arch): if kvm_available(self.arch):
self._shutdown_timeout = self.shutdown_timeout_default
self._args += ["-enable-kvm"] self._args += ["-enable-kvm"]
else: else:
logging.info("KVM not available, not using -enable-kvm") logging.info("KVM not available, not using -enable-kvm")
self._shutdown_timeout = \
self.shutdown_timeout_default * self.tcg_timeout_multiplier
self._data_args = [] self._data_args = []
if self._config['qemu_args'] != None: 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"): def wait_ssh(self, wait_root=False, seconds=300, cmd="exit 0"):
# Allow more time for VM to boot under TCG. # Allow more time for VM to boot under TCG.
if not kvm_available(self.arch): if not kvm_available(self.arch):
seconds *= self.tcg_ssh_timeout_multiplier seconds *= self.tcg_timeout_multiplier
starttime = datetime.datetime.now() starttime = datetime.datetime.now()
endtime = starttime + datetime.timedelta(seconds=seconds) endtime = starttime + datetime.timedelta(seconds=seconds)
cmd_success = False cmd_success = False
@ -441,14 +446,14 @@ class BaseVM(object):
raise Exception("Timeout while waiting for guest ssh") raise Exception("Timeout while waiting for guest ssh")
def shutdown(self): def shutdown(self):
self._guest.shutdown() self._guest.shutdown(timeout=self._shutdown_timeout)
def wait(self): def wait(self):
self._guest.wait() self._guest.wait(timeout=self._shutdown_timeout)
def graceful_shutdown(self): def graceful_shutdown(self):
self.ssh_root(self.poweroff) self.ssh_root(self.poweroff)
self._guest.wait() self._guest.wait(timeout=self._shutdown_timeout)
def qmp(self, *args, **kwargs): def qmp(self, *args, **kwargs):
return self._guest.qmp(*args, **kwargs) return self._guest.qmp(*args, **kwargs)

15
util/oslib-posix.c
View File

@ -841,3 +841,18 @@ char *qemu_get_host_name(Error **errp)
return g_steal_pointer(&hostname); 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;
}

11
util/oslib-win32.c
View File

@ -828,3 +828,14 @@ char *qemu_get_host_name(Error **errp)
return g_utf16_to_utf8(tmp, size, NULL, NULL, NULL); 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;
}