2022-10-14 20:48:41 +01:00
|
|
|
// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
|
|
|
|
#pragma once
|
|
|
|
|
2023-10-21 02:10:30 +01:00
|
|
|
#include <algorithm>
|
2024-04-12 18:18:49 +01:00
|
|
|
#include <array>
|
|
|
|
#include <memory>
|
2022-10-14 20:48:41 +01:00
|
|
|
#include <string>
|
2023-12-02 07:46:57 +00:00
|
|
|
#include <vector>
|
2022-10-14 20:48:41 +01:00
|
|
|
|
2023-09-15 18:26:59 +01:00
|
|
|
#include <stddef.h>
|
2023-05-12 18:50:47 +01:00
|
|
|
#include <stdint.h>
|
|
|
|
|
2022-10-14 20:48:41 +01:00
|
|
|
struct lua_State;
|
|
|
|
|
|
|
|
namespace Luau
|
|
|
|
{
|
|
|
|
namespace CodeGen
|
|
|
|
{
|
|
|
|
|
2023-07-28 16:13:53 +01:00
|
|
|
enum CodeGenFlags
|
|
|
|
{
|
|
|
|
// Only run native codegen for modules that have been marked with --!native
|
|
|
|
CodeGen_OnlyNativeModules = 1 << 0,
|
2023-10-06 20:02:32 +01:00
|
|
|
// Run native codegen for functions that the compiler considers not profitable
|
|
|
|
CodeGen_ColdFunctions = 1 << 1,
|
2023-07-28 16:13:53 +01:00
|
|
|
};
|
|
|
|
|
2024-02-16 02:04:39 +00:00
|
|
|
// These enum values can be reported through telemetry.
|
|
|
|
// To ensure consistency, changes should be additive.
|
2023-08-25 18:23:55 +01:00
|
|
|
enum class CodeGenCompilationResult
|
|
|
|
{
|
2024-02-16 02:04:39 +00:00
|
|
|
Success = 0, // Successfully generated code for at least one function
|
|
|
|
NothingToCompile = 1, // There were no new functions to compile
|
|
|
|
NotNativeModule = 2, // Module does not have `--!native` comment
|
2023-08-25 18:23:55 +01:00
|
|
|
|
2024-02-16 02:04:39 +00:00
|
|
|
CodeGenNotInitialized = 3, // Native codegen system is not initialized
|
|
|
|
CodeGenOverflowInstructionLimit = 4, // Instruction limit overflow
|
|
|
|
CodeGenOverflowBlockLimit = 5, // Block limit overflow
|
|
|
|
CodeGenOverflowBlockInstructionLimit = 6, // Block instruction limit overflow
|
|
|
|
CodeGenAssemblerFinalizationFailure = 7, // Failure during assembler finalization
|
|
|
|
CodeGenLoweringFailure = 8, // Lowering failed
|
|
|
|
AllocationFailed = 9, // Native codegen failed due to an allocation error
|
2024-05-03 21:17:51 +01:00
|
|
|
|
|
|
|
Count = 10,
|
2023-08-25 18:23:55 +01:00
|
|
|
};
|
|
|
|
|
2024-05-03 21:17:51 +01:00
|
|
|
std::string toString(const CodeGenCompilationResult& result);
|
|
|
|
|
2024-03-30 23:14:44 +00:00
|
|
|
struct ProtoCompilationFailure
|
|
|
|
{
|
|
|
|
CodeGenCompilationResult result = CodeGenCompilationResult::Success;
|
|
|
|
|
|
|
|
std::string debugname;
|
|
|
|
int line = -1;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct CompilationResult
|
|
|
|
{
|
|
|
|
CodeGenCompilationResult result = CodeGenCompilationResult::Success;
|
|
|
|
|
|
|
|
std::vector<ProtoCompilationFailure> protoFailures;
|
|
|
|
|
|
|
|
[[nodiscard]] bool hasErrors() const
|
|
|
|
{
|
|
|
|
return result != CodeGenCompilationResult::Success || !protoFailures.empty();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2023-08-11 15:42:37 +01:00
|
|
|
struct CompilationStats
|
|
|
|
{
|
|
|
|
size_t bytecodeSizeBytes = 0;
|
|
|
|
size_t nativeCodeSizeBytes = 0;
|
|
|
|
size_t nativeDataSizeBytes = 0;
|
|
|
|
size_t nativeMetadataSizeBytes = 0;
|
|
|
|
|
2024-02-16 02:04:39 +00:00
|
|
|
uint32_t functionsTotal = 0;
|
2023-08-11 15:42:37 +01:00
|
|
|
uint32_t functionsCompiled = 0;
|
2024-04-12 18:18:49 +01:00
|
|
|
uint32_t functionsBound = 0;
|
2023-08-11 15:42:37 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
using AllocationCallback = void(void* context, void* oldPointer, size_t oldSize, void* newPointer, size_t newSize);
|
|
|
|
|
2022-10-14 20:48:41 +01:00
|
|
|
bool isSupported();
|
|
|
|
|
2024-04-12 18:18:49 +01:00
|
|
|
class SharedCodeGenContext;
|
|
|
|
|
|
|
|
struct SharedCodeGenContextDeleter
|
|
|
|
{
|
|
|
|
void operator()(const SharedCodeGenContext* context) const noexcept;
|
|
|
|
};
|
|
|
|
|
|
|
|
using UniqueSharedCodeGenContext = std::unique_ptr<SharedCodeGenContext, SharedCodeGenContextDeleter>;
|
|
|
|
|
|
|
|
// Creates a new SharedCodeGenContext that can be used by multiple Luau VMs
|
|
|
|
// concurrently, using either the default allocator parameters or custom
|
|
|
|
// allocator parameters.
|
|
|
|
[[nodiscard]] UniqueSharedCodeGenContext createSharedCodeGenContext();
|
|
|
|
|
|
|
|
[[nodiscard]] UniqueSharedCodeGenContext createSharedCodeGenContext(AllocationCallback* allocationCallback, void* allocationCallbackContext);
|
|
|
|
|
|
|
|
[[nodiscard]] UniqueSharedCodeGenContext createSharedCodeGenContext(
|
|
|
|
size_t blockSize, size_t maxTotalSize, AllocationCallback* allocationCallback, void* allocationCallbackContext);
|
|
|
|
|
|
|
|
// Destroys the provided SharedCodeGenContext. All Luau VMs using the
|
|
|
|
// SharedCodeGenContext must be destroyed before this function is called.
|
|
|
|
void destroySharedCodeGenContext(const SharedCodeGenContext* codeGenContext) noexcept;
|
|
|
|
|
2023-08-11 15:42:37 +01:00
|
|
|
void create(lua_State* L, AllocationCallback* allocationCallback, void* allocationCallbackContext);
|
2022-10-14 20:48:41 +01:00
|
|
|
void create(lua_State* L);
|
2024-04-12 18:18:49 +01:00
|
|
|
void create(lua_State* L, SharedCodeGenContext* codeGenContext);
|
2022-10-14 20:48:41 +01:00
|
|
|
|
2024-03-15 23:37:39 +00:00
|
|
|
// Check if native execution is enabled
|
|
|
|
[[nodiscard]] bool isNativeExecutionEnabled(lua_State* L);
|
|
|
|
|
|
|
|
// Enable or disable native execution according to `enabled` argument
|
|
|
|
void setNativeExecutionEnabled(lua_State* L, bool enabled);
|
|
|
|
|
2024-04-12 18:18:49 +01:00
|
|
|
using ModuleId = std::array<uint8_t, 16>;
|
|
|
|
|
2022-10-14 20:48:41 +01:00
|
|
|
// Builds target function and all inner functions
|
2024-03-30 23:14:44 +00:00
|
|
|
CompilationResult compile(lua_State* L, int idx, unsigned int flags = 0, CompilationStats* stats = nullptr);
|
2024-04-12 18:18:49 +01:00
|
|
|
CompilationResult compile(const ModuleId& moduleId, lua_State* L, int idx, unsigned int flags = 0, CompilationStats* stats = nullptr);
|
2022-10-14 20:48:41 +01:00
|
|
|
|
2023-05-12 18:50:47 +01:00
|
|
|
using AnnotatorFn = void (*)(void* context, std::string& result, int fid, int instpos);
|
2022-10-21 18:54:01 +01:00
|
|
|
|
2024-01-27 03:20:56 +00:00
|
|
|
// Output "#" before IR blocks and instructions
|
|
|
|
enum class IncludeIrPrefix
|
|
|
|
{
|
|
|
|
No,
|
|
|
|
Yes
|
|
|
|
};
|
|
|
|
|
|
|
|
// Output user count and last use information of blocks and instructions
|
|
|
|
enum class IncludeUseInfo
|
|
|
|
{
|
|
|
|
No,
|
|
|
|
Yes
|
|
|
|
};
|
|
|
|
|
|
|
|
// Output CFG informations like block predecessors, successors and etc
|
|
|
|
enum class IncludeCfgInfo
|
|
|
|
{
|
|
|
|
No,
|
|
|
|
Yes
|
|
|
|
};
|
|
|
|
|
|
|
|
// Output VM register live in/out information for blocks
|
|
|
|
enum class IncludeRegFlowInfo
|
|
|
|
{
|
|
|
|
No,
|
|
|
|
Yes
|
|
|
|
};
|
|
|
|
|
2022-10-21 18:54:01 +01:00
|
|
|
struct AssemblyOptions
|
|
|
|
{
|
2023-06-24 07:19:39 +01:00
|
|
|
enum Target
|
|
|
|
{
|
|
|
|
Host,
|
|
|
|
A64,
|
|
|
|
A64_NoFeatures,
|
|
|
|
X64_Windows,
|
|
|
|
X64_SystemV,
|
|
|
|
};
|
|
|
|
|
|
|
|
Target target = Host;
|
|
|
|
|
2023-10-21 02:10:30 +01:00
|
|
|
unsigned int flags = 0;
|
|
|
|
|
2022-10-21 18:54:01 +01:00
|
|
|
bool outputBinary = false;
|
2023-01-27 22:28:31 +00:00
|
|
|
|
|
|
|
bool includeAssembly = false;
|
|
|
|
bool includeIr = false;
|
|
|
|
bool includeOutlinedCode = false;
|
2024-04-25 23:26:09 +01:00
|
|
|
bool includeIrTypes = false;
|
2022-10-21 18:54:01 +01:00
|
|
|
|
2024-01-27 03:20:56 +00:00
|
|
|
IncludeIrPrefix includeIrPrefix = IncludeIrPrefix::Yes;
|
|
|
|
IncludeUseInfo includeUseInfo = IncludeUseInfo::Yes;
|
|
|
|
IncludeCfgInfo includeCfgInfo = IncludeCfgInfo::Yes;
|
|
|
|
IncludeRegFlowInfo includeRegFlowInfo = IncludeRegFlowInfo::Yes;
|
2024-01-19 18:04:46 +00:00
|
|
|
|
2022-10-21 18:54:01 +01:00
|
|
|
// Optional annotator function can be provided to describe each instruction, it takes function id and sequential instruction id
|
2023-05-12 18:50:47 +01:00
|
|
|
AnnotatorFn annotator = nullptr;
|
2022-10-21 18:54:01 +01:00
|
|
|
void* annotatorContext = nullptr;
|
|
|
|
};
|
|
|
|
|
2023-11-03 23:45:04 +00:00
|
|
|
struct BlockLinearizationStats
|
|
|
|
{
|
|
|
|
unsigned int constPropInstructionCount = 0;
|
|
|
|
double timeSeconds = 0.0;
|
|
|
|
|
|
|
|
BlockLinearizationStats& operator+=(const BlockLinearizationStats& that)
|
|
|
|
{
|
|
|
|
this->constPropInstructionCount += that.constPropInstructionCount;
|
|
|
|
this->timeSeconds += that.timeSeconds;
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
BlockLinearizationStats operator+(const BlockLinearizationStats& other) const
|
|
|
|
{
|
|
|
|
BlockLinearizationStats result(*this);
|
|
|
|
result += other;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2024-01-12 22:25:27 +00:00
|
|
|
enum FunctionStatsFlags
|
|
|
|
{
|
|
|
|
// Enable stats collection per function
|
|
|
|
FunctionStats_Enable = 1 << 0,
|
|
|
|
// Compute function bytecode summary
|
|
|
|
FunctionStats_BytecodeSummary = 1 << 1,
|
|
|
|
};
|
|
|
|
|
2023-12-02 07:46:57 +00:00
|
|
|
struct FunctionStats
|
|
|
|
{
|
|
|
|
std::string name;
|
|
|
|
int line = -1;
|
|
|
|
unsigned bcodeCount = 0;
|
|
|
|
unsigned irCount = 0;
|
|
|
|
unsigned asmCount = 0;
|
2024-01-12 22:25:27 +00:00
|
|
|
unsigned asmSize = 0;
|
|
|
|
std::vector<std::vector<unsigned>> bytecodeSummary;
|
2023-12-02 07:46:57 +00:00
|
|
|
};
|
|
|
|
|
2023-09-15 18:26:59 +01:00
|
|
|
struct LoweringStats
|
|
|
|
{
|
2023-10-21 02:10:30 +01:00
|
|
|
unsigned totalFunctions = 0;
|
|
|
|
unsigned skippedFunctions = 0;
|
2023-09-15 18:26:59 +01:00
|
|
|
int spillsToSlot = 0;
|
|
|
|
int spillsToRestore = 0;
|
|
|
|
unsigned maxSpillSlotsUsed = 0;
|
2023-10-21 02:10:30 +01:00
|
|
|
unsigned blocksPreOpt = 0;
|
|
|
|
unsigned blocksPostOpt = 0;
|
|
|
|
unsigned maxBlockInstructions = 0;
|
2023-09-15 18:26:59 +01:00
|
|
|
|
|
|
|
int regAllocErrors = 0;
|
|
|
|
int loweringErrors = 0;
|
2023-10-21 02:10:30 +01:00
|
|
|
|
2023-11-03 23:45:04 +00:00
|
|
|
BlockLinearizationStats blockLinearizationStats;
|
|
|
|
|
2024-01-12 22:25:27 +00:00
|
|
|
unsigned functionStatsFlags = 0;
|
2023-12-02 07:46:57 +00:00
|
|
|
std::vector<FunctionStats> functions;
|
|
|
|
|
2023-10-21 02:10:30 +01:00
|
|
|
LoweringStats operator+(const LoweringStats& other) const
|
|
|
|
{
|
|
|
|
LoweringStats result(*this);
|
|
|
|
result += other;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
LoweringStats& operator+=(const LoweringStats& that)
|
|
|
|
{
|
|
|
|
this->totalFunctions += that.totalFunctions;
|
|
|
|
this->skippedFunctions += that.skippedFunctions;
|
|
|
|
this->spillsToSlot += that.spillsToSlot;
|
|
|
|
this->spillsToRestore += that.spillsToRestore;
|
|
|
|
this->maxSpillSlotsUsed = std::max(this->maxSpillSlotsUsed, that.maxSpillSlotsUsed);
|
|
|
|
this->blocksPreOpt += that.blocksPreOpt;
|
|
|
|
this->blocksPostOpt += that.blocksPostOpt;
|
|
|
|
this->maxBlockInstructions = std::max(this->maxBlockInstructions, that.maxBlockInstructions);
|
|
|
|
this->regAllocErrors += that.regAllocErrors;
|
|
|
|
this->loweringErrors += that.loweringErrors;
|
2023-11-03 23:45:04 +00:00
|
|
|
this->blockLinearizationStats += that.blockLinearizationStats;
|
2024-01-12 22:25:27 +00:00
|
|
|
if (this->functionStatsFlags & FunctionStats_Enable)
|
2023-12-02 07:46:57 +00:00
|
|
|
this->functions.insert(this->functions.end(), that.functions.begin(), that.functions.end());
|
2023-10-21 02:10:30 +01:00
|
|
|
return *this;
|
|
|
|
}
|
2023-09-15 18:26:59 +01:00
|
|
|
};
|
|
|
|
|
2022-10-21 18:54:01 +01:00
|
|
|
// Generates assembly for target function and all inner functions
|
2023-09-15 18:26:59 +01:00
|
|
|
std::string getAssembly(lua_State* L, int idx, AssemblyOptions options = {}, LoweringStats* stats = nullptr);
|
2022-10-14 20:48:41 +01:00
|
|
|
|
2023-05-12 18:50:47 +01:00
|
|
|
using PerfLogFn = void (*)(void* context, uintptr_t addr, unsigned size, const char* symbol);
|
|
|
|
|
|
|
|
void setPerfLog(void* context, PerfLogFn logFn);
|
|
|
|
|
2022-10-14 20:48:41 +01:00
|
|
|
} // namespace CodeGen
|
|
|
|
} // namespace Luau
|