Initial project import

tools/v/vlib/builtin/overflow/overflow.v

@@ -0,0 +1,494 @@
+module overflow
+
+// Functions for integer arithmetic overflow.
+fn C.__builtin_add_overflow(x any, y any, z voidptr) bool
+fn C.__builtin_sub_overflow(x any, y any, z voidptr) bool
+fn C.__builtin_mul_overflow(x any, y any, z voidptr) bool
+
+// add_i8 computes `x` + `y` for i8 values, and panic if overflow occurs
+@[inline]
+fn add_i8(x i8, y i8) i8 {
+	mut res := i8(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_add_overflow(x, y, &res)
+	} $else {
+		res64 := i64(x) + i64(y)
+		res = i8(res64)
+		is_overflow = res64 > max_i8 || res64 < min_i8
+	}
+	if is_overflow {
+		panic('attempt to add with overflow(i8(${x}) + i8(${y}))')
+	}
+	return res
+}
+
+// add_u8 computes `x` + `y` for u8 values, and panic if overflow occurs
+@[inline]
+fn add_u8(x u8, y u8) u8 {
+	mut res := u8(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_add_overflow(x, y, &res)
+	} $else {
+		res = x + y
+		is_overflow = res < x
+	}
+	if is_overflow {
+		panic('attempt to add with overflow(u8(${x}) + u8(${y}))')
+	}
+	return res
+}
+
+// sub_i8 computes `x` - `y` for i8 values, and panic if overflow occurs
+@[inline]
+fn sub_i8(x i8, y i8) i8 {
+	mut res := i8(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_sub_overflow(x, y, &res)
+	} $else {
+		res64 := i64(x) - i64(y)
+		res = i8(res64)
+		is_overflow = res64 > max_i8 || res64 < min_i8
+	}
+	if is_overflow {
+		panic('attempt to sub with overflow(i8(${x}) - i8(${y}))')
+	}
+	return res
+}
+
+// sub_u8 computes `x` - `y` for u8 values, and panic if overflow occurs
+@[inline]
+fn sub_u8(x u8, y u8) u8 {
+	mut res := u8(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_sub_overflow(x, y, &res)
+	} $else {
+		res = x - y
+		is_overflow = x < y
+	}
+	if is_overflow {
+		panic('attempt to sub with overflow(u8(${x}) - u8(${y}))')
+	}
+	return res
+}
+
+// mul_i8 computes `x` * `y` for i8 values, and panic if overflow occurs
+@[inline]
+fn mul_i8(x i8, y i8) i8 {
+	mut res := i8(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_mul_overflow(x, y, &res)
+	} $else {
+		res64 := i64(x) * i64(y)
+		res = i8(res64)
+		is_overflow = res64 > max_i8 || res64 < min_i8
+	}
+	if is_overflow {
+		panic('attempt to mul with overflow(i8(${x}) * i8(${y}))')
+	}
+	return res
+}
+
+// mul_u8 computes `x` * `y` for u8 values, and panic if overflow occurs
+@[inline]
+fn mul_u8(x u8, y u8) u8 {
+	mut res := u8(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_mul_overflow(x, y, &res)
+	} $else {
+		res64 := u64(x) * u64(y)
+		res = u8(res64)
+		is_overflow = res64 > max_u8
+	}
+	if is_overflow {
+		panic('attempt to mul with overflow(u8(${x}) * u8(${y}))')
+	}
+	return res
+}
+
+// add_i16 computes `x` + `y` for i16 values, and panic if overflow occurs
+@[inline]
+fn add_i16(x i16, y i16) i16 {
+	mut res := i16(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_add_overflow(x, y, &res)
+	} $else {
+		res64 := i64(x) + i64(y)
+		res = i16(res64)
+		is_overflow = res64 > max_i16 || res64 < min_i16
+	}
+	if is_overflow {
+		panic('attempt to add with overflow(i16(${x}) + i16(${y}))')
+	}
+	return res
+}
+
+// add_u16 computes `x` + `y` for u16 values, and panic if overflow occurs
+@[inline]
+fn add_u16(x u16, y u16) u16 {
+	mut res := u16(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_add_overflow(x, y, &res)
+	} $else {
+		res = x + y
+		is_overflow = res < x
+	}
+	if is_overflow {
+		panic('attempt to add with overflow(u16(${x}) + u16(${y}))')
+	}
+	return res
+}
+
+// sub_i16 computes `x` - `y` for i16 values, and panic if overflow occurs
+@[inline]
+fn sub_i16(x i16, y i16) i16 {
+	mut res := i16(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_sub_overflow(x, y, &res)
+	} $else {
+		res64 := i64(x) - i64(y)
+		res = i16(res64)
+		is_overflow = res64 > max_i16 || res64 < min_i16
+	}
+	if is_overflow {
+		panic('attempt to sub with overflow(i16(${x}) - i16(${y}))')
+	}
+	return res
+}
+
+// sub_u16 computes `x` - `y` for u16 values, and panic if overflow occurs
+@[inline]
+fn sub_u16(x u16, y u16) u16 {
+	mut res := u16(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_sub_overflow(x, y, &res)
+	} $else {
+		res = x - y
+		is_overflow = x < y
+	}
+	if is_overflow {
+		panic('attempt to sub with overflow(u16(${x}) - u16(${y}))')
+	}
+	return res
+}
+
+// mul_i16 computes `x` * `y` for i16 values, and panic if overflow occurs
+@[inline]
+fn mul_i16(x i16, y i16) i16 {
+	mut res := i16(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_mul_overflow(x, y, &res)
+	} $else {
+		res64 := i64(x) * i64(y)
+		res = i16(res64)
+		is_overflow = res64 > max_i16 || res64 < min_i16
+	}
+	if is_overflow {
+		panic('attempt to mul with overflow(i16(${x}) * i16(${y}))')
+	}
+	return res
+}
+
+// mul_u16 computes `x` * `y` for u16 values, and panic if overflow occurs
+@[inline]
+fn mul_u16(x u16, y u16) u16 {
+	mut res := u16(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_mul_overflow(x, y, &res)
+	} $else {
+		res64 := u64(x) * u64(y)
+		res = u16(res64)
+		is_overflow = res64 > max_u16
+	}
+	if is_overflow {
+		panic('attempt to mul with overflow(u16(${x}) * u16(${y}))')
+	}
+	return res
+}
+
+// add_i32 computes `x` + `y` for i32 values, and panic if overflow occurs
+@[inline]
+fn add_i32(x i32, y i32) i32 {
+	mut res := i32(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_add_overflow(x, y, &res)
+	} $else {
+		res64 := i64(x) + i64(y)
+		res = i32(res64)
+		is_overflow = res64 > max_i32 || res64 < min_i32
+	}
+	if is_overflow {
+		panic('attempt to add with overflow(i32(${x}) + i32(${y}))')
+	}
+	return res
+}
+
+// add_u32 computes `x` + `y` for u32 values, and panic if overflow occurs
+@[inline]
+fn add_u32(x u32, y u32) u32 {
+	mut res := u32(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_add_overflow(x, y, &res)
+	} $else {
+		res = x + y
+		is_overflow = res < x
+	}
+	if is_overflow {
+		panic('attempt to add with overflow(u32(${x}) + u32(${y}))')
+	}
+	return res
+}
+
+// sub_i32 computes `x` - `y` for i32 values, and panic if overflow occurs
+@[inline]
+fn sub_i32(x i32, y i32) i32 {
+	mut res := i32(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_sub_overflow(x, y, &res)
+	} $else {
+		res64 := i64(x) - i64(y)
+		res = i32(res64)
+		is_overflow = res64 > max_i32 || res64 < min_i32
+	}
+	if is_overflow {
+		panic('attempt to sub with overflow(i32(${x}) - i32(${y}))')
+	}
+	return res
+}
+
+// sub_u32 computes `x` - `y` for u32 values, and panic if overflow occurs
+@[inline]
+fn sub_u32(x u32, y u32) u32 {
+	mut res := u32(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_sub_overflow(x, y, &res)
+	} $else {
+		res = x - y
+		is_overflow = x < y
+	}
+	if is_overflow {
+		panic('attempt to sub with overflow(u32(${x}) - u32(${y}))')
+	}
+	return res
+}
+
+// mul_i32 computes `x` * `y` for i32 values, and panic if overflow occurs
+@[inline]
+fn mul_i32(x i32, y i32) i32 {
+	mut res := i32(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_mul_overflow(x, y, &res)
+	} $else {
+		res64 := i64(x) * i64(y)
+		res = i32(res64)
+		is_overflow = res64 > max_i32 || res64 < min_i32
+	}
+	if is_overflow {
+		panic('attempt to mul with overflow(i32(${x}) * i32(${y}))')
+	}
+	return res
+}
+
+// mul_u32 computes `x` * `y` for u32 values, and panic if overflow occurs
+@[inline]
+fn mul_u32(x u32, y u32) u32 {
+	mut res := u32(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_mul_overflow(x, y, &res)
+	} $else {
+		res64 := u64(x) * u64(y)
+		res = u32(res64)
+		is_overflow = res64 > max_u32
+	}
+	if is_overflow {
+		panic('attempt to mul with overflow(u32(${x}) * u32(${y}))')
+	}
+	return res
+}
+
+// add_i64 computes `x` + `y` for i64 values, and panic if overflow occurs
+@[inline]
+fn add_i64(x i64, y i64) i64 {
+	mut res := i64(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_add_overflow(x, y, &res)
+	} $else {
+		res = x + y
+		is_overflow = (x > 0 && y > 0 && res < 0) || (x < 0 && y < 0 && res > 0)
+	}
+	if is_overflow {
+		panic('attempt to add with overflow(i64(${x}) + i64(${y}))')
+	}
+	return res
+}
+
+// add_u64 computes `x` + `y` for u64 values, and panic if overflow occurs
+@[inline]
+fn add_u64(x u64, y u64) u64 {
+	mut res := u64(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_add_overflow(x, y, &res)
+	} $else {
+		res = x + y
+		is_overflow = res < x
+	}
+	if is_overflow {
+		panic('attempt to add with overflow(u64(${x}) + u64(${y}))')
+	}
+	return res
+}
+
+// sub_i64 computes `x` - `y` for i64 values, and panic if overflow occurs
+@[inline]
+fn sub_i64(x i64, y i64) i64 {
+	mut res := i64(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_sub_overflow(x, y, &res)
+	} $else {
+		res = x - y
+		is_overflow = (x >= 0 && y < 0 && res < 0) || (x < 0 && y > 0 && res > 0)
+	}
+	if is_overflow {
+		panic('attempt to sub with overflow(i64(${x}) - i64(${y}))')
+	}
+	return res
+}
+
+// sub_u64 computes `x` - `y` for u64 values, and panic if overflow occurs
+@[inline]
+fn sub_u64(x u64, y u64) u64 {
+	mut res := u64(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_sub_overflow(x, y, &res)
+	} $else {
+		res = x - y
+		is_overflow = x < y
+	}
+	if is_overflow {
+		panic('attempt to sub with overflow(u64(${x}) - u64(${y}))')
+	}
+	return res
+}
+
+// mul_i64 computes `x` * `y` for i64 values, and panic if overflow occurs
+@[inline]
+fn mul_i64(x i64, y i64) i64 {
+	mut res := i64(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_mul_overflow(x, y, &res)
+	} $else {
+		res = x * y
+		if x == 0 || y == 0 {
+			is_overflow = false
+		} else if x == min_i64 {
+			is_overflow = y != 1
+		} else if y == min_i64 {
+			is_overflow = x != 1
+		} else {
+			if x > 0 {
+				if y > 0 {
+					is_overflow = x > max_i64 / y
+				} else {
+					is_overflow = y < min_i64 / x
+				}
+			} else if x < 0 {
+				if y > 0 {
+					is_overflow = x < min_i64 / y
+				} else {
+					is_overflow = y < max_i64 / x
+				}
+			}
+		}
+	}
+	if is_overflow {
+		panic('attempt to mul with overflow(i64(${x}) * i64(${y}))')
+	}
+	return res
+}
+
+// mul_u64 computes `x` * `y` for u64 values, and panic if overflow occurs
+@[inline]
+fn mul_u64(x u64, y u64) u64 {
+	mut res := u64(0)
+	mut is_overflow := false
+	$if gcc || clang {
+		is_overflow = C.__builtin_mul_overflow(x, y, &res)
+	} $else {
+		res = x * y
+		is_overflow = y != 0 && x > max_u64 / y
+	}
+	if is_overflow {
+		panic('attempt to mul with overflow(u64(${x}) * u64(${y}))')
+	}
+	return res
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// These are here to prevent cgen errors for `./v -check-overflow vlib/math/vec/vec4_test.v`
+// TODO: check for correctness and add tests. Improve markused so it keeps them, when they are used.
+@[inline; markused]
+fn add_int(x int, y int) int {
+	return add_i32(x, y)
+}
+
+@[inline; markused]
+fn sub_int(x int, y int) int {
+	return sub_i32(x, y)
+}
+
+@[inline; markused]
+fn mul_int(x int, y int) int {
+	return mul_i32(x, y)
+}
+
+@[inline; markused]
+fn add_f32(x f32, y f32) f32 {
+	return x + y
+}
+
+@[inline; markused]
+fn sub_f32(x f32, y f32) f32 {
+	return x - y
+}
+
+@[inline; markused]
+fn mul_f32(x f32, y f32) f32 {
+	return x * y
+}
+
+@[inline; markused]
+fn add_f64(x f64, y f64) f64 {
+	return x + y
+}
+
+@[inline; markused]
+fn sub_f64(x f64, y f64) f64 {
+	return x - y
+}
+
+@[inline; markused]
+fn mul_f64(x f64, y f64) f64 {
+	return x * y
+}