Add extra 128 bit integer procedures

core/runtime/internal_windows.odin

@@ -1,7 +1,26 @@
 package runtime
 
 @(link_name="__umodti3")
-umodti3 :: proc "c" (a, b: i128) -> i128 {
+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;
@@ -13,12 +32,104 @@ umodti3 :: proc "c" (a, b: i128) -> i128 {
 }
 
 
-@(link_name="__udivmodti4")
-udivmodti4 :: proc "c" (a, b: u128, rem: ^u128) -> u128 {
-	return udivmod128(a, b, rem);
+@(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="__udivti3")
-udivti3 :: proc "c" (a, b: u128) -> u128 {
-	return udivmodti4(a, b, nil);
+@(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;
 }

src/checker.cpp

@@ -1706,6 +1706,11 @@ void generate_minimum_dependency_set(Checker *c, Entity *start) {
 
 		str_lit("umodti3"),
 		str_lit("udivti3"),
+		str_lit("modti3"),
+		str_lit("divti3"),
+		str_lit("fixdfti"),
+		str_lit("floattidf"),
+
 
 		str_lit("memset"),
 		str_lit("memcpy"),