Fix some issues with RK variant opcodes in LSL

Author: HaroldCindy

Compiler/src/LSLCompiler.cpp

@@ -1459,21 +1459,31 @@ bool LuauVisitor::visit(LSLBinaryExpression* bin_expr)
         }
 
         // Check if we can use RK-variant opcodes for SUB/DIV
-        // Only check this for operations that actually have reversed K-variants
-        if ((op == '-' || op == '/') &&
-            lhs->getNodeSubType() == NODE_CONSTANT_EXPRESSION &&
-            (lhs->getIType() == LST_INTEGER || lhs->getIType() == LST_FLOATINGPOINT))
+        // SUBRK supports both integers and floats, DIVRK only supports floats
+        if (lhs->getNodeSubType() == NODE_CONSTANT_EXPRESSION)
         {
-            auto* lhs_const = dynamic_cast<LSLConstantExpression*>(lhs);
-            auto lhs_const_idx = addConstant(lhs_const->getConstantValue());
+            LuauOpcode rk_op = LOP_NOP;
+            if (op == '-' && (lhs->getIType() == LST_INTEGER || lhs->getIType() == LST_FLOATINGPOINT))
+            {
+                rk_op = LOP_SUBRK;
+            }
+            else if (op == '/' && lhs->getIType() == LST_FLOATINGPOINT)
+            {
+                // DIVRK only works with floats - no IDIVRK exists
+                rk_op = LOP_DIVRK;
+            }
 
-            // Constant index is low enough to fit
-            if (lhs_const_idx >= 0 && lhs_const_idx <= 255)
+            if (rk_op != LOP_NOP)
             {
-                LuauOpcode rk_op = (op == '-') ? LOP_SUBRK : LOP_DIVRK;
-                mBuilder->emitABC(rk_op, target_reg, (uint8_t)lhs_const_idx, rhs_reg);
-                // maybeMove(expected_target, target_reg);
-                return false;
+                auto* lhs_const = dynamic_cast<LSLConstantExpression*>(lhs);
+                auto lhs_const_idx = addConstant(lhs_const->getConstantValue());
+
+                // Constant index is low enough to fit
+                if (lhs_const_idx >= 0 && lhs_const_idx <= 255)
+                {
+                    mBuilder->emitABC(rk_op, target_reg, (uint8_t)lhs_const_idx, rhs_reg);
+                    return false;
+                }
             }
         }
 

VM/src/lvmexecute.cpp

@@ -3041,14 +3041,18 @@ static void luau_execute(lua_State* L)
                 TValue* kv = VM_KV(LUAU_INSN_B(insn));
                 StkId rc = VM_REG(LUAU_INSN_C(insn));
 
-                // NOTE: ServerLua can't use these for integer-aware paths!
-
                 // fast-path
                 if (ttisnumber(rc))
                 {
                     setnvalue(ra, nvalue(kv) - nvalue(rc));
                     VM_NEXT();
                 }
+                else if (l_isinteger(kv) && l_isinteger(rc))
+                {
+                    // ServerLua: integer math
+                    setintvalue(ra, intvalue(kv) - intvalue(rc));
+                    VM_NEXT();
+                }
                 else
                 {
                     // slow-path, may invoke C/Lua via metamethods

tests/LSL.test.cpp

@@ -1031,6 +1031,11 @@ TEST_CASE("Extensive LSL Ares Test")
     runAresYieldTest("conformance2_yield.lsl");
 }
 
+TEST_CASE("RK optimization issues")
+{
+    runConformance("rk_issues.lsl");
+}
+
 
 static std::string mono_to_lower_string(const std::string &str)
 {

tests/conformance/rk_issues.lsl

@@ -0,0 +1,23 @@
+checkTruth(string name, integer val)
+{
+    if (!val)
+    {
+        llOwnerSay(name + ": FAILED");
+        // Force a crash.
+        llOwnerSay((string)(0/0));
+    }
+}
+
+default {
+    state_entry() {
+        integer a = (1 - (0 / 3));
+        integer b = 3 - 4;
+        float c = (1.0 - (0 / 3.0));
+        float d = 3.0 - 4.0;
+        list foo = [a, b, c, d];
+        checkTruth("a is integer", llGetListEntryType(foo, 0) == TYPE_INTEGER);
+        checkTruth("b is integer", llGetListEntryType(foo, 1) == TYPE_INTEGER);
+        checkTruth("c is float", llGetListEntryType(foo, 2) == TYPE_FLOAT);
+        checkTruth("d is float", llGetListEntryType(foo, 3) == TYPE_FLOAT);
+    }
+}