-
Notifications
You must be signed in to change notification settings - Fork 64
Changes
Updated to build with LLVM 3.7
Added ability to dump out the assembly code
Added options for better control of auto compilation
Added MAC OS X as a supported platform
Restricted JIT execution to main thread to enable coroutines to work in interpreted mode
Revised tbaa metadata to use struct path nodes consistently
Added support for Ravi arrays in pairs() and ipairs()
Implemented new opcodes to enable typed checking of upvalue operations
Implemented faster version of fornum loop when index is integer and step is a positive constant
Added API to control JIT optimisation levels
Implemented OP_RAVI_TOARRAY? and OP_RAVI_MOVEA? opcodes in LLVM
Implemented OP_RAVI_SETTABLE_A? and OP_RAVI_GETTABLE_A? in LLVM
Implemented OP-CLOSURE, OP_CONCAT and OP_VARARG in LLVM
Implemented OP_LOADKX, OP_SELF in LLVM
Implemented OP_SETUPVAL and OP_SETUPTAB in LLVM
Implemented OP_POW, OP_UNM in LLVM
Implemented OP_LEN in LLVM
Implemented OP_IDIV, OP_NOT and OP_MOD in LLVM
Implemented OP_TFORCALL and OP_TFORLOOP in LLVM
Implemented OP_NEWTABLE, OP_SELIST and OP_TAILCALL in LLVM
Implemented OP_RAVI_NEWARRAY?, OP_GETUPVAL, OP_GETTABUP in LLVM
Implemented OP_DIV, OP_ADD, OP_SUB, and OP_MUL in LLVM
Implemented OP_TEST and OP_TESTSET in LLVM
Several more op codes added. Plus an API added for compiling functions.
Checked in implementation of OP_FORPREP, OP_FORLOOP and OP_MOVE in LLVM. Added simple forloop benchmark.
Checked in implementation of FORPREP opcode in LLVM; reorganised some of the LLVM generation code
Added tbaa decorations in LLVM IR to allow better optimization.
Implemented LLVM code generation for OP_LOADK, OP_RETURN, OP_LT, OP_LE, OP_EQ, OP_JMP. A function with only these instructions is compiled before execution provided it was called from OP_CALL instruction in lvm.c.
Checked in LLVM type definitions for major Lua structures that will need to be used by the JITed code.
Created some basic structures for LLVM interface.
LLVM is now a dependency of the build process.
Removed some arithmetic operators as they were redundant. Added ADDFIRN and ADDIIRN for when the constant is small and can be set to operand C. More such cleanup needed for SUB & MUL operators.
More changes to support array types. Also better support for inferring types in fornum statements.
Added new op codes for creating int and double arrays. Made changes to the parser to recognize array declarations. Made changes to VM to handle array types. TODO - need to initialize array variables. Need to allow set a typed variable to a value of array element if types are same. Need to ensure that user cannot subvert the array type. Need to set extra elements to nil to ensure compatibility.
Started work on supporting array type. Right now working on enhancing the table type to support specialized array operations.
More fixes for how we identify the types for variable in local declaration statements. int and double variables initialized to 0 using new opcodes LOADIZ and LOADFZ. Also changed the type identification referred to below to use the 'nactvar' instead of relying on 'startpc'.
Fixed an issue with type identification of registers - as Lua code can have declarations mixed with executable code, a reference to a local variable needs to be checked against the code range where the variable is 'visible'. The code that checks for the type of a register was missing this check and hence incorrectly identifying the type. Also added ability to control and generate debug messages at run time - focus is on parser and code generation.
Added opcodes for coercing values to expected types after a function call. Expanded the arithmetic opcodes to include MUL, DIV and SUB operations.
Working on figuring out a way to coerce types after a function call. This is necessary due to dynamic nature of Lua - the return type of a function is not known at compilation time.
Added the ability to generate code for local variables with type decorations (only int and double) for now, and support for type specific instructions to perform arithmetic operations; also added code to validate types to ensure that variables that are typed do not get assigned values of wrong type.
Went back to 32-bit instructions due to complexity of the 2-instruction approach.
Added RAVI opcodes for eq, lt, le operators Enhanced parser to recognise local name:type syntax. But constants are not typed yet.
Added RAVI opcode implementation in lvm.c for add, sub, mul and div operations.
Added various opcodes in opcodes.h. OP_RAVI opcode introduces a 64-bit instruction where the real opcode is stored in 10 bits - and a,b & c take up 16 bits each.
Added RAVI opcode UNMF to the VM - floating point unary minus.
Need to add more opcodes. So as a first step modified the SIZE_OP to 8 bits and adjusted SIZE_B and SIZE_C in lopcodes.h.
Also in luaconf.h change LUAI_FUNC to LUA_API so that we can write some test cases using internal routines.