mirror of
https://github.com/darlinghq/darling-xnu.git
synced 2024-11-26 22:10:24 +00:00
104 lines
2.8 KiB
C
104 lines
2.8 KiB
C
/*
|
|
* Copyright (c) 1999, 2003, 2006, 2007, 2010 Apple Inc. All rights reserved.
|
|
*
|
|
* @APPLE_LICENSE_HEADER_START@
|
|
*
|
|
* This file contains Original Code and/or Modifications of Original Code
|
|
* as defined in and that are subject to the Apple Public Source License
|
|
* Version 2.0 (the 'License'). You may not use this file except in
|
|
* compliance with the License. Please obtain a copy of the License at
|
|
* http://www.opensource.apple.com/apsl/ and read it before using this
|
|
* file.
|
|
*
|
|
* The Original Code and all software distributed under the License are
|
|
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
|
|
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
|
|
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
|
|
* Please see the License for the specific language governing rights and
|
|
* limitations under the License.
|
|
*
|
|
* @APPLE_LICENSE_HEADER_END@
|
|
*/
|
|
/*
|
|
* Code duplicated from Libc/gen/nanosleep.c
|
|
*/
|
|
|
|
#ifndef _ARITHMETIC_128_H_
|
|
#define _ARITHMETIC_128_H_
|
|
|
|
#include <stdint.h>
|
|
|
|
#if __LP64__
|
|
|
|
static __inline uint64_t
|
|
multi_overflow(uint64_t a, uint64_t b)
|
|
{
|
|
__uint128_t prod;
|
|
prod = (__uint128_t)a * (__uint128_t)b;
|
|
return (uint64_t) (prod >> 64);
|
|
}
|
|
|
|
#else
|
|
|
|
typedef struct {
|
|
uint64_t high;
|
|
uint64_t low;
|
|
} uint128_data_t;
|
|
|
|
/* 128-bit addition: acc += add */
|
|
static __inline void
|
|
add128_128(uint128_data_t *acc, uint128_data_t *add)
|
|
{
|
|
acc->high += add->high;
|
|
acc->low += add->low;
|
|
if (acc->low < add->low) {
|
|
acc->high++; // carry
|
|
}
|
|
}
|
|
|
|
/* 64x64 -> 128 bit multiplication */
|
|
static __inline void
|
|
mul64x64(uint64_t x, uint64_t y, uint128_data_t *prod)
|
|
{
|
|
uint128_data_t add;
|
|
/*
|
|
* Split the two 64-bit multiplicands into 32-bit parts:
|
|
* x => 2^32 * x1 + x2
|
|
* y => 2^32 * y1 + y2
|
|
*/
|
|
uint32_t x1 = (uint32_t)(x >> 32);
|
|
uint32_t x2 = (uint32_t)x;
|
|
uint32_t y1 = (uint32_t)(y >> 32);
|
|
uint32_t y2 = (uint32_t)y;
|
|
/*
|
|
* direct multiplication:
|
|
* x * y => 2^64 * (x1 * y1) + 2^32 (x1 * y2 + x2 * y1) + (x2 * y2)
|
|
* The first and last terms are direct assignmenet into the uint128_t
|
|
* structure. Then we add the middle two terms separately, to avoid
|
|
* 64-bit overflow. (We could use the Karatsuba algorithm to save
|
|
* one multiply, but it is harder to deal with 64-bit overflows.)
|
|
*/
|
|
prod->high = (uint64_t)x1 * (uint64_t)y1;
|
|
prod->low = (uint64_t)x2 * (uint64_t)y2;
|
|
add.low = (uint64_t)x1 * (uint64_t)y2;
|
|
add.high = (add.low >> 32);
|
|
add.low <<= 32;
|
|
add128_128(prod, &add);
|
|
add.low = (uint64_t)x2 * (uint64_t)y1;
|
|
add.high = (add.low >> 32);
|
|
add.low <<= 32;
|
|
add128_128(prod, &add);
|
|
}
|
|
|
|
static __inline uint64_t
|
|
multi_overflow(uint64_t a, uint64_t b)
|
|
{
|
|
uint128_data_t prod;
|
|
mul64x64(a, b, &prod);
|
|
return prod.high;
|
|
}
|
|
|
|
#endif /* __LP64__ */
|
|
#endif /* _ARITHMETIC_128_H_ */
|