Merge remote-tracking branch 'Kernel/master'

Kernel/arch/i386/arithmetic_operations.c

@@ -0,0 +1,379 @@
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+
+/* Source: https://github.com/glitchub/arith64 */
+#define arith64_u64 unsigned long long int
+#define arith64_s64 signed long long int
+#define arith64_u32 unsigned int
+#define arith64_s32 int
+
+typedef union
+{
+	arith64_u64 u64;
+	arith64_s64 s64;
+	struct
+	{
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+		arith64_u32 hi;
+		arith64_u32 lo;
+#else
+		arith64_u32 lo;
+		arith64_u32 hi;
+#endif
+	} u32;
+	struct
+	{
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+		arith64_s32 hi;
+		arith64_s32 lo;
+#else
+		arith64_s32 lo;
+		arith64_s32 hi;
+#endif
+	} s32;
+} arith64_word;
+
+#define arith64_hi(n) (arith64_word){.u64 = n}.u32.hi
+#define arith64_lo(n) (arith64_word){.u64 = n}.u32.lo
+#define arith64_neg(a, b) (((a) ^ ((((arith64_s64)(b)) >= 0) - 1)) + (((arith64_s64)(b)) < 0))
+#define arith64_abs(a) arith64_neg(a, a)
+
+arith64_s64 __absvdi2(arith64_s64 a)
+{
+	return arith64_abs(a);
+}
+
+arith64_s64 __ashldi3(arith64_s64 a, int b)
+{
+	arith64_word w = {.s64 = a};
+
+	b &= 63;
+
+	if (b >= 32)
+	{
+		w.u32.hi = w.u32.lo << (b - 32);
+		w.u32.lo = 0;
+	}
+	else if (b)
+	{
+		w.u32.hi = (w.u32.lo >> (32 - b)) | (w.u32.hi << b);
+		w.u32.lo <<= b;
+	}
+	return w.s64;
+}
+
+arith64_s64 __ashrdi3(arith64_s64 a, int b)
+{
+	arith64_word w = {.s64 = a};
+
+	b &= 63;
+
+	if (b >= 32)
+	{
+		w.s32.lo = w.s32.hi >> (b - 32);
+		w.s32.hi >>= 31; // 0xFFFFFFFF or 0
+	}
+	else if (b)
+	{
+		w.u32.lo = (w.u32.hi << (32 - b)) | (w.u32.lo >> b);
+		w.s32.hi >>= b;
+	}
+	return w.s64;
+}
+
+int __clzsi2(arith64_u32 a)
+{
+	int b, n = 0;
+	b = !(a & 0xffff0000) << 4;
+	n += b;
+	a <<= b;
+	b = !(a & 0xff000000) << 3;
+	n += b;
+	a <<= b;
+	b = !(a & 0xf0000000) << 2;
+	n += b;
+	a <<= b;
+	b = !(a & 0xc0000000) << 1;
+	n += b;
+	a <<= b;
+	return n + !(a & 0x80000000);
+}
+
+int __clzdi2(arith64_u64 a)
+{
+	int b, n = 0;
+	b = !(a & 0xffffffff00000000ULL) << 5;
+	n += b;
+	a <<= b;
+	b = !(a & 0xffff000000000000ULL) << 4;
+	n += b;
+	a <<= b;
+	b = !(a & 0xff00000000000000ULL) << 3;
+	n += b;
+	a <<= b;
+	b = !(a & 0xf000000000000000ULL) << 2;
+	n += b;
+	a <<= b;
+	b = !(a & 0xc000000000000000ULL) << 1;
+	n += b;
+	a <<= b;
+	return n + !(a & 0x8000000000000000ULL);
+}
+
+int __ctzsi2(arith64_u32 a)
+{
+	int b, n = 0;
+	b = !(a & 0x0000ffff) << 4;
+	n += b;
+	a >>= b;
+	b = !(a & 0x000000ff) << 3;
+	n += b;
+	a >>= b;
+	b = !(a & 0x0000000f) << 2;
+	n += b;
+	a >>= b;
+	b = !(a & 0x00000003) << 1;
+	n += b;
+	a >>= b;
+	return n + !(a & 0x00000001);
+}
+
+int __ctzdi2(arith64_u64 a)
+{
+	int b, n = 0;
+	b = !(a & 0x00000000ffffffffULL) << 5;
+	n += b;
+	a >>= b;
+	b = !(a & 0x000000000000ffffULL) << 4;
+	n += b;
+	a >>= b;
+	b = !(a & 0x00000000000000ffULL) << 3;
+	n += b;
+	a >>= b;
+	b = !(a & 0x000000000000000fULL) << 2;
+	n += b;
+	a >>= b;
+	b = !(a & 0x0000000000000003ULL) << 1;
+	n += b;
+	a >>= b;
+	return n + !(a & 0x0000000000000001ULL);
+}
+
+arith64_u64 __divmoddi4(arith64_u64 a, arith64_u64 b, arith64_u64 *c)
+{
+	if (b > a)
+	{
+		if (c)
+			*c = a;
+		return 0;
+	}
+	if (!arith64_hi(b))
+	{
+		if (b == 0)
+		{
+			volatile char x = 0;
+			x = 1 / x;
+		}
+		if (b == 1)
+		{
+			if (c)
+				*c = 0;
+			return a;
+		}
+		if (!arith64_hi(a))
+		{
+			if (c)
+				*c = arith64_lo(a) % arith64_lo(b);
+			return arith64_lo(a) / arith64_lo(b);
+		}
+	}
+
+	char bits = __clzdi2(b) - __clzdi2(a) + 1;
+	arith64_u64 rem = a >> bits;
+	a <<= 64 - bits;
+	arith64_u64 wrap = 0;
+	while (bits-- > 0)
+	{
+		rem = (rem << 1) | (a >> 63);
+		a = (a << 1) | (wrap & 1);
+		wrap = ((arith64_s64)(b - rem - 1) >> 63);
+		rem -= b & wrap;
+	}
+	if (c)
+		*c = rem;
+	return (a << 1) | (wrap & 1);
+}
+
+arith64_s64 __divdi3(arith64_s64 a, arith64_s64 b)
+{
+	arith64_u64 q = __divmoddi4(arith64_abs(a), arith64_abs(b), (void *)0);
+	return arith64_neg(q, a ^ b);
+}
+
+int __ffsdi2(arith64_u64 a) { return a ? __ctzdi2(a) + 1 : 0; }
+
+arith64_u64 __lshrdi3(arith64_u64 a, int b)
+{
+	arith64_word w = {.u64 = a};
+
+	b &= 63;
+
+	if (b >= 32)
+	{
+		w.u32.lo = w.u32.hi >> (b - 32);
+		w.u32.hi = 0;
+	}
+	else if (b)
+	{
+		w.u32.lo = (w.u32.hi << (32 - b)) | (w.u32.lo >> b);
+		w.u32.hi >>= b;
+	}
+	return w.u64;
+}
+
+arith64_s64 __moddi3(arith64_s64 a, arith64_s64 b)
+{
+	arith64_u64 r;
+	__divmoddi4(arith64_abs(a), arith64_abs(b), &r);
+	return arith64_neg(r, a);
+}
+
+int __popcountsi2(arith64_u32 a)
+{
+
+	a = a - ((a >> 1) & 0x55555555);
+	a = ((a >> 2) & 0x33333333) + (a & 0x33333333);
+	a = (a + (a >> 4)) & 0x0F0F0F0F;
+	a = (a + (a >> 16));
+
+	return (a + (a >> 8)) & 63;
+}
+
+int __popcountdi2(arith64_u64 a)
+{
+
+	a = a - ((a >> 1) & 0x5555555555555555ULL);
+	a = ((a >> 2) & 0x3333333333333333ULL) + (a & 0x3333333333333333ULL);
+	a = (a + (a >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
+	a = (a + (a >> 32));
+	a = (a + (a >> 16));
+
+	return (a + (a >> 8)) & 127;
+}
+
+arith64_u64 __udivdi3(arith64_u64 a, arith64_u64 b) { return __divmoddi4(a, b, (void *)0); }
+
+arith64_u64 __umoddi3(arith64_u64 a, arith64_u64 b)
+{
+	arith64_u64 r;
+	__divmoddi4(a, b, &r);
+	return r;
+}
+
+/* Good documentation: https://splichal.eu/scripts/sphinx/gccint/_build/html/the-gcc-low-level-runtime-library/routines-for-floating-point-emulation.html */
+
+double __adddf3(double a, double b) { return a + b; }
+double __muldf3(double a, double b) { return a * b; }
+double __floatsidf(int i) { return (double)i; }
+int __ltdf2(double a, double b) { return a < b; }
+int __gtdf2(double a, double b) { return a > b; }
+int __nedf2(double a, double b) { return a != b; }
+int __eqdf2(double a, double b) { return a == b; }
+double __floatdidf(long i) { return (double)i; }
+double __divdf3(double a, double b) { return a / b; }
+double __subdf3(double a, double b) { return a - b; }
+int __gedf2(double a, double b) { return a >= b; }
+int __fixdfsi(double a) { return (int)a; }
+long __fixdfdi(double a) { return (long)a; }
+int __ledf2(double a, double b) { return a <= b; }
+
+/* FIXME: Check if these functions are implemented correctly */
+
+typedef long long int64_t;
+typedef unsigned long long uint64_t;
+typedef unsigned int uint32_t;
+typedef struct
+{
+	uint64_t value;
+} atomic_uint64_t;
+
+/* No longer needed? */
+
+// uint64_t __atomic_load_8(const atomic_uint64_t *p)
+// {
+// 	uint64_t value;
+// 	__asm__ volatile("lock cmpxchg8b %1"
+// 					 : "=A"(value)
+// 					 : "m"(*p)
+// 					 : "memory");
+// 	return value;
+// }
+
+// void __atomic_store_8(atomic_uint64_t *p, uint64_t value)
+// {
+// 	__asm__ volatile("lock cmpxchg8b %0"
+// 					 : "=m"(p->value)
+// 					 : "a"((uint32_t)value), "d"((uint32_t)(value >> 32)), "m"(*p)
+// 					 : "memory");
+// }
+
+int __fixsfsi(float a)
+{
+	return (int)a;
+}
+
+int __ltsf2(float a, float b)
+{
+	return -(a < b);
+}
+
+int __nesf2(float a, float b)
+{
+	return a == b;
+}
+
+int __eqsf2(float a, float b)
+{
+	return !(a == b);
+}
+
+float __divsf3(float a, float b)
+{
+	return (a / b);
+}
+
+double __extendsfdf2(float a)
+{
+	return (double)a;
+}
+
+float __truncdfsf2(double a)
+{
+	return (float)a;
+}
+
+float __subsf3(float a, float b)
+{
+	return (a - b);
+}
+
+float __floatsisf(int a)
+{
+	return (float)a;
+}
+
+int __fixunssfsi(float a)
+{
+	return (int)a;
+}
+
+float __mulsf3(float a, float b)
+{
+	return (a * b);
+}
+
+float __addsf3(float a, float b)
+{
+	return (a + b);
+}