mirror of
https://github.com/odin-lang/Odin.git
synced 2025-12-29 09:24:33 +00:00
136 lines
3.3 KiB
Odin
136 lines
3.3 KiB
Odin
package runtime
|
|
|
|
@(link_name="__umodti3")
|
|
umodti3 :: proc "c" (a, b: u128) -> u128 {
|
|
r: u128 = ---;
|
|
_ = udivmod128(a, b, &r);
|
|
return r;
|
|
}
|
|
|
|
|
|
@(link_name="__udivmodti4")
|
|
udivmodti4 :: proc "c" (a, b: u128, rem: ^u128) -> u128 {
|
|
return udivmod128(a, b, rem);
|
|
}
|
|
|
|
@(link_name="__udivti3")
|
|
udivti3 :: proc "c" (a, b: u128) -> u128 {
|
|
return udivmodti4(a, b, nil);
|
|
}
|
|
|
|
|
|
@(link_name="__modti3")
|
|
modti3 :: proc "c" (a, b: i128) -> i128 {
|
|
s_a := a >> (128 - 1);
|
|
s_b := b >> (128 - 1);
|
|
an := (a ~ s_a) - s_a;
|
|
bn := (b ~ s_b) - s_b;
|
|
|
|
r: u128 = ---;
|
|
_ = udivmod128(transmute(u128)an, transmute(u128)bn, &r);
|
|
return (transmute(i128)r ~ s_a) - s_a;
|
|
}
|
|
|
|
|
|
@(link_name="__divmodti4")
|
|
divmodti4 :: proc "c" (a, b: i128, rem: ^i128) -> i128 {
|
|
u := udivmod128(transmute(u128)a, transmute(u128)b, cast(^u128)rem);
|
|
return transmute(i128)u;
|
|
}
|
|
|
|
@(link_name="__divti3")
|
|
divti3 :: proc "c" (a, b: i128) -> i128 {
|
|
u := udivmodti4(transmute(u128)a, transmute(u128)b, nil);
|
|
return transmute(i128)u;
|
|
}
|
|
|
|
|
|
@(link_name="__fixdfti")
|
|
fixdfti :: proc(a: u64) -> i128 {
|
|
significandBits :: 52;
|
|
typeWidth :: (size_of(u64)*8);
|
|
exponentBits :: (typeWidth - significandBits - 1);
|
|
maxExponent :: ((1 << exponentBits) - 1);
|
|
exponentBias :: (maxExponent >> 1);
|
|
|
|
implicitBit :: (u64(1) << significandBits);
|
|
significandMask :: (implicitBit - 1);
|
|
signBit :: (u64(1) << (significandBits + exponentBits));
|
|
absMask :: (signBit - 1);
|
|
exponentMask :: (absMask ~ significandMask);
|
|
|
|
// Break a into sign, exponent, significand
|
|
aRep := a;
|
|
aAbs := aRep & absMask;
|
|
sign := i128(-1 if aRep & signBit != 0 else 1);
|
|
exponent := u64((aAbs >> significandBits) - exponentBias);
|
|
significand := u64((aAbs & significandMask) | implicitBit);
|
|
|
|
// If exponent is negative, the result is zero.
|
|
if exponent < 0 {
|
|
return 0;
|
|
}
|
|
|
|
// If the value is too large for the integer type, saturate.
|
|
if exponent >= size_of(i128) * 8 {
|
|
return max(i128) if sign == 1 else min(i128);
|
|
}
|
|
|
|
// If 0 <= exponent < significandBits, right shift to get the result.
|
|
// Otherwise, shift left.
|
|
if exponent < significandBits {
|
|
return sign * i128(significand >> (significandBits - exponent));
|
|
} else {
|
|
return sign * (i128(significand) << (exponent - significandBits));
|
|
}
|
|
|
|
}
|
|
|
|
@(default_calling_convention = "none")
|
|
foreign {
|
|
@(link_name="llvm.ctlz.i128") _clz_i128 :: proc(x: i128, is_zero_undef := false) -> i128 ---
|
|
}
|
|
|
|
|
|
@(link_name="__floattidf")
|
|
floattidf :: proc(a: i128) -> f64 {
|
|
DBL_MANT_DIG :: 53;
|
|
if a == 0 {
|
|
return 0.0;
|
|
}
|
|
a := a;
|
|
N :: size_of(i128) * 8;
|
|
s := a >> (N-1);
|
|
a = (a ~ s) - s;
|
|
sd: = N - _clz_i128(a); // number of significant digits
|
|
e := u32(sd - 1); // exponent
|
|
if sd > DBL_MANT_DIG {
|
|
switch sd {
|
|
case DBL_MANT_DIG + 1:
|
|
a <<= 1;
|
|
case DBL_MANT_DIG + 2:
|
|
// okay
|
|
case:
|
|
a = i128(u128(a) >> u128(sd - (DBL_MANT_DIG+2))) |
|
|
i128(u128(a) & (~u128(0) >> u128(N + DBL_MANT_DIG+2 - sd)) != 0);
|
|
};
|
|
|
|
a |= i128((a & 4) != 0);
|
|
a += 1;
|
|
a >>= 2;
|
|
|
|
if a & (1 << DBL_MANT_DIG) != 0 {
|
|
a >>= 1;
|
|
e += 1;
|
|
}
|
|
} else {
|
|
a <<= u128(DBL_MANT_DIG - sd);
|
|
}
|
|
fb: [2]u32;
|
|
fb[1] = (u32(s) & 0x80000000) | // sign
|
|
((e + 1023) << 20) | // exponent
|
|
((u32(a) >> 32) & 0x000FFFFF); // mantissa-high
|
|
fb[1] = u32(a); // mantissa-low
|
|
return transmute(f64)fb;
|
|
}
|