AK: Implement C++ 'Time' type for easier time-calculations

This adds a bunch of code in the hope that other, wrong code can be deleted.

Related to #5315.

AK/Time.cpp

@@ -25,8 +25,18 @@
  */
 
 #include <AK/Assertions.h>
+#include <AK/Checked.h>
+#include <AK/LogStream.h>
 #include <AK/Time.h>
 
+// Make a reasonable guess as to which timespec/timeval definition to use.
+// It doesn't really matter, since both are identical.
+#ifdef KERNEL
+#    include <Kernel/UnixTypes.h>
+#else
+#    include <sys/time.h>
+#endif
+
 namespace AK {
 
 int day_of_year(int year, unsigned month, int day)
@@ -61,4 +71,127 @@ unsigned day_of_week(int year, unsigned month, int day)
 
     return (year + year / 4 - year / 100 + year / 400 + seek_table[month - 1] + day) % 7;
 }
+
+ALWAYS_INLINE static i32 sane_mod(i32& numerator, i32 denominator)
+{
+    VERIFY(2 <= denominator && denominator <= 1'000'000'000);
+    // '%' in C/C++ does not work in the obvious way:
+    // For example, -9 % 7 is -2, not +5.
+    // However, we want a representation like "(-2)*7 + (+5)".
+    i32 dividend = numerator / denominator;
+    numerator %= denominator;
+    if (numerator < 0) {
+        // Does not overflow: different signs.
+        numerator += denominator;
+        // Does not underflow: denominator >= 2.
+        dividend -= 1;
+    }
+    return dividend;
+}
+Time Time::from_timespec(const struct timespec& ts)
+{
+    i32 nsecs = ts.tv_nsec;
+    i32 extra_secs = sane_mod(nsecs, 1'000'000'000);
+    return Time::from_half_sanitized(ts.tv_sec, extra_secs, nsecs);
+}
+Time Time::from_timeval(const struct timeval& tv)
+{
+    i32 usecs = tv.tv_usec;
+    i32 extra_secs = sane_mod(usecs, 1'000'000);
+    VERIFY(0 <= usecs && usecs < 1'000'000);
+    return Time::from_half_sanitized(tv.tv_sec, extra_secs, usecs * 1'000);
+}
+
+timespec Time::to_timespec() const
+{
+    VERIFY(m_nanoseconds < 1'000'000'000);
+    return { static_cast<i64>(m_seconds), static_cast<i32>(m_nanoseconds) };
+}
+timeval Time::to_timeval() const
+{
+    VERIFY(m_nanoseconds < 1'000'000'000);
+    return { static_cast<i64>(m_seconds), static_cast<i32>(m_nanoseconds) / 1000 };
+}
+
+Time Time::operator+(const Time& other) const
+{
+    VERIFY(m_nanoseconds < 1'000'000'000);
+    VERIFY(other.m_nanoseconds < 1'000'000'000);
+
+    u32 new_nsecs = m_nanoseconds + other.m_nanoseconds;
+    u32 extra_secs = new_nsecs / 1'000'000'000;
+    new_nsecs %= 1'000'000'000;
+
+    i64 this_secs = m_seconds;
+    i64 other_secs = other.m_seconds;
+    // We would like to just add "this_secs + other_secs + extra_secs".
+    // However, computing this naively may overflow even though the result is in-bounds.
+    // Example in 8-bit: (-127) + (-2) + (+1) = (-128), which fits in an i8.
+    // Example in 8-bit, the other way around: (-2) + (127) + (+1) = 126.
+    // So we do something more sophisticated:
+    if (extra_secs) {
+        VERIFY(extra_secs == 1);
+        if (this_secs != 0x7fff'ffff'ffff'ffff) {
+            this_secs += 1;
+        } else if (other_secs != 0x7fff'ffff'ffff'ffff) {
+            other_secs += 1;
+        } else {
+            /* If *both* are INT64_MAX, then adding them will overflow in any case. */
+            return Time::max();
+        }
+        extra_secs = 0;
+    }
+
+    Checked<i64> new_secs { this_secs };
+    new_secs += other_secs;
+    if (new_secs.has_overflow()) {
+        if (other_secs > 0)
+            return Time::max();
+        else
+            return Time::min();
+    }
+
+    return Time { new_secs.value(), new_nsecs };
+}
+Time Time::operator-(const Time& other) const
+{
+    VERIFY(m_nanoseconds < 1'000'000'000);
+    VERIFY(other.m_nanoseconds < 1'000'000'000);
+
+    if (other.m_nanoseconds)
+        return *this + Time((i64) ~(u64)other.m_seconds, 1'000'000'000 - other.m_nanoseconds);
+
+    if (other.m_seconds != (i64)-0x8000'0000'0000'0000)
+        return *this + Time(-other.m_seconds, 0);
+
+    // Only remaining case: We want to subtract -0x8000'0000'0000'0000 seconds,
+    // i.e. add a very large number.
+
+    if (m_seconds >= 0)
+        return Time::max();
+    return Time { (m_seconds + 0x4000'0000'0000'0000) + 0x4000'0000'0000'0000, m_nanoseconds };
+}
+
+Time Time::from_half_sanitized(i64 seconds, i32 extra_seconds, u32 nanoseconds)
+{
+    VERIFY(nanoseconds < 1'000'000'000);
+
+    if ((seconds <= 0 && extra_seconds > 0) || (seconds >= 0 && extra_seconds < 0)) {
+        // Opposite signs mean that we can definitely add them together without fear of overflowing i64:
+        seconds += extra_seconds;
+        extra_seconds = 0;
+    }
+
+    // Now the only possible way to become invalid is overflowing i64 towards positive infinity:
+    if (Checked<i64>::addition_would_overflow<i64, i64>(seconds, extra_seconds)) {
+        if (seconds < 0) {
+            return Time::min();
+        } else {
+            return Time::max();
+        }
+    }
+
+    return Time { seconds + extra_seconds, nanoseconds };
+}
+
 }