v0.18.1+luau706

Author: khvzak

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "luau0-src"
-version = "0.18.0+luau705"
+version = "0.18.1+luau706"
 authors = ["Aleksandr Orlenko <zxteam@protonmail.com>"]
 edition = "2024"
 repository = "https://github.com/mlua-rs/luau-src-rs"

luau/Ast/src/Parser.cpp

@@ -4039,8 +4039,7 @@ AstExpr* Parser::parseInterpString()
         {
             AstArray<AstArray<char>> stringsArray = copy(strings);
             AstArray<AstExpr*> exprs = copy(expressions);
-            AstExprInterpString* node =
-                allocator.alloc<AstExprInterpString>(Location{startLocation, lexer.previousLocation()}, stringsArray, exprs);
+            AstExprInterpString* node = allocator.alloc<AstExprInterpString>(Location{startLocation, lexer.previousLocation()}, stringsArray, exprs);
             if (options.storeCstData)
                 cstNodeMap[node] = allocator.alloc<CstExprInterpString>(copy(sourceStrings), copy(stringPositions));
             if (auto top = lexer.peekBraceStackTop())

luau/CodeGen/include/Luau/IrBuilder.h

@@ -50,6 +50,8 @@ struct IrBuilder
 
     IrOp cond(IrCondition cond);
 
+    IrOp inst(IrCmd cmd, const IrOps& ops);
+    IrOp inst(IrCmd cmd, std::initializer_list<IrOp> ops);
     IrOp inst(IrCmd cmd);
     IrOp inst(IrCmd cmd, IrOp a);
     IrOp inst(IrCmd cmd, IrOp a, IrOp b);

luau/CodeGen/include/Luau/IrData.h

@@ -6,13 +6,22 @@
 #include "Luau/Label.h"
 #include "Luau/RegisterX64.h"
 #include "Luau/RegisterA64.h"
+#include "Luau/SmallVector.h"
 
 #include <optional>
 #include <vector>
 
 #include <stdint.h>
 #include <string.h>
 
+#define OP_A(inst) getOp(inst, 0)
+#define OP_B(inst) getOp(inst, 1)
+#define OP_C(inst) getOp(inst, 2)
+#define OP_D(inst) getOp(inst, 3)
+#define OP_E(inst) getOp(inst, 4)
+#define OP_F(inst) getOp(inst, 5)
+#define OP_G(inst) getOp(inst, 6)
+
 struct Proto;
 
 LUAU_FASTFLAG(LuauCodegenChainedSpills)
@@ -1008,18 +1017,15 @@ enum class IrValueKind : uint8_t
     Count
 };
 
+using IrOps = SmallVector<IrOp, 6>;
+
 struct IrInst
 {
     IrCmd cmd;
 
     // Operands
-    IrOp a;
-    IrOp b;
-    IrOp c;
-    IrOp d;
-    IrOp e;
-    IrOp f;
-    IrOp g;
+    // All frequiently used instructions use only A-D slots.
+    IrOps ops;
 
     uint32_t lastUse = 0;
     uint16_t useCount = 0;
@@ -1032,6 +1038,20 @@ struct IrInst
     bool needsReload = false;
 };
 
+inline IrOp& getOp(IrInst& inst, uint32_t idx)
+{
+    if (LUAU_UNLIKELY(idx >= inst.ops.size()))
+    {
+        inst.ops.resize(idx + 1);
+    }
+    return inst.ops[idx];
+}
+
+inline IrOp& getOp(IrInst* inst, uint32_t idx)
+{
+    return getOp(*inst, idx);
+}
+
 // When IrInst operands are used, current instruction index is often required to track lifetime
 inline constexpr uint32_t kInvalidInstIdx = ~0u;
 
@@ -1068,13 +1088,8 @@ struct IrInstHash
         uint32_t h = 25;
 
         h = mix(h, uint32_t(key.cmd));
-        h = mix(h, key.a);
-        h = mix(h, key.b);
-        h = mix(h, key.c);
-        h = mix(h, key.d);
-        h = mix(h, key.e);
-        h = mix(h, key.f);
-        h = mix(h, key.g);
+        for (size_t i = 0; i < 7; i++)
+            h = mix(h, i < uint32_t(key.ops.size()) ? key.ops[i] : IrOp{});
 
         // MurmurHash2 tail
         h ^= h >> 13;
@@ -1089,7 +1104,35 @@ struct IrInstEq
 {
     bool operator()(const IrInst& a, const IrInst& b) const
     {
-        return a.cmd == b.cmd && a.a == b.a && a.b == b.b && a.c == b.c && a.d == b.d && a.e == b.e && a.f == b.f && a.g == b.g;
+        if (a.cmd != b.cmd)
+            return false;
+        if (a.ops.size() == b.ops.size())
+        {
+            for (size_t i = 0; i < a.ops.size(); i++)
+                if (a.ops[i] != b.ops[i])
+                    return false;
+        }
+        else if (a.ops.size() < b.ops.size())
+        {
+            size_t i = 0;
+            for (; i < a.ops.size(); i++)
+                if (a.ops[i] != b.ops[i])
+                    return false;
+            for (; i < b.ops.size(); i++)
+                if (b.ops[i].kind != IrOpKind::None)
+                    return false;
+        }
+        else
+        {
+            size_t i = 0;
+            for (; i < b.ops.size(); i++)
+                if (a.ops[i] != b.ops[i])
+                    return false;
+            for (; i < a.ops.size(); i++)
+                if (a.ops[i].kind != IrOpKind::None)
+                    return false;
+        }
+        return true;
     }
 };
 

luau/CodeGen/include/Luau/IrDump.h

@@ -38,14 +38,7 @@ const char* getBytecodeTypeName(uint8_t type, const char* const* userdataTypes);
 
 void toString(std::string& result, const BytecodeTypes& bcTypes, const char* const* userdataTypes);
 
-void toStringDetailed(
-    IrToStringContext& ctx,
-    const IrBlock& block,
-    uint32_t blockIdx,
-    const IrInst& inst,
-    uint32_t instIdx,
-    IncludeUseInfo includeUseInfo
-);
+void toStringDetailed(IrToStringContext& ctx, const IrBlock& block, uint32_t blockIdx, IrInst& inst, uint32_t instIdx, IncludeUseInfo includeUseInfo);
 void toStringDetailed(
     IrToStringContext& ctx,
     const IrBlock& block,
@@ -55,9 +48,9 @@ void toStringDetailed(
     IncludeRegFlowInfo includeRegFlowInfo
 );
 
-std::string toString(const IrFunction& function, IncludeUseInfo includeUseInfo);
+std::string toString(IrFunction& function, IncludeUseInfo includeUseInfo);
 
-std::string dump(const IrFunction& function);
+std::string dump(IrFunction& function);
 
 std::string toDot(const IrFunction& function, bool includeInst);
 std::string toDotCfg(const IrFunction& function);

luau/CodeGen/include/Luau/IrUtils.h

@@ -287,21 +287,19 @@ void visitArguments(IrInst& inst, F&& func)
     if (isPseudo(inst.cmd))
         return;
 
-    func(inst.a);
-    func(inst.b);
-    func(inst.c);
-    func(inst.d);
-    func(inst.e);
-    func(inst.f);
-    func(inst.g);
+    for (auto& op : inst.ops)
+        func(op);
 }
 template<typename F>
 bool anyArgumentMatch(IrInst& inst, F&& func)
 {
     if (isPseudo(inst.cmd))
         return false;
 
-    return func(inst.a) || func(inst.b) || func(inst.c) || func(inst.d) || func(inst.e) || func(inst.f) || func(inst.g);
+    for (auto& op : inst.ops)
+        if (func(op))
+            return true;
+    return false;
 }
 
 bool isGCO(uint8_t tag);
@@ -310,6 +308,9 @@ bool isGCO(uint8_t tag);
 bool isUserdataBytecodeType(uint8_t ty);
 bool isCustomUserdataBytecodeType(uint8_t ty);
 
+// Check that 'ty' is 'expected' or 'any'
+bool isExpectedOrUnknownBytecodeType(uint8_t ty, LuauBytecodeType expected);
+
 HostMetamethod tmToHostMetamethod(int tm);
 
 // Manually add or remove use of an operand