Add bit32.s32() and bit32.smul() for signed 32-bit int math

Author: HaroldCindy

VM/src/lbitlib.cpp

@@ -252,6 +252,43 @@ static int b_swap(lua_State* L)
     return 1;
 }
 
+// ServerLua: convert double to signed 32-bit via fmod (no UB for any input)
+static int32_t double_to_s32(double n)
+{
+    // NaN/Inf: i386 fistp returns INT32_MIN ("integer indefinite")
+    if (!isfinite(n))
+        return INT32_MIN;
+    double truncated;
+    modf(n, &truncated);
+    // fmod handles arbitrarily large values; result is in (-2^32, 2^32)
+    constexpr double kUint32Mod = (double)UINT32_MAX + 1.0;
+    constexpr double kInt32Upper = -(double)INT32_MIN;
+    double result = fmod(truncated, kUint32Mod);
+    // Wrap into signed 32-bit range [-2^31, 2^31)
+    if (result >= kInt32Upper)
+        result -= kUint32Mod;
+    else if (result < -kInt32Upper)
+        result += kUint32Mod;
+    return (int32_t)result;
+}
+
+// ServerLua: normalize to signed 32-bit range using pure floating-point math (no UB)
+static int b_s32(lua_State* L)
+{
+    lua_pushnumber(L, (double)double_to_s32(luaL_checknumber(L, 1)));
+    return 1;
+}
+
+// ServerLua: signed 32-bit multiply without float64 precision loss
+static int b_smul(lua_State* L)
+{
+    int32_t a = double_to_s32(luaL_checknumber(L, 1));
+    int32_t b = double_to_s32(luaL_checknumber(L, 2));
+    int32_t result = (int32_t)((int64_t)a * (int64_t)b);
+    lua_pushnumber(L, (double)result);
+    return 1;
+}
+
 static const luaL_Reg bitlib[] = {
     {"arshift", b_arshift},
     {"band", b_and},
@@ -265,6 +302,8 @@ static const luaL_Reg bitlib[] = {
     {"replace", b_replace},
     {"rrotate", b_rrot},
     {"rshift", b_rshift},
+    {"s32", b_s32},
+    {"smul", b_smul},
     {"countlz", b_countlz},
     {"countrz", b_countrz},
     {"byteswap", b_swap},

tests/SLConformance.test.cpp

@@ -730,6 +730,11 @@ TEST_CASE("Integer bitwise operations")
     runConformance("integer_bitwise.lua");
 }
 
+TEST_CASE("bit32.s32")
+{
+    runConformance("bit32_s32.lua");
+}
+
 // ServerLua: interrupt state for lljson yield tests
 static bool jsonInterruptEnabled = false;
 static int jsonYieldCount = 0;

tests/conformance/bit32_s32.lua

@@ -0,0 +1,56 @@
+-- basic identity cases
+assert(bit32.s32(0) == 0)
+assert(bit32.s32(1) == 1)
+assert(bit32.s32(-1) == -1)
+
+-- positive values within signed range are unchanged
+assert(bit32.s32(0x7FFFFFFF) == 2147483647)
+
+-- unsigned values above INT32_MAX wrap to negative
+assert(bit32.s32(0x80000000) == -2147483648)
+assert(bit32.s32(0xFFFFFFFF) == -1)
+assert(bit32.s32(0xFFFFFFFE) == -2)
+
+-- composing with bit32 operations (the primary use case)
+assert(bit32.s32(bit32.bnot(0)) == -1)
+assert(bit32.s32(bit32.bor(0x80000000, 1)) == -2147483647)
+
+-- truncation toward zero
+assert(bit32.s32(2.7) == 2)
+assert(bit32.s32(-2.7) == -2)
+assert(bit32.s32(0.9) == 0)
+assert(bit32.s32(-0.9) == 0)
+
+-- modular wrapping for values beyond uint32 range
+assert(bit32.s32(0x100000000) == 0)
+assert(bit32.s32(0x100000001) == 1)
+assert(bit32.s32(0x1FFFFFFFF) == -1)
+
+-- large values still wrap correctly (no UB through fmod path)
+assert(bit32.s32(1e15) == -1530494976)
+assert(bit32.s32(-1e15) == 1530494976)
+
+-- NaN and Inf produce INT32_MIN (matches i386 "integer indefinite")
+assert(bit32.s32(0/0) == -2147483648)
+assert(bit32.s32(1/0) == -2147483648)
+assert(bit32.s32(-1/0) == -2147483648)
+
+-- result is always a plain number, never an LSL integer
+assert(type(bit32.s32(42)) == "number")
+
+-- smul: basic multiplication
+assert(bit32.smul(3, 4) == 12)
+assert(bit32.smul(-3, 4) == -12)
+assert(bit32.smul(-3, -4) == 12)
+
+-- smul: overflow wrapping
+assert(bit32.smul(0x7FFFFFFF, 2) == -2)
+assert(bit32.smul(0x80000000, -1) == -2147483648)
+
+-- smul: the case that bit32.s32(a*b) gets wrong due to float64 precision loss
+assert(bit32.smul(0x10000, 0x10000) == 0)
+
+-- smul: result is always a plain number
+assert(type(bit32.smul(2, 3)) == "number")
+
+return "OK"

tests/conformance/types.luau

@@ -12,6 +12,8 @@ local ignore =
 	"_G.dangerouslyexecuterequiredmodule",
 	"_G.table.append",
 	"_G.table.extend",
+	"_G.bit32.s32",
+	"_G.bit32.smul",
 
 	-- what follows is a set of mismatches that hopefully eventually will go down to 0
 	"_G.require", -- need to move to Roblox type defs