mirror of
https://github.com/luau-lang/luau.git
synced 2024-12-14 06:00:39 +00:00
4b267aa5c5
* Added a limit on how many instructions the Compiler can safely produce (reported by @TheGreatSageEqualToHeaven) C++ API Changes: * With work started on read-only and write-only properties, `Property::type` member variable has been replaced with `TypeId type()` and `setType(TypeId)` functions. * New `LazyType` unwrap callback now has a `void` return type, all that's required from the callback is to write into `unwrapped` field. In our work on the new type solver, the following issues were fixed: * Work has started to support https://github.com/Roblox/luau/pull/77 and https://github.com/Roblox/luau/pull/79 * Refinements are no longer applied on l-values, removing some false-positive errors * Improved overload resolution against expected result type * `Frontend::prepareModuleScope` now works in the new solver * Cofinite strings are now comparable And these are the changes in native code generation (JIT): * Fixed MIN_NUM and MAX_NUM constant fold when one of the arguments is NaN * Added constant folding for number conversions and bit operations * Value spilling and rematerialization is now supported on arm64 * Improved FASTCALL2K IR generation to support second argument constant * Added value numbering and load/store propagation optimizations * Added STORE_VECTOR on arm64, completing the IR lowering on this target
59 lines
2.3 KiB
C++
59 lines
2.3 KiB
C++
// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
|
|
#pragma once
|
|
|
|
#include "Luau/AssemblyBuilderA64.h"
|
|
|
|
#include "EmitCommon.h"
|
|
|
|
#include "lobject.h"
|
|
#include "ltm.h"
|
|
#include "lstate.h"
|
|
|
|
// AArch64 ABI reminder:
|
|
// Arguments: x0-x7, v0-v7
|
|
// Return: x0, v0 (or x8 that points to the address of the resulting structure)
|
|
// Volatile: x9-x15, v16-v31 ("caller-saved", any call may change them)
|
|
// Intra-procedure-call temporary: x16-x17 (any call or relocated jump may change them, as linker may point branches to veneers to perform long jumps)
|
|
// Non-volatile: x19-x28, v8-v15 ("callee-saved", preserved after calls, only bottom half of SIMD registers is preserved!)
|
|
// Reserved: x18: reserved for platform use; x29: frame pointer (unless omitted); x30: link register; x31: stack pointer
|
|
|
|
namespace Luau
|
|
{
|
|
namespace CodeGen
|
|
{
|
|
|
|
struct NativeState;
|
|
|
|
namespace A64
|
|
{
|
|
|
|
// Data that is very common to access is placed in non-volatile registers:
|
|
// 1. Constant registers (only loaded during codegen entry)
|
|
constexpr RegisterA64 rState = x19; // lua_State* L
|
|
constexpr RegisterA64 rNativeContext = x20; // NativeContext* context
|
|
|
|
// 2. Frame registers (reloaded when call frame changes; rBase is also reloaded after all calls that may reallocate stack)
|
|
constexpr RegisterA64 rConstants = x21; // TValue* k
|
|
constexpr RegisterA64 rClosure = x22; // Closure* cl
|
|
constexpr RegisterA64 rCode = x23; // Instruction* code
|
|
constexpr RegisterA64 rBase = x24; // StkId base
|
|
|
|
// Native code is as stackless as the interpreter, so we can place some data on the stack once and have it accessible at any point
|
|
// See CodeGenA64.cpp for layout
|
|
constexpr unsigned kStashSlots = 8; // stashed non-volatile registers
|
|
constexpr unsigned kSpillSlots = 22; // slots for spilling temporary registers
|
|
constexpr unsigned kTempSlots = 2; // 16 bytes of temporary space, such luxury!
|
|
|
|
constexpr unsigned kStackSize = (kStashSlots + kSpillSlots + kTempSlots) * 8;
|
|
|
|
constexpr AddressA64 sSpillArea = mem(sp, kStashSlots * 8);
|
|
constexpr AddressA64 sTemporary = mem(sp, (kStashSlots + kSpillSlots) * 8);
|
|
|
|
inline void emitUpdateBase(AssemblyBuilderA64& build)
|
|
{
|
|
build.ldr(rBase, mem(rState, offsetof(lua_State, base)));
|
|
}
|
|
|
|
} // namespace A64
|
|
} // namespace CodeGen
|
|
} // namespace Luau
|