github/acrn-hypervisor
1
0
Fork 0
mirror of https://github.com/projectacrn/acrn-hypervisor.git synced 2025-06-21 21:19:35 +00:00
Code Issues Projects Releases Wiki Activity

hv: clean up div related code

Browse Source 
- replace udiv64 with direct integer divide
- remove lib/div.c

Tracked-On: #861
Signed-off-by: Shiqing Gao <shiqing.gao@intel.com>
Acked-by: Eddie Dong <eddie.dong@intel.com>
This commit is contained in:
Shiqing Gao 2018-09-12 13:31:42 +08:00 committed by lijinxia
parent 1d2ed1adee
commit 7cab77dace
4 changed files with 2 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
hypervisor/Makefile
View File

@ -154,7 +154,6 @@ C_SRCS += arch/x86/guest/pm.c
C_SRCS += lib/spinlock.c
C_SRCS += lib/udelay.c
C_SRCS += lib/mdelay.c
C_SRCS += lib/div.c
C_SRCS += lib/string.c
C_SRCS += lib/memory.c
C_SRCS += lib/crypto/hkdf_wrap.c

8
hypervisor/include/lib/rtl.h
View File

@ -19,12 +19,6 @@ union u_qword {
};
struct udiv_result {
union u_qword q;
union u_qword r;
};
/* Function prototypes */
void udelay(uint32_t us);
void *memchr(const void *void_s, int c, size_t n);
@ -37,8 +31,6 @@ void mdelay(uint32_t loop_count_arg);
size_t strnlen_s(const char *str_arg, size_t maxlen_arg);
void *memset(void *base, uint8_t v, size_t n);
void *memcpy_s(void *d, size_t dmax, const void *s, size_t slen_arg);
int udiv64(uint64_t dividend_arg, uint64_t divisor_arg, struct udiv_result *res);
int udiv32(uint32_t dividend, uint32_t divisor, struct udiv_result *res);
int atoi(const char *str);
long strtol_deci(const char *nptr);
uint64_t strtoul_hex(const char *nptr);

118
hypervisor/lib/div.c
View File

@ -1,118 +0,0 @@
/*
* Copyright (C) 2018 Intel Corporation. All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#include <hv_lib.h>
static int do_udiv32(uint32_t dividend_arg, uint32_t divisor_arg,
struct udiv_result *res)
{
uint32_t dividend = dividend_arg;
uint32_t divisor = divisor_arg;
uint32_t mask;
/* dividend is always greater than or equal to the divisor. Neither
* divisor nor dividend are 0. Thus: * clz(dividend) and clz(divisor)
* are valid * clz(dividend)<=clz(divisor)
*/
mask = (uint32_t)(clz(divisor) - clz(dividend));
/* align divisor and dividend */
divisor <<= mask;
mask = 1U << mask;
/* division loop */
do {
if (dividend >= divisor) {
dividend -= divisor;
res->q.dwords.low |= mask;
}
divisor >>= 1U;
mask >>= 1U;
} while ((mask != 0U) && (dividend != 0U));
/* dividend now contains the reminder */
res->r.dwords.low = dividend;
return 0;
}
int udiv32(uint32_t dividend, uint32_t divisor, struct udiv_result *res)
{
/* initialize the result */
res->q.dwords.low = 0U;
res->r.dwords.low = 0U;
/* test for "division by 0" condition */
if (divisor == 0U) {
res->q.dwords.low = 0xffffffffU;
return 1;
}
/* trivial case: divisor==dividend */
if (divisor == dividend) {
res->q.dwords.low = 1U;
return 0;
}
/* trivial case: divisor>dividend */
if (divisor > dividend) {
res->r.dwords.low = dividend;
return 0;
}
/* now that the trivial cases are eliminated we can call the generic
* function.
*/
return do_udiv32(dividend, divisor, res);
}
int udiv64(uint64_t dividend_arg, uint64_t divisor_arg, struct udiv_result *res)
{
uint64_t dividend = dividend_arg;
uint64_t divisor = divisor_arg;
uint64_t mask;
uint64_t bits;
/* initialize the result */
res->q.qword = 0UL;
res->r.qword = 0UL;
/* test for "division by 0" condition */
if (divisor == 0UL) {
res->q.qword = 0xffffffffffffffffUL;
return -1;
}
/* trivial case: divisor==dividend */
if (divisor == dividend) {
res->q.qword = 1UL;
return 0;
}
/* trivial case: divisor>dividend */
if (divisor > dividend) {
res->r.qword = dividend;
return 0;
}
/* simplified case: only 32 bit operands Note that the preconditions
* for do_udiv32() are fulfilled, since the tests were made above.
*/
if (((divisor >> 32UL) == 0UL) && ((dividend >> 32UL) == 0UL)) {
return do_udiv32((uint32_t) dividend, (uint32_t) divisor, res);
}
/* dividend is always greater than or equal to the divisor. Neither
* divisor nor dividend are 0. Thus: * clz(dividend) and clz(divisor)
* are valid * clz(dividend)<=clz(divisor)
*/
/* align divisor and dividend. */
bits = (uint64_t)(clz64(divisor) - clz64(dividend));
divisor <<= bits;
mask = 1UL << bits;
/* division loop */
do {
if (dividend >= divisor) {
dividend -= divisor;
res->q.qword |= mask;
}
divisor >>= 1UL;
mask >>= 1UL;
} while (((bits--) != 0UL) && (dividend != 0UL));
res->r.qword = dividend;
return 0;
}

7
hypervisor/lib/sprintf.c
View File

@ -348,8 +348,6 @@ static int print_decimal(struct print_param *param, int64_t value)
union u_qword v;
/* next value in 32/64 bit */
union u_qword nv;
/* helper union for division result */
struct udiv_result d;
int ret;
/* assume an unsigned 64 bit value */
@ -381,10 +379,9 @@ static int print_decimal(struct print_param *param, int64_t value)
/* process 64 bit value as long as needed */
while (v.dwords.high != 0U) {
/* determine digits from right to left */
udiv64(v.qword, 10U, &d);
pos--;
*pos = d.r.dwords.low + '0';
v.qword = d.q.qword;
*pos = (char)(v.qword % 10UL) + '0';
v.qword = v.qword / 10UL;
}
/* process 32 bit (or reduced 64 bit) value */