luau-analyzer-sys 0.1.1

A high-performance, embedded Luau type-checking and analysis engine written in Rust. This crate provides bindings to the Luau analyzer, allowing you to integrate static analysis and code intelligence directly into your applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
#pragma once

#include "Luau/AssemblyBuilderX64.h"
#include "Luau/IrData.h"
#include "Luau/OperandX64.h"
#include "Luau/RegisterX64.h"

#include <array>

// TODO: call wrapper can be used to suggest target registers for ScopedRegX64 to compute data into argument registers directly

namespace Luau
{
namespace CodeGen
{
namespace X64
{

struct IrRegAllocX64;
struct ScopedRegX64;

struct CallArgument
{
    SizeX64 targetSize = SizeX64::none;

    OperandX64 source = noreg;
    IrOp sourceOp;

    OperandX64 target = noreg;
    bool candidate = true;
};

class IrCallWrapperX64
{
public:
    IrCallWrapperX64(IrRegAllocX64& regs, AssemblyBuilderX64& build, uint32_t instIdx = kInvalidInstIdx);

    void addArgument(SizeX64 targetSize, OperandX64 source, IrOp sourceOp = {});
    void addArgument(SizeX64 targetSize, ScopedRegX64& scopedReg);

    // Declare that the call produces a result that should be placed in the selected register
    void setResultRegister(RegisterX64 reg, uint32_t instIdx);

    void call(const OperandX64& func);

    RegisterX64 suggestNextArgumentRegister(SizeX64 size) const;
    // Returns the register for argument position N, sized according to 'size', for the given ABI.
    // N must be 0-3: on Windows, args 4+ are passed on the stack (not in registers).
    template<size_t N>
    static RegisterX64 suggestArgumentRegister(SizeX64 size, AssemblyBuilderX64& build);

    IrRegAllocX64& regs;
    AssemblyBuilderX64& build;
    uint32_t instIdx = ~0u;

private:
    OperandX64 getNextArgumentTarget(SizeX64 size) const;
    void countRegisterUses();
    CallArgument* findNonInterferingArgument();
    bool interferesWithOperand(const OperandX64& op, RegisterX64 reg) const;
    bool interferesWithActiveSources(const CallArgument& targetArg, int targetArgIndex) const;
    bool interferesWithActiveTarget(RegisterX64 sourceReg) const;
    void moveToTarget(CallArgument& arg);
    void freeSourceRegisters(CallArgument& arg);
    void renameRegister(RegisterX64& target, RegisterX64 reg, RegisterX64 replacement);
    void renameSourceRegisters(RegisterX64 reg, RegisterX64 replacement);
    RegisterX64 findConflictingTarget() const;
    void renameConflictingRegister(RegisterX64 conflict);

    int getRegisterUses(RegisterX64 reg) const;
    void addRegisterUse(RegisterX64 reg);
    void removeRegisterUse(RegisterX64 reg);

    static const int kMaxCallArguments = 6;
    std::array<CallArgument, kMaxCallArguments> args;
    int argCount = 0;

    int gprPos = 0;
    int xmmPos = 0;

    OperandX64 funcOp;

    RegisterX64 resultReg = noreg;
    uint32_t resultInstIdx = kInvalidInstIdx;

    // Internal counters for remaining register use counts
    std::array<uint8_t, 16> gprUses;
    std::array<uint8_t, 16> xmmUses;
};

} // namespace X64
} // namespace CodeGen
} // namespace Luau