Bump Luau to 0.710

Author: khvzak

luau/Ast/src/Ast.cpp

@@ -3,7 +3,6 @@
 
 #include "Luau/Common.h"
 
-LUAU_FASTFLAGVARIABLE(LuauStandaloneParseType)
 
 LUAU_FASTFLAG(LuauExplicitTypeInstantiationSyntax)
 

luau/Ast/src/Parser.cpp

@@ -20,7 +20,6 @@ LUAU_FASTINTVARIABLE(LuauParseErrorLimit, 100)
 LUAU_FASTFLAGVARIABLE(LuauSolverV2)
 LUAU_DYNAMIC_FASTFLAGVARIABLE(DebugLuauReportReturnTypeVariadicWithTypeSuffix, false)
 LUAU_FASTFLAGVARIABLE(LuauExplicitTypeInstantiationSyntax)
-LUAU_FASTFLAG(LuauStandaloneParseType)
 LUAU_FASTFLAGVARIABLE(LuauCstStatDoWithStatsStart)
 LUAU_FASTFLAGVARIABLE(DesugaredArrayTypeReferenceIsEmpty)
 
@@ -244,14 +243,11 @@ ParseNodeResult<Node> Parser::runParse(const char* buffer, size_t bufferSize, As
         Node* expr = f(p);
         size_t lines = p.lexer.current().location.end.line + (bufferSize > 0 && buffer[bufferSize - 1] != '\n');
 
-        if (FFlag::LuauStandaloneParseType)
+        Lexeme eof = p.lexer.next();
+        if (eof.type != Lexeme::Eof)
         {
-            Lexeme eof = p.lexer.next();
-            if (eof.type != Lexeme::Eof)
-            {
-                expr = nullptr;
-                p.parseErrors.emplace_back(eof.location, "Expected end of file");
-            }
+            expr = nullptr;
+            p.parseErrors.emplace_back(eof.location, "Expected end of file");
         }
 
         return ParseNodeResult<Node>{

luau/CodeGen/include/Luau/CodeGenOptions.h

@@ -19,6 +19,13 @@ enum CodeGenFlags
     CodeGen_ColdFunctions = 1 << 1,
 };
 
+enum class CodeGenCounter : unsigned
+{
+    RegularBlockExecuted = 1,
+    FallbackBlockExecuted = 2,
+    VmExitTaken = 3,
+};
+
 using AllocationCallback = void(void* context, void* oldPointer, size_t oldSize, void* newPointer, size_t newSize);
 
 struct IrBuilder;
@@ -119,8 +126,9 @@ struct CompilationOptions
 
     // null-terminated array of userdata types names that might have custom lowering
     const char* const* userdataTypes = nullptr;
-};
 
+    bool recordCounters = false;
+};
 
 using AnnotatorFn = void (*)(void* context, std::string& result, int fid, int instpos);
 

luau/CodeGen/include/Luau/ConditionX64.h

@@ -120,7 +120,7 @@ inline ConditionX64 getInverseCondition(ConditionX64 cond)
     case ConditionX64::BelowEqual:
         return ConditionX64::AboveEqual;
     case ConditionX64::Above:
-        return ConditionX64::Above;
+        return ConditionX64::Below;
     case ConditionX64::AboveEqual:
         return ConditionX64::BelowEqual;
     case ConditionX64::Equal:

luau/CodeGen/include/Luau/IrBuilder.h

@@ -62,6 +62,7 @@ struct IrBuilder
 
     IrOp block(IrBlockKind kind); // Requested kind can be ignored if we are in an outlined sequence
     IrOp blockAtInst(uint32_t index);
+    IrOp fallbackBlock(uint32_t pcpos);
 
     IrOp vmReg(uint8_t index);
     IrOp vmConst(uint32_t index);

luau/CodeGen/include/Luau/IrData.h

@@ -2,6 +2,7 @@
 #pragma once
 
 #include "Luau/Bytecode.h"
+#include "Luau/DenseHash.h"
 #include "Luau/IrAnalysis.h"
 #include "Luau/Label.h"
 #include "Luau/RegisterX64.h"
@@ -1202,6 +1203,7 @@ struct IrBlock
     uint32_t chainkey = 0;
     uint32_t expectedNextBlock = ~0u;
 
+    // Bytecode PC position at which the block was generated
     uint32_t startpc = kBlockNoStartPc;
 
     Label label;
@@ -1268,6 +1270,8 @@ struct IrFunction
     uint32_t entryLocation = 0;
     uint32_t endLocation = 0;
 
+    std::vector<uint32_t> extraNativeData;
+
     // For each instruction, an operand that can be used to recompute the value
     std::vector<ValueRestoreLocation> valueRestoreOps;
     std::vector<uint32_t> validRestoreOpBlocks;
@@ -1282,6 +1286,8 @@ struct IrFunction
 
     LoweringStats* stats = nullptr;
 
+    bool recordCounters = false; // Taken from CompilationOptions for easy access
+
     IrBlock& blockOp(IrOp op)
     {
         CODEGEN_ASSERT(op.kind == IrOpKind::Block);

luau/CodeGen/include/Luau/IrUtils.h

@@ -5,8 +5,6 @@
 #include "Luau/Common.h"
 #include "Luau/IrData.h"
 
-LUAU_FASTFLAG(LuauCodegenUpvalueLoadProp2)
-
 namespace Luau
 {
 namespace CodeGen
@@ -184,9 +182,8 @@ inline bool hasResult(IrCmd cmd)
     case IrCmd::BUFFER_READI32:
     case IrCmd::BUFFER_READF32:
     case IrCmd::BUFFER_READF64:
-        return true;
     case IrCmd::GET_UPVALUE:
-        return FFlag::LuauCodegenUpvalueLoadProp2;
+        return true;
     default:
         break;
     }

luau/CodeGen/include/Luau/IrVisitUseDef.h

@@ -4,8 +4,6 @@
 #include "Luau/Common.h"
 #include "Luau/IrData.h"
 
-LUAU_FASTFLAG(LuauCodegenUpvalueLoadProp2)
-
 namespace Luau
 {
 namespace CodeGen
@@ -82,12 +80,8 @@ static void visitVmRegDefsUses(T& visitor, IrFunction& function, IrInst& inst)
         visitor.defRange(vmRegOp(OP_A(inst)), function.uintOp(OP_B(inst)));
         break;
     case IrCmd::GET_UPVALUE:
-        if (!FFlag::LuauCodegenUpvalueLoadProp2)
-            visitor.def(OP_A(inst));
         break;
     case IrCmd::SET_UPVALUE:
-        if (!FFlag::LuauCodegenUpvalueLoadProp2)
-            visitor.use(OP_B(inst));
         break;
     case IrCmd::INTERRUPT:
         break;

luau/CodeGen/include/Luau/NativeProtoExecData.h

@@ -32,6 +32,9 @@ struct NativeProtoExecDataHeader
     // elements in the instruction offsets array following this header.
     uint32_t bytecodeInstructionCount = 0;
 
+    // The number of extra uin32_t elements of custom data after the bytecode offsets
+    uint32_t extraDataCount = 0;
+
     // The size of the native code for this NativeProto, in bytes.
     size_t nativeCodeSize = 0;
 };
@@ -47,7 +50,7 @@ struct NativeProtoExecDataDeleter
 
 using NativeProtoExecDataPtr = std::unique_ptr<uint32_t[], NativeProtoExecDataDeleter>;
 
-[[nodiscard]] NativeProtoExecDataPtr createNativeProtoExecData(uint32_t bytecodeInstructionCount);
+[[nodiscard]] NativeProtoExecDataPtr createNativeProtoExecData(uint32_t bytecodeInstructionCount, uint32_t extraDataCount);
 void destroyNativeProtoExecData(const uint32_t* instructionOffsets) noexcept;
 
 [[nodiscard]] NativeProtoExecDataHeader& getNativeProtoExecDataHeader(uint32_t* instructionOffsets) noexcept;

luau/CodeGen/src/AssemblyBuilderA64.cpp

@@ -7,10 +7,7 @@
 #include <stdarg.h>
 #include <stdio.h>
 
-LUAU_FASTFLAG(LuauCodegenUpvalueLoadProp2)
-LUAU_FASTFLAG(LuauCodegenSplitFloat)
-LUAU_FASTFLAG(LuauCodegenLocationEndFix)
-LUAU_FASTFLAG(LuauCodegenUintToFloat)
+LUAU_FASTFLAG(LuauCodegenA64ClosureOffset)
 
 namespace Luau
 {
@@ -1032,23 +1029,13 @@ void AssemblyBuilderA64::scvtf(RegisterA64 dst, RegisterA64 src)
 
 void AssemblyBuilderA64::ucvtf(RegisterA64 dst, RegisterA64 src)
 {
-    if (FFlag::LuauCodegenUintToFloat)
-    {
-        CODEGEN_ASSERT(dst.kind == KindA64::d || dst.kind == KindA64::s);
-        CODEGEN_ASSERT(src.kind == KindA64::w || src.kind == KindA64::x);
-
-        if (dst.kind == KindA64::d)
-            placeR1("ucvtf", dst, src, 0b000'11110'01'1'00'011'000000);
-        else
-            placeR1("ucvtf", dst, src, 0b000'11110'00'1'00'011'000000);
-    }
-    else
-    {
-        CODEGEN_ASSERT(dst.kind == KindA64::d);
-        CODEGEN_ASSERT(src.kind == KindA64::w || src.kind == KindA64::x);
+    CODEGEN_ASSERT(dst.kind == KindA64::d || dst.kind == KindA64::s);
+    CODEGEN_ASSERT(src.kind == KindA64::w || src.kind == KindA64::x);
 
+    if (dst.kind == KindA64::d)
         placeR1("ucvtf", dst, src, 0b000'11110'01'1'00'011'000000);
-    }
+    else
+        placeR1("ucvtf", dst, src, 0b000'11110'00'1'00'011'000000);
 }
 
 void AssemblyBuilderA64::fjcvtzs(RegisterA64 dst, RegisterA64 src)
@@ -1168,7 +1155,7 @@ uint32_t AssemblyBuilderA64::getCodeSize() const
 
 unsigned AssemblyBuilderA64::getInstructionCount() const
 {
-    return FFlag::LuauCodegenLocationEndFix ? unsigned(getCodeSize()) : unsigned(getCodeSize()) / 4;
+    return unsigned(getCodeSize());
 }
 
 bool AssemblyBuilderA64::isMaskSupported(uint32_t mask)
@@ -1298,11 +1285,20 @@ void AssemblyBuilderA64::placeA(const char* name, RegisterA64 dst, AddressA64 sr
         break;
     case AddressKindA64::imm:
         if (unsigned(src.data >> sizelog) < 1024 && (src.data & ((1 << sizelog) - 1)) == 0)
+        {
             place(dst.index | (src.base.index << 5) | ((src.data >> sizelog) << 10) | (opsize << 22) | (1 << 24));
+        }
         else if (src.data >= -256 && src.data <= 255)
+        {
             place(dst.index | (src.base.index << 5) | ((src.data & ((1 << 9) - 1)) << 12) | (opsize << 22));
+        }
         else
+        {
+            if (FFlag::LuauCodegenA64ClosureOffset)
+                overflowed = true;
+
             CODEGEN_ASSERT(!"Unable to encode large immediate offset");
+        }
         break;
     case AddressKindA64::pre:
         CODEGEN_ASSERT(src.data >= -256 && src.data <= 255);