falso
/
qemu-irix
mirror of https://github.com/n64decomp/qemu-irix.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

qemu-common.h: Move muldiv64() to host-utils.h 

Move the muldiv64() function from qemu-common.h to host-utils.h.
This puts it together with all the other arithmetic functions
where we provide a version with __int128_t and a fallback
without, and allows headers which need muldiv64() to avoid
including qemu-common.h.

We don't include host-utils from qemu-common.h, to avoid dragging
more things into qemu-common.h than it already has; in practice
everywhere that needs muldiv64() can get it via qemu/timer.h.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
This commit is contained in:
Peter Maydell 2015-08-19 16:20:20 +01:00
parent 03557b9aba
commit 49caffe0cc
3 changed files with 30 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
include/qemu-common.h
View File

@ -411,37 +411,6 @@ static inline uint8_t from_bcd(uint8_t val)
return ((val >> 4) * 10) + (val & 0x0f); return ((val >> 4) * 10) + (val & 0x0f);
} }
/* compute with 96 bit intermediate result: (a*b)/c */
#ifdef CONFIG_INT128
static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
{
return (__int128_t)a * b / c;
}
#else
static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
{
union {
uint64_t ll;
struct {
#ifdef HOST_WORDS_BIGENDIAN
uint32_t high, low;
#else
uint32_t low, high;
#endif
} l;
} u, res;
uint64_t rl, rh;
u.ll = a;
rl = (uint64_t)u.l.low * (uint64_t)b;
rh = (uint64_t)u.l.high * (uint64_t)b;
rh += (rl >> 32);
res.l.high = rh / c;
res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
return res.ll;
}
#endif
/* Round number down to multiple */ /* Round number down to multiple */
#define QEMU_ALIGN_DOWN(n, m) ((n) / (m) * (m)) #define QEMU_ALIGN_DOWN(n, m) ((n) / (m) * (m))

29
include/qemu/host-utils.h
View File

@ -45,6 +45,12 @@ static inline void muls64(uint64_t *plow, uint64_t *phigh,
*phigh = r >> 64; *phigh = r >> 64;
} }
/* compute with 96 bit intermediate result: (a*b)/c */
static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
{
return (__int128_t)a * b / c;
}
static inline int divu128(uint64_t *plow, uint64_t *phigh, uint64_t divisor) static inline int divu128(uint64_t *plow, uint64_t *phigh, uint64_t divisor)
{ {
if (divisor == 0) { if (divisor == 0) {
@ -75,6 +81,29 @@ void muls64(uint64_t *phigh, uint64_t *plow, int64_t a, int64_t b);
void mulu64(uint64_t *phigh, uint64_t *plow, uint64_t a, uint64_t b); void mulu64(uint64_t *phigh, uint64_t *plow, uint64_t a, uint64_t b);
int divu128(uint64_t *plow, uint64_t *phigh, uint64_t divisor); int divu128(uint64_t *plow, uint64_t *phigh, uint64_t divisor);
int divs128(int64_t *plow, int64_t *phigh, int64_t divisor); int divs128(int64_t *plow, int64_t *phigh, int64_t divisor);
static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
{
union {
uint64_t ll;
struct {
#ifdef HOST_WORDS_BIGENDIAN
uint32_t high, low;
#else
uint32_t low, high;
#endif
} l;
} u, res;
uint64_t rl, rh;
u.ll = a;
rl = (uint64_t)u.l.low * (uint64_t)b;
rh = (uint64_t)u.l.high * (uint64_t)b;
rh += (rl >> 32);
res.l.high = rh / c;
res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
return res.ll;
}
#endif #endif
/** /**

1
include/qemu/timer.h
View File

@ -4,6 +4,7 @@
#include "qemu/typedefs.h" #include "qemu/typedefs.h"
#include "qemu-common.h" #include "qemu-common.h"
#include "qemu/notify.h" #include "qemu/notify.h"
#include "qemu/host-utils.h"
#define NANOSECONDS_PER_SECOND 1000000000LL #define NANOSECONDS_PER_SECOND 1000000000LL