├── .gitignore ├── CMakeLists.txt ├── README.md ├── bcDec └── bcDec.cpp ├── dynasm ├── dasm_arm.h ├── dasm_arm.lua ├── dasm_arm64.h ├── dasm_arm64.lua ├── dasm_mips.h ├── dasm_mips.lua ├── dasm_mips64.lua ├── dasm_ppc.h ├── dasm_ppc.lua ├── dasm_proto.h ├── dasm_x64.lua ├── dasm_x86.h ├── dasm_x86.lua └── dynasm.lua ├── etc ├── luajit.1 └── luajit.pc └── src ├── Makefile ├── Makefile.dep ├── buildvm.exp ├── defs.h ├── host ├── README ├── buildvm.c ├── buildvm.h ├── buildvm_arch.h ├── buildvm_asm.c ├── buildvm_fold.c ├── buildvm_lib.c ├── buildvm_libbc.h ├── buildvm_peobj.c ├── genlibbc.lua ├── genminilua.lua └── minilua.c ├── jit ├── bc.lua ├── bcsave.lua ├── dis_arm.lua ├── dis_arm64.lua ├── dis_arm64be.lua ├── dis_mips.lua ├── dis_mips64.lua ├── dis_mips64el.lua ├── dis_mipsel.lua ├── dis_ppc.lua ├── dis_x64.lua ├── dis_x86.lua ├── dump.lua ├── p.lua ├── v.lua ├── vmdef.lua └── zone.lua ├── lauxlib.h ├── lib_aux.c ├── lib_base.c ├── lib_bit.c ├── lib_debug.c ├── lib_ffi.c ├── lib_init.c ├── lib_io.c ├── lib_jit.c ├── lib_math.c ├── lib_os.c ├── lib_package.c ├── lib_string.c ├── lib_table.c ├── lj.supp ├── lj_alloc.c ├── lj_alloc.h ├── lj_api.c ├── lj_arch.h ├── lj_asm.c ├── lj_asm.h ├── lj_asm_arm.h ├── lj_asm_arm64.h ├── lj_asm_mips.h ├── lj_asm_ppc.h ├── lj_asm_x86.h ├── lj_bc.c ├── lj_bc.h ├── lj_bcdef.h ├── lj_bcdump.h ├── lj_bcread.c ├── lj_bcwrite.c ├── lj_buf.c ├── lj_buf.h ├── lj_carith.c ├── lj_carith.h ├── lj_ccall.c ├── lj_ccall.h ├── lj_ccallback.c ├── lj_ccallback.h ├── lj_cconv.c ├── lj_cconv.h ├── lj_cdata.c ├── lj_cdata.h ├── lj_char.c ├── lj_char.h ├── lj_clib.c ├── lj_clib.h ├── lj_cparse.c ├── lj_cparse.h ├── lj_crecord.c ├── lj_crecord.h ├── lj_ctype.c ├── lj_ctype.h ├── lj_debug.c ├── lj_debug.h ├── lj_def.h ├── lj_dispatch.c ├── lj_dispatch.h ├── lj_emit_arm.h ├── lj_emit_arm64.h ├── lj_emit_mips.h ├── lj_emit_ppc.h ├── lj_emit_x86.h ├── lj_err.c ├── lj_err.h ├── lj_errmsg.h ├── lj_ff.h ├── lj_ffdef.h ├── lj_ffrecord.c ├── lj_ffrecord.h ├── lj_folddef.h ├── lj_frame.h ├── lj_func.c ├── lj_func.h ├── lj_gc.c ├── lj_gc.h ├── lj_gdbjit.c ├── lj_gdbjit.h ├── lj_ir.c ├── lj_ir.h ├── lj_ircall.h ├── lj_iropt.h ├── lj_jit.h ├── lj_lex.c ├── lj_lex.h ├── lj_lib.c ├── lj_lib.h ├── lj_libdef.h ├── lj_load.c ├── lj_mcode.c ├── lj_mcode.h ├── lj_meta.c ├── lj_meta.h ├── lj_obj.c ├── lj_obj.h ├── lj_opt_dce.c ├── lj_opt_fold.c ├── lj_opt_loop.c ├── lj_opt_mem.c ├── lj_opt_narrow.c ├── lj_opt_sink.c ├── lj_opt_split.c ├── lj_parse.c ├── lj_parse.h ├── lj_profile.c ├── lj_profile.h ├── lj_recdef.h ├── lj_record.c ├── lj_record.h ├── lj_snap.c ├── lj_snap.h ├── lj_state.c ├── lj_state.h ├── lj_str.c ├── lj_str.h ├── lj_strfmt.c ├── lj_strfmt.h ├── lj_strfmt_num.c ├── lj_strscan.c ├── lj_strscan.h ├── lj_tab.c ├── lj_tab.h ├── lj_target.h ├── lj_target_arm.h ├── lj_target_arm64.h ├── lj_target_mips.h ├── lj_target_ppc.h ├── lj_target_x86.h ├── lj_trace.c ├── lj_trace.h ├── lj_traceerr.h ├── lj_udata.c ├── lj_udata.h ├── lj_vm.h ├── lj_vmevent.c ├── lj_vmevent.h ├── lj_vmmath.c ├── ljamalg.c ├── lua.h ├── lua.hpp ├── luaconf.h ├── luajit.c ├── luajit.h ├── lualib.h ├── minilua.exp ├── msvcbuild.bat ├── ps4build.bat ├── psvitabuild.bat ├── vm_arm.dasc ├── vm_arm64.dasc ├── vm_mips.dasc ├── vm_mips64.dasc ├── vm_ppc.dasc ├── vm_x64.dasc ├── vm_x86.dasc ├── xb1build.bat └── xedkbuild.bat /.gitignore: -------------------------------------------------------------------------------- 1 | # Prerequisites 2 | *.d 3 | 4 | # Compiled Object files 5 | *.slo 6 | *.lo 7 | *.o 8 | *.obj 9 | 10 | # Precompiled Headers 11 | *.gch 12 | *.pch 13 | 14 | # Compiled Dynamic libraries 15 | *.so 16 | *.dylib 17 | *.dll 18 | 19 | # Fortran module files 20 | *.mod 21 | *.smod 22 | 23 | # Compiled Static libraries 24 | *.lai 25 | *.la 26 | *.a 27 | *.lib 28 | 29 | # Executables 30 | *.exe 31 | *.out 32 | *.app 33 | 34 | .vscode 35 | build -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.0.0) 2 | project(bcDecoder VERSION 0.1.0) 3 | 4 | set(CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE x86) 5 | set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MT") 6 | set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MTd") 7 | 8 | file(GLOB LUA51C ${PROJECT_SOURCE_DIR}/src/lj_*.c ${PROJECT_SOURCE_DIR}/src/lib_*.c ) 9 | add_library(Lua51 ${LUA51C}) 10 | target_include_directories(Lua51 PUBLIC ${PROJECT_SOURCE_DIR}/src) 11 | target_link_directories(Lua51 PUBLIC ${PROJECT_SOURCE_DIR}/src) 12 | target_compile_definitions(Lua51 PRIVATE "WIN32" "_WINDOWS" "_USRDLL" "LUA51_EXPORTS" "_CRT_SECURE_NO_WARNINGS") 13 | IF( MSVC ) 14 | add_custom_command(TARGET Lua51 PRE_BUILD 15 | COMMAND cd /d ${PROJECT_SOURCE_DIR}/src 16 | COMMAND ${PROJECT_SOURCE_DIR}/src/msvcbuild.bat 17 | COMMAND cd /d ${PROJECT_SOURCE_DIR} 18 | ) 19 | target_link_libraries(Lua51 ${PROJECT_SOURCE_DIR}/src/lj_vm.obj) 20 | ENDIF ( MSVC ) 21 | 22 | set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT") 23 | set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd") 24 | add_executable(bcDec ${PROJECT_SOURCE_DIR}/bcDec/bcDec.cpp) 25 | target_link_libraries(bcDec Lua51) 26 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # AzurLane5.1-bcDec 2 | The luajit byte code decoder for AzurLane5.1 3 | 4 | ## Build 5 | * Visual Studio required 6 | * supports x86 only 7 | 8 | ## Usage 9 | 10 | `bcDec "InputFilePath/InputDir" ["OutputDir"]` 11 | -------------------------------------------------------------------------------- /bcDec/bcDec.cpp: -------------------------------------------------------------------------------- 1 |  2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | #include "lua.h" 12 | #include "lauxlib.h" 13 | #include "lualib.h" 14 | #include "luajit.h" 15 | #include "lj_arch.h" 16 | #include "lj_buf.h" 17 | #include "lj_lib.h" 18 | #include "lj_bcdump.h" 19 | 20 | 21 | static std::string remove_unnecessary_slashes(const std::string& path_str) 22 | { 23 | size_t end_pos = path_str.find_last_not_of(R"(\/)"); 24 | size_t begin_pos = path_str.find_first_not_of(R"(\/)"); 25 | if ((begin_pos > path_str.length()) || (end_pos > path_str.length())) 26 | { 27 | return std::string(); 28 | } 29 | else 30 | { 31 | return path_str.substr(begin_pos, end_pos - begin_pos + 1); 32 | } 33 | } 34 | 35 | static std::string append_path(const std::string& path_left, const std::string& path_right) 36 | { 37 | return remove_unnecessary_slashes(path_left) + '\\' + remove_unnecessary_slashes(path_right); 38 | } 39 | 40 | static std::string get_filename_from_path(const std::string& _filepath) 41 | { 42 | std::string _norm = remove_unnecessary_slashes(_filepath); 43 | size_t slash_pos = _norm.find_last_of(R"(\/)"); 44 | if (slash_pos > _norm.length()) 45 | { 46 | return _norm; 47 | } 48 | else 49 | { 50 | return _norm.substr(slash_pos + 1); 51 | } 52 | } 53 | 54 | static std::string get_filename_stem(std::string filename) 55 | { 56 | std::string _normalized = remove_unnecessary_slashes(filename); 57 | size_t dot_pos = _normalized.find('.'); 58 | if (dot_pos > _normalized.length()) 59 | { 60 | return _normalized; 61 | } 62 | else 63 | { 64 | return _normalized.substr(0, dot_pos); 65 | } 66 | } 67 | 68 | static std::string get_parent_path(std::string file_path) 69 | { 70 | std::string _norm = remove_unnecessary_slashes(file_path); 71 | size_t slash_pos = _norm.find_last_of(R"(\/)"); 72 | if (slash_pos > _norm.length()) 73 | { 74 | return _norm; 75 | } 76 | else 77 | { 78 | return _norm.substr(0, slash_pos); 79 | } 80 | } 81 | 82 | void mkd(const std::string& _dir_path) 83 | { 84 | std::string cmd = R"(mkdir ")"; 85 | cmd += _dir_path; 86 | cmd += "\""; 87 | system(cmd.c_str()); 88 | } 89 | 90 | 91 | namespace EPathType 92 | { 93 | enum Type 94 | { 95 | Invalid, 96 | Directory, 97 | Regular, 98 | }; 99 | } 100 | 101 | 102 | static EPathType::Type stat_path(std::string _path) 103 | { 104 | struct stat st; 105 | if (0 == stat(_path.c_str(), &st)) 106 | { 107 | if (st.st_mode & S_IFDIR) 108 | { 109 | return EPathType::Directory; 110 | 111 | } 112 | else if (st.st_mode & S_IFREG) 113 | { 114 | return EPathType::Regular; 115 | } 116 | } 117 | return EPathType::Invalid; 118 | } 119 | 120 | 121 | static int writer_buf(lua_State *L, const void *p, size_t size, void *sb) 122 | { 123 | lj_buf_putmem((SBuf *)sb, p, (MSize)size); 124 | UNUSED(L); 125 | return 0; 126 | } 127 | 128 | bool DecodeByteCode(lua_State* L, const char* _BCFilePath, const char* _OutputFilePath) 129 | { 130 | bool bSuccess = false; 131 | size_t sz = 0; 132 | const char* decbuf = nullptr; 133 | std::ofstream ofs; 134 | 135 | luaL_loadfile(L, _BCFilePath); 136 | 137 | GCfunc *fn = lj_lib_checkfunc(L, 1); 138 | static int strip = 1; 139 | SBuf *sb = lj_buf_tmp_(L); 140 | L->top = L->base + 1; 141 | if (!isluafunc(fn) || lj_bcwrite(L, funcproto(fn), writer_buf, sb, strip)) 142 | { 143 | lj_err_caller(L, LJ_ERR_STRDUMP); 144 | bSuccess = false; 145 | goto exit; 146 | } 147 | 148 | setstrV(L, L->top - 1, lj_buf_str(L, sb)); 149 | lj_gc_check(L); 150 | 151 | decbuf = lua_tolstring(L, -1, &sz); 152 | ofs.open(_OutputFilePath, std::ios::binary | std::ios::trunc); 153 | ofs.write(decbuf, sz); 154 | ofs.close(); 155 | bSuccess = true; 156 | 157 | exit: 158 | lua_settop(L, 0); 159 | return bSuccess; 160 | } 161 | 162 | void DecFileTo_Impl(lua_State* L, const std::string& _In_filepath, const char* _OutputDir) 163 | { 164 | std::string fn_stem = get_filename_stem(get_filename_from_path(_In_filepath)); 165 | std::string OutPath = append_path(_OutputDir, fn_stem) + ".lj"; 166 | DecodeByteCode(L, _In_filepath.c_str(), OutPath.c_str()); 167 | } 168 | 169 | inline void DecSingle(lua_State* L, const char* _InputFilePath, const char* _OutputDir) 170 | { 171 | mkd(_OutputDir); 172 | DecFileTo_Impl(L, _InputFilePath, _OutputDir); 173 | } 174 | 175 | void DecDirectory(lua_State* L, const char* _InputDir, const char* _OutputDir) 176 | { 177 | mkd(_OutputDir); 178 | 179 | _finddata_t fileinf; 180 | long handle = _findfirst(append_path(_InputDir, "*").c_str(), &fileinf); 181 | do 182 | { 183 | if (fileinf.attrib != _A_SUBDIR) 184 | { 185 | std::cout << fileinf.name << std::endl; 186 | std::string file_path = append_path(_InputDir, fileinf.name); 187 | DecFileTo_Impl(L, file_path, _OutputDir); 188 | 189 | } 190 | } while (!_findnext(handle, &fileinf)); 191 | _findclose(handle); 192 | } 193 | 194 | 195 | int main(int _argc, char **_argv) 196 | { 197 | lua_State *L = lua_open(); 198 | 199 | switch (_argc) 200 | { 201 | case 2: 202 | { 203 | auto st = stat_path(_argv[1]); 204 | if (st == EPathType::Invalid) 205 | { 206 | std::cout << "Invalid input path." << std::endl; 207 | break; 208 | } 209 | if (st == EPathType::Directory) 210 | { 211 | std::string outdir = append_path(_argv[1], "dec"); 212 | DecDirectory(L, _argv[1], outdir.c_str()); 213 | } 214 | else 215 | { 216 | std::string outdir = append_path(get_parent_path(_argv[1]), "dec"); 217 | DecSingle(L, _argv[1], outdir.c_str()); 218 | } 219 | 220 | break; 221 | } 222 | case 3: 223 | { 224 | auto st = stat_path(_argv[1]); 225 | if (st == EPathType::Invalid) 226 | { 227 | std::cout << "Invalid input path." << std::endl; 228 | break; 229 | } 230 | if (st == EPathType::Directory) 231 | { 232 | DecDirectory(L, _argv[1], _argv[2]); 233 | } 234 | else 235 | { 236 | DecSingle(L, _argv[1], _argv[2]); 237 | } 238 | break; 239 | } 240 | 241 | default: 242 | { 243 | std::cout << R"(Usage: bcDec "InputFilePath/InputDir" ["OutputDir"])" << std::endl; 244 | } 245 | break; 246 | } 247 | 248 | lua_close(L); 249 | return 0; 250 | } -------------------------------------------------------------------------------- /dynasm/dasm_mips64.lua: -------------------------------------------------------------------------------- 1 | ------------------------------------------------------------------------------ 2 | -- DynASM MIPS64 module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- See dynasm.lua for full copyright notice. 6 | ------------------------------------------------------------------------------ 7 | -- This module just sets 64 bit mode for the combined MIPS/MIPS64 module. 8 | -- All the interesting stuff is there. 9 | ------------------------------------------------------------------------------ 10 | 11 | mips64 = true -- Using a global is an ugly, but effective solution. 12 | return require("dasm_mips") 13 | -------------------------------------------------------------------------------- /dynasm/dasm_proto.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** DynASM encoding engine prototypes. 3 | ** Copyright (C) 2005-2017 Mike Pall. All rights reserved. 4 | ** Released under the MIT license. See dynasm.lua for full copyright notice. 5 | */ 6 | 7 | #ifndef _DASM_PROTO_H 8 | #define _DASM_PROTO_H 9 | 10 | #include 11 | #include 12 | 13 | #define DASM_IDENT "DynASM 1.4.0" 14 | #define DASM_VERSION 10400 /* 1.4.0 */ 15 | 16 | #ifndef Dst_DECL 17 | #define Dst_DECL dasm_State **Dst 18 | #endif 19 | 20 | #ifndef Dst_REF 21 | #define Dst_REF (*Dst) 22 | #endif 23 | 24 | #ifndef DASM_FDEF 25 | #define DASM_FDEF extern 26 | #endif 27 | 28 | #ifndef DASM_M_GROW 29 | #define DASM_M_GROW(ctx, t, p, sz, need) \ 30 | do { \ 31 | size_t _sz = (sz), _need = (need); \ 32 | if (_sz < _need) { \ 33 | if (_sz < 16) _sz = 16; \ 34 | while (_sz < _need) _sz += _sz; \ 35 | (p) = (t *)realloc((p), _sz); \ 36 | if ((p) == NULL) exit(1); \ 37 | (sz) = _sz; \ 38 | } \ 39 | } while(0) 40 | #endif 41 | 42 | #ifndef DASM_M_FREE 43 | #define DASM_M_FREE(ctx, p, sz) free(p) 44 | #endif 45 | 46 | /* Internal DynASM encoder state. */ 47 | typedef struct dasm_State dasm_State; 48 | 49 | 50 | /* Initialize and free DynASM state. */ 51 | DASM_FDEF void dasm_init(Dst_DECL, int maxsection); 52 | DASM_FDEF void dasm_free(Dst_DECL); 53 | 54 | /* Setup global array. Must be called before dasm_setup(). */ 55 | DASM_FDEF void dasm_setupglobal(Dst_DECL, void **gl, unsigned int maxgl); 56 | 57 | /* Grow PC label array. Can be called after dasm_setup(), too. */ 58 | DASM_FDEF void dasm_growpc(Dst_DECL, unsigned int maxpc); 59 | 60 | /* Setup encoder. */ 61 | DASM_FDEF void dasm_setup(Dst_DECL, const void *actionlist); 62 | 63 | /* Feed encoder with actions. Calls are generated by pre-processor. */ 64 | DASM_FDEF void dasm_put(Dst_DECL, int start, ...); 65 | 66 | /* Link sections and return the resulting size. */ 67 | DASM_FDEF int dasm_link(Dst_DECL, size_t *szp); 68 | 69 | /* Encode sections into buffer. */ 70 | DASM_FDEF int dasm_encode(Dst_DECL, void *buffer); 71 | 72 | /* Get PC label offset. */ 73 | DASM_FDEF int dasm_getpclabel(Dst_DECL, unsigned int pc); 74 | 75 | #ifdef DASM_CHECKS 76 | /* Optional sanity checker to call between isolated encoding steps. */ 77 | DASM_FDEF int dasm_checkstep(Dst_DECL, int secmatch); 78 | #else 79 | #define dasm_checkstep(a, b) 0 80 | #endif 81 | 82 | 83 | #endif /* _DASM_PROTO_H */ 84 | -------------------------------------------------------------------------------- /dynasm/dasm_x64.lua: -------------------------------------------------------------------------------- 1 | ------------------------------------------------------------------------------ 2 | -- DynASM x64 module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- See dynasm.lua for full copyright notice. 6 | ------------------------------------------------------------------------------ 7 | -- This module just sets 64 bit mode for the combined x86/x64 module. 8 | -- All the interesting stuff is there. 9 | ------------------------------------------------------------------------------ 10 | 11 | x64 = true -- Using a global is an ugly, but effective solution. 12 | return require("dasm_x86") 13 | -------------------------------------------------------------------------------- /etc/luajit.1: -------------------------------------------------------------------------------- 1 | .TH luajit 1 "" "" "LuaJIT documentation" 2 | .SH NAME 3 | luajit \- Just-In-Time Compiler for the Lua Language 4 | \fB 5 | .SH SYNOPSIS 6 | .B luajit 7 | [\fIoptions\fR]... [\fIscript\fR [\fIargs\fR]...] 8 | .SH "WEB SITE" 9 | .IR http://luajit.org 10 | .SH DESCRIPTION 11 | .PP 12 | This is the command-line program to run Lua programs with \fBLuaJIT\fR. 13 | .PP 14 | \fBLuaJIT\fR is a just-in-time (JIT) compiler for the Lua language. 15 | The virtual machine (VM) is based on a fast interpreter combined with 16 | a trace compiler. It can significantly improve the performance of Lua programs. 17 | .PP 18 | \fBLuaJIT\fR is API\- and ABI-compatible with the VM of the standard 19 | Lua\ 5.1 interpreter. When embedding the VM into an application, 20 | the built library can be used as a drop-in replacement. 21 | .SH OPTIONS 22 | .TP 23 | .BI "\-e " chunk 24 | Run the given chunk of Lua code. 25 | .TP 26 | .BI "\-l " library 27 | Load the named library, just like \fBrequire("\fR\fIlibrary\fR\fB")\fR. 28 | .TP 29 | .BI "\-b " ... 30 | Save or list bytecode. Run without arguments to get help on options. 31 | .TP 32 | .BI "\-j " command 33 | Perform LuaJIT control command (optional space after \fB\-j\fR). 34 | .TP 35 | .BI "\-O" [opt] 36 | Control LuaJIT optimizations. 37 | .TP 38 | .B "\-i" 39 | Run in interactive mode. 40 | .TP 41 | .B "\-v" 42 | Show \fBLuaJIT\fR version. 43 | .TP 44 | .B "\-E" 45 | Ignore environment variables. 46 | .TP 47 | .B "\-\-" 48 | Stop processing options. 49 | .TP 50 | .B "\-" 51 | Read script from stdin instead. 52 | .PP 53 | After all options are processed, the given \fIscript\fR is run. 54 | The arguments are passed in the global \fIarg\fR table. 55 | .PP 56 | Interactive mode is only entered, if no \fIscript\fR and no \fB\-e\fR 57 | option is given. Interactive mode can be left with EOF (\fICtrl\-Z\fB). 58 | .SH EXAMPLES 59 | .TP 60 | luajit hello.lua world 61 | 62 | Prints "Hello world", assuming \fIhello.lua\fR contains: 63 | .br 64 | print("Hello", arg[1]) 65 | .TP 66 | luajit \-e "local x=0; for i=1,1e9 do x=x+i end; print(x)" 67 | 68 | Calculates the sum of the numbers from 1 to 1000000000. 69 | .br 70 | And finishes in a reasonable amount of time, too. 71 | .TP 72 | luajit \-jv \-e "for i=1,10 do for j=1,10 do for k=1,100 do end end end" 73 | 74 | Runs some nested loops and shows the resulting traces. 75 | .SH COPYRIGHT 76 | .PP 77 | \fBLuaJIT\fR is Copyright \(co 2005-2017 Mike Pall. 78 | .br 79 | \fBLuaJIT\fR is open source software, released under the MIT license. 80 | .SH SEE ALSO 81 | .PP 82 | More details in the provided HTML docs or at: 83 | .IR http://luajit.org 84 | .br 85 | More about the Lua language can be found at: 86 | .IR http://lua.org/docs.html 87 | .PP 88 | lua(1) 89 | -------------------------------------------------------------------------------- /etc/luajit.pc: -------------------------------------------------------------------------------- 1 | # Package information for LuaJIT to be used by pkg-config. 2 | majver=2 3 | minver=1 4 | relver=0 5 | version=${majver}.${minver}.${relver}-beta3 6 | abiver=5.1 7 | 8 | prefix=/usr/local 9 | multilib=lib 10 | exec_prefix=${prefix} 11 | libdir=${exec_prefix}/${multilib} 12 | libname=luajit-${abiver} 13 | includedir=${prefix}/include/luajit-${majver}.${minver} 14 | 15 | INSTALL_LMOD=${prefix}/share/lua/${abiver} 16 | INSTALL_CMOD=${prefix}/${multilib}/lua/${abiver} 17 | 18 | Name: LuaJIT 19 | Description: Just-in-time compiler for Lua 20 | URL: http://luajit.org 21 | Version: ${version} 22 | Requires: 23 | Libs: -L${libdir} -l${libname} 24 | Libs.private: -Wl,-E -lm -ldl 25 | Cflags: -I${includedir} 26 | -------------------------------------------------------------------------------- /src/buildvm.exp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jspzyhl/AzurLane5.1-bcDec/ffb4794a653ed6ff6ccb395a7e9d218c71667b3f/src/buildvm.exp -------------------------------------------------------------------------------- /src/host/README: -------------------------------------------------------------------------------- 1 | The files in this directory are only used during the build process of LuaJIT. 2 | For cross-compilation, they must be executed on the host, not on the target. 3 | 4 | These files should NOT be installed! 5 | -------------------------------------------------------------------------------- /src/host/buildvm.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** LuaJIT VM builder. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _BUILDVM_H 7 | #define _BUILDVM_H 8 | 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #include "lj_def.h" 16 | #include "lj_arch.h" 17 | 18 | /* Hardcoded limits. Increase as needed. */ 19 | #define BUILD_MAX_RELOC 200 /* Max. number of relocations. */ 20 | #define BUILD_MAX_FOLD 4096 /* Max. number of fold rules. */ 21 | 22 | /* Prefix for scanned library definitions. */ 23 | #define LIBDEF_PREFIX "LJLIB_" 24 | 25 | /* Prefix for scanned fold definitions. */ 26 | #define FOLDDEF_PREFIX "LJFOLD" 27 | 28 | /* Prefixes for generated labels. */ 29 | #define LABEL_PREFIX "lj_" 30 | #define LABEL_PREFIX_BC LABEL_PREFIX "BC_" 31 | #define LABEL_PREFIX_FF LABEL_PREFIX "ff_" 32 | #define LABEL_PREFIX_CF LABEL_PREFIX "cf_" 33 | #define LABEL_PREFIX_FFH LABEL_PREFIX "ffh_" 34 | #define LABEL_PREFIX_LIBCF LABEL_PREFIX "lib_cf_" 35 | #define LABEL_PREFIX_LIBINIT LABEL_PREFIX "lib_init_" 36 | 37 | /* Forward declaration. */ 38 | struct dasm_State; 39 | 40 | /* Build modes. */ 41 | #define BUILDDEF(_) \ 42 | _(elfasm) _(coffasm) _(machasm) _(peobj) _(raw) \ 43 | _(bcdef) _(ffdef) _(libdef) _(recdef) _(vmdef) \ 44 | _(folddef) 45 | 46 | typedef enum { 47 | #define BUILDENUM(name) BUILD_##name, 48 | BUILDDEF(BUILDENUM) 49 | #undef BUILDENUM 50 | BUILD__MAX 51 | } BuildMode; 52 | 53 | /* Code relocation. */ 54 | typedef struct BuildReloc { 55 | int32_t ofs; 56 | int sym; 57 | int type; 58 | } BuildReloc; 59 | 60 | typedef struct BuildSym { 61 | const char *name; 62 | int32_t ofs; 63 | } BuildSym; 64 | 65 | /* Build context structure. */ 66 | typedef struct BuildCtx { 67 | /* DynASM state pointer. Should be first member. */ 68 | struct dasm_State *D; 69 | /* Parsed command line. */ 70 | BuildMode mode; 71 | FILE *fp; 72 | const char *outname; 73 | char **args; 74 | /* Code and symbols generated by DynASM. */ 75 | uint8_t *code; 76 | size_t codesz; 77 | int npc, nglob, nsym, nreloc, nrelocsym; 78 | void **glob; 79 | BuildSym *sym; 80 | const char **relocsym; 81 | int32_t *bc_ofs; 82 | const char *beginsym; 83 | /* Strings generated by DynASM. */ 84 | const char *const *globnames; 85 | const char *const *extnames; 86 | const char *dasm_ident; 87 | const char *dasm_arch; 88 | /* Relocations. */ 89 | BuildReloc reloc[BUILD_MAX_RELOC]; 90 | } BuildCtx; 91 | 92 | extern void owrite(BuildCtx *ctx, const void *ptr, size_t sz); 93 | extern void emit_asm(BuildCtx *ctx); 94 | extern void emit_peobj(BuildCtx *ctx); 95 | extern void emit_lib(BuildCtx *ctx); 96 | extern void emit_fold(BuildCtx *ctx); 97 | 98 | extern const char *const bc_names[]; 99 | extern const char *const ir_names[]; 100 | extern const char *const irt_names[]; 101 | extern const char *const irfpm_names[]; 102 | extern const char *const irfield_names[]; 103 | extern const char *const ircall_names[]; 104 | 105 | #endif 106 | -------------------------------------------------------------------------------- /src/host/buildvm_libbc.h: -------------------------------------------------------------------------------- 1 | /* This is a generated file. DO NOT EDIT! */ 2 | 3 | static const int libbc_endian = 0; 4 | 5 | static const uint8_t libbc_code[] = { 6 | #if LJ_FR2 7 | 0,1,2,0,0,1,2,24,1,0,0,76,1,2,0,241,135,158,166,3,220,203,178,130,4,0,1,2,0, 8 | 0,1,2,24,1,0,0,76,1,2,0,243,244,148,165,20,198,190,199,252,3,0,1,2,0,0,0,3, 9 | 16,0,5,0,21,1,0,0,76,1,2,0,0,2,10,0,0,0,15,16,0,12,0,16,1,9,0,41,2,1,0,21,3, 10 | 0,0,41,4,1,0,77,2,8,128,18,6,1,0,18,8,5,0,59,9,5,0,66,6,3,2,10,6,0,0,88,7,1, 11 | 128,76,6,2,0,79,2,248,127,75,0,1,0,0,2,11,0,0,0,16,16,0,12,0,16,1,9,0,43,2, 12 | 0,0,18,3,0,0,41,4,0,0,88,5,7,128,18,7,1,0,18,9,5,0,18,10,6,0,66,7,3,2,10,7, 13 | 0,0,88,8,1,128,76,7,2,0,70,5,3,3,82,5,247,127,75,0,1,0,0,1,2,0,0,0,3,16,0,12, 14 | 0,21,1,0,0,76,1,2,0,0,2,10,0,0,2,30,16,0,12,0,21,2,0,0,11,1,0,0,88,3,7,128, 15 | 8,2,0,0,88,3,23,128,59,3,2,0,43,4,0,0,64,4,2,0,76,3,2,0,88,3,18,128,16,1,14, 16 | 0,41,3,1,0,3,3,1,0,88,3,14,128,3,1,2,0,88,3,12,128,59,3,1,0,22,4,1,1,18,5,2, 17 | 0,41,6,1,0,77,4,4,128,23,8,1,7,59,9,7,0,64,9,8,0,79,4,252,127,43,4,0,0,64,4, 18 | 2,0,76,3,2,0,75,0,1,0,0,2,0,5,12,0,0,0,35,16,0,12,0,16,1,14,0,16,2,14,0,16, 19 | 3,14,0,11,4,0,0,88,5,1,128,18,4,0,0,16,4,12,0,3,1,2,0,88,5,24,128,33,5,1,3, 20 | 0,2,3,0,88,6,4,128,2,3,1,0,88,6,2,128,4,4,0,0,88,6,9,128,18,6,1,0,18,7,2,0, 21 | 41,8,1,0,77,6,4,128,32,10,5,9,59,11,9,0,64,11,10,4,79,6,252,127,88,6,8,128, 22 | 18,6,2,0,18,7,1,0,41,8,255,255,77,6,4,128,32,10,5,9,59,11,9,0,64,11,10,4,79, 23 | 6,252,127,76,4,2,0,0 24 | #else 25 | 0,1,2,0,0,1,2,24,1,0,0,76,1,2,0,241,135,158,166,3,220,203,178,130,4,0,1,2,0, 26 | 0,1,2,24,1,0,0,76,1,2,0,243,244,148,165,20,198,190,199,252,3,0,1,2,0,0,0,3, 27 | 16,0,5,0,21,1,0,0,76,1,2,0,0,2,9,0,0,0,15,16,0,12,0,16,1,9,0,41,2,1,0,21,3, 28 | 0,0,41,4,1,0,77,2,8,128,18,6,1,0,18,7,5,0,59,8,5,0,66,6,3,2,10,6,0,0,88,7,1, 29 | 128,76,6,2,0,79,2,248,127,75,0,1,0,0,2,10,0,0,0,16,16,0,12,0,16,1,9,0,43,2, 30 | 0,0,18,3,0,0,41,4,0,0,88,5,7,128,18,7,1,0,18,8,5,0,18,9,6,0,66,7,3,2,10,7,0, 31 | 0,88,8,1,128,76,7,2,0,70,5,3,3,82,5,247,127,75,0,1,0,0,1,2,0,0,0,3,16,0,12, 32 | 0,21,1,0,0,76,1,2,0,0,2,10,0,0,2,30,16,0,12,0,21,2,0,0,11,1,0,0,88,3,7,128, 33 | 8,2,0,0,88,3,23,128,59,3,2,0,43,4,0,0,64,4,2,0,76,3,2,0,88,3,18,128,16,1,14, 34 | 0,41,3,1,0,3,3,1,0,88,3,14,128,3,1,2,0,88,3,12,128,59,3,1,0,22,4,1,1,18,5,2, 35 | 0,41,6,1,0,77,4,4,128,23,8,1,7,59,9,7,0,64,9,8,0,79,4,252,127,43,4,0,0,64,4, 36 | 2,0,76,3,2,0,75,0,1,0,0,2,0,5,12,0,0,0,35,16,0,12,0,16,1,14,0,16,2,14,0,16, 37 | 3,14,0,11,4,0,0,88,5,1,128,18,4,0,0,16,4,12,0,3,1,2,0,88,5,24,128,33,5,1,3, 38 | 0,2,3,0,88,6,4,128,2,3,1,0,88,6,2,128,4,4,0,0,88,6,9,128,18,6,1,0,18,7,2,0, 39 | 41,8,1,0,77,6,4,128,32,10,5,9,59,11,9,0,64,11,10,4,79,6,252,127,88,6,8,128, 40 | 18,6,2,0,18,7,1,0,41,8,255,255,77,6,4,128,32,10,5,9,59,11,9,0,64,11,10,4,79, 41 | 6,252,127,76,4,2,0,0 42 | #endif 43 | }; 44 | 45 | static const struct { const char *name; int ofs; } libbc_map[] = { 46 | {"math_deg",0}, 47 | {"math_rad",25}, 48 | {"string_len",50}, 49 | {"table_foreachi",69}, 50 | {"table_foreach",136}, 51 | {"table_getn",207}, 52 | {"table_remove",226}, 53 | {"table_move",355}, 54 | {NULL,502} 55 | }; 56 | 57 | -------------------------------------------------------------------------------- /src/host/genlibbc.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- Lua script to dump the bytecode of the library functions written in Lua. 3 | -- The resulting 'buildvm_libbc.h' is used for the build process of LuaJIT. 4 | ---------------------------------------------------------------------------- 5 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 6 | -- Released under the MIT license. See Copyright Notice in luajit.h 7 | ---------------------------------------------------------------------------- 8 | 9 | local ffi = require("ffi") 10 | local bit = require("bit") 11 | local vmdef = require("jit.vmdef") 12 | local bcnames = vmdef.bcnames 13 | 14 | local format = string.format 15 | 16 | local isbe = (string.byte(string.dump(function() end), 5) % 2 == 1) 17 | 18 | local function usage(arg) 19 | io.stderr:write("Usage: ", arg and arg[0] or "genlibbc", 20 | " [-o buildvm_libbc.h] lib_*.c\n") 21 | os.exit(1) 22 | end 23 | 24 | local function parse_arg(arg) 25 | local outfile = "-" 26 | if not (arg and arg[1]) then 27 | usage(arg) 28 | end 29 | if arg[1] == "-o" then 30 | outfile = arg[2] 31 | if not outfile then usage(arg) end 32 | table.remove(arg, 1) 33 | table.remove(arg, 1) 34 | end 35 | return outfile 36 | end 37 | 38 | local function read_files(names) 39 | local src = "" 40 | for _,name in ipairs(names) do 41 | local fp = assert(io.open(name)) 42 | src = src .. fp:read("*a") 43 | fp:close() 44 | end 45 | return src 46 | end 47 | 48 | local function transform_lua(code) 49 | local fixup = {} 50 | local n = -30000 51 | code = string.gsub(code, "CHECK_(%w*)%((.-)%)", function(tp, var) 52 | n = n + 1 53 | fixup[n] = { "CHECK", tp } 54 | return format("%s=%d", var, n) 55 | end) 56 | code = string.gsub(code, "PAIRS%((.-)%)", function(var) 57 | fixup.PAIRS = true 58 | return format("nil, %s, 0", var) 59 | end) 60 | return "return "..code, fixup 61 | end 62 | 63 | local function read_uleb128(p) 64 | local v = p[0]; p = p + 1 65 | if v >= 128 then 66 | local sh = 7; v = v - 128 67 | repeat 68 | local r = p[0] 69 | v = v + bit.lshift(bit.band(r, 127), sh) 70 | sh = sh + 7 71 | p = p + 1 72 | until r < 128 73 | end 74 | return p, v 75 | end 76 | 77 | -- ORDER LJ_T 78 | local name2itype = { 79 | str = 5, func = 9, tab = 12, int = 14, num = 15 80 | } 81 | 82 | local BC = {} 83 | for i=0,#bcnames/6-1 do 84 | BC[string.gsub(string.sub(bcnames, i*6+1, i*6+6), " ", "")] = i 85 | end 86 | local xop, xra = isbe and 3 or 0, isbe and 2 or 1 87 | local xrc, xrb = isbe and 1 or 2, isbe and 0 or 3 88 | 89 | local function fixup_dump(dump, fixup) 90 | local buf = ffi.new("uint8_t[?]", #dump+1, dump) 91 | local p = buf+5 92 | local n, sizebc 93 | p, n = read_uleb128(p) 94 | local start = p 95 | p = p + 4 96 | p = read_uleb128(p) 97 | p = read_uleb128(p) 98 | p, sizebc = read_uleb128(p) 99 | local rawtab = {} 100 | for i=0,sizebc-1 do 101 | local op = p[xop] 102 | if op == BC.KSHORT then 103 | local rd = p[xrc] + 256*p[xrb] 104 | rd = bit.arshift(bit.lshift(rd, 16), 16) 105 | local f = fixup[rd] 106 | if f then 107 | if f[1] == "CHECK" then 108 | local tp = f[2] 109 | if tp == "tab" then rawtab[p[xra]] = true end 110 | p[xop] = tp == "num" and BC.ISNUM or BC.ISTYPE 111 | p[xrb] = 0 112 | p[xrc] = name2itype[tp] 113 | else 114 | error("unhandled fixup type: "..f[1]) 115 | end 116 | end 117 | elseif op == BC.TGETV then 118 | if rawtab[p[xrb]] then 119 | p[xop] = BC.TGETR 120 | end 121 | elseif op == BC.TSETV then 122 | if rawtab[p[xrb]] then 123 | p[xop] = BC.TSETR 124 | end 125 | elseif op == BC.ITERC then 126 | if fixup.PAIRS then 127 | p[xop] = BC.ITERN 128 | end 129 | end 130 | p = p + 4 131 | end 132 | return ffi.string(start, n) 133 | end 134 | 135 | local function find_defs(src) 136 | local defs = {} 137 | for name, code in string.gmatch(src, "LJLIB_LUA%(([^)]*)%)%s*/%*(.-)%*/") do 138 | local env = {} 139 | local tcode, fixup = transform_lua(code) 140 | local func = assert(load(tcode, "", nil, env))() 141 | defs[name] = fixup_dump(string.dump(func, true), fixup) 142 | defs[#defs+1] = name 143 | end 144 | return defs 145 | end 146 | 147 | local function gen_header(defs) 148 | local t = {} 149 | local function w(x) t[#t+1] = x end 150 | w("/* This is a generated file. DO NOT EDIT! */\n\n") 151 | w("static const int libbc_endian = ") w(isbe and 1 or 0) w(";\n\n") 152 | local s = "" 153 | for _,name in ipairs(defs) do 154 | s = s .. defs[name] 155 | end 156 | w("static const uint8_t libbc_code[] = {\n") 157 | local n = 0 158 | for i=1,#s do 159 | local x = string.byte(s, i) 160 | w(x); w(",") 161 | n = n + (x < 10 and 2 or (x < 100 and 3 or 4)) 162 | if n >= 75 then n = 0; w("\n") end 163 | end 164 | w("0\n};\n\n") 165 | w("static const struct { const char *name; int ofs; } libbc_map[] = {\n") 166 | local m = 0 167 | for _,name in ipairs(defs) do 168 | w('{"'); w(name); w('",'); w(m) w('},\n') 169 | m = m + #defs[name] 170 | end 171 | w("{NULL,"); w(m); w("}\n};\n\n") 172 | return table.concat(t) 173 | end 174 | 175 | local function write_file(name, data) 176 | if name == "-" then 177 | assert(io.write(data)) 178 | assert(io.flush()) 179 | else 180 | local fp = io.open(name) 181 | if fp then 182 | local old = fp:read("*a") 183 | fp:close() 184 | if data == old then return end 185 | end 186 | fp = assert(io.open(name, "w")) 187 | assert(fp:write(data)) 188 | assert(fp:close()) 189 | end 190 | end 191 | 192 | local outfile = parse_arg(arg) 193 | local src = read_files(arg) 194 | local defs = find_defs(src) 195 | local hdr = gen_header(defs) 196 | write_file(outfile, hdr) 197 | 198 | -------------------------------------------------------------------------------- /src/jit/bc.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- LuaJIT bytecode listing module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- Released under the MIT license. See Copyright Notice in luajit.h 6 | ---------------------------------------------------------------------------- 7 | -- 8 | -- This module lists the bytecode of a Lua function. If it's loaded by -jbc 9 | -- it hooks into the parser and lists all functions of a chunk as they 10 | -- are parsed. 11 | -- 12 | -- Example usage: 13 | -- 14 | -- luajit -jbc -e 'local x=0; for i=1,1e6 do x=x+i end; print(x)' 15 | -- luajit -jbc=- foo.lua 16 | -- luajit -jbc=foo.list foo.lua 17 | -- 18 | -- Default output is to stderr. To redirect the output to a file, pass a 19 | -- filename as an argument (use '-' for stdout) or set the environment 20 | -- variable LUAJIT_LISTFILE. The file is overwritten every time the module 21 | -- is started. 22 | -- 23 | -- This module can also be used programmatically: 24 | -- 25 | -- local bc = require("jit.bc") 26 | -- 27 | -- local function foo() print("hello") end 28 | -- 29 | -- bc.dump(foo) --> -- BYTECODE -- [...] 30 | -- print(bc.line(foo, 2)) --> 0002 KSTR 1 1 ; "hello" 31 | -- 32 | -- local out = { 33 | -- -- Do something with each line: 34 | -- write = function(t, ...) io.write(...) end, 35 | -- close = function(t) end, 36 | -- flush = function(t) end, 37 | -- } 38 | -- bc.dump(foo, out) 39 | -- 40 | ------------------------------------------------------------------------------ 41 | 42 | -- Cache some library functions and objects. 43 | local jit = require("jit") 44 | assert(jit.version_num == 20100, "LuaJIT core/library version mismatch") 45 | local jutil = require("jit.util") 46 | local vmdef = require("jit.vmdef") 47 | local bit = require("bit") 48 | local sub, gsub, format = string.sub, string.gsub, string.format 49 | local byte, band, shr = string.byte, bit.band, bit.rshift 50 | local funcinfo, funcbc, funck = jutil.funcinfo, jutil.funcbc, jutil.funck 51 | local funcuvname = jutil.funcuvname 52 | local bcnames = vmdef.bcnames 53 | local stdout, stderr = io.stdout, io.stderr 54 | 55 | ------------------------------------------------------------------------------ 56 | 57 | local function ctlsub(c) 58 | if c == "\n" then return "\\n" 59 | elseif c == "\r" then return "\\r" 60 | elseif c == "\t" then return "\\t" 61 | else return format("\\%03d", byte(c)) 62 | end 63 | end 64 | 65 | -- Return one bytecode line. 66 | local function bcline(func, pc, prefix) 67 | local ins, m = funcbc(func, pc) 68 | if not ins then return end 69 | local ma, mb, mc = band(m, 7), band(m, 15*8), band(m, 15*128) 70 | local a = band(shr(ins, 8), 0xff) 71 | local oidx = 6*band(ins, 0xff) 72 | local op = sub(bcnames, oidx+1, oidx+6) 73 | local s = format("%04d %s %-6s %3s ", 74 | pc, prefix or " ", op, ma == 0 and "" or a) 75 | local d = shr(ins, 16) 76 | if mc == 13*128 then -- BCMjump 77 | return format("%s=> %04d\n", s, pc+d-0x7fff) 78 | end 79 | if mb ~= 0 then 80 | d = band(d, 0xff) 81 | elseif mc == 0 then 82 | return s.."\n" 83 | end 84 | local kc 85 | if mc == 10*128 then -- BCMstr 86 | kc = funck(func, -d-1) 87 | kc = format(#kc > 40 and '"%.40s"~' or '"%s"', gsub(kc, "%c", ctlsub)) 88 | elseif mc == 9*128 then -- BCMnum 89 | kc = funck(func, d) 90 | if op == "TSETM " then kc = kc - 2^52 end 91 | elseif mc == 12*128 then -- BCMfunc 92 | local fi = funcinfo(funck(func, -d-1)) 93 | if fi.ffid then 94 | kc = vmdef.ffnames[fi.ffid] 95 | else 96 | kc = fi.loc 97 | end 98 | elseif mc == 5*128 then -- BCMuv 99 | kc = funcuvname(func, d) 100 | end 101 | if ma == 5 then -- BCMuv 102 | local ka = funcuvname(func, a) 103 | if kc then kc = ka.." ; "..kc else kc = ka end 104 | end 105 | if mb ~= 0 then 106 | local b = shr(ins, 24) 107 | if kc then return format("%s%3d %3d ; %s\n", s, b, d, kc) end 108 | return format("%s%3d %3d\n", s, b, d) 109 | end 110 | if kc then return format("%s%3d ; %s\n", s, d, kc) end 111 | if mc == 7*128 and d > 32767 then d = d - 65536 end -- BCMlits 112 | return format("%s%3d\n", s, d) 113 | end 114 | 115 | -- Collect branch targets of a function. 116 | local function bctargets(func) 117 | local target = {} 118 | for pc=1,1000000000 do 119 | local ins, m = funcbc(func, pc) 120 | if not ins then break end 121 | if band(m, 15*128) == 13*128 then target[pc+shr(ins, 16)-0x7fff] = true end 122 | end 123 | return target 124 | end 125 | 126 | -- Dump bytecode instructions of a function. 127 | local function bcdump(func, out, all) 128 | if not out then out = stdout end 129 | local fi = funcinfo(func) 130 | if all and fi.children then 131 | for n=-1,-1000000000,-1 do 132 | local k = funck(func, n) 133 | if not k then break end 134 | if type(k) == "proto" then bcdump(k, out, true) end 135 | end 136 | end 137 | out:write(format("-- BYTECODE -- %s-%d\n", fi.loc, fi.lastlinedefined)) 138 | local target = bctargets(func) 139 | for pc=1,1000000000 do 140 | local s = bcline(func, pc, target[pc] and "=>") 141 | if not s then break end 142 | out:write(s) 143 | end 144 | out:write("\n") 145 | out:flush() 146 | end 147 | 148 | ------------------------------------------------------------------------------ 149 | 150 | -- Active flag and output file handle. 151 | local active, out 152 | 153 | -- List handler. 154 | local function h_list(func) 155 | return bcdump(func, out) 156 | end 157 | 158 | -- Detach list handler. 159 | local function bclistoff() 160 | if active then 161 | active = false 162 | jit.attach(h_list) 163 | if out and out ~= stdout and out ~= stderr then out:close() end 164 | out = nil 165 | end 166 | end 167 | 168 | -- Open the output file and attach list handler. 169 | local function bcliston(outfile) 170 | if active then bclistoff() end 171 | if not outfile then outfile = os.getenv("LUAJIT_LISTFILE") end 172 | if outfile then 173 | out = outfile == "-" and stdout or assert(io.open(outfile, "w")) 174 | else 175 | out = stderr 176 | end 177 | jit.attach(h_list, "bc") 178 | active = true 179 | end 180 | 181 | -- Public module functions. 182 | return { 183 | line = bcline, 184 | dump = bcdump, 185 | targets = bctargets, 186 | on = bcliston, 187 | off = bclistoff, 188 | start = bcliston -- For -j command line option. 189 | } 190 | 191 | -------------------------------------------------------------------------------- /src/jit/dis_arm64be.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- LuaJIT ARM64BE disassembler wrapper module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- Released under the MIT license. See Copyright Notice in luajit.h 6 | ---------------------------------------------------------------------------- 7 | -- ARM64 instructions are always little-endian. So just forward to the 8 | -- common ARM64 disassembler module. All the interesting stuff is there. 9 | ------------------------------------------------------------------------------ 10 | 11 | return require((string.match(..., ".*%.") or "").."dis_arm64") 12 | 13 | -------------------------------------------------------------------------------- /src/jit/dis_mips64.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- LuaJIT MIPS64 disassembler wrapper module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- Released under the MIT license. See Copyright Notice in luajit.h 6 | ---------------------------------------------------------------------------- 7 | -- This module just exports the big-endian functions from the 8 | -- MIPS disassembler module. All the interesting stuff is there. 9 | ------------------------------------------------------------------------------ 10 | 11 | local dis_mips = require((string.match(..., ".*%.") or "").."dis_mips") 12 | return { 13 | create = dis_mips.create, 14 | disass = dis_mips.disass, 15 | regname = dis_mips.regname 16 | } 17 | 18 | -------------------------------------------------------------------------------- /src/jit/dis_mips64el.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- LuaJIT MIPS64EL disassembler wrapper module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- Released under the MIT license. See Copyright Notice in luajit.h 6 | ---------------------------------------------------------------------------- 7 | -- This module just exports the little-endian functions from the 8 | -- MIPS disassembler module. All the interesting stuff is there. 9 | ------------------------------------------------------------------------------ 10 | 11 | local dis_mips = require((string.match(..., ".*%.") or "").."dis_mips") 12 | return { 13 | create = dis_mips.create_el, 14 | disass = dis_mips.disass_el, 15 | regname = dis_mips.regname 16 | } 17 | 18 | -------------------------------------------------------------------------------- /src/jit/dis_mipsel.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- LuaJIT MIPSEL disassembler wrapper module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- Released under the MIT license. See Copyright Notice in luajit.h 6 | ---------------------------------------------------------------------------- 7 | -- This module just exports the little-endian functions from the 8 | -- MIPS disassembler module. All the interesting stuff is there. 9 | ------------------------------------------------------------------------------ 10 | 11 | local dis_mips = require((string.match(..., ".*%.") or "").."dis_mips") 12 | return { 13 | create = dis_mips.create_el, 14 | disass = dis_mips.disass_el, 15 | regname = dis_mips.regname 16 | } 17 | 18 | -------------------------------------------------------------------------------- /src/jit/dis_x64.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- LuaJIT x64 disassembler wrapper module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- Released under the MIT license. See Copyright Notice in luajit.h 6 | ---------------------------------------------------------------------------- 7 | -- This module just exports the 64 bit functions from the combined 8 | -- x86/x64 disassembler module. All the interesting stuff is there. 9 | ------------------------------------------------------------------------------ 10 | 11 | local dis_x86 = require((string.match(..., ".*%.") or "").."dis_x86") 12 | return { 13 | create = dis_x86.create64, 14 | disass = dis_x86.disass64, 15 | regname = dis_x86.regname64 16 | } 17 | 18 | -------------------------------------------------------------------------------- /src/jit/v.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- Verbose mode of the LuaJIT compiler. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- Released under the MIT license. See Copyright Notice in luajit.h 6 | ---------------------------------------------------------------------------- 7 | -- 8 | -- This module shows verbose information about the progress of the 9 | -- JIT compiler. It prints one line for each generated trace. This module 10 | -- is useful to see which code has been compiled or where the compiler 11 | -- punts and falls back to the interpreter. 12 | -- 13 | -- Example usage: 14 | -- 15 | -- luajit -jv -e "for i=1,1000 do for j=1,1000 do end end" 16 | -- luajit -jv=myapp.out myapp.lua 17 | -- 18 | -- Default output is to stderr. To redirect the output to a file, pass a 19 | -- filename as an argument (use '-' for stdout) or set the environment 20 | -- variable LUAJIT_VERBOSEFILE. The file is overwritten every time the 21 | -- module is started. 22 | -- 23 | -- The output from the first example should look like this: 24 | -- 25 | -- [TRACE 1 (command line):1 loop] 26 | -- [TRACE 2 (1/3) (command line):1 -> 1] 27 | -- 28 | -- The first number in each line is the internal trace number. Next are 29 | -- the file name ('(command line)') and the line number (':1') where the 30 | -- trace has started. Side traces also show the parent trace number and 31 | -- the exit number where they are attached to in parentheses ('(1/3)'). 32 | -- An arrow at the end shows where the trace links to ('-> 1'), unless 33 | -- it loops to itself. 34 | -- 35 | -- In this case the inner loop gets hot and is traced first, generating 36 | -- a root trace. Then the last exit from the 1st trace gets hot, too, 37 | -- and triggers generation of the 2nd trace. The side trace follows the 38 | -- path along the outer loop and *around* the inner loop, back to its 39 | -- start, and then links to the 1st trace. Yes, this may seem unusual, 40 | -- if you know how traditional compilers work. Trace compilers are full 41 | -- of surprises like this -- have fun! :-) 42 | -- 43 | -- Aborted traces are shown like this: 44 | -- 45 | -- [TRACE --- foo.lua:44 -- leaving loop in root trace at foo:lua:50] 46 | -- 47 | -- Don't worry -- trace aborts are quite common, even in programs which 48 | -- can be fully compiled. The compiler may retry several times until it 49 | -- finds a suitable trace. 50 | -- 51 | -- Of course this doesn't work with features that are not-yet-implemented 52 | -- (NYI error messages). The VM simply falls back to the interpreter. This 53 | -- may not matter at all if the particular trace is not very high up in 54 | -- the CPU usage profile. Oh, and the interpreter is quite fast, too. 55 | -- 56 | -- Also check out the -jdump module, which prints all the gory details. 57 | -- 58 | ------------------------------------------------------------------------------ 59 | 60 | -- Cache some library functions and objects. 61 | local jit = require("jit") 62 | assert(jit.version_num == 20100, "LuaJIT core/library version mismatch") 63 | local jutil = require("jit.util") 64 | local vmdef = require("jit.vmdef") 65 | local funcinfo, traceinfo = jutil.funcinfo, jutil.traceinfo 66 | local type, format = type, string.format 67 | local stdout, stderr = io.stdout, io.stderr 68 | 69 | -- Active flag and output file handle. 70 | local active, out 71 | 72 | ------------------------------------------------------------------------------ 73 | 74 | local startloc, startex 75 | 76 | local function fmtfunc(func, pc) 77 | local fi = funcinfo(func, pc) 78 | if fi.loc then 79 | return fi.loc 80 | elseif fi.ffid then 81 | return vmdef.ffnames[fi.ffid] 82 | elseif fi.addr then 83 | return format("C:%x", fi.addr) 84 | else 85 | return "(?)" 86 | end 87 | end 88 | 89 | -- Format trace error message. 90 | local function fmterr(err, info) 91 | if type(err) == "number" then 92 | if type(info) == "function" then info = fmtfunc(info) end 93 | err = format(vmdef.traceerr[err], info) 94 | end 95 | return err 96 | end 97 | 98 | -- Dump trace states. 99 | local function dump_trace(what, tr, func, pc, otr, oex) 100 | if what == "start" then 101 | startloc = fmtfunc(func, pc) 102 | startex = otr and "("..otr.."/"..(oex == -1 and "stitch" or oex)..") " or "" 103 | else 104 | if what == "abort" then 105 | local loc = fmtfunc(func, pc) 106 | if loc ~= startloc then 107 | out:write(format("[TRACE --- %s%s -- %s at %s]\n", 108 | startex, startloc, fmterr(otr, oex), loc)) 109 | else 110 | out:write(format("[TRACE --- %s%s -- %s]\n", 111 | startex, startloc, fmterr(otr, oex))) 112 | end 113 | elseif what == "stop" then 114 | local info = traceinfo(tr) 115 | local link, ltype = info.link, info.linktype 116 | if ltype == "interpreter" then 117 | out:write(format("[TRACE %3s %s%s -- fallback to interpreter]\n", 118 | tr, startex, startloc)) 119 | elseif ltype == "stitch" then 120 | out:write(format("[TRACE %3s %s%s %s %s]\n", 121 | tr, startex, startloc, ltype, fmtfunc(func, pc))) 122 | elseif link == tr or link == 0 then 123 | out:write(format("[TRACE %3s %s%s %s]\n", 124 | tr, startex, startloc, ltype)) 125 | elseif ltype == "root" then 126 | out:write(format("[TRACE %3s %s%s -> %d]\n", 127 | tr, startex, startloc, link)) 128 | else 129 | out:write(format("[TRACE %3s %s%s -> %d %s]\n", 130 | tr, startex, startloc, link, ltype)) 131 | end 132 | else 133 | out:write(format("[TRACE %s]\n", what)) 134 | end 135 | out:flush() 136 | end 137 | end 138 | 139 | ------------------------------------------------------------------------------ 140 | 141 | -- Detach dump handlers. 142 | local function dumpoff() 143 | if active then 144 | active = false 145 | jit.attach(dump_trace) 146 | if out and out ~= stdout and out ~= stderr then out:close() end 147 | out = nil 148 | end 149 | end 150 | 151 | -- Open the output file and attach dump handlers. 152 | local function dumpon(outfile) 153 | if active then dumpoff() end 154 | if not outfile then outfile = os.getenv("LUAJIT_VERBOSEFILE") end 155 | if outfile then 156 | out = outfile == "-" and stdout or assert(io.open(outfile, "w")) 157 | else 158 | out = stderr 159 | end 160 | jit.attach(dump_trace, "trace") 161 | active = true 162 | end 163 | 164 | -- Public module functions. 165 | return { 166 | on = dumpon, 167 | off = dumpoff, 168 | start = dumpon -- For -j command line option. 169 | } 170 | 171 | -------------------------------------------------------------------------------- /src/jit/zone.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- LuaJIT profiler zones. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- Released under the MIT license. See Copyright Notice in luajit.h 6 | ---------------------------------------------------------------------------- 7 | -- 8 | -- This module implements a simple hierarchical zone model. 9 | -- 10 | -- Example usage: 11 | -- 12 | -- local zone = require("jit.zone") 13 | -- zone("AI") 14 | -- ... 15 | -- zone("A*") 16 | -- ... 17 | -- print(zone:get()) --> "A*" 18 | -- ... 19 | -- zone() 20 | -- ... 21 | -- print(zone:get()) --> "AI" 22 | -- ... 23 | -- zone() 24 | -- 25 | ---------------------------------------------------------------------------- 26 | 27 | local remove = table.remove 28 | 29 | return setmetatable({ 30 | flush = function(t) 31 | for i=#t,1,-1 do t[i] = nil end 32 | end, 33 | get = function(t) 34 | return t[#t] 35 | end 36 | }, { 37 | __call = function(t, zone) 38 | if zone then 39 | t[#t+1] = zone 40 | else 41 | return (assert(remove(t), "empty zone stack")) 42 | end 43 | end 44 | }) 45 | 46 | -------------------------------------------------------------------------------- /src/lib_bit.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Bit manipulation library. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #define lib_bit_c 7 | #define LUA_LIB 8 | 9 | #include "lua.h" 10 | #include "lauxlib.h" 11 | #include "lualib.h" 12 | 13 | #include "lj_obj.h" 14 | #include "lj_err.h" 15 | #include "lj_buf.h" 16 | #include "lj_strscan.h" 17 | #include "lj_strfmt.h" 18 | #if LJ_HASFFI 19 | #include "lj_ctype.h" 20 | #include "lj_cdata.h" 21 | #include "lj_cconv.h" 22 | #include "lj_carith.h" 23 | #endif 24 | #include "lj_ff.h" 25 | #include "lj_lib.h" 26 | 27 | /* ------------------------------------------------------------------------ */ 28 | 29 | #define LJLIB_MODULE_bit 30 | 31 | #if LJ_HASFFI 32 | static int bit_result64(lua_State *L, CTypeID id, uint64_t x) 33 | { 34 | GCcdata *cd = lj_cdata_new_(L, id, 8); 35 | *(uint64_t *)cdataptr(cd) = x; 36 | setcdataV(L, L->base-1-LJ_FR2, cd); 37 | return FFH_RES(1); 38 | } 39 | #else 40 | static int32_t bit_checkbit(lua_State *L, int narg) 41 | { 42 | TValue *o = L->base + narg-1; 43 | if (!(o < L->top && lj_strscan_numberobj(o))) 44 | lj_err_argt(L, narg, LUA_TNUMBER); 45 | if (LJ_LIKELY(tvisint(o))) { 46 | return intV(o); 47 | } else { 48 | int32_t i = lj_num2bit(numV(o)); 49 | if (LJ_DUALNUM) setintV(o, i); 50 | return i; 51 | } 52 | } 53 | #endif 54 | 55 | LJLIB_ASM(bit_tobit) LJLIB_REC(bit_tobit) 56 | { 57 | #if LJ_HASFFI 58 | CTypeID id = 0; 59 | setintV(L->base-1-LJ_FR2, (int32_t)lj_carith_check64(L, 1, &id)); 60 | return FFH_RES(1); 61 | #else 62 | lj_lib_checknumber(L, 1); 63 | return FFH_RETRY; 64 | #endif 65 | } 66 | 67 | LJLIB_ASM(bit_bnot) LJLIB_REC(bit_unary IR_BNOT) 68 | { 69 | #if LJ_HASFFI 70 | CTypeID id = 0; 71 | uint64_t x = lj_carith_check64(L, 1, &id); 72 | return id ? bit_result64(L, id, ~x) : FFH_RETRY; 73 | #else 74 | lj_lib_checknumber(L, 1); 75 | return FFH_RETRY; 76 | #endif 77 | } 78 | 79 | LJLIB_ASM(bit_bswap) LJLIB_REC(bit_unary IR_BSWAP) 80 | { 81 | #if LJ_HASFFI 82 | CTypeID id = 0; 83 | uint64_t x = lj_carith_check64(L, 1, &id); 84 | return id ? bit_result64(L, id, lj_bswap64(x)) : FFH_RETRY; 85 | #else 86 | lj_lib_checknumber(L, 1); 87 | return FFH_RETRY; 88 | #endif 89 | } 90 | 91 | LJLIB_ASM(bit_lshift) LJLIB_REC(bit_shift IR_BSHL) 92 | { 93 | #if LJ_HASFFI 94 | CTypeID id = 0, id2 = 0; 95 | uint64_t x = lj_carith_check64(L, 1, &id); 96 | int32_t sh = (int32_t)lj_carith_check64(L, 2, &id2); 97 | if (id) { 98 | x = lj_carith_shift64(x, sh, curr_func(L)->c.ffid - (int)FF_bit_lshift); 99 | return bit_result64(L, id, x); 100 | } 101 | if (id2) setintV(L->base+1, sh); 102 | return FFH_RETRY; 103 | #else 104 | lj_lib_checknumber(L, 1); 105 | bit_checkbit(L, 2); 106 | return FFH_RETRY; 107 | #endif 108 | } 109 | LJLIB_ASM_(bit_rshift) LJLIB_REC(bit_shift IR_BSHR) 110 | LJLIB_ASM_(bit_arshift) LJLIB_REC(bit_shift IR_BSAR) 111 | LJLIB_ASM_(bit_rol) LJLIB_REC(bit_shift IR_BROL) 112 | LJLIB_ASM_(bit_ror) LJLIB_REC(bit_shift IR_BROR) 113 | 114 | LJLIB_ASM(bit_band) LJLIB_REC(bit_nary IR_BAND) 115 | { 116 | #if LJ_HASFFI 117 | CTypeID id = 0; 118 | TValue *o = L->base, *top = L->top; 119 | int i = 0; 120 | do { lj_carith_check64(L, ++i, &id); } while (++o < top); 121 | if (id) { 122 | CTState *cts = ctype_cts(L); 123 | CType *ct = ctype_get(cts, id); 124 | int op = curr_func(L)->c.ffid - (int)FF_bit_bor; 125 | uint64_t x, y = op >= 0 ? 0 : ~(uint64_t)0; 126 | o = L->base; 127 | do { 128 | lj_cconv_ct_tv(cts, ct, (uint8_t *)&x, o, 0); 129 | if (op < 0) y &= x; else if (op == 0) y |= x; else y ^= x; 130 | } while (++o < top); 131 | return bit_result64(L, id, y); 132 | } 133 | return FFH_RETRY; 134 | #else 135 | int i = 0; 136 | do { lj_lib_checknumber(L, ++i); } while (L->base+i < L->top); 137 | return FFH_RETRY; 138 | #endif 139 | } 140 | LJLIB_ASM_(bit_bor) LJLIB_REC(bit_nary IR_BOR) 141 | LJLIB_ASM_(bit_bxor) LJLIB_REC(bit_nary IR_BXOR) 142 | 143 | /* ------------------------------------------------------------------------ */ 144 | 145 | LJLIB_CF(bit_tohex) LJLIB_REC(.) 146 | { 147 | #if LJ_HASFFI 148 | CTypeID id = 0, id2 = 0; 149 | uint64_t b = lj_carith_check64(L, 1, &id); 150 | int32_t n = L->base+1>=L->top ? (id ? 16 : 8) : 151 | (int32_t)lj_carith_check64(L, 2, &id2); 152 | #else 153 | uint32_t b = (uint32_t)bit_checkbit(L, 1); 154 | int32_t n = L->base+1>=L->top ? 8 : bit_checkbit(L, 2); 155 | #endif 156 | SBuf *sb = lj_buf_tmp_(L); 157 | SFormat sf = (STRFMT_UINT|STRFMT_T_HEX); 158 | if (n < 0) { n = -n; sf |= STRFMT_F_UPPER; } 159 | sf |= ((SFormat)((n+1)&255) << STRFMT_SH_PREC); 160 | #if LJ_HASFFI 161 | if (n < 16) b &= ((uint64_t)1 << 4*n)-1; 162 | #else 163 | if (n < 8) b &= (1u << 4*n)-1; 164 | #endif 165 | sb = lj_strfmt_putfxint(sb, sf, b); 166 | setstrV(L, L->top-1, lj_buf_str(L, sb)); 167 | lj_gc_check(L); 168 | return 1; 169 | } 170 | 171 | /* ------------------------------------------------------------------------ */ 172 | 173 | #include "lj_libdef.h" 174 | 175 | LUALIB_API int luaopen_bit(lua_State *L) 176 | { 177 | LJ_LIB_REG(L, LUA_BITLIBNAME, bit); 178 | return 1; 179 | } 180 | 181 | -------------------------------------------------------------------------------- /src/lib_init.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Library initialization. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | ** 5 | ** Major parts taken verbatim from the Lua interpreter. 6 | ** Copyright (C) 1994-2008 Lua.org, PUC-Rio. See Copyright Notice in lua.h 7 | */ 8 | 9 | #define lib_init_c 10 | #define LUA_LIB 11 | 12 | #include "lua.h" 13 | #include "lauxlib.h" 14 | #include "lualib.h" 15 | 16 | #include "lj_arch.h" 17 | 18 | static const luaL_Reg lj_lib_load[] = { 19 | { "", luaopen_base }, 20 | { LUA_LOADLIBNAME, luaopen_package }, 21 | { LUA_TABLIBNAME, luaopen_table }, 22 | { LUA_IOLIBNAME, luaopen_io }, 23 | { LUA_OSLIBNAME, luaopen_os }, 24 | { LUA_STRLIBNAME, luaopen_string }, 25 | { LUA_MATHLIBNAME, luaopen_math }, 26 | { LUA_DBLIBNAME, luaopen_debug }, 27 | { LUA_BITLIBNAME, luaopen_bit }, 28 | { LUA_JITLIBNAME, luaopen_jit }, 29 | { NULL, NULL } 30 | }; 31 | 32 | static const luaL_Reg lj_lib_preload[] = { 33 | #if LJ_HASFFI 34 | { LUA_FFILIBNAME, luaopen_ffi }, 35 | #endif 36 | { NULL, NULL } 37 | }; 38 | 39 | LUALIB_API void luaL_openlibs(lua_State *L) 40 | { 41 | const luaL_Reg *lib; 42 | for (lib = lj_lib_load; lib->func; lib++) { 43 | lua_pushcfunction(L, lib->func); 44 | lua_pushstring(L, lib->name); 45 | lua_call(L, 1, 0); 46 | } 47 | luaL_findtable(L, LUA_REGISTRYINDEX, "_PRELOAD", 48 | sizeof(lj_lib_preload)/sizeof(lj_lib_preload[0])-1); 49 | for (lib = lj_lib_preload; lib->func; lib++) { 50 | lua_pushcfunction(L, lib->func); 51 | lua_setfield(L, -2, lib->name); 52 | } 53 | lua_pop(L, 1); 54 | } 55 | 56 | -------------------------------------------------------------------------------- /src/lj.supp: -------------------------------------------------------------------------------- 1 | # Valgrind suppression file for LuaJIT 2.0. 2 | { 3 | Optimized string compare 4 | Memcheck:Addr4 5 | fun:lj_str_cmp 6 | } 7 | { 8 | Optimized string compare 9 | Memcheck:Addr1 10 | fun:lj_str_cmp 11 | } 12 | { 13 | Optimized string compare 14 | Memcheck:Addr4 15 | fun:lj_str_new 16 | } 17 | { 18 | Optimized string compare 19 | Memcheck:Addr1 20 | fun:lj_str_new 21 | } 22 | { 23 | Optimized string compare 24 | Memcheck:Cond 25 | fun:lj_str_new 26 | } 27 | { 28 | Optimized string compare 29 | Memcheck:Addr4 30 | fun:str_fastcmp 31 | } 32 | { 33 | Optimized string compare 34 | Memcheck:Addr1 35 | fun:str_fastcmp 36 | } 37 | { 38 | Optimized string compare 39 | Memcheck:Cond 40 | fun:str_fastcmp 41 | } 42 | -------------------------------------------------------------------------------- /src/lj_alloc.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Bundled memory allocator. 3 | ** Donated to the public domain. 4 | */ 5 | 6 | #ifndef _LJ_ALLOC_H 7 | #define _LJ_ALLOC_H 8 | 9 | #include "lj_def.h" 10 | 11 | #ifndef LUAJIT_USE_SYSMALLOC 12 | LJ_FUNC void *lj_alloc_create(void); 13 | LJ_FUNC void lj_alloc_destroy(void *msp); 14 | LJ_FUNC void *lj_alloc_f(void *msp, void *ptr, size_t osize, size_t nsize); 15 | #endif 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /src/lj_asm.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** IR assembler (SSA IR -> machine code). 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_ASM_H 7 | #define _LJ_ASM_H 8 | 9 | #include "lj_jit.h" 10 | 11 | #if LJ_HASJIT 12 | LJ_FUNC void lj_asm_trace(jit_State *J, GCtrace *T); 13 | LJ_FUNC void lj_asm_patchexit(jit_State *J, GCtrace *T, ExitNo exitno, 14 | MCode *target); 15 | #endif 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /src/lj_bc.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Bytecode instruction modes. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #define lj_bc_c 7 | #define LUA_CORE 8 | 9 | #include "lj_obj.h" 10 | #include "lj_bc.h" 11 | 12 | /* Bytecode offsets and bytecode instruction modes. */ 13 | #include "lj_bcdef.h" 14 | 15 | -------------------------------------------------------------------------------- /src/lj_bcdef.h: -------------------------------------------------------------------------------- 1 | /* This is a generated file. DO NOT EDIT! */ 2 | 3 | LJ_DATADEF const uint16_t lj_bc_ofs[] = { 4 | 0, 5 | 65, 6 | 130, 7 | 195, 8 | 260, 9 | 387, 10 | 517, 11 | 577, 12 | 637, 13 | 701, 14 | 765, 15 | 816, 16 | 866, 17 | 916, 18 | 966, 19 | 1006, 20 | 1046, 21 | 1073, 22 | 1101, 23 | 1132, 24 | 1163, 25 | 1218, 26 | 1291, 27 | 1340, 28 | 1389, 29 | 1438, 30 | 1487, 31 | 1541, 32 | 1590, 33 | 1639, 34 | 1688, 35 | 1737, 36 | 1769, 37 | 1829, 38 | 1889, 39 | 1949, 40 | 2009, 41 | 2052, 42 | 2134, 43 | 2222, 44 | 2255, 45 | 2288, 46 | 2317, 47 | 2344, 48 | 2367, 49 | 2409, 50 | 2449, 51 | 2532, 52 | 2610, 53 | 2646, 54 | 2678, 55 | 2728, 56 | 2798, 57 | 2911, 58 | 2998, 59 | 3014, 60 | 3030, 61 | 3179, 62 | 3305, 63 | 3408, 64 | 3466, 65 | 3638, 66 | 3877, 67 | 4003, 68 | 4145, 69 | 4234, 70 | 4279, 71 | 4320, 72 | 4324, 73 | 4468, 74 | 4543, 75 | 4711, 76 | 4899, 77 | 4986, 78 | 4990, 79 | 5119, 80 | 5206, 81 | 5311, 82 | 5398, 83 | 5493, 84 | 5512, 85 | 5581, 86 | 5647, 87 | 5666, 88 | 5709, 89 | 5747, 90 | 5766, 91 | 5783, 92 | 5813, 93 | 5837, 94 | 5856, 95 | 5917, 96 | 5970, 97 | 5970, 98 | 6087, 99 | 6088, 100 | 6170, 101 | 8091, 102 | 8162, 103 | 8638, 104 | 8758, 105 | 8815, 106 | 8946, 107 | 8211, 108 | 8353, 109 | 8443, 110 | 8510, 111 | 8538, 112 | 9004, 113 | 9044, 114 | 9688, 115 | 9099, 116 | 9421, 117 | 9738, 118 | 9856, 119 | 9877, 120 | 9898, 121 | 9968, 122 | 10010, 123 | 10052, 124 | 10094, 125 | 10136, 126 | 10178, 127 | 10220, 128 | 10262, 129 | 10304, 130 | 10346, 131 | 10388, 132 | 10662, 133 | 10806, 134 | 9926, 135 | 10493, 136 | 10430, 137 | 10556, 138 | 10619, 139 | 10902, 140 | 10955, 141 | 11576, 142 | 11945, 143 | 11896, 144 | 12010, 145 | 12082, 146 | 12157, 147 | 12232, 148 | 12307, 149 | 11626, 150 | 11716, 151 | 11806, 152 | 11008, 153 | 11055, 154 | 11169, 155 | 11330, 156 | 11412, 157 | 11494 158 | }; 159 | 160 | LJ_DATADEF const uint16_t lj_bc_mode[] = { 161 | BCDEF(BCMODE) 162 | BCMODE_FF, 163 | BCMODE_FF, 164 | BCMODE_FF, 165 | BCMODE_FF, 166 | BCMODE_FF, 167 | BCMODE_FF, 168 | BCMODE_FF, 169 | BCMODE_FF, 170 | BCMODE_FF, 171 | BCMODE_FF, 172 | BCMODE_FF, 173 | BCMODE_FF, 174 | BCMODE_FF, 175 | BCMODE_FF, 176 | BCMODE_FF, 177 | BCMODE_FF, 178 | BCMODE_FF, 179 | BCMODE_FF, 180 | BCMODE_FF, 181 | BCMODE_FF, 182 | BCMODE_FF, 183 | BCMODE_FF, 184 | BCMODE_FF, 185 | BCMODE_FF, 186 | BCMODE_FF, 187 | BCMODE_FF, 188 | BCMODE_FF, 189 | BCMODE_FF, 190 | BCMODE_FF, 191 | BCMODE_FF, 192 | BCMODE_FF, 193 | BCMODE_FF, 194 | BCMODE_FF, 195 | BCMODE_FF, 196 | BCMODE_FF, 197 | BCMODE_FF, 198 | BCMODE_FF, 199 | BCMODE_FF, 200 | BCMODE_FF, 201 | BCMODE_FF, 202 | BCMODE_FF, 203 | BCMODE_FF, 204 | BCMODE_FF, 205 | BCMODE_FF, 206 | BCMODE_FF, 207 | BCMODE_FF, 208 | BCMODE_FF, 209 | BCMODE_FF, 210 | BCMODE_FF, 211 | BCMODE_FF, 212 | BCMODE_FF, 213 | BCMODE_FF, 214 | BCMODE_FF, 215 | BCMODE_FF, 216 | BCMODE_FF, 217 | BCMODE_FF, 218 | BCMODE_FF 219 | }; 220 | 221 | -------------------------------------------------------------------------------- /src/lj_bcdump.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Bytecode dump definitions. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_BCDUMP_H 7 | #define _LJ_BCDUMP_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_lex.h" 11 | 12 | /* -- Bytecode dump format ------------------------------------------------ */ 13 | 14 | /* 15 | ** dump = header proto+ 0U 16 | ** header = ESC 'L' 'J' versionB flagsU [namelenU nameB*] 17 | ** proto = lengthU pdata 18 | ** pdata = phead bcinsW* uvdataH* kgc* knum* [debugB*] 19 | ** phead = flagsB numparamsB framesizeB numuvB numkgcU numknU numbcU 20 | ** [debuglenU [firstlineU numlineU]] 21 | ** kgc = kgctypeU { ktab | (loU hiU) | (rloU rhiU iloU ihiU) | strB* } 22 | ** knum = intU0 | (loU1 hiU) 23 | ** ktab = narrayU nhashU karray* khash* 24 | ** karray = ktabk 25 | ** khash = ktabk ktabk 26 | ** ktabk = ktabtypeU { intU | (loU hiU) | strB* } 27 | ** 28 | ** B = 8 bit, H = 16 bit, W = 32 bit, U = ULEB128 of W, U0/U1 = ULEB128 of W+1 29 | */ 30 | 31 | /* Bytecode dump header. */ 32 | #define BCDUMP_HEAD1 0x1b 33 | #define BCDUMP_HEAD2 0x4c 34 | #define BCDUMP_HEAD3 0x4a 35 | 36 | /* If you perform *any* kind of private modifications to the bytecode itself 37 | ** or to the dump format, you *must* set BCDUMP_VERSION to 0x80 or higher. 38 | */ 39 | #define BCDUMP_VERSION 2 40 | 41 | /* Compatibility flags. */ 42 | #define BCDUMP_F_BE 0x01 43 | #define BCDUMP_F_STRIP 0x02 44 | #define BCDUMP_F_FFI 0x04 45 | #define BCDUMP_F_FR2 0x08 46 | 47 | #define BCDUMP_F_KNOWN (BCDUMP_F_FR2*2-1) 48 | 49 | /* Type codes for the GC constants of a prototype. Plus length for strings. */ 50 | enum { 51 | BCDUMP_KGC_CHILD, BCDUMP_KGC_TAB, BCDUMP_KGC_I64, BCDUMP_KGC_U64, 52 | BCDUMP_KGC_COMPLEX, BCDUMP_KGC_STR 53 | }; 54 | 55 | /* Type codes for the keys/values of a constant table. */ 56 | enum { 57 | BCDUMP_KTAB_NIL, BCDUMP_KTAB_FALSE, BCDUMP_KTAB_TRUE, 58 | BCDUMP_KTAB_INT, BCDUMP_KTAB_NUM, BCDUMP_KTAB_STR 59 | }; 60 | 61 | /* -- Bytecode reader/writer ---------------------------------------------- */ 62 | 63 | #ifdef __cplusplus 64 | extern "C" 65 | { 66 | #endif 67 | 68 | LJ_FUNC int lj_bcwrite(lua_State *L, GCproto *pt, lua_Writer writer, 69 | void *data, int strip); 70 | LJ_FUNC GCproto *lj_bcread_proto(LexState *ls); 71 | LJ_FUNC GCproto *lj_bcread(LexState *ls); 72 | 73 | // az_5.1 74 | GCproto *lj_bcread_mod(LexState *ls); 75 | 76 | #ifdef __cplusplus 77 | }; 78 | #endif 79 | 80 | 81 | #endif 82 | -------------------------------------------------------------------------------- /src/lj_bcread.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jspzyhl/AzurLane5.1-bcDec/ffb4794a653ed6ff6ccb395a7e9d218c71667b3f/src/lj_bcread.c -------------------------------------------------------------------------------- /src/lj_buf.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Buffer handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #define lj_buf_c 7 | #define LUA_CORE 8 | 9 | #include "lj_obj.h" 10 | #include "lj_gc.h" 11 | #include "lj_err.h" 12 | #include "lj_buf.h" 13 | #include "lj_str.h" 14 | #include "lj_tab.h" 15 | #include "lj_strfmt.h" 16 | 17 | /* -- Buffer management --------------------------------------------------- */ 18 | 19 | static void buf_grow(SBuf *sb, MSize sz) 20 | { 21 | MSize osz = sbufsz(sb), len = sbuflen(sb), nsz = osz; 22 | char *b; 23 | if (nsz < LJ_MIN_SBUF) nsz = LJ_MIN_SBUF; 24 | while (nsz < sz) nsz += nsz; 25 | b = (char *)lj_mem_realloc(sbufL(sb), sbufB(sb), osz, nsz); 26 | setmref(sb->b, b); 27 | setmref(sb->p, b + len); 28 | setmref(sb->e, b + nsz); 29 | } 30 | 31 | LJ_NOINLINE char *LJ_FASTCALL lj_buf_need2(SBuf *sb, MSize sz) 32 | { 33 | lua_assert(sz > sbufsz(sb)); 34 | if (LJ_UNLIKELY(sz > LJ_MAX_BUF)) 35 | lj_err_mem(sbufL(sb)); 36 | buf_grow(sb, sz); 37 | return sbufB(sb); 38 | } 39 | 40 | LJ_NOINLINE char *LJ_FASTCALL lj_buf_more2(SBuf *sb, MSize sz) 41 | { 42 | MSize len = sbuflen(sb); 43 | lua_assert(sz > sbufleft(sb)); 44 | if (LJ_UNLIKELY(sz > LJ_MAX_BUF || len + sz > LJ_MAX_BUF)) 45 | lj_err_mem(sbufL(sb)); 46 | buf_grow(sb, len + sz); 47 | return sbufP(sb); 48 | } 49 | 50 | void LJ_FASTCALL lj_buf_shrink(lua_State *L, SBuf *sb) 51 | { 52 | char *b = sbufB(sb); 53 | MSize osz = (MSize)(sbufE(sb) - b); 54 | if (osz > 2*LJ_MIN_SBUF) { 55 | MSize n = (MSize)(sbufP(sb) - b); 56 | b = lj_mem_realloc(L, b, osz, (osz >> 1)); 57 | setmref(sb->b, b); 58 | setmref(sb->p, b + n); 59 | setmref(sb->e, b + (osz >> 1)); 60 | } 61 | } 62 | 63 | char * LJ_FASTCALL lj_buf_tmp(lua_State *L, MSize sz) 64 | { 65 | SBuf *sb = &G(L)->tmpbuf; 66 | setsbufL(sb, L); 67 | return lj_buf_need(sb, sz); 68 | } 69 | 70 | /* -- Low-level buffer put operations ------------------------------------- */ 71 | 72 | SBuf *lj_buf_putmem(SBuf *sb, const void *q, MSize len) 73 | { 74 | char *p = lj_buf_more(sb, len); 75 | p = lj_buf_wmem(p, q, len); 76 | setsbufP(sb, p); 77 | return sb; 78 | } 79 | 80 | SBuf * LJ_FASTCALL lj_buf_putchar(SBuf *sb, int c) 81 | { 82 | char *p = lj_buf_more(sb, 1); 83 | *p++ = (char)c; 84 | setsbufP(sb, p); 85 | return sb; 86 | } 87 | 88 | SBuf * LJ_FASTCALL lj_buf_putstr(SBuf *sb, GCstr *s) 89 | { 90 | MSize len = s->len; 91 | char *p = lj_buf_more(sb, len); 92 | p = lj_buf_wmem(p, strdata(s), len); 93 | setsbufP(sb, p); 94 | return sb; 95 | } 96 | 97 | /* -- High-level buffer put operations ------------------------------------ */ 98 | 99 | SBuf * LJ_FASTCALL lj_buf_putstr_reverse(SBuf *sb, GCstr *s) 100 | { 101 | MSize len = s->len; 102 | char *p = lj_buf_more(sb, len), *e = p+len; 103 | const char *q = strdata(s)+len-1; 104 | while (p < e) 105 | *p++ = *q--; 106 | setsbufP(sb, p); 107 | return sb; 108 | } 109 | 110 | SBuf * LJ_FASTCALL lj_buf_putstr_lower(SBuf *sb, GCstr *s) 111 | { 112 | MSize len = s->len; 113 | char *p = lj_buf_more(sb, len), *e = p+len; 114 | const char *q = strdata(s); 115 | for (; p < e; p++, q++) { 116 | uint32_t c = *(unsigned char *)q; 117 | #if LJ_TARGET_PPC 118 | *p = c + ((c >= 'A' && c <= 'Z') << 5); 119 | #else 120 | if (c >= 'A' && c <= 'Z') c += 0x20; 121 | *p = c; 122 | #endif 123 | } 124 | setsbufP(sb, p); 125 | return sb; 126 | } 127 | 128 | SBuf * LJ_FASTCALL lj_buf_putstr_upper(SBuf *sb, GCstr *s) 129 | { 130 | MSize len = s->len; 131 | char *p = lj_buf_more(sb, len), *e = p+len; 132 | const char *q = strdata(s); 133 | for (; p < e; p++, q++) { 134 | uint32_t c = *(unsigned char *)q; 135 | #if LJ_TARGET_PPC 136 | *p = c - ((c >= 'a' && c <= 'z') << 5); 137 | #else 138 | if (c >= 'a' && c <= 'z') c -= 0x20; 139 | *p = c; 140 | #endif 141 | } 142 | setsbufP(sb, p); 143 | return sb; 144 | } 145 | 146 | SBuf *lj_buf_putstr_rep(SBuf *sb, GCstr *s, int32_t rep) 147 | { 148 | MSize len = s->len; 149 | if (rep > 0 && len) { 150 | uint64_t tlen = (uint64_t)rep * len; 151 | char *p; 152 | if (LJ_UNLIKELY(tlen > LJ_MAX_STR)) 153 | lj_err_mem(sbufL(sb)); 154 | p = lj_buf_more(sb, (MSize)tlen); 155 | if (len == 1) { /* Optimize a common case. */ 156 | uint32_t c = strdata(s)[0]; 157 | do { *p++ = c; } while (--rep > 0); 158 | } else { 159 | const char *e = strdata(s) + len; 160 | do { 161 | const char *q = strdata(s); 162 | do { *p++ = *q++; } while (q < e); 163 | } while (--rep > 0); 164 | } 165 | setsbufP(sb, p); 166 | } 167 | return sb; 168 | } 169 | 170 | SBuf *lj_buf_puttab(SBuf *sb, GCtab *t, GCstr *sep, int32_t i, int32_t e) 171 | { 172 | MSize seplen = sep ? sep->len : 0; 173 | if (i <= e) { 174 | for (;;) { 175 | cTValue *o = lj_tab_getint(t, i); 176 | char *p; 177 | if (!o) { 178 | badtype: /* Error: bad element type. */ 179 | setsbufP(sb, (void *)(intptr_t)i); /* Store failing index. */ 180 | return NULL; 181 | } else if (tvisstr(o)) { 182 | MSize len = strV(o)->len; 183 | p = lj_buf_wmem(lj_buf_more(sb, len + seplen), strVdata(o), len); 184 | } else if (tvisint(o)) { 185 | p = lj_strfmt_wint(lj_buf_more(sb, STRFMT_MAXBUF_INT+seplen), intV(o)); 186 | } else if (tvisnum(o)) { 187 | p = lj_buf_more(lj_strfmt_putfnum(sb, STRFMT_G14, numV(o)), seplen); 188 | } else { 189 | goto badtype; 190 | } 191 | if (i++ == e) { 192 | setsbufP(sb, p); 193 | break; 194 | } 195 | if (seplen) p = lj_buf_wmem(p, strdata(sep), seplen); 196 | setsbufP(sb, p); 197 | } 198 | } 199 | return sb; 200 | } 201 | 202 | /* -- Miscellaneous buffer operations ------------------------------------- */ 203 | 204 | GCstr * LJ_FASTCALL lj_buf_tostr(SBuf *sb) 205 | { 206 | return lj_str_new(sbufL(sb), sbufB(sb), sbuflen(sb)); 207 | } 208 | 209 | /* Concatenate two strings. */ 210 | GCstr *lj_buf_cat2str(lua_State *L, GCstr *s1, GCstr *s2) 211 | { 212 | MSize len1 = s1->len, len2 = s2->len; 213 | char *buf = lj_buf_tmp(L, len1 + len2); 214 | memcpy(buf, strdata(s1), len1); 215 | memcpy(buf+len1, strdata(s2), len2); 216 | return lj_str_new(L, buf, len1 + len2); 217 | } 218 | 219 | /* Read ULEB128 from buffer. */ 220 | uint32_t LJ_FASTCALL lj_buf_ruleb128(const char **pp) 221 | { 222 | const uint8_t *p = (const uint8_t *)*pp; 223 | uint32_t v = *p++; 224 | if (LJ_UNLIKELY(v >= 0x80)) { 225 | int sh = 0; 226 | v &= 0x7f; 227 | do { v |= ((*p & 0x7f) << (sh += 7)); } while (*p++ >= 0x80); 228 | } 229 | *pp = (const char *)p; 230 | return v; 231 | } 232 | 233 | -------------------------------------------------------------------------------- /src/lj_buf.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Buffer handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_BUF_H 7 | #define _LJ_BUF_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_gc.h" 11 | #include "lj_str.h" 12 | 13 | /* Resizable string buffers. Struct definition in lj_obj.h. */ 14 | #define sbufB(sb) (mref((sb)->b, char)) 15 | #define sbufP(sb) (mref((sb)->p, char)) 16 | #define sbufE(sb) (mref((sb)->e, char)) 17 | #define sbufL(sb) (mref((sb)->L, lua_State)) 18 | #define sbufsz(sb) ((MSize)(sbufE((sb)) - sbufB((sb)))) 19 | #define sbuflen(sb) ((MSize)(sbufP((sb)) - sbufB((sb)))) 20 | #define sbufleft(sb) ((MSize)(sbufE((sb)) - sbufP((sb)))) 21 | #define setsbufP(sb, q) (setmref((sb)->p, (q))) 22 | #define setsbufL(sb, l) (setmref((sb)->L, (l))) 23 | 24 | #ifdef __cplusplus 25 | extern "C" 26 | { 27 | #endif 28 | 29 | /* Buffer management */ 30 | LJ_FUNC char *LJ_FASTCALL lj_buf_need2(SBuf *sb, MSize sz); 31 | LJ_FUNC char *LJ_FASTCALL lj_buf_more2(SBuf *sb, MSize sz); 32 | LJ_FUNC void LJ_FASTCALL lj_buf_shrink(lua_State *L, SBuf *sb); 33 | LJ_FUNC char * LJ_FASTCALL lj_buf_tmp(lua_State *L, MSize sz); 34 | 35 | static LJ_AINLINE void lj_buf_init(lua_State *L, SBuf *sb) 36 | { 37 | setsbufL(sb, L); 38 | setmref(sb->p, NULL); setmref(sb->e, NULL); setmref(sb->b, NULL); 39 | } 40 | 41 | static LJ_AINLINE void lj_buf_reset(SBuf *sb) 42 | { 43 | setmrefr(sb->p, sb->b); 44 | } 45 | 46 | static LJ_AINLINE SBuf *lj_buf_tmp_(lua_State *L) 47 | { 48 | SBuf *sb = &G(L)->tmpbuf; 49 | setsbufL(sb, L); 50 | lj_buf_reset(sb); 51 | return sb; 52 | } 53 | 54 | static LJ_AINLINE void lj_buf_free(global_State *g, SBuf *sb) 55 | { 56 | lj_mem_free(g, sbufB(sb), sbufsz(sb)); 57 | } 58 | 59 | static LJ_AINLINE char *lj_buf_need(SBuf *sb, MSize sz) 60 | { 61 | if (LJ_UNLIKELY(sz > sbufsz(sb))) 62 | return lj_buf_need2(sb, sz); 63 | return sbufB(sb); 64 | } 65 | 66 | static LJ_AINLINE char *lj_buf_more(SBuf *sb, MSize sz) 67 | { 68 | if (LJ_UNLIKELY(sz > sbufleft(sb))) 69 | return lj_buf_more2(sb, sz); 70 | return sbufP(sb); 71 | } 72 | 73 | /* Low-level buffer put operations */ 74 | LJ_FUNC SBuf *lj_buf_putmem(SBuf *sb, const void *q, MSize len); 75 | //LJ_FUNC SBuf *lj_buf_putmem(SBuf *sb, const void *q, MSize len); 76 | LJ_FUNC SBuf * LJ_FASTCALL lj_buf_putchar(SBuf *sb, int c); 77 | LJ_FUNC SBuf * LJ_FASTCALL lj_buf_putstr(SBuf *sb, GCstr *s); 78 | 79 | static LJ_AINLINE char *lj_buf_wmem(char *p, const void *q, MSize len) 80 | { 81 | return (char *)memcpy(p, q, len) + len; 82 | } 83 | 84 | static LJ_AINLINE void lj_buf_putb(SBuf *sb, int c) 85 | { 86 | char *p = lj_buf_more(sb, 1); 87 | *p++ = (char)c; 88 | setsbufP(sb, p); 89 | } 90 | 91 | /* High-level buffer put operations */ 92 | LJ_FUNCA SBuf * LJ_FASTCALL lj_buf_putstr_reverse(SBuf *sb, GCstr *s); 93 | LJ_FUNCA SBuf * LJ_FASTCALL lj_buf_putstr_lower(SBuf *sb, GCstr *s); 94 | LJ_FUNCA SBuf * LJ_FASTCALL lj_buf_putstr_upper(SBuf *sb, GCstr *s); 95 | LJ_FUNC SBuf *lj_buf_putstr_rep(SBuf *sb, GCstr *s, int32_t rep); 96 | LJ_FUNC SBuf *lj_buf_puttab(SBuf *sb, GCtab *t, GCstr *sep, 97 | int32_t i, int32_t e); 98 | 99 | /* Miscellaneous buffer operations */ 100 | LJ_FUNCA GCstr * LJ_FASTCALL lj_buf_tostr(SBuf *sb); 101 | LJ_FUNC GCstr *lj_buf_cat2str(lua_State *L, GCstr *s1, GCstr *s2); 102 | LJ_FUNC uint32_t LJ_FASTCALL lj_buf_ruleb128(const char **pp); 103 | 104 | static LJ_AINLINE GCstr *lj_buf_str(lua_State *L, SBuf *sb) 105 | { 106 | return lj_str_new(L, sbufB(sb), sbuflen(sb)); 107 | } 108 | 109 | #ifdef __cplusplus 110 | }; 111 | #endif 112 | 113 | #endif 114 | -------------------------------------------------------------------------------- /src/lj_carith.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** C data arithmetic. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CARITH_H 7 | #define _LJ_CARITH_H 8 | 9 | #include "lj_obj.h" 10 | 11 | #if LJ_HASFFI 12 | 13 | LJ_FUNC int lj_carith_op(lua_State *L, MMS mm); 14 | 15 | #if LJ_32 16 | LJ_FUNC uint64_t lj_carith_shl64(uint64_t x, int32_t sh); 17 | LJ_FUNC uint64_t lj_carith_shr64(uint64_t x, int32_t sh); 18 | LJ_FUNC uint64_t lj_carith_sar64(uint64_t x, int32_t sh); 19 | LJ_FUNC uint64_t lj_carith_rol64(uint64_t x, int32_t sh); 20 | LJ_FUNC uint64_t lj_carith_ror64(uint64_t x, int32_t sh); 21 | #endif 22 | LJ_FUNC uint64_t lj_carith_shift64(uint64_t x, int32_t sh, int op); 23 | LJ_FUNC uint64_t lj_carith_check64(lua_State *L, int narg, CTypeID *id); 24 | 25 | #if LJ_32 && LJ_HASJIT 26 | LJ_FUNC int64_t lj_carith_mul64(int64_t x, int64_t k); 27 | #endif 28 | LJ_FUNC uint64_t lj_carith_divu64(uint64_t a, uint64_t b); 29 | LJ_FUNC int64_t lj_carith_divi64(int64_t a, int64_t b); 30 | LJ_FUNC uint64_t lj_carith_modu64(uint64_t a, uint64_t b); 31 | LJ_FUNC int64_t lj_carith_modi64(int64_t a, int64_t b); 32 | LJ_FUNC uint64_t lj_carith_powu64(uint64_t x, uint64_t k); 33 | LJ_FUNC int64_t lj_carith_powi64(int64_t x, int64_t k); 34 | 35 | #endif 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /src/lj_ccall.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** FFI C call handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CCALL_H 7 | #define _LJ_CCALL_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_ctype.h" 11 | 12 | #if LJ_HASFFI 13 | 14 | /* -- C calling conventions ----------------------------------------------- */ 15 | 16 | #if LJ_TARGET_X86ORX64 17 | 18 | #if LJ_TARGET_X86 19 | #define CCALL_NARG_GPR 2 /* For fastcall arguments. */ 20 | #define CCALL_NARG_FPR 0 21 | #define CCALL_NRET_GPR 2 22 | #define CCALL_NRET_FPR 1 /* For FP results on x87 stack. */ 23 | #define CCALL_ALIGN_STACKARG 0 /* Don't align argument on stack. */ 24 | #elif LJ_ABI_WIN 25 | #define CCALL_NARG_GPR 4 26 | #define CCALL_NARG_FPR 4 27 | #define CCALL_NRET_GPR 1 28 | #define CCALL_NRET_FPR 1 29 | #define CCALL_SPS_EXTRA 4 30 | #else 31 | #define CCALL_NARG_GPR 6 32 | #define CCALL_NARG_FPR 8 33 | #define CCALL_NRET_GPR 2 34 | #define CCALL_NRET_FPR 2 35 | #define CCALL_VECTOR_REG 1 /* Pass vectors in registers. */ 36 | #endif 37 | 38 | #define CCALL_SPS_FREE 1 39 | #define CCALL_ALIGN_CALLSTATE 16 40 | 41 | typedef LJ_ALIGN(16) union FPRArg { 42 | double d[2]; 43 | float f[4]; 44 | uint8_t b[16]; 45 | uint16_t s[8]; 46 | int i[4]; 47 | int64_t l[2]; 48 | } FPRArg; 49 | 50 | typedef intptr_t GPRArg; 51 | 52 | #elif LJ_TARGET_ARM 53 | 54 | #define CCALL_NARG_GPR 4 55 | #define CCALL_NRET_GPR 2 /* For softfp double. */ 56 | #if LJ_ABI_SOFTFP 57 | #define CCALL_NARG_FPR 0 58 | #define CCALL_NRET_FPR 0 59 | #else 60 | #define CCALL_NARG_FPR 8 61 | #define CCALL_NRET_FPR 4 62 | #endif 63 | #define CCALL_SPS_FREE 0 64 | 65 | typedef intptr_t GPRArg; 66 | typedef union FPRArg { 67 | double d; 68 | float f[2]; 69 | } FPRArg; 70 | 71 | #elif LJ_TARGET_ARM64 72 | 73 | #define CCALL_NARG_GPR 8 74 | #define CCALL_NRET_GPR 2 75 | #define CCALL_NARG_FPR 8 76 | #define CCALL_NRET_FPR 4 77 | #define CCALL_SPS_FREE 0 78 | 79 | typedef intptr_t GPRArg; 80 | typedef union FPRArg { 81 | double d; 82 | struct { LJ_ENDIAN_LOHI(float f; , float g;) }; 83 | struct { LJ_ENDIAN_LOHI(uint32_t lo; , uint32_t hi;) }; 84 | } FPRArg; 85 | 86 | #elif LJ_TARGET_PPC 87 | 88 | #define CCALL_NARG_GPR 8 89 | #define CCALL_NARG_FPR 8 90 | #define CCALL_NRET_GPR 4 /* For complex double. */ 91 | #define CCALL_NRET_FPR 1 92 | #define CCALL_SPS_EXTRA 4 93 | #define CCALL_SPS_FREE 0 94 | 95 | typedef intptr_t GPRArg; 96 | typedef double FPRArg; 97 | 98 | #elif LJ_TARGET_MIPS32 99 | 100 | #define CCALL_NARG_GPR 4 101 | #define CCALL_NARG_FPR (LJ_ABI_SOFTFP ? 0 : 2) 102 | #define CCALL_NRET_GPR (LJ_ABI_SOFTFP ? 4 : 2) 103 | #define CCALL_NRET_FPR (LJ_ABI_SOFTFP ? 0 : 2) 104 | #define CCALL_SPS_EXTRA 7 105 | #define CCALL_SPS_FREE 1 106 | 107 | typedef intptr_t GPRArg; 108 | typedef union FPRArg { 109 | double d; 110 | struct { LJ_ENDIAN_LOHI(float f; , float g;) }; 111 | } FPRArg; 112 | 113 | #elif LJ_TARGET_MIPS64 114 | 115 | /* FP args are positional and overlay the GPR array. */ 116 | #define CCALL_NARG_GPR 8 117 | #define CCALL_NARG_FPR 0 118 | #define CCALL_NRET_GPR 2 119 | #define CCALL_NRET_FPR (LJ_ABI_SOFTFP ? 0 : 2) 120 | #define CCALL_SPS_EXTRA 3 121 | #define CCALL_SPS_FREE 1 122 | 123 | typedef intptr_t GPRArg; 124 | typedef union FPRArg { 125 | double d; 126 | struct { LJ_ENDIAN_LOHI(float f; , float g;) }; 127 | } FPRArg; 128 | 129 | #else 130 | #error "Missing calling convention definitions for this architecture" 131 | #endif 132 | 133 | #ifndef CCALL_SPS_EXTRA 134 | #define CCALL_SPS_EXTRA 0 135 | #endif 136 | #ifndef CCALL_VECTOR_REG 137 | #define CCALL_VECTOR_REG 0 138 | #endif 139 | #ifndef CCALL_ALIGN_STACKARG 140 | #define CCALL_ALIGN_STACKARG 1 141 | #endif 142 | #ifndef CCALL_ALIGN_CALLSTATE 143 | #define CCALL_ALIGN_CALLSTATE 8 144 | #endif 145 | 146 | #define CCALL_NUM_GPR \ 147 | (CCALL_NARG_GPR > CCALL_NRET_GPR ? CCALL_NARG_GPR : CCALL_NRET_GPR) 148 | #define CCALL_NUM_FPR \ 149 | (CCALL_NARG_FPR > CCALL_NRET_FPR ? CCALL_NARG_FPR : CCALL_NRET_FPR) 150 | 151 | /* Check against constants in lj_ctype.h. */ 152 | LJ_STATIC_ASSERT(CCALL_NUM_GPR <= CCALL_MAX_GPR); 153 | LJ_STATIC_ASSERT(CCALL_NUM_FPR <= CCALL_MAX_FPR); 154 | 155 | #define CCALL_MAXSTACK 32 156 | 157 | /* -- C call state -------------------------------------------------------- */ 158 | 159 | typedef LJ_ALIGN(CCALL_ALIGN_CALLSTATE) struct CCallState { 160 | void (*func)(void); /* Pointer to called function. */ 161 | uint32_t spadj; /* Stack pointer adjustment. */ 162 | uint8_t nsp; /* Number of stack slots. */ 163 | uint8_t retref; /* Return value by reference. */ 164 | #if LJ_TARGET_X64 165 | uint8_t ngpr; /* Number of arguments in GPRs. */ 166 | uint8_t nfpr; /* Number of arguments in FPRs. */ 167 | #elif LJ_TARGET_X86 168 | uint8_t resx87; /* Result on x87 stack: 1:float, 2:double. */ 169 | #elif LJ_TARGET_ARM64 170 | void *retp; /* Aggregate return pointer in x8. */ 171 | #elif LJ_TARGET_PPC 172 | uint8_t nfpr; /* Number of arguments in FPRs. */ 173 | #endif 174 | #if LJ_32 175 | int32_t align1; 176 | #endif 177 | #if CCALL_NUM_FPR 178 | FPRArg fpr[CCALL_NUM_FPR]; /* Arguments/results in FPRs. */ 179 | #endif 180 | GPRArg gpr[CCALL_NUM_GPR]; /* Arguments/results in GPRs. */ 181 | GPRArg stack[CCALL_MAXSTACK]; /* Stack slots. */ 182 | } CCallState; 183 | 184 | /* -- C call handling ----------------------------------------------------- */ 185 | 186 | /* Really belongs to lj_vm.h. */ 187 | LJ_ASMF void LJ_FASTCALL lj_vm_ffi_call(CCallState *cc); 188 | 189 | LJ_FUNC CTypeID lj_ccall_ctid_vararg(CTState *cts, cTValue *o); 190 | LJ_FUNC int lj_ccall_func(lua_State *L, GCcdata *cd); 191 | 192 | #endif 193 | 194 | #endif 195 | -------------------------------------------------------------------------------- /src/lj_ccallback.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** FFI C callback handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CCALLBACK_H 7 | #define _LJ_CCALLBACK_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_ctype.h" 11 | 12 | #if LJ_HASFFI 13 | 14 | /* Really belongs to lj_vm.h. */ 15 | LJ_ASMF void lj_vm_ffi_callback(void); 16 | 17 | LJ_FUNC MSize lj_ccallback_ptr2slot(CTState *cts, void *p); 18 | LJ_FUNCA lua_State * LJ_FASTCALL lj_ccallback_enter(CTState *cts, void *cf); 19 | LJ_FUNCA void LJ_FASTCALL lj_ccallback_leave(CTState *cts, TValue *o); 20 | LJ_FUNC void *lj_ccallback_new(CTState *cts, CType *ct, GCfunc *fn); 21 | LJ_FUNC void lj_ccallback_mcode_free(CTState *cts); 22 | 23 | #endif 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /src/lj_cconv.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** C type conversions. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CCONV_H 7 | #define _LJ_CCONV_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_ctype.h" 11 | 12 | #if LJ_HASFFI 13 | 14 | /* Compressed C type index. ORDER CCX. */ 15 | enum { 16 | CCX_B, /* Bool. */ 17 | CCX_I, /* Integer. */ 18 | CCX_F, /* Floating-point number. */ 19 | CCX_C, /* Complex. */ 20 | CCX_V, /* Vector. */ 21 | CCX_P, /* Pointer. */ 22 | CCX_A, /* Refarray. */ 23 | CCX_S /* Struct/union. */ 24 | }; 25 | 26 | /* Convert C type info to compressed C type index. ORDER CT. ORDER CCX. */ 27 | static LJ_AINLINE uint32_t cconv_idx(CTInfo info) 28 | { 29 | uint32_t idx = ((info >> 26) & 15u); /* Dispatch bits. */ 30 | lua_assert(ctype_type(info) <= CT_MAYCONVERT); 31 | #if LJ_64 32 | idx = ((uint32_t)(U64x(f436fff5,fff7f021) >> 4*idx) & 15u); 33 | #else 34 | idx = (((idx < 8 ? 0xfff7f021u : 0xf436fff5) >> 4*(idx & 7u)) & 15u); 35 | #endif 36 | lua_assert(idx < 8); 37 | return idx; 38 | } 39 | 40 | #define cconv_idx2(dinfo, sinfo) \ 41 | ((cconv_idx((dinfo)) << 3) + cconv_idx((sinfo))) 42 | 43 | #define CCX(dst, src) ((CCX_##dst << 3) + CCX_##src) 44 | 45 | /* Conversion flags. */ 46 | #define CCF_CAST 0x00000001u 47 | #define CCF_FROMTV 0x00000002u 48 | #define CCF_SAME 0x00000004u 49 | #define CCF_IGNQUAL 0x00000008u 50 | 51 | #define CCF_ARG_SHIFT 8 52 | #define CCF_ARG(n) ((n) << CCF_ARG_SHIFT) 53 | #define CCF_GETARG(f) ((f) >> CCF_ARG_SHIFT) 54 | 55 | LJ_FUNC int lj_cconv_compatptr(CTState *cts, CType *d, CType *s, CTInfo flags); 56 | LJ_FUNC void lj_cconv_ct_ct(CTState *cts, CType *d, CType *s, 57 | uint8_t *dp, uint8_t *sp, CTInfo flags); 58 | LJ_FUNC int lj_cconv_tv_ct(CTState *cts, CType *s, CTypeID sid, 59 | TValue *o, uint8_t *sp); 60 | LJ_FUNC int lj_cconv_tv_bf(CTState *cts, CType *s, TValue *o, uint8_t *sp); 61 | LJ_FUNC void lj_cconv_ct_tv(CTState *cts, CType *d, 62 | uint8_t *dp, TValue *o, CTInfo flags); 63 | LJ_FUNC void lj_cconv_bf_tv(CTState *cts, CType *d, uint8_t *dp, TValue *o); 64 | LJ_FUNC int lj_cconv_multi_init(CTState *cts, CType *d, TValue *o); 65 | LJ_FUNC void lj_cconv_ct_init(CTState *cts, CType *d, CTSize sz, 66 | uint8_t *dp, TValue *o, MSize len); 67 | 68 | #endif 69 | 70 | #endif 71 | -------------------------------------------------------------------------------- /src/lj_cdata.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** C data management. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CDATA_H 7 | #define _LJ_CDATA_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_gc.h" 11 | #include "lj_ctype.h" 12 | 13 | #if LJ_HASFFI 14 | 15 | /* Get C data pointer. */ 16 | static LJ_AINLINE void *cdata_getptr(void *p, CTSize sz) 17 | { 18 | if (LJ_64 && sz == 4) { /* Support 32 bit pointers on 64 bit targets. */ 19 | return ((void *)(uintptr_t)*(uint32_t *)p); 20 | } else { 21 | lua_assert(sz == CTSIZE_PTR); 22 | return *(void **)p; 23 | } 24 | } 25 | 26 | /* Set C data pointer. */ 27 | static LJ_AINLINE void cdata_setptr(void *p, CTSize sz, const void *v) 28 | { 29 | if (LJ_64 && sz == 4) { /* Support 32 bit pointers on 64 bit targets. */ 30 | *(uint32_t *)p = (uint32_t)(uintptr_t)v; 31 | } else { 32 | lua_assert(sz == CTSIZE_PTR); 33 | *(void **)p = (void *)v; 34 | } 35 | } 36 | 37 | /* Allocate fixed-size C data object. */ 38 | static LJ_AINLINE GCcdata *lj_cdata_new(CTState *cts, CTypeID id, CTSize sz) 39 | { 40 | GCcdata *cd; 41 | #ifdef LUA_USE_ASSERT 42 | CType *ct = ctype_raw(cts, id); 43 | lua_assert((ctype_hassize(ct->info) ? ct->size : CTSIZE_PTR) == sz); 44 | #endif 45 | cd = (GCcdata *)lj_mem_newgco(cts->L, sizeof(GCcdata) + sz); 46 | cd->gct = ~LJ_TCDATA; 47 | cd->ctypeid = ctype_check(cts, id); 48 | return cd; 49 | } 50 | 51 | /* Variant which works without a valid CTState. */ 52 | static LJ_AINLINE GCcdata *lj_cdata_new_(lua_State *L, CTypeID id, CTSize sz) 53 | { 54 | GCcdata *cd = (GCcdata *)lj_mem_newgco(L, sizeof(GCcdata) + sz); 55 | cd->gct = ~LJ_TCDATA; 56 | cd->ctypeid = id; 57 | return cd; 58 | } 59 | 60 | LJ_FUNC GCcdata *lj_cdata_newref(CTState *cts, const void *pp, CTypeID id); 61 | LJ_FUNC GCcdata *lj_cdata_newv(lua_State *L, CTypeID id, CTSize sz, 62 | CTSize align); 63 | LJ_FUNC GCcdata *lj_cdata_newx(CTState *cts, CTypeID id, CTSize sz, 64 | CTInfo info); 65 | 66 | LJ_FUNC void LJ_FASTCALL lj_cdata_free(global_State *g, GCcdata *cd); 67 | LJ_FUNC void lj_cdata_setfin(lua_State *L, GCcdata *cd, GCobj *obj, 68 | uint32_t it); 69 | 70 | LJ_FUNC CType *lj_cdata_index(CTState *cts, GCcdata *cd, cTValue *key, 71 | uint8_t **pp, CTInfo *qual); 72 | LJ_FUNC int lj_cdata_get(CTState *cts, CType *s, TValue *o, uint8_t *sp); 73 | LJ_FUNC void lj_cdata_set(CTState *cts, CType *d, uint8_t *dp, TValue *o, 74 | CTInfo qual); 75 | 76 | #endif 77 | 78 | #endif 79 | -------------------------------------------------------------------------------- /src/lj_char.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Character types. 3 | ** Donated to the public domain. 4 | ** 5 | ** This is intended to replace the problematic libc single-byte NLS functions. 6 | ** These just don't make sense anymore with UTF-8 locales becoming the norm 7 | ** on POSIX systems. It never worked too well on Windows systems since hardly 8 | ** anyone bothered to call setlocale(). 9 | ** 10 | ** This table is hardcoded for ASCII. Identifiers include the characters 11 | ** 128-255, too. This allows for the use of all non-ASCII chars as identifiers 12 | ** in the lexer. This is a broad definition, but works well in practice 13 | ** for both UTF-8 locales and most single-byte locales (such as ISO-8859-*). 14 | ** 15 | ** If you really need proper character types for UTF-8 strings, please use 16 | ** an add-on library such as slnunicode: http://luaforge.net/projects/sln/ 17 | */ 18 | 19 | #define lj_char_c 20 | #define LUA_CORE 21 | 22 | #include "lj_char.h" 23 | 24 | LJ_DATADEF const uint8_t lj_char_bits[257] = { 25 | 0, 26 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 1, 1, 27 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 28 | 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 29 | 152,152,152,152,152,152,152,152,152,152, 4, 4, 4, 4, 4, 4, 30 | 4,176,176,176,176,176,176,160,160,160,160,160,160,160,160,160, 31 | 160,160,160,160,160,160,160,160,160,160,160, 4, 4, 4, 4,132, 32 | 4,208,208,208,208,208,208,192,192,192,192,192,192,192,192,192, 33 | 192,192,192,192,192,192,192,192,192,192,192, 4, 4, 4, 4, 1, 34 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 35 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 36 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 37 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 38 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 39 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 40 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 41 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128 42 | }; 43 | 44 | -------------------------------------------------------------------------------- /src/lj_char.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Character types. 3 | ** Donated to the public domain. 4 | */ 5 | 6 | #ifndef _LJ_CHAR_H 7 | #define _LJ_CHAR_H 8 | 9 | #include "lj_def.h" 10 | 11 | #define LJ_CHAR_CNTRL 0x01 12 | #define LJ_CHAR_SPACE 0x02 13 | #define LJ_CHAR_PUNCT 0x04 14 | #define LJ_CHAR_DIGIT 0x08 15 | #define LJ_CHAR_XDIGIT 0x10 16 | #define LJ_CHAR_UPPER 0x20 17 | #define LJ_CHAR_LOWER 0x40 18 | #define LJ_CHAR_IDENT 0x80 19 | #define LJ_CHAR_ALPHA (LJ_CHAR_LOWER|LJ_CHAR_UPPER) 20 | #define LJ_CHAR_ALNUM (LJ_CHAR_ALPHA|LJ_CHAR_DIGIT) 21 | #define LJ_CHAR_GRAPH (LJ_CHAR_ALNUM|LJ_CHAR_PUNCT) 22 | 23 | /* Only pass -1 or 0..255 to these macros. Never pass a signed char! */ 24 | #define lj_char_isa(c, t) ((lj_char_bits+1)[(c)] & t) 25 | #define lj_char_iscntrl(c) lj_char_isa((c), LJ_CHAR_CNTRL) 26 | #define lj_char_isspace(c) lj_char_isa((c), LJ_CHAR_SPACE) 27 | #define lj_char_ispunct(c) lj_char_isa((c), LJ_CHAR_PUNCT) 28 | #define lj_char_isdigit(c) lj_char_isa((c), LJ_CHAR_DIGIT) 29 | #define lj_char_isxdigit(c) lj_char_isa((c), LJ_CHAR_XDIGIT) 30 | #define lj_char_isupper(c) lj_char_isa((c), LJ_CHAR_UPPER) 31 | #define lj_char_islower(c) lj_char_isa((c), LJ_CHAR_LOWER) 32 | #define lj_char_isident(c) lj_char_isa((c), LJ_CHAR_IDENT) 33 | #define lj_char_isalpha(c) lj_char_isa((c), LJ_CHAR_ALPHA) 34 | #define lj_char_isalnum(c) lj_char_isa((c), LJ_CHAR_ALNUM) 35 | #define lj_char_isgraph(c) lj_char_isa((c), LJ_CHAR_GRAPH) 36 | 37 | #define lj_char_toupper(c) ((c) - (lj_char_islower(c) >> 1)) 38 | #define lj_char_tolower(c) ((c) + lj_char_isupper(c)) 39 | 40 | LJ_DATA const uint8_t lj_char_bits[257]; 41 | 42 | #endif 43 | -------------------------------------------------------------------------------- /src/lj_clib.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** FFI C library loader. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CLIB_H 7 | #define _LJ_CLIB_H 8 | 9 | #include "lj_obj.h" 10 | 11 | #if LJ_HASFFI 12 | 13 | /* Namespace for C library indexing. */ 14 | #define CLNS_INDEX ((1u<env. */ 20 | } CLibrary; 21 | 22 | LJ_FUNC TValue *lj_clib_index(lua_State *L, CLibrary *cl, GCstr *name); 23 | LJ_FUNC void lj_clib_load(lua_State *L, GCtab *mt, GCstr *name, int global); 24 | LJ_FUNC void lj_clib_unload(CLibrary *cl); 25 | LJ_FUNC void lj_clib_default(lua_State *L, GCtab *mt); 26 | 27 | #endif 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /src/lj_cparse.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** C declaration parser. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CPARSE_H 7 | #define _LJ_CPARSE_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_ctype.h" 11 | 12 | #if LJ_HASFFI 13 | 14 | /* C parser limits. */ 15 | #define CPARSE_MAX_BUF 32768 /* Max. token buffer size. */ 16 | #define CPARSE_MAX_DECLSTACK 100 /* Max. declaration stack depth. */ 17 | #define CPARSE_MAX_DECLDEPTH 20 /* Max. recursive declaration depth. */ 18 | #define CPARSE_MAX_PACKSTACK 7 /* Max. pack pragma stack depth. */ 19 | 20 | /* Flags for C parser mode. */ 21 | #define CPARSE_MODE_MULTI 1 /* Process multiple declarations. */ 22 | #define CPARSE_MODE_ABSTRACT 2 /* Accept abstract declarators. */ 23 | #define CPARSE_MODE_DIRECT 4 /* Accept direct declarators. */ 24 | #define CPARSE_MODE_FIELD 8 /* Accept field width in bits, too. */ 25 | #define CPARSE_MODE_NOIMPLICIT 16 /* Reject implicit declarations. */ 26 | #define CPARSE_MODE_SKIP 32 /* Skip definitions, ignore errors. */ 27 | 28 | typedef int CPChar; /* C parser character. Unsigned ext. from char. */ 29 | typedef int CPToken; /* C parser token. */ 30 | 31 | /* C parser internal value representation. */ 32 | typedef struct CPValue { 33 | union { 34 | int32_t i32; /* Value for CTID_INT32. */ 35 | uint32_t u32; /* Value for CTID_UINT32. */ 36 | }; 37 | CTypeID id; /* C Type ID of the value. */ 38 | } CPValue; 39 | 40 | /* C parser state. */ 41 | typedef struct CPState { 42 | CPChar c; /* Current character. */ 43 | CPToken tok; /* Current token. */ 44 | CPValue val; /* Token value. */ 45 | GCstr *str; /* Interned string of identifier/keyword. */ 46 | CType *ct; /* C type table entry. */ 47 | const char *p; /* Current position in input buffer. */ 48 | SBuf sb; /* String buffer for tokens. */ 49 | lua_State *L; /* Lua state. */ 50 | CTState *cts; /* C type state. */ 51 | TValue *param; /* C type parameters. */ 52 | const char *srcname; /* Current source name. */ 53 | BCLine linenumber; /* Input line counter. */ 54 | int depth; /* Recursive declaration depth. */ 55 | uint32_t tmask; /* Type mask for next identifier. */ 56 | uint32_t mode; /* C parser mode. */ 57 | uint8_t packstack[CPARSE_MAX_PACKSTACK]; /* Stack for pack pragmas. */ 58 | uint8_t curpack; /* Current position in pack pragma stack. */ 59 | } CPState; 60 | 61 | LJ_FUNC int lj_cparse(CPState *cp); 62 | 63 | #endif 64 | 65 | #endif 66 | -------------------------------------------------------------------------------- /src/lj_crecord.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Trace recorder for C data operations. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CRECORD_H 7 | #define _LJ_CRECORD_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_jit.h" 11 | #include "lj_ffrecord.h" 12 | 13 | #if LJ_HASJIT && LJ_HASFFI 14 | LJ_FUNC void LJ_FASTCALL recff_cdata_index(jit_State *J, RecordFFData *rd); 15 | LJ_FUNC void LJ_FASTCALL recff_cdata_call(jit_State *J, RecordFFData *rd); 16 | LJ_FUNC void LJ_FASTCALL recff_cdata_arith(jit_State *J, RecordFFData *rd); 17 | LJ_FUNC void LJ_FASTCALL recff_clib_index(jit_State *J, RecordFFData *rd); 18 | LJ_FUNC void LJ_FASTCALL recff_ffi_new(jit_State *J, RecordFFData *rd); 19 | LJ_FUNC void LJ_FASTCALL recff_ffi_errno(jit_State *J, RecordFFData *rd); 20 | LJ_FUNC void LJ_FASTCALL recff_ffi_string(jit_State *J, RecordFFData *rd); 21 | LJ_FUNC void LJ_FASTCALL recff_ffi_copy(jit_State *J, RecordFFData *rd); 22 | LJ_FUNC void LJ_FASTCALL recff_ffi_fill(jit_State *J, RecordFFData *rd); 23 | LJ_FUNC void LJ_FASTCALL recff_ffi_typeof(jit_State *J, RecordFFData *rd); 24 | LJ_FUNC void LJ_FASTCALL recff_ffi_istype(jit_State *J, RecordFFData *rd); 25 | LJ_FUNC void LJ_FASTCALL recff_ffi_abi(jit_State *J, RecordFFData *rd); 26 | LJ_FUNC void LJ_FASTCALL recff_ffi_xof(jit_State *J, RecordFFData *rd); 27 | LJ_FUNC void LJ_FASTCALL recff_ffi_gc(jit_State *J, RecordFFData *rd); 28 | 29 | LJ_FUNC void LJ_FASTCALL recff_bit64_tobit(jit_State *J, RecordFFData *rd); 30 | LJ_FUNC int LJ_FASTCALL recff_bit64_unary(jit_State *J, RecordFFData *rd); 31 | LJ_FUNC int LJ_FASTCALL recff_bit64_nary(jit_State *J, RecordFFData *rd); 32 | LJ_FUNC int LJ_FASTCALL recff_bit64_shift(jit_State *J, RecordFFData *rd); 33 | LJ_FUNC TRef recff_bit64_tohex(jit_State *J, RecordFFData *rd, TRef hdr); 34 | 35 | LJ_FUNC void LJ_FASTCALL lj_crecord_tonumber(jit_State *J, RecordFFData *rd); 36 | #endif 37 | 38 | #endif 39 | -------------------------------------------------------------------------------- /src/lj_debug.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Debugging and introspection. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_DEBUG_H 7 | #define _LJ_DEBUG_H 8 | 9 | #include "lj_obj.h" 10 | 11 | typedef struct lj_Debug { 12 | /* Common fields. Must be in the same order as in lua.h. */ 13 | int event; 14 | const char *name; 15 | const char *namewhat; 16 | const char *what; 17 | const char *source; 18 | int currentline; 19 | int nups; 20 | int linedefined; 21 | int lastlinedefined; 22 | char short_src[LUA_IDSIZE]; 23 | int i_ci; 24 | /* Extended fields. Only valid if lj_debug_getinfo() is called with ext = 1.*/ 25 | int nparams; 26 | int isvararg; 27 | } lj_Debug; 28 | 29 | LJ_FUNC cTValue *lj_debug_frame(lua_State *L, int level, int *size); 30 | LJ_FUNC BCLine LJ_FASTCALL lj_debug_line(GCproto *pt, BCPos pc); 31 | LJ_FUNC const char *lj_debug_uvname(GCproto *pt, uint32_t idx); 32 | LJ_FUNC const char *lj_debug_uvnamev(cTValue *o, uint32_t idx, TValue **tvp); 33 | LJ_FUNC const char *lj_debug_slotname(GCproto *pt, const BCIns *pc, 34 | BCReg slot, const char **name); 35 | LJ_FUNC const char *lj_debug_funcname(lua_State *L, cTValue *frame, 36 | const char **name); 37 | LJ_FUNC void lj_debug_shortname(char *out, GCstr *str, BCLine line); 38 | LJ_FUNC void lj_debug_addloc(lua_State *L, const char *msg, 39 | cTValue *frame, cTValue *nextframe); 40 | LJ_FUNC void lj_debug_pushloc(lua_State *L, GCproto *pt, BCPos pc); 41 | LJ_FUNC int lj_debug_getinfo(lua_State *L, const char *what, lj_Debug *ar, 42 | int ext); 43 | #if LJ_HASPROFILE 44 | LJ_FUNC void lj_debug_dumpstack(lua_State *L, SBuf *sb, const char *fmt, 45 | int depth); 46 | #endif 47 | 48 | /* Fixed internal variable names. */ 49 | #define VARNAMEDEF(_) \ 50 | _(FOR_IDX, "(for index)") \ 51 | _(FOR_STOP, "(for limit)") \ 52 | _(FOR_STEP, "(for step)") \ 53 | _(FOR_GEN, "(for generator)") \ 54 | _(FOR_STATE, "(for state)") \ 55 | _(FOR_CTL, "(for control)") 56 | 57 | enum { 58 | VARNAME_END, 59 | #define VARNAMEENUM(name, str) VARNAME_##name, 60 | VARNAMEDEF(VARNAMEENUM) 61 | #undef VARNAMEENUM 62 | VARNAME__MAX 63 | }; 64 | 65 | #endif 66 | -------------------------------------------------------------------------------- /src/lj_dispatch.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Instruction dispatch handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_DISPATCH_H 7 | #define _LJ_DISPATCH_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_bc.h" 11 | #if LJ_HASJIT 12 | #include "lj_jit.h" 13 | #endif 14 | 15 | #if LJ_TARGET_MIPS 16 | /* Need our own global offset table for the dreaded MIPS calling conventions. */ 17 | 18 | #ifndef _LJ_VM_H 19 | LJ_ASMF int32_t LJ_FASTCALL lj_vm_modi(int32_t a, int32_t b); 20 | #endif 21 | 22 | #if LJ_SOFTFP 23 | #ifndef _LJ_IRCALL_H 24 | extern double __adddf3(double a, double b); 25 | extern double __subdf3(double a, double b); 26 | extern double __muldf3(double a, double b); 27 | extern double __divdf3(double a, double b); 28 | #endif 29 | #define SFGOTDEF(_) _(sqrt) _(__adddf3) _(__subdf3) _(__muldf3) _(__divdf3) 30 | #else 31 | #define SFGOTDEF(_) 32 | #endif 33 | #if LJ_HASJIT 34 | #define JITGOTDEF(_) _(lj_trace_exit) _(lj_trace_hot) 35 | #else 36 | #define JITGOTDEF(_) 37 | #endif 38 | #if LJ_HASFFI 39 | #define FFIGOTDEF(_) \ 40 | _(lj_meta_equal_cd) _(lj_ccallback_enter) _(lj_ccallback_leave) 41 | #else 42 | #define FFIGOTDEF(_) 43 | #endif 44 | #define GOTDEF(_) \ 45 | _(floor) _(ceil) _(trunc) _(log) _(log10) _(exp) _(sin) _(cos) _(tan) \ 46 | _(asin) _(acos) _(atan) _(sinh) _(cosh) _(tanh) _(frexp) _(modf) _(atan2) \ 47 | _(pow) _(fmod) _(ldexp) _(lj_vm_modi) \ 48 | _(lj_dispatch_call) _(lj_dispatch_ins) _(lj_dispatch_stitch) \ 49 | _(lj_dispatch_profile) _(lj_err_throw) \ 50 | _(lj_ffh_coroutine_wrap_err) _(lj_func_closeuv) _(lj_func_newL_gc) \ 51 | _(lj_gc_barrieruv) _(lj_gc_step) _(lj_gc_step_fixtop) _(lj_meta_arith) \ 52 | _(lj_meta_call) _(lj_meta_cat) _(lj_meta_comp) _(lj_meta_equal) \ 53 | _(lj_meta_for) _(lj_meta_istype) _(lj_meta_len) _(lj_meta_tget) \ 54 | _(lj_meta_tset) _(lj_state_growstack) _(lj_strfmt_number) \ 55 | _(lj_str_new) _(lj_tab_dup) _(lj_tab_get) _(lj_tab_getinth) _(lj_tab_len) \ 56 | _(lj_tab_new) _(lj_tab_newkey) _(lj_tab_next) _(lj_tab_reasize) \ 57 | _(lj_tab_setinth) _(lj_buf_putstr_reverse) _(lj_buf_putstr_lower) \ 58 | _(lj_buf_putstr_upper) _(lj_buf_tostr) \ 59 | JITGOTDEF(_) FFIGOTDEF(_) SFGOTDEF(_) 60 | 61 | enum { 62 | #define GOTENUM(name) LJ_GOT_##name, 63 | GOTDEF(GOTENUM) 64 | #undef GOTENUM 65 | LJ_GOT__MAX 66 | }; 67 | #endif 68 | 69 | /* Type of hot counter. Must match the code in the assembler VM. */ 70 | /* 16 bits are sufficient. Only 0.0015% overhead with maximum slot penalty. */ 71 | typedef uint16_t HotCount; 72 | 73 | /* Number of hot counter hash table entries (must be a power of two). */ 74 | #define HOTCOUNT_SIZE 64 75 | #define HOTCOUNT_PCMASK ((HOTCOUNT_SIZE-1)*sizeof(HotCount)) 76 | 77 | /* Hotcount decrements. */ 78 | #define HOTCOUNT_LOOP 2 79 | #define HOTCOUNT_CALL 1 80 | 81 | /* This solves a circular dependency problem -- bump as needed. Sigh. */ 82 | #define GG_NUM_ASMFF 57 83 | 84 | #define GG_LEN_DDISP (BC__MAX + GG_NUM_ASMFF) 85 | #define GG_LEN_SDISP BC_FUNCF 86 | #define GG_LEN_DISP (GG_LEN_DDISP + GG_LEN_SDISP) 87 | 88 | /* Global state, main thread and extra fields are allocated together. */ 89 | typedef struct GG_State { 90 | lua_State L; /* Main thread. */ 91 | global_State g; /* Global state. */ 92 | #if LJ_TARGET_MIPS 93 | ASMFunction got[LJ_GOT__MAX]; /* Global offset table. */ 94 | #endif 95 | #if LJ_HASJIT 96 | jit_State J; /* JIT state. */ 97 | HotCount hotcount[HOTCOUNT_SIZE]; /* Hot counters. */ 98 | #endif 99 | ASMFunction dispatch[GG_LEN_DISP]; /* Instruction dispatch tables. */ 100 | BCIns bcff[GG_NUM_ASMFF]; /* Bytecode for ASM fast functions. */ 101 | } GG_State; 102 | 103 | #define GG_OFS(field) ((int)offsetof(GG_State, field)) 104 | #define G2GG(gl) ((GG_State *)((char *)(gl) - GG_OFS(g))) 105 | #define J2GG(j) ((GG_State *)((char *)(j) - GG_OFS(J))) 106 | #define L2GG(L) (G2GG(G(L))) 107 | #define J2G(J) (&J2GG(J)->g) 108 | #define G2J(gl) (&G2GG(gl)->J) 109 | #define L2J(L) (&L2GG(L)->J) 110 | #define GG_G2J (GG_OFS(J) - GG_OFS(g)) 111 | #define GG_G2DISP (GG_OFS(dispatch) - GG_OFS(g)) 112 | #define GG_DISP2G (GG_OFS(g) - GG_OFS(dispatch)) 113 | #define GG_DISP2J (GG_OFS(J) - GG_OFS(dispatch)) 114 | #define GG_DISP2HOT (GG_OFS(hotcount) - GG_OFS(dispatch)) 115 | #define GG_DISP2STATIC (GG_LEN_DDISP*(int)sizeof(ASMFunction)) 116 | 117 | #define hotcount_get(gg, pc) \ 118 | (gg)->hotcount[(u32ptr(pc)>>2) & (HOTCOUNT_SIZE-1)] 119 | #define hotcount_set(gg, pc, val) \ 120 | (hotcount_get((gg), (pc)) = (HotCount)(val)) 121 | 122 | /* Dispatch table management. */ 123 | LJ_FUNC void lj_dispatch_init(GG_State *GG); 124 | #if LJ_HASJIT 125 | LJ_FUNC void lj_dispatch_init_hotcount(global_State *g); 126 | #endif 127 | LJ_FUNC void lj_dispatch_update(global_State *g); 128 | 129 | /* Instruction dispatch callback for hooks or when recording. */ 130 | LJ_FUNCA void LJ_FASTCALL lj_dispatch_ins(lua_State *L, const BCIns *pc); 131 | LJ_FUNCA ASMFunction LJ_FASTCALL lj_dispatch_call(lua_State *L, const BCIns*pc); 132 | #if LJ_HASJIT 133 | LJ_FUNCA void LJ_FASTCALL lj_dispatch_stitch(jit_State *J, const BCIns *pc); 134 | #endif 135 | #if LJ_HASPROFILE 136 | LJ_FUNCA void LJ_FASTCALL lj_dispatch_profile(lua_State *L, const BCIns *pc); 137 | #endif 138 | 139 | #if LJ_HASFFI && !defined(_BUILDVM_H) 140 | /* Save/restore errno and GetLastError() around hooks, exits and recording. */ 141 | #include 142 | #if LJ_TARGET_WINDOWS 143 | #define WIN32_LEAN_AND_MEAN 144 | #include 145 | #define ERRNO_SAVE int olderr = errno; DWORD oldwerr = GetLastError(); 146 | #define ERRNO_RESTORE errno = olderr; SetLastError(oldwerr); 147 | #else 148 | #define ERRNO_SAVE int olderr = errno; 149 | #define ERRNO_RESTORE errno = olderr; 150 | #endif 151 | #else 152 | #define ERRNO_SAVE 153 | #define ERRNO_RESTORE 154 | #endif 155 | 156 | #endif 157 | -------------------------------------------------------------------------------- /src/lj_err.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Error handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_ERR_H 7 | #define _LJ_ERR_H 8 | 9 | #include 10 | 11 | #include "lj_obj.h" 12 | 13 | typedef enum { 14 | #define ERRDEF(name, msg) \ 15 | LJ_ERR_##name, LJ_ERR_##name##_ = LJ_ERR_##name + sizeof(msg)-1, 16 | #include "lj_errmsg.h" 17 | LJ_ERR__MAX 18 | } ErrMsg; 19 | 20 | LJ_DATA const char *lj_err_allmsg; 21 | #define err2msg(em) (lj_err_allmsg+(int)(em)) 22 | 23 | #ifdef __cplusplus 24 | extern "C" 25 | { 26 | #endif 27 | 28 | 29 | LJ_FUNC GCstr *lj_err_str(lua_State *L, ErrMsg em); 30 | LJ_FUNCA_NORET void LJ_FASTCALL lj_err_throw(lua_State *L, int errcode); 31 | LJ_FUNC_NORET void lj_err_mem(lua_State *L); 32 | LJ_FUNC_NORET void lj_err_run(lua_State *L); 33 | LJ_FUNC_NORET void lj_err_msg(lua_State *L, ErrMsg em); 34 | LJ_FUNC_NORET void lj_err_lex(lua_State *L, GCstr *src, const char *tok, 35 | BCLine line, ErrMsg em, va_list argp); 36 | LJ_FUNC_NORET void lj_err_optype(lua_State *L, cTValue *o, ErrMsg opm); 37 | LJ_FUNC_NORET void lj_err_comp(lua_State *L, cTValue *o1, cTValue *o2); 38 | LJ_FUNC_NORET void lj_err_optype_call(lua_State *L, TValue *o); 39 | LJ_FUNC_NORET void lj_err_callermsg(lua_State *L, const char *msg); 40 | LJ_FUNC_NORET void lj_err_callerv(lua_State *L, ErrMsg em, ...); 41 | LJ_FUNC_NORET void lj_err_caller(lua_State *L, ErrMsg em); 42 | LJ_FUNC_NORET void lj_err_arg(lua_State *L, int narg, ErrMsg em); 43 | LJ_FUNC_NORET void lj_err_argv(lua_State *L, int narg, ErrMsg em, ...); 44 | LJ_FUNC_NORET void lj_err_argtype(lua_State *L, int narg, const char *xname); 45 | LJ_FUNC_NORET void lj_err_argt(lua_State *L, int narg, int tt); 46 | 47 | int lj_err_str_mod(int L, int em); 48 | 49 | #ifdef __cplusplus 50 | }; 51 | #endif 52 | 53 | #endif 54 | -------------------------------------------------------------------------------- /src/lj_ff.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Fast function IDs. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_FF_H 7 | #define _LJ_FF_H 8 | 9 | /* Fast function ID. */ 10 | typedef enum { 11 | FF_LUA_ = FF_LUA, /* Lua function (must be 0). */ 12 | FF_C_ = FF_C, /* Regular C function (must be 1). */ 13 | #define FFDEF(name) FF_##name, 14 | #include "lj_ffdef.h" 15 | FF__MAX 16 | } FastFunc; 17 | 18 | #endif 19 | -------------------------------------------------------------------------------- /src/lj_ffdef.h: -------------------------------------------------------------------------------- 1 | /* This is a generated file. DO NOT EDIT! */ 2 | 3 | FFDEF(assert) 4 | FFDEF(type) 5 | FFDEF(next) 6 | FFDEF(pairs) 7 | FFDEF(ipairs_aux) 8 | FFDEF(ipairs) 9 | FFDEF(getmetatable) 10 | FFDEF(setmetatable) 11 | FFDEF(getfenv) 12 | FFDEF(setfenv) 13 | FFDEF(rawget) 14 | FFDEF(rawset) 15 | FFDEF(rawequal) 16 | FFDEF(unpack) 17 | FFDEF(select) 18 | FFDEF(tonumber) 19 | FFDEF(tostring) 20 | FFDEF(error) 21 | FFDEF(pcall) 22 | FFDEF(xpcall) 23 | FFDEF(loadfile) 24 | FFDEF(load) 25 | FFDEF(loadstring) 26 | FFDEF(dofile) 27 | FFDEF(gcinfo) 28 | FFDEF(collectgarbage) 29 | FFDEF(newproxy) 30 | FFDEF(print) 31 | FFDEF(coroutine_status) 32 | FFDEF(coroutine_running) 33 | FFDEF(coroutine_isyieldable) 34 | FFDEF(coroutine_create) 35 | FFDEF(coroutine_yield) 36 | FFDEF(coroutine_resume) 37 | FFDEF(coroutine_wrap_aux) 38 | FFDEF(coroutine_wrap) 39 | FFDEF(math_abs) 40 | FFDEF(math_floor) 41 | FFDEF(math_ceil) 42 | FFDEF(math_sqrt) 43 | FFDEF(math_log10) 44 | FFDEF(math_exp) 45 | FFDEF(math_sin) 46 | FFDEF(math_cos) 47 | FFDEF(math_tan) 48 | FFDEF(math_asin) 49 | FFDEF(math_acos) 50 | FFDEF(math_atan) 51 | FFDEF(math_sinh) 52 | FFDEF(math_cosh) 53 | FFDEF(math_tanh) 54 | FFDEF(math_frexp) 55 | FFDEF(math_modf) 56 | FFDEF(math_log) 57 | FFDEF(math_atan2) 58 | FFDEF(math_pow) 59 | FFDEF(math_fmod) 60 | FFDEF(math_ldexp) 61 | FFDEF(math_min) 62 | FFDEF(math_max) 63 | FFDEF(math_random) 64 | FFDEF(math_randomseed) 65 | FFDEF(bit_tobit) 66 | FFDEF(bit_bnot) 67 | FFDEF(bit_bswap) 68 | FFDEF(bit_lshift) 69 | FFDEF(bit_rshift) 70 | FFDEF(bit_arshift) 71 | FFDEF(bit_rol) 72 | FFDEF(bit_ror) 73 | FFDEF(bit_band) 74 | FFDEF(bit_bor) 75 | FFDEF(bit_bxor) 76 | FFDEF(bit_tohex) 77 | FFDEF(string_byte) 78 | FFDEF(string_char) 79 | FFDEF(string_sub) 80 | FFDEF(string_rep) 81 | FFDEF(string_reverse) 82 | FFDEF(string_lower) 83 | FFDEF(string_upper) 84 | FFDEF(string_dump) 85 | FFDEF(string_find) 86 | FFDEF(string_match) 87 | FFDEF(string_gmatch_aux) 88 | FFDEF(string_gmatch) 89 | FFDEF(string_gsub) 90 | FFDEF(string_format) 91 | FFDEF(table_maxn) 92 | FFDEF(table_insert) 93 | FFDEF(table_concat) 94 | FFDEF(table_sort) 95 | FFDEF(table_new) 96 | FFDEF(table_clear) 97 | FFDEF(io_method_close) 98 | FFDEF(io_method_read) 99 | FFDEF(io_method_write) 100 | FFDEF(io_method_flush) 101 | FFDEF(io_method_seek) 102 | FFDEF(io_method_setvbuf) 103 | FFDEF(io_method_lines) 104 | FFDEF(io_method___gc) 105 | FFDEF(io_method___tostring) 106 | FFDEF(io_open) 107 | FFDEF(io_popen) 108 | FFDEF(io_tmpfile) 109 | FFDEF(io_close) 110 | FFDEF(io_read) 111 | FFDEF(io_write) 112 | FFDEF(io_flush) 113 | FFDEF(io_input) 114 | FFDEF(io_output) 115 | FFDEF(io_lines) 116 | FFDEF(io_type) 117 | FFDEF(os_execute) 118 | FFDEF(os_remove) 119 | FFDEF(os_rename) 120 | FFDEF(os_tmpname) 121 | FFDEF(os_getenv) 122 | FFDEF(os_exit) 123 | FFDEF(os_clock) 124 | FFDEF(os_date) 125 | FFDEF(os_time) 126 | FFDEF(os_difftime) 127 | FFDEF(os_setlocale) 128 | FFDEF(debug_getregistry) 129 | FFDEF(debug_getmetatable) 130 | FFDEF(debug_setmetatable) 131 | FFDEF(debug_getfenv) 132 | FFDEF(debug_setfenv) 133 | FFDEF(debug_getinfo) 134 | FFDEF(debug_getlocal) 135 | FFDEF(debug_setlocal) 136 | FFDEF(debug_getupvalue) 137 | FFDEF(debug_setupvalue) 138 | FFDEF(debug_upvalueid) 139 | FFDEF(debug_upvaluejoin) 140 | FFDEF(debug_sethook) 141 | FFDEF(debug_gethook) 142 | FFDEF(debug_debug) 143 | FFDEF(debug_traceback) 144 | FFDEF(jit_on) 145 | FFDEF(jit_off) 146 | FFDEF(jit_flush) 147 | FFDEF(jit_status) 148 | FFDEF(jit_attach) 149 | FFDEF(jit_util_funcinfo) 150 | FFDEF(jit_util_funcbc) 151 | FFDEF(jit_util_funck) 152 | FFDEF(jit_util_funcuvname) 153 | FFDEF(jit_util_traceinfo) 154 | FFDEF(jit_util_traceir) 155 | FFDEF(jit_util_tracek) 156 | FFDEF(jit_util_tracesnap) 157 | FFDEF(jit_util_tracemc) 158 | FFDEF(jit_util_traceexitstub) 159 | FFDEF(jit_util_ircalladdr) 160 | FFDEF(jit_opt_start) 161 | FFDEF(jit_profile_start) 162 | FFDEF(jit_profile_stop) 163 | FFDEF(jit_profile_dumpstack) 164 | FFDEF(ffi_meta___index) 165 | FFDEF(ffi_meta___newindex) 166 | FFDEF(ffi_meta___eq) 167 | FFDEF(ffi_meta___len) 168 | FFDEF(ffi_meta___lt) 169 | FFDEF(ffi_meta___le) 170 | FFDEF(ffi_meta___concat) 171 | FFDEF(ffi_meta___call) 172 | FFDEF(ffi_meta___add) 173 | FFDEF(ffi_meta___sub) 174 | FFDEF(ffi_meta___mul) 175 | FFDEF(ffi_meta___div) 176 | FFDEF(ffi_meta___mod) 177 | FFDEF(ffi_meta___pow) 178 | FFDEF(ffi_meta___unm) 179 | FFDEF(ffi_meta___tostring) 180 | FFDEF(ffi_meta___pairs) 181 | FFDEF(ffi_meta___ipairs) 182 | FFDEF(ffi_clib___index) 183 | FFDEF(ffi_clib___newindex) 184 | FFDEF(ffi_clib___gc) 185 | FFDEF(ffi_callback_free) 186 | FFDEF(ffi_callback_set) 187 | FFDEF(ffi_cdef) 188 | FFDEF(ffi_new) 189 | FFDEF(ffi_cast) 190 | FFDEF(ffi_typeof) 191 | FFDEF(ffi_typeinfo) 192 | FFDEF(ffi_istype) 193 | FFDEF(ffi_sizeof) 194 | FFDEF(ffi_alignof) 195 | FFDEF(ffi_offsetof) 196 | FFDEF(ffi_errno) 197 | FFDEF(ffi_string) 198 | FFDEF(ffi_copy) 199 | FFDEF(ffi_fill) 200 | FFDEF(ffi_abi) 201 | FFDEF(ffi_metatype) 202 | FFDEF(ffi_gc) 203 | FFDEF(ffi_load) 204 | 205 | #undef FFDEF 206 | 207 | #ifndef FF_NUM_ASMFUNC 208 | #define FF_NUM_ASMFUNC 57 209 | #endif 210 | 211 | -------------------------------------------------------------------------------- /src/lj_ffrecord.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Fast function call recorder. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_FFRECORD_H 7 | #define _LJ_FFRECORD_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_jit.h" 11 | 12 | #if LJ_HASJIT 13 | /* Data used by handlers to record a fast function. */ 14 | typedef struct RecordFFData { 15 | TValue *argv; /* Runtime argument values. */ 16 | ptrdiff_t nres; /* Number of returned results (defaults to 1). */ 17 | uint32_t data; /* Per-ffid auxiliary data (opcode, literal etc.). */ 18 | } RecordFFData; 19 | 20 | LJ_FUNC int32_t lj_ffrecord_select_mode(jit_State *J, TRef tr, TValue *tv); 21 | LJ_FUNC void lj_ffrecord_func(jit_State *J); 22 | #endif 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /src/lj_func.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Function handling (prototypes, functions and upvalues). 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | ** 5 | ** Portions taken verbatim or adapted from the Lua interpreter. 6 | ** Copyright (C) 1994-2008 Lua.org, PUC-Rio. See Copyright Notice in lua.h 7 | */ 8 | 9 | #define lj_func_c 10 | #define LUA_CORE 11 | 12 | #include "lj_obj.h" 13 | #include "lj_gc.h" 14 | #include "lj_func.h" 15 | #include "lj_trace.h" 16 | #include "lj_vm.h" 17 | 18 | /* -- Prototypes ---------------------------------------------------------- */ 19 | 20 | void LJ_FASTCALL lj_func_freeproto(global_State *g, GCproto *pt) 21 | { 22 | lj_mem_free(g, pt, pt->sizept); 23 | } 24 | 25 | /* -- Upvalues ------------------------------------------------------------ */ 26 | 27 | static void unlinkuv(GCupval *uv) 28 | { 29 | lua_assert(uvprev(uvnext(uv)) == uv && uvnext(uvprev(uv)) == uv); 30 | setgcrefr(uvnext(uv)->prev, uv->prev); 31 | setgcrefr(uvprev(uv)->next, uv->next); 32 | } 33 | 34 | /* Find existing open upvalue for a stack slot or create a new one. */ 35 | static GCupval *func_finduv(lua_State *L, TValue *slot) 36 | { 37 | global_State *g = G(L); 38 | GCRef *pp = &L->openupval; 39 | GCupval *p; 40 | GCupval *uv; 41 | /* Search the sorted list of open upvalues. */ 42 | while (gcref(*pp) != NULL && uvval((p = gco2uv(gcref(*pp)))) >= slot) { 43 | lua_assert(!p->closed && uvval(p) != &p->tv); 44 | if (uvval(p) == slot) { /* Found open upvalue pointing to same slot? */ 45 | if (isdead(g, obj2gco(p))) /* Resurrect it, if it's dead. */ 46 | flipwhite(obj2gco(p)); 47 | return p; 48 | } 49 | pp = &p->nextgc; 50 | } 51 | /* No matching upvalue found. Create a new one. */ 52 | uv = lj_mem_newt(L, sizeof(GCupval), GCupval); 53 | newwhite(g, uv); 54 | uv->gct = ~LJ_TUPVAL; 55 | uv->closed = 0; /* Still open. */ 56 | setmref(uv->v, slot); /* Pointing to the stack slot. */ 57 | /* NOBARRIER: The GCupval is new (marked white) and open. */ 58 | setgcrefr(uv->nextgc, *pp); /* Insert into sorted list of open upvalues. */ 59 | setgcref(*pp, obj2gco(uv)); 60 | setgcref(uv->prev, obj2gco(&g->uvhead)); /* Insert into GC list, too. */ 61 | setgcrefr(uv->next, g->uvhead.next); 62 | setgcref(uvnext(uv)->prev, obj2gco(uv)); 63 | setgcref(g->uvhead.next, obj2gco(uv)); 64 | lua_assert(uvprev(uvnext(uv)) == uv && uvnext(uvprev(uv)) == uv); 65 | return uv; 66 | } 67 | 68 | /* Create an empty and closed upvalue. */ 69 | static GCupval *func_emptyuv(lua_State *L) 70 | { 71 | GCupval *uv = (GCupval *)lj_mem_newgco(L, sizeof(GCupval)); 72 | uv->gct = ~LJ_TUPVAL; 73 | uv->closed = 1; 74 | setnilV(&uv->tv); 75 | setmref(uv->v, &uv->tv); 76 | return uv; 77 | } 78 | 79 | /* Close all open upvalues pointing to some stack level or above. */ 80 | void LJ_FASTCALL lj_func_closeuv(lua_State *L, TValue *level) 81 | { 82 | GCupval *uv; 83 | global_State *g = G(L); 84 | while (gcref(L->openupval) != NULL && 85 | uvval((uv = gco2uv(gcref(L->openupval)))) >= level) { 86 | GCobj *o = obj2gco(uv); 87 | lua_assert(!isblack(o) && !uv->closed && uvval(uv) != &uv->tv); 88 | setgcrefr(L->openupval, uv->nextgc); /* No longer in open list. */ 89 | if (isdead(g, o)) { 90 | lj_func_freeuv(g, uv); 91 | } else { 92 | unlinkuv(uv); 93 | lj_gc_closeuv(g, uv); 94 | } 95 | } 96 | } 97 | 98 | void LJ_FASTCALL lj_func_freeuv(global_State *g, GCupval *uv) 99 | { 100 | if (!uv->closed) 101 | unlinkuv(uv); 102 | lj_mem_freet(g, uv); 103 | } 104 | 105 | /* -- Functions (closures) ------------------------------------------------ */ 106 | 107 | GCfunc *lj_func_newC(lua_State *L, MSize nelems, GCtab *env) 108 | { 109 | GCfunc *fn = (GCfunc *)lj_mem_newgco(L, sizeCfunc(nelems)); 110 | fn->c.gct = ~LJ_TFUNC; 111 | fn->c.ffid = FF_C; 112 | fn->c.nupvalues = (uint8_t)nelems; 113 | /* NOBARRIER: The GCfunc is new (marked white). */ 114 | setmref(fn->c.pc, &G(L)->bc_cfunc_ext); 115 | setgcref(fn->c.env, obj2gco(env)); 116 | return fn; 117 | } 118 | 119 | static GCfunc *func_newL(lua_State *L, GCproto *pt, GCtab *env) 120 | { 121 | uint32_t count; 122 | GCfunc *fn = (GCfunc *)lj_mem_newgco(L, sizeLfunc((MSize)pt->sizeuv)); 123 | fn->l.gct = ~LJ_TFUNC; 124 | fn->l.ffid = FF_LUA; 125 | fn->l.nupvalues = 0; /* Set to zero until upvalues are initialized. */ 126 | /* NOBARRIER: Really a setgcref. But the GCfunc is new (marked white). */ 127 | setmref(fn->l.pc, proto_bc(pt)); 128 | setgcref(fn->l.env, obj2gco(env)); 129 | /* Saturating 3 bit counter (0..7) for created closures. */ 130 | count = (uint32_t)pt->flags + PROTO_CLCOUNT; 131 | pt->flags = (uint8_t)(count - ((count >> PROTO_CLC_BITS) & PROTO_CLCOUNT)); 132 | return fn; 133 | } 134 | 135 | /* Create a new Lua function with empty upvalues. */ 136 | GCfunc *lj_func_newL_empty(lua_State *L, GCproto *pt, GCtab *env) 137 | { 138 | GCfunc *fn = func_newL(L, pt, env); 139 | MSize i, nuv = pt->sizeuv; 140 | /* NOBARRIER: The GCfunc is new (marked white). */ 141 | for (i = 0; i < nuv; i++) { 142 | GCupval *uv = func_emptyuv(L); 143 | int32_t v = proto_uv(pt)[i]; 144 | uv->immutable = ((v / PROTO_UV_IMMUTABLE) & 1); 145 | uv->dhash = (uint32_t)(uintptr_t)pt ^ (v << 24); 146 | setgcref(fn->l.uvptr[i], obj2gco(uv)); 147 | } 148 | fn->l.nupvalues = (uint8_t)nuv; 149 | return fn; 150 | } 151 | 152 | /* Do a GC check and create a new Lua function with inherited upvalues. */ 153 | GCfunc *lj_func_newL_gc(lua_State *L, GCproto *pt, GCfuncL *parent) 154 | { 155 | GCfunc *fn; 156 | GCRef *puv; 157 | MSize i, nuv; 158 | TValue *base; 159 | lj_gc_check_fixtop(L); 160 | fn = func_newL(L, pt, tabref(parent->env)); 161 | /* NOBARRIER: The GCfunc is new (marked white). */ 162 | puv = parent->uvptr; 163 | nuv = pt->sizeuv; 164 | base = L->base; 165 | for (i = 0; i < nuv; i++) { 166 | uint32_t v = proto_uv(pt)[i]; 167 | GCupval *uv; 168 | if ((v & PROTO_UV_LOCAL)) { 169 | uv = func_finduv(L, base + (v & 0xff)); 170 | uv->immutable = ((v / PROTO_UV_IMMUTABLE) & 1); 171 | uv->dhash = (uint32_t)(uintptr_t)mref(parent->pc, char) ^ (v << 24); 172 | } else { 173 | uv = &gcref(puv[v])->uv; 174 | } 175 | setgcref(fn->l.uvptr[i], obj2gco(uv)); 176 | } 177 | fn->l.nupvalues = (uint8_t)nuv; 178 | return fn; 179 | } 180 | 181 | void LJ_FASTCALL lj_func_free(global_State *g, GCfunc *fn) 182 | { 183 | MSize size = isluafunc(fn) ? sizeLfunc((MSize)fn->l.nupvalues) : 184 | sizeCfunc((MSize)fn->c.nupvalues); 185 | lj_mem_free(g, fn, size); 186 | } 187 | 188 | -------------------------------------------------------------------------------- /src/lj_func.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Function handling (prototypes, functions and upvalues). 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_FUNC_H 7 | #define _LJ_FUNC_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Prototypes. */ 12 | LJ_FUNC void LJ_FASTCALL lj_func_freeproto(global_State *g, GCproto *pt); 13 | 14 | /* Upvalues. */ 15 | LJ_FUNCA void LJ_FASTCALL lj_func_closeuv(lua_State *L, TValue *level); 16 | LJ_FUNC void LJ_FASTCALL lj_func_freeuv(global_State *g, GCupval *uv); 17 | 18 | /* Functions (closures). */ 19 | LJ_FUNC GCfunc *lj_func_newC(lua_State *L, MSize nelems, GCtab *env); 20 | LJ_FUNC GCfunc *lj_func_newL_empty(lua_State *L, GCproto *pt, GCtab *env); 21 | LJ_FUNCA GCfunc *lj_func_newL_gc(lua_State *L, GCproto *pt, GCfuncL *parent); 22 | LJ_FUNC void LJ_FASTCALL lj_func_free(global_State *g, GCfunc *c); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /src/lj_gc.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Garbage collector. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_GC_H 7 | #define _LJ_GC_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Garbage collector states. Order matters. */ 12 | enum { 13 | GCSpause, GCSpropagate, GCSatomic, GCSsweepstring, GCSsweep, GCSfinalize 14 | }; 15 | 16 | #ifdef __cplusplus 17 | extern "C" 18 | { 19 | #endif 20 | 21 | /* Bitmasks for marked field of GCobj. */ 22 | #define LJ_GC_WHITE0 0x01 23 | #define LJ_GC_WHITE1 0x02 24 | #define LJ_GC_BLACK 0x04 25 | #define LJ_GC_FINALIZED 0x08 26 | #define LJ_GC_WEAKKEY 0x08 27 | #define LJ_GC_WEAKVAL 0x10 28 | #define LJ_GC_CDATA_FIN 0x10 29 | #define LJ_GC_FIXED 0x20 30 | #define LJ_GC_SFIXED 0x40 31 | 32 | #define LJ_GC_WHITES (LJ_GC_WHITE0 | LJ_GC_WHITE1) 33 | #define LJ_GC_COLORS (LJ_GC_WHITES | LJ_GC_BLACK) 34 | #define LJ_GC_WEAK (LJ_GC_WEAKKEY | LJ_GC_WEAKVAL) 35 | 36 | /* Macros to test and set GCobj colors. */ 37 | #define iswhite(x) ((x)->gch.marked & LJ_GC_WHITES) 38 | #define isblack(x) ((x)->gch.marked & LJ_GC_BLACK) 39 | #define isgray(x) (!((x)->gch.marked & (LJ_GC_BLACK|LJ_GC_WHITES))) 40 | #define tviswhite(x) (tvisgcv(x) && iswhite(gcV(x))) 41 | #define otherwhite(g) (g->gc.currentwhite ^ LJ_GC_WHITES) 42 | #define isdead(g, v) ((v)->gch.marked & otherwhite(g) & LJ_GC_WHITES) 43 | 44 | #define curwhite(g) ((g)->gc.currentwhite & LJ_GC_WHITES) 45 | #define newwhite(g, x) (obj2gco(x)->gch.marked = (uint8_t)curwhite(g)) 46 | #define makewhite(g, x) \ 47 | ((x)->gch.marked = ((x)->gch.marked & (uint8_t)~LJ_GC_COLORS) | curwhite(g)) 48 | #define flipwhite(x) ((x)->gch.marked ^= LJ_GC_WHITES) 49 | #define black2gray(x) ((x)->gch.marked &= (uint8_t)~LJ_GC_BLACK) 50 | #define fixstring(s) ((s)->marked |= LJ_GC_FIXED) 51 | #define markfinalized(x) ((x)->gch.marked |= LJ_GC_FINALIZED) 52 | 53 | /* Collector. */ 54 | LJ_FUNC size_t lj_gc_separateudata(global_State *g, int all); 55 | LJ_FUNC void lj_gc_finalize_udata(lua_State *L); 56 | #if LJ_HASFFI 57 | LJ_FUNC void lj_gc_finalize_cdata(lua_State *L); 58 | #else 59 | #define lj_gc_finalize_cdata(L) UNUSED(L) 60 | #endif 61 | LJ_FUNC void lj_gc_freeall(global_State *g); 62 | LJ_FUNCA int LJ_FASTCALL lj_gc_step(lua_State *L); 63 | LJ_FUNCA void LJ_FASTCALL lj_gc_step_fixtop(lua_State *L); 64 | #if LJ_HASJIT 65 | LJ_FUNC int LJ_FASTCALL lj_gc_step_jit(global_State *g, MSize steps); 66 | #endif 67 | LJ_FUNC void lj_gc_fullgc(lua_State *L); 68 | 69 | /* GC check: drive collector forward if the GC threshold has been reached. */ 70 | #define lj_gc_check(L) \ 71 | { if (LJ_UNLIKELY(G(L)->gc.total >= G(L)->gc.threshold)) \ 72 | lj_gc_step(L); } 73 | #define lj_gc_check_fixtop(L) \ 74 | { if (LJ_UNLIKELY(G(L)->gc.total >= G(L)->gc.threshold)) \ 75 | lj_gc_step_fixtop(L); } 76 | 77 | /* Write barriers. */ 78 | LJ_FUNC void lj_gc_barrierf(global_State *g, GCobj *o, GCobj *v); 79 | LJ_FUNCA void LJ_FASTCALL lj_gc_barrieruv(global_State *g, TValue *tv); 80 | LJ_FUNC void lj_gc_closeuv(global_State *g, GCupval *uv); 81 | #if LJ_HASJIT 82 | LJ_FUNC void lj_gc_barriertrace(global_State *g, uint32_t traceno); 83 | #endif 84 | 85 | /* Move the GC propagation frontier back for tables (make it gray again). */ 86 | static LJ_AINLINE void lj_gc_barrierback(global_State *g, GCtab *t) 87 | { 88 | GCobj *o = obj2gco(t); 89 | lua_assert(isblack(o) && !isdead(g, o)); 90 | lua_assert(g->gc.state != GCSfinalize && g->gc.state != GCSpause); 91 | black2gray(o); 92 | setgcrefr(t->gclist, g->gc.grayagain); 93 | setgcref(g->gc.grayagain, o); 94 | } 95 | 96 | /* Barrier for stores to table objects. TValue and GCobj variant. */ 97 | #define lj_gc_anybarriert(L, t) \ 98 | { if (LJ_UNLIKELY(isblack(obj2gco(t)))) lj_gc_barrierback(G(L), (t)); } 99 | #define lj_gc_barriert(L, t, tv) \ 100 | { if (tviswhite(tv) && isblack(obj2gco(t))) \ 101 | lj_gc_barrierback(G(L), (t)); } 102 | #define lj_gc_objbarriert(L, t, o) \ 103 | { if (iswhite(obj2gco(o)) && isblack(obj2gco(t))) \ 104 | lj_gc_barrierback(G(L), (t)); } 105 | 106 | /* Barrier for stores to any other object. TValue and GCobj variant. */ 107 | #define lj_gc_barrier(L, p, tv) \ 108 | { if (tviswhite(tv) && isblack(obj2gco(p))) \ 109 | lj_gc_barrierf(G(L), obj2gco(p), gcV(tv)); } 110 | #define lj_gc_objbarrier(L, p, o) \ 111 | { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \ 112 | lj_gc_barrierf(G(L), obj2gco(p), obj2gco(o)); } 113 | 114 | /* Allocator. */ 115 | LJ_FUNC void *lj_mem_realloc(lua_State *L, void *p, GCSize osz, GCSize nsz); 116 | LJ_FUNC void * LJ_FASTCALL lj_mem_newgco(lua_State *L, GCSize size); 117 | LJ_FUNC void *lj_mem_grow(lua_State *L, void *p, 118 | MSize *szp, MSize lim, MSize esz); 119 | 120 | #define lj_mem_new(L, s) lj_mem_realloc(L, NULL, 0, (s)) 121 | 122 | static LJ_AINLINE void lj_mem_free(global_State *g, void *p, size_t osize) 123 | { 124 | g->gc.total -= (GCSize)osize; 125 | g->allocf(g->allocd, p, osize, 0); 126 | } 127 | 128 | #define lj_mem_newvec(L, n, t) ((t *)lj_mem_new(L, (GCSize)((n)*sizeof(t)))) 129 | #define lj_mem_reallocvec(L, p, on, n, t) \ 130 | ((p) = (t *)lj_mem_realloc(L, p, (on)*sizeof(t), (GCSize)((n)*sizeof(t)))) 131 | #define lj_mem_growvec(L, p, n, m, t) \ 132 | ((p) = (t *)lj_mem_grow(L, (p), &(n), (m), (MSize)sizeof(t))) 133 | #define lj_mem_freevec(g, p, n, t) lj_mem_free(g, (p), (n)*sizeof(t)) 134 | 135 | #define lj_mem_newobj(L, t) ((t *)lj_mem_newgco(L, sizeof(t))) 136 | #define lj_mem_newt(L, s, t) ((t *)lj_mem_new(L, (s))) 137 | #define lj_mem_freet(g, p) lj_mem_free(g, (p), sizeof(*(p))) 138 | 139 | #ifdef __cplusplus 140 | }; 141 | #endif 142 | 143 | 144 | #endif 145 | -------------------------------------------------------------------------------- /src/lj_gdbjit.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Client for the GDB JIT API. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_GDBJIT_H 7 | #define _LJ_GDBJIT_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_jit.h" 11 | 12 | #if LJ_HASJIT && defined(LUAJIT_USE_GDBJIT) 13 | 14 | LJ_FUNC void lj_gdbjit_addtrace(jit_State *J, GCtrace *T); 15 | LJ_FUNC void lj_gdbjit_deltrace(jit_State *J, GCtrace *T); 16 | 17 | #else 18 | #define lj_gdbjit_addtrace(J, T) UNUSED(T) 19 | #define lj_gdbjit_deltrace(J, T) UNUSED(T) 20 | #endif 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /src/lj_iropt.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Common header for IR emitter and optimizations. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_IROPT_H 7 | #define _LJ_IROPT_H 8 | 9 | #include 10 | 11 | #include "lj_obj.h" 12 | #include "lj_jit.h" 13 | 14 | #if LJ_HASJIT 15 | /* IR emitter. */ 16 | LJ_FUNC void LJ_FASTCALL lj_ir_growtop(jit_State *J); 17 | LJ_FUNC TRef LJ_FASTCALL lj_ir_emit(jit_State *J); 18 | 19 | /* Save current IR in J->fold.ins, but do not emit it (yet). */ 20 | static LJ_AINLINE void lj_ir_set_(jit_State *J, uint16_t ot, IRRef1 a, IRRef1 b) 21 | { 22 | J->fold.ins.ot = ot; J->fold.ins.op1 = a; J->fold.ins.op2 = b; 23 | } 24 | 25 | #define lj_ir_set(J, ot, a, b) \ 26 | lj_ir_set_(J, (uint16_t)(ot), (IRRef1)(a), (IRRef1)(b)) 27 | 28 | /* Get ref of next IR instruction and optionally grow IR. 29 | ** Note: this may invalidate all IRIns*! 30 | */ 31 | static LJ_AINLINE IRRef lj_ir_nextins(jit_State *J) 32 | { 33 | IRRef ref = J->cur.nins; 34 | if (LJ_UNLIKELY(ref >= J->irtoplim)) lj_ir_growtop(J); 35 | J->cur.nins = ref + 1; 36 | return ref; 37 | } 38 | 39 | LJ_FUNC TRef lj_ir_ggfload(jit_State *J, IRType t, uintptr_t ofs); 40 | 41 | /* Interning of constants. */ 42 | LJ_FUNC TRef LJ_FASTCALL lj_ir_kint(jit_State *J, int32_t k); 43 | LJ_FUNC TRef lj_ir_k64(jit_State *J, IROp op, uint64_t u64); 44 | LJ_FUNC TRef lj_ir_knum_u64(jit_State *J, uint64_t u64); 45 | LJ_FUNC TRef lj_ir_knumint(jit_State *J, lua_Number n); 46 | LJ_FUNC TRef lj_ir_kint64(jit_State *J, uint64_t u64); 47 | LJ_FUNC TRef lj_ir_kgc(jit_State *J, GCobj *o, IRType t); 48 | LJ_FUNC TRef lj_ir_kptr_(jit_State *J, IROp op, void *ptr); 49 | LJ_FUNC TRef lj_ir_knull(jit_State *J, IRType t); 50 | LJ_FUNC TRef lj_ir_kslot(jit_State *J, TRef key, IRRef slot); 51 | LJ_FUNC TRef lj_ir_ktrace(jit_State *J); 52 | 53 | #if LJ_64 54 | #define lj_ir_kintp(J, k) lj_ir_kint64(J, (uint64_t)(k)) 55 | #else 56 | #define lj_ir_kintp(J, k) lj_ir_kint(J, (int32_t)(k)) 57 | #endif 58 | 59 | static LJ_AINLINE TRef lj_ir_knum(jit_State *J, lua_Number n) 60 | { 61 | TValue tv; 62 | tv.n = n; 63 | return lj_ir_knum_u64(J, tv.u64); 64 | } 65 | 66 | #define lj_ir_kstr(J, str) lj_ir_kgc(J, obj2gco((str)), IRT_STR) 67 | #define lj_ir_ktab(J, tab) lj_ir_kgc(J, obj2gco((tab)), IRT_TAB) 68 | #define lj_ir_kfunc(J, func) lj_ir_kgc(J, obj2gco((func)), IRT_FUNC) 69 | #define lj_ir_kptr(J, ptr) lj_ir_kptr_(J, IR_KPTR, (ptr)) 70 | #define lj_ir_kkptr(J, ptr) lj_ir_kptr_(J, IR_KKPTR, (ptr)) 71 | 72 | /* Special FP constants. */ 73 | #define lj_ir_knum_zero(J) lj_ir_knum_u64(J, U64x(00000000,00000000)) 74 | #define lj_ir_knum_one(J) lj_ir_knum_u64(J, U64x(3ff00000,00000000)) 75 | #define lj_ir_knum_tobit(J) lj_ir_knum_u64(J, U64x(43380000,00000000)) 76 | 77 | /* Special 128 bit SIMD constants. */ 78 | #define lj_ir_ksimd(J, idx) \ 79 | lj_ir_ggfload(J, IRT_NUM, (uintptr_t)LJ_KSIMD(J, idx) - (uintptr_t)J2GG(J)) 80 | 81 | /* Access to constants. */ 82 | LJ_FUNC void lj_ir_kvalue(lua_State *L, TValue *tv, const IRIns *ir); 83 | 84 | /* Convert IR operand types. */ 85 | LJ_FUNC TRef LJ_FASTCALL lj_ir_tonumber(jit_State *J, TRef tr); 86 | LJ_FUNC TRef LJ_FASTCALL lj_ir_tonum(jit_State *J, TRef tr); 87 | LJ_FUNC TRef LJ_FASTCALL lj_ir_tostr(jit_State *J, TRef tr); 88 | 89 | /* Miscellaneous IR ops. */ 90 | LJ_FUNC int lj_ir_numcmp(lua_Number a, lua_Number b, IROp op); 91 | LJ_FUNC int lj_ir_strcmp(GCstr *a, GCstr *b, IROp op); 92 | LJ_FUNC void lj_ir_rollback(jit_State *J, IRRef ref); 93 | 94 | /* Emit IR instructions with on-the-fly optimizations. */ 95 | LJ_FUNC TRef LJ_FASTCALL lj_opt_fold(jit_State *J); 96 | LJ_FUNC TRef LJ_FASTCALL lj_opt_cse(jit_State *J); 97 | LJ_FUNC TRef LJ_FASTCALL lj_opt_cselim(jit_State *J, IRRef lim); 98 | 99 | /* Special return values for the fold functions. */ 100 | enum { 101 | NEXTFOLD, /* Couldn't fold, pass on. */ 102 | RETRYFOLD, /* Retry fold with modified fins. */ 103 | KINTFOLD, /* Return ref for int constant in fins->i. */ 104 | FAILFOLD, /* Guard would always fail. */ 105 | DROPFOLD, /* Guard eliminated. */ 106 | MAX_FOLD 107 | }; 108 | 109 | #define INTFOLD(k) ((J->fold.ins.i = (k)), (TRef)KINTFOLD) 110 | #define INT64FOLD(k) (lj_ir_kint64(J, (k))) 111 | #define CONDFOLD(cond) ((TRef)FAILFOLD + (TRef)(cond)) 112 | #define LEFTFOLD (J->fold.ins.op1) 113 | #define RIGHTFOLD (J->fold.ins.op2) 114 | #define CSEFOLD (lj_opt_cse(J)) 115 | #define EMITFOLD (lj_ir_emit(J)) 116 | 117 | /* Load/store forwarding. */ 118 | LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_aload(jit_State *J); 119 | LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_hload(jit_State *J); 120 | LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_uload(jit_State *J); 121 | LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_fload(jit_State *J); 122 | LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_xload(jit_State *J); 123 | LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_tab_len(jit_State *J); 124 | LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_hrefk(jit_State *J); 125 | LJ_FUNC int LJ_FASTCALL lj_opt_fwd_href_nokey(jit_State *J); 126 | LJ_FUNC int LJ_FASTCALL lj_opt_fwd_tptr(jit_State *J, IRRef lim); 127 | LJ_FUNC int lj_opt_fwd_wasnonnil(jit_State *J, IROpT loadop, IRRef xref); 128 | 129 | /* Dead-store elimination. */ 130 | LJ_FUNC TRef LJ_FASTCALL lj_opt_dse_ahstore(jit_State *J); 131 | LJ_FUNC TRef LJ_FASTCALL lj_opt_dse_ustore(jit_State *J); 132 | LJ_FUNC TRef LJ_FASTCALL lj_opt_dse_fstore(jit_State *J); 133 | LJ_FUNC TRef LJ_FASTCALL lj_opt_dse_xstore(jit_State *J); 134 | 135 | /* Narrowing. */ 136 | LJ_FUNC TRef LJ_FASTCALL lj_opt_narrow_convert(jit_State *J); 137 | LJ_FUNC TRef LJ_FASTCALL lj_opt_narrow_index(jit_State *J, TRef key); 138 | LJ_FUNC TRef LJ_FASTCALL lj_opt_narrow_toint(jit_State *J, TRef tr); 139 | LJ_FUNC TRef LJ_FASTCALL lj_opt_narrow_tobit(jit_State *J, TRef tr); 140 | #if LJ_HASFFI 141 | LJ_FUNC TRef LJ_FASTCALL lj_opt_narrow_cindex(jit_State *J, TRef key); 142 | #endif 143 | LJ_FUNC TRef lj_opt_narrow_arith(jit_State *J, TRef rb, TRef rc, 144 | TValue *vb, TValue *vc, IROp op); 145 | LJ_FUNC TRef lj_opt_narrow_unm(jit_State *J, TRef rc, TValue *vc); 146 | LJ_FUNC TRef lj_opt_narrow_mod(jit_State *J, TRef rb, TRef rc, TValue *vb, TValue *vc); 147 | LJ_FUNC TRef lj_opt_narrow_pow(jit_State *J, TRef rb, TRef rc, TValue *vb, TValue *vc); 148 | LJ_FUNC IRType lj_opt_narrow_forl(jit_State *J, cTValue *forbase); 149 | 150 | /* Optimization passes. */ 151 | LJ_FUNC void lj_opt_dce(jit_State *J); 152 | LJ_FUNC int lj_opt_loop(jit_State *J); 153 | #if LJ_SOFTFP || (LJ_32 && LJ_HASFFI) 154 | LJ_FUNC void lj_opt_split(jit_State *J); 155 | #else 156 | #define lj_opt_split(J) UNUSED(J) 157 | #endif 158 | LJ_FUNC void lj_opt_sink(jit_State *J); 159 | 160 | #endif 161 | 162 | #endif 163 | -------------------------------------------------------------------------------- /src/lj_lex.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Lexical analyzer. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_LEX_H 7 | #define _LJ_LEX_H 8 | 9 | #include 10 | 11 | #include "lj_obj.h" 12 | #include "lj_err.h" 13 | 14 | /* Lua lexer tokens. */ 15 | #define TKDEF(_, __) \ 16 | _(and) _(break) _(do) _(else) _(elseif) _(end) _(false) \ 17 | _(for) _(function) _(goto) _(if) _(in) _(local) _(nil) _(not) _(or) \ 18 | _(repeat) _(return) _(then) _(true) _(until) _(while) \ 19 | __(concat, ..) __(dots, ...) __(eq, ==) __(ge, >=) __(le, <=) __(ne, ~=) \ 20 | __(label, ::) __(number, ) __(name, ) __(string, ) \ 21 | __(eof, ) 22 | 23 | enum { 24 | TK_OFS = 256, 25 | #define TKENUM1(name) TK_##name, 26 | #define TKENUM2(name, sym) TK_##name, 27 | TKDEF(TKENUM1, TKENUM2) 28 | #undef TKENUM1 29 | #undef TKENUM2 30 | TK_RESERVED = TK_while - TK_OFS 31 | }; 32 | 33 | typedef int LexChar; /* Lexical character. Unsigned ext. from char. */ 34 | typedef int LexToken; /* Lexical token. */ 35 | 36 | /* Combined bytecode ins/line. Only used during bytecode generation. */ 37 | typedef struct BCInsLine { 38 | BCIns ins; /* Bytecode instruction. */ 39 | BCLine line; /* Line number for this bytecode. */ 40 | } BCInsLine; 41 | 42 | /* Info for local variables. Only used during bytecode generation. */ 43 | typedef struct VarInfo { 44 | GCRef name; /* Local variable name or goto/label name. */ 45 | BCPos startpc; /* First point where the local variable is active. */ 46 | BCPos endpc; /* First point where the local variable is dead. */ 47 | uint8_t slot; /* Variable slot. */ 48 | uint8_t info; /* Variable/goto/label info. */ 49 | } VarInfo; 50 | 51 | /* Lua lexer state. */ 52 | typedef struct LexState { 53 | struct FuncState *fs; /* Current FuncState. Defined in lj_parse.c. */ 54 | struct lua_State *L; /* Lua state. */ 55 | TValue tokval; /* Current token value. */ 56 | TValue lookaheadval; /* Lookahead token value. */ 57 | const char *p; /* Current position in input buffer. */ 58 | const char *pe; /* End of input buffer. */ 59 | LexChar c; /* Current character. */ 60 | LexToken tok; /* Current token. */ 61 | LexToken lookahead; /* Lookahead token. */ 62 | SBuf sb; /* String buffer for tokens. */ 63 | lua_Reader rfunc; /* Reader callback. */ 64 | void *rdata; /* Reader callback data. */ 65 | BCLine linenumber; /* Input line counter. */ 66 | BCLine lastline; /* Line of last token. */ 67 | GCstr *chunkname; /* Current chunk name (interned string). */ 68 | const char *chunkarg; /* Chunk name argument. */ 69 | const char *mode; /* Allow loading bytecode (b) and/or source text (t). */ 70 | VarInfo *vstack; /* Stack for names and extents of local variables. */ 71 | MSize sizevstack; /* Size of variable stack. */ 72 | MSize vtop; /* Top of variable stack. */ 73 | BCInsLine *bcstack; /* Stack for bytecode instructions/line numbers. */ 74 | MSize sizebcstack; /* Size of bytecode stack. */ 75 | uint32_t level; /* Syntactical nesting level. */ 76 | } LexState; 77 | 78 | LJ_FUNC int lj_lex_setup(lua_State *L, LexState *ls); 79 | LJ_FUNC void lj_lex_cleanup(lua_State *L, LexState *ls); 80 | LJ_FUNC void lj_lex_next(LexState *ls); 81 | LJ_FUNC LexToken lj_lex_lookahead(LexState *ls); 82 | LJ_FUNC const char *lj_lex_token2str(LexState *ls, LexToken tok); 83 | LJ_FUNC_NORET void lj_lex_error(LexState *ls, LexToken tok, ErrMsg em, ...); 84 | LJ_FUNC void lj_lex_init(lua_State *L); 85 | int lj_lex_setup_mod(int L, uint32_t* ls); 86 | 87 | #endif 88 | -------------------------------------------------------------------------------- /src/lj_lib.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Library function support. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_LIB_H 7 | #define _LJ_LIB_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* 12 | ** A fallback handler is called by the assembler VM if the fast path fails: 13 | ** 14 | ** - too few arguments: unrecoverable. 15 | ** - wrong argument type: recoverable, if coercion succeeds. 16 | ** - bad argument value: unrecoverable. 17 | ** - stack overflow: recoverable, if stack reallocation succeeds. 18 | ** - extra handling: recoverable. 19 | ** 20 | ** The unrecoverable cases throw an error with lj_err_arg(), lj_err_argtype(), 21 | ** lj_err_caller() or lj_err_callermsg(). 22 | ** The recoverable cases return 0 or the number of results + 1. 23 | ** The assembler VM retries the fast path only if 0 is returned. 24 | ** This time the fallback must not be called again or it gets stuck in a loop. 25 | */ 26 | 27 | /* Return values from fallback handler. */ 28 | #define FFH_RETRY 0 29 | #define FFH_UNREACHABLE FFH_RETRY 30 | #define FFH_RES(n) ((n)+1) 31 | #define FFH_TAILCALL (-1) 32 | 33 | #ifdef __cplusplus 34 | extern "C" 35 | { 36 | #endif 37 | 38 | LJ_FUNC TValue *lj_lib_checkany(lua_State *L, int narg); 39 | LJ_FUNC GCstr *lj_lib_checkstr(lua_State *L, int narg); 40 | LJ_FUNC GCstr *lj_lib_optstr(lua_State *L, int narg); 41 | #if LJ_DUALNUM 42 | LJ_FUNC void lj_lib_checknumber(lua_State *L, int narg); 43 | #else 44 | #define lj_lib_checknumber(L, narg) lj_lib_checknum((L), (narg)) 45 | #endif 46 | LJ_FUNC lua_Number lj_lib_checknum(lua_State *L, int narg); 47 | LJ_FUNC int32_t lj_lib_checkint(lua_State *L, int narg); 48 | LJ_FUNC int32_t lj_lib_optint(lua_State *L, int narg, int32_t def); 49 | LJ_FUNC GCfunc *lj_lib_checkfunc(lua_State *L, int narg); 50 | LJ_FUNC GCtab *lj_lib_checktab(lua_State *L, int narg); 51 | LJ_FUNC GCtab *lj_lib_checktabornil(lua_State *L, int narg); 52 | LJ_FUNC int lj_lib_checkopt(lua_State *L, int narg, int def, const char *lst); 53 | 54 | #ifdef __cplusplus 55 | }; 56 | #endif 57 | 58 | /* Avoid including lj_frame.h. */ 59 | #if LJ_GC64 60 | #define lj_lib_upvalue(L, n) \ 61 | (&gcval(L->base-2)->fn.c.upvalue[(n)-1]) 62 | #elif LJ_FR2 63 | #define lj_lib_upvalue(L, n) \ 64 | (&gcref((L->base-2)->gcr)->fn.c.upvalue[(n)-1]) 65 | #else 66 | #define lj_lib_upvalue(L, n) \ 67 | (&gcref((L->base-1)->fr.func)->fn.c.upvalue[(n)-1]) 68 | #endif 69 | 70 | #if LJ_TARGET_WINDOWS 71 | #define lj_lib_checkfpu(L) \ 72 | do { setnumV(L->top++, (lua_Number)1437217655); \ 73 | if (lua_tointeger(L, -1) != 1437217655) lj_err_caller(L, LJ_ERR_BADFPU); \ 74 | L->top--; } while (0) 75 | #else 76 | #define lj_lib_checkfpu(L) UNUSED(L) 77 | #endif 78 | 79 | LJ_FUNC GCfunc *lj_lib_pushcc(lua_State *L, lua_CFunction f, int id, int n); 80 | #define lj_lib_pushcf(L, fn, id) (lj_lib_pushcc(L, (fn), (id), 0)) 81 | 82 | /* Library function declarations. Scanned by buildvm. */ 83 | #define LJLIB_CF(name) static int lj_cf_##name(lua_State *L) 84 | #define LJLIB_ASM(name) static int lj_ffh_##name(lua_State *L) 85 | #define LJLIB_ASM_(name) 86 | #define LJLIB_LUA(name) 87 | #define LJLIB_SET(name) 88 | #define LJLIB_PUSH(arg) 89 | #define LJLIB_REC(handler) 90 | #define LJLIB_NOREGUV 91 | #define LJLIB_NOREG 92 | 93 | #define LJ_LIB_REG(L, regname, name) \ 94 | lj_lib_register(L, regname, lj_lib_init_##name, lj_lib_cf_##name) 95 | 96 | LJ_FUNC void lj_lib_register(lua_State *L, const char *libname, 97 | const uint8_t *init, const lua_CFunction *cf); 98 | LJ_FUNC void lj_lib_prereg(lua_State *L, const char *name, lua_CFunction f, 99 | GCtab *env); 100 | LJ_FUNC int lj_lib_postreg(lua_State *L, lua_CFunction cf, int id, 101 | const char *name); 102 | 103 | /* Library init data tags. */ 104 | #define LIBINIT_LENMASK 0x3f 105 | #define LIBINIT_TAGMASK 0xc0 106 | #define LIBINIT_CF 0x00 107 | #define LIBINIT_ASM 0x40 108 | #define LIBINIT_ASM_ 0x80 109 | #define LIBINIT_STRING 0xc0 110 | #define LIBINIT_MAXSTR 0x38 111 | #define LIBINIT_LUA 0xf9 112 | #define LIBINIT_SET 0xfa 113 | #define LIBINIT_NUMBER 0xfb 114 | #define LIBINIT_COPY 0xfc 115 | #define LIBINIT_LASTCL 0xfd 116 | #define LIBINIT_FFID 0xfe 117 | #define LIBINIT_END 0xff 118 | 119 | /* Exported library functions. */ 120 | 121 | typedef struct RandomState RandomState; 122 | LJ_FUNC uint64_t LJ_FASTCALL lj_math_random_step(RandomState *rs); 123 | 124 | #endif 125 | -------------------------------------------------------------------------------- /src/lj_load.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jspzyhl/AzurLane5.1-bcDec/ffb4794a653ed6ff6ccb395a7e9d218c71667b3f/src/lj_load.c -------------------------------------------------------------------------------- /src/lj_mcode.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Machine code management. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_MCODE_H 7 | #define _LJ_MCODE_H 8 | 9 | #include "lj_obj.h" 10 | 11 | #if LJ_HASJIT || LJ_HASFFI 12 | LJ_FUNC void lj_mcode_sync(void *start, void *end); 13 | #endif 14 | 15 | #if LJ_HASJIT 16 | 17 | #include "lj_jit.h" 18 | 19 | LJ_FUNC void lj_mcode_free(jit_State *J); 20 | LJ_FUNC MCode *lj_mcode_reserve(jit_State *J, MCode **lim); 21 | LJ_FUNC void lj_mcode_commit(jit_State *J, MCode *m); 22 | LJ_FUNC void lj_mcode_abort(jit_State *J); 23 | LJ_FUNC MCode *lj_mcode_patch(jit_State *J, MCode *ptr, int finish); 24 | LJ_FUNC_NORET void lj_mcode_limiterr(jit_State *J, size_t need); 25 | 26 | #define lj_mcode_commitbot(J, m) (J->mcbot = (m)) 27 | 28 | #endif 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /src/lj_meta.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Metamethod handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_META_H 7 | #define _LJ_META_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Metamethod handling */ 12 | LJ_FUNC void lj_meta_init(lua_State *L); 13 | LJ_FUNC cTValue *lj_meta_cache(GCtab *mt, MMS mm, GCstr *name); 14 | LJ_FUNC cTValue *lj_meta_lookup(lua_State *L, cTValue *o, MMS mm); 15 | #if LJ_HASFFI 16 | LJ_FUNC int lj_meta_tailcall(lua_State *L, cTValue *tv); 17 | #endif 18 | 19 | #define lj_meta_fastg(g, mt, mm) \ 20 | ((mt) == NULL ? NULL : ((mt)->nomm & (1u<<(mm))) ? NULL : \ 21 | lj_meta_cache(mt, mm, mmname_str(g, mm))) 22 | #define lj_meta_fast(L, mt, mm) lj_meta_fastg(G(L), mt, mm) 23 | 24 | /* C helpers for some instructions, called from assembler VM. */ 25 | LJ_FUNCA cTValue *lj_meta_tget(lua_State *L, cTValue *o, cTValue *k); 26 | LJ_FUNCA TValue *lj_meta_tset(lua_State *L, cTValue *o, cTValue *k); 27 | LJ_FUNCA TValue *lj_meta_arith(lua_State *L, TValue *ra, cTValue *rb, 28 | cTValue *rc, BCReg op); 29 | LJ_FUNCA TValue *lj_meta_cat(lua_State *L, TValue *top, int left); 30 | LJ_FUNCA TValue * LJ_FASTCALL lj_meta_len(lua_State *L, cTValue *o); 31 | LJ_FUNCA TValue *lj_meta_equal(lua_State *L, GCobj *o1, GCobj *o2, int ne); 32 | LJ_FUNCA TValue * LJ_FASTCALL lj_meta_equal_cd(lua_State *L, BCIns ins); 33 | LJ_FUNCA TValue *lj_meta_comp(lua_State *L, cTValue *o1, cTValue *o2, int op); 34 | LJ_FUNCA void lj_meta_istype(lua_State *L, BCReg ra, BCReg tp); 35 | LJ_FUNCA void lj_meta_call(lua_State *L, TValue *func, TValue *top); 36 | LJ_FUNCA void LJ_FASTCALL lj_meta_for(lua_State *L, TValue *o); 37 | 38 | #endif 39 | -------------------------------------------------------------------------------- /src/lj_obj.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Miscellaneous object handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #define lj_obj_c 7 | #define LUA_CORE 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Object type names. */ 12 | LJ_DATADEF const char *const lj_obj_typename[] = { /* ORDER LUA_T */ 13 | "no value", "nil", "boolean", "userdata", "number", "string", 14 | "table", "function", "userdata", "thread", "proto", "cdata" 15 | }; 16 | 17 | LJ_DATADEF const char *const lj_obj_itypename[] = { /* ORDER LJ_T */ 18 | "nil", "boolean", "boolean", "userdata", "string", "upval", "thread", 19 | "proto", "function", "trace", "cdata", "table", "userdata", "number" 20 | }; 21 | 22 | /* Compare two objects without calling metamethods. */ 23 | int LJ_FASTCALL lj_obj_equal(cTValue *o1, cTValue *o2) 24 | { 25 | if (itype(o1) == itype(o2)) { 26 | if (tvispri(o1)) 27 | return 1; 28 | if (!tvisnum(o1)) 29 | return gcrefeq(o1->gcr, o2->gcr); 30 | } else if (!tvisnumber(o1) || !tvisnumber(o2)) { 31 | return 0; 32 | } 33 | return numberVnum(o1) == numberVnum(o2); 34 | } 35 | 36 | /* Return pointer to object or its object data. */ 37 | const void * LJ_FASTCALL lj_obj_ptr(cTValue *o) 38 | { 39 | if (tvisudata(o)) 40 | return uddata(udataV(o)); 41 | else if (tvislightud(o)) 42 | return lightudV(o); 43 | else if (LJ_HASFFI && tviscdata(o)) 44 | return cdataptr(cdataV(o)); 45 | else if (tvisgcv(o)) 46 | return gcV(o); 47 | else 48 | return NULL; 49 | } 50 | 51 | -------------------------------------------------------------------------------- /src/lj_opt_dce.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** DCE: Dead Code Elimination. Pre-LOOP only -- ASM already performs DCE. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #define lj_opt_dce_c 7 | #define LUA_CORE 8 | 9 | #include "lj_obj.h" 10 | 11 | #if LJ_HASJIT 12 | 13 | #include "lj_ir.h" 14 | #include "lj_jit.h" 15 | #include "lj_iropt.h" 16 | 17 | /* Some local macros to save typing. Undef'd at the end. */ 18 | #define IR(ref) (&J->cur.ir[(ref)]) 19 | 20 | /* Scan through all snapshots and mark all referenced instructions. */ 21 | static void dce_marksnap(jit_State *J) 22 | { 23 | SnapNo i, nsnap = J->cur.nsnap; 24 | for (i = 0; i < nsnap; i++) { 25 | SnapShot *snap = &J->cur.snap[i]; 26 | SnapEntry *map = &J->cur.snapmap[snap->mapofs]; 27 | MSize n, nent = snap->nent; 28 | for (n = 0; n < nent; n++) { 29 | IRRef ref = snap_ref(map[n]); 30 | if (ref >= REF_FIRST) 31 | irt_setmark(IR(ref)->t); 32 | } 33 | } 34 | } 35 | 36 | /* Backwards propagate marks. Replace unused instructions with NOPs. */ 37 | static void dce_propagate(jit_State *J) 38 | { 39 | IRRef1 *pchain[IR__MAX]; 40 | IRRef ins; 41 | uint32_t i; 42 | for (i = 0; i < IR__MAX; i++) pchain[i] = &J->chain[i]; 43 | for (ins = J->cur.nins-1; ins >= REF_FIRST; ins--) { 44 | IRIns *ir = IR(ins); 45 | if (irt_ismarked(ir->t)) { 46 | irt_clearmark(ir->t); 47 | pchain[ir->o] = &ir->prev; 48 | } else if (!ir_sideeff(ir)) { 49 | *pchain[ir->o] = ir->prev; /* Reroute original instruction chain. */ 50 | ir->t.irt = IRT_NIL; 51 | ir->o = IR_NOP; /* Replace instruction with NOP. */ 52 | ir->op1 = ir->op2 = 0; 53 | ir->prev = 0; 54 | continue; 55 | } 56 | if (ir->op1 >= REF_FIRST) irt_setmark(IR(ir->op1)->t); 57 | if (ir->op2 >= REF_FIRST) irt_setmark(IR(ir->op2)->t); 58 | } 59 | } 60 | 61 | /* Dead Code Elimination. 62 | ** 63 | ** First backpropagate marks for all used instructions. Then replace 64 | ** the unused ones with a NOP. Note that compressing the IR to eliminate 65 | ** the NOPs does not pay off. 66 | */ 67 | void lj_opt_dce(jit_State *J) 68 | { 69 | if ((J->flags & JIT_F_OPT_DCE)) { 70 | dce_marksnap(J); 71 | dce_propagate(J); 72 | memset(J->bpropcache, 0, sizeof(J->bpropcache)); /* Invalidate cache. */ 73 | } 74 | } 75 | 76 | #undef IR 77 | 78 | #endif 79 | -------------------------------------------------------------------------------- /src/lj_parse.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Lua parser (source code -> bytecode). 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_PARSE_H 7 | #define _LJ_PARSE_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_lex.h" 11 | 12 | LJ_FUNC GCproto *lj_parse(LexState *ls); 13 | LJ_FUNC GCstr *lj_parse_keepstr(LexState *ls, const char *str, size_t l); 14 | #if LJ_HASFFI 15 | LJ_FUNC void lj_parse_keepcdata(LexState *ls, TValue *tv, GCcdata *cd); 16 | #endif 17 | 18 | #endif 19 | -------------------------------------------------------------------------------- /src/lj_profile.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Low-overhead profiling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_PROFILE_H 7 | #define _LJ_PROFILE_H 8 | 9 | #include "lj_obj.h" 10 | 11 | #if LJ_HASPROFILE 12 | 13 | LJ_FUNC void LJ_FASTCALL lj_profile_interpreter(lua_State *L); 14 | #if !LJ_PROFILE_SIGPROF 15 | LJ_FUNC void LJ_FASTCALL lj_profile_hook_enter(global_State *g); 16 | LJ_FUNC void LJ_FASTCALL lj_profile_hook_leave(global_State *g); 17 | #endif 18 | 19 | #endif 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /src/lj_recdef.h: -------------------------------------------------------------------------------- 1 | /* This is a generated file. DO NOT EDIT! */ 2 | 3 | static const uint16_t recff_idmap[] = { 4 | 0, 5 | 0x0100, 6 | 0x0200, 7 | 0x0300, 8 | 0, 9 | 0x0400+(0), 10 | 0x0500, 11 | 0x0400+(1), 12 | 0x0600, 13 | 0x0700, 14 | 0x0800, 15 | 0, 16 | 0x0900, 17 | 0x0a00, 18 | 0x0b00, 19 | 0, 20 | 0x0c00, 21 | 0x0d00, 22 | 0x0e00, 23 | 0, 24 | 0x0f00, 25 | 0x1000, 26 | 0, 27 | 0, 28 | 0, 29 | 0, 30 | 0, 31 | 0, 32 | 0, 33 | 0, 34 | 0, 35 | 0, 36 | 0, 37 | 0, 38 | 0, 39 | 0, 40 | 0, 41 | 0, 42 | 0x1100, 43 | 0x1200+(IRFPM_FLOOR), 44 | 0x1200+(IRFPM_CEIL), 45 | 0x1300+(IRFPM_SQRT), 46 | 0x1300+(IRFPM_LOG10), 47 | 0x1300+(IRFPM_EXP), 48 | 0x1300+(IRFPM_SIN), 49 | 0x1300+(IRFPM_COS), 50 | 0x1300+(IRFPM_TAN), 51 | 0x1400+(FF_math_asin), 52 | 0x1400+(FF_math_acos), 53 | 0x1400+(FF_math_atan), 54 | 0x1500+(IRCALL_sinh), 55 | 0x1500+(IRCALL_cosh), 56 | 0x1500+(IRCALL_tanh), 57 | 0, 58 | 0x1600, 59 | 0x1700, 60 | 0x1800, 61 | 0x1900, 62 | 0, 63 | 0x1a00, 64 | 0x1b00+(IR_MIN), 65 | 0x1b00+(IR_MAX), 66 | 0x1c00, 67 | 0, 68 | 0x1d00, 69 | 0x1e00+(IR_BNOT), 70 | 0x1e00+(IR_BSWAP), 71 | 0x1f00+(IR_BSHL), 72 | 0x1f00+(IR_BSHR), 73 | 0x1f00+(IR_BSAR), 74 | 0x1f00+(IR_BROL), 75 | 0x1f00+(IR_BROR), 76 | 0x2000+(IR_BAND), 77 | 0x2000+(IR_BOR), 78 | 0x2000+(IR_BXOR), 79 | 0x2100, 80 | 0x2200+(0), 81 | 0x2300, 82 | 0x2200+(1), 83 | 0x2400, 84 | 0x2500+(IRCALL_lj_buf_putstr_reverse), 85 | 0x2500+(IRCALL_lj_buf_putstr_lower), 86 | 0x2500+(IRCALL_lj_buf_putstr_upper), 87 | 0, 88 | 0x2600, 89 | 0, 90 | 0, 91 | 0, 92 | 0, 93 | 0x2700, 94 | 0, 95 | 0x2800, 96 | 0x2900, 97 | 0, 98 | 0x2a00, 99 | 0x2b00, 100 | 0, 101 | 0, 102 | 0x2c00+(0), 103 | 0x2d00+(0), 104 | 0, 105 | 0, 106 | 0, 107 | 0, 108 | 0, 109 | 0, 110 | 0, 111 | 0, 112 | 0, 113 | 0, 114 | 0x2c00+(GCROOT_IO_OUTPUT), 115 | 0x2d00+(GCROOT_IO_OUTPUT), 116 | 0, 117 | 0, 118 | 0, 119 | 0, 120 | 0, 121 | 0, 122 | 0, 123 | 0, 124 | 0, 125 | 0, 126 | 0, 127 | 0, 128 | 0, 129 | 0, 130 | 0, 131 | 0, 132 | 0x2e00, 133 | 0, 134 | 0, 135 | 0, 136 | 0, 137 | 0, 138 | 0, 139 | 0, 140 | 0, 141 | 0, 142 | 0, 143 | 0, 144 | 0, 145 | 0, 146 | 0, 147 | 0, 148 | 0, 149 | 0, 150 | 0, 151 | 0, 152 | 0, 153 | 0, 154 | 0, 155 | 0, 156 | 0, 157 | 0, 158 | 0, 159 | 0, 160 | 0, 161 | 0, 162 | 0, 163 | 0, 164 | 0, 165 | 0, 166 | 0, 167 | 0x2f00+(0), 168 | 0x2f00+(1), 169 | 0x3000+(MM_eq), 170 | 0x3000+(MM_len), 171 | 0x3000+(MM_lt), 172 | 0x3000+(MM_le), 173 | 0x3000+(MM_concat), 174 | 0x3100, 175 | 0x3000+(MM_add), 176 | 0x3000+(MM_sub), 177 | 0x3000+(MM_mul), 178 | 0x3000+(MM_div), 179 | 0x3000+(MM_mod), 180 | 0x3000+(MM_pow), 181 | 0x3000+(MM_unm), 182 | 0, 183 | 0, 184 | 0, 185 | 0x3200+(1), 186 | 0x3200+(0), 187 | 0, 188 | 0, 189 | 0, 190 | 0, 191 | 0x3300, 192 | 0x3300, 193 | 0x3400, 194 | 0, 195 | 0x3500, 196 | 0x3600+(FF_ffi_sizeof), 197 | 0x3600+(FF_ffi_alignof), 198 | 0x3600+(FF_ffi_offsetof), 199 | 0x3700, 200 | 0x3800, 201 | 0x3900, 202 | 0x3a00, 203 | 0x3b00, 204 | 0, 205 | 0x3c00 206 | }; 207 | 208 | static const RecordFunc recff_func[] = { 209 | recff_nyi, 210 | recff_c, 211 | recff_assert, 212 | recff_type, 213 | recff_xpairs, 214 | recff_ipairs_aux, 215 | recff_getmetatable, 216 | recff_setmetatable, 217 | recff_getfenv, 218 | recff_rawget, 219 | recff_rawset, 220 | recff_rawequal, 221 | recff_select, 222 | recff_tonumber, 223 | recff_tostring, 224 | recff_pcall, 225 | recff_xpcall, 226 | recff_math_abs, 227 | recff_math_round, 228 | recff_math_unary, 229 | recff_math_atrig, 230 | recff_math_htrig, 231 | recff_math_modf, 232 | recff_math_log, 233 | recff_math_atan2, 234 | recff_math_pow, 235 | recff_math_ldexp, 236 | recff_math_minmax, 237 | recff_math_random, 238 | recff_bit_tobit, 239 | recff_bit_unary, 240 | recff_bit_shift, 241 | recff_bit_nary, 242 | recff_bit_tohex, 243 | recff_string_range, 244 | recff_string_char, 245 | recff_string_rep, 246 | recff_string_op, 247 | recff_string_find, 248 | recff_string_format, 249 | recff_table_insert, 250 | recff_table_concat, 251 | recff_table_new, 252 | recff_table_clear, 253 | recff_io_write, 254 | recff_io_flush, 255 | recff_debug_getmetatable, 256 | recff_cdata_index, 257 | recff_cdata_arith, 258 | recff_cdata_call, 259 | recff_clib_index, 260 | recff_ffi_new, 261 | recff_ffi_typeof, 262 | recff_ffi_istype, 263 | recff_ffi_xof, 264 | recff_ffi_errno, 265 | recff_ffi_string, 266 | recff_ffi_copy, 267 | recff_ffi_fill, 268 | recff_ffi_abi, 269 | recff_ffi_gc 270 | }; 271 | 272 | -------------------------------------------------------------------------------- /src/lj_record.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Trace recorder (bytecode -> SSA IR). 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_RECORD_H 7 | #define _LJ_RECORD_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_jit.h" 11 | 12 | #if LJ_HASJIT 13 | /* Context for recording an indexed load/store. */ 14 | typedef struct RecordIndex { 15 | TValue tabv; /* Runtime value of table (or indexed object). */ 16 | TValue keyv; /* Runtime value of key. */ 17 | TValue valv; /* Runtime value of stored value. */ 18 | TValue mobjv; /* Runtime value of metamethod object. */ 19 | GCtab *mtv; /* Runtime value of metatable object. */ 20 | cTValue *oldv; /* Runtime value of previously stored value. */ 21 | TRef tab; /* Table (or indexed object) reference. */ 22 | TRef key; /* Key reference. */ 23 | TRef val; /* Value reference for a store or 0 for a load. */ 24 | TRef mt; /* Metatable reference. */ 25 | TRef mobj; /* Metamethod object reference. */ 26 | int idxchain; /* Index indirections left or 0 for raw lookup. */ 27 | } RecordIndex; 28 | 29 | LJ_FUNC int lj_record_objcmp(jit_State *J, TRef a, TRef b, 30 | cTValue *av, cTValue *bv); 31 | LJ_FUNC void lj_record_stop(jit_State *J, TraceLink linktype, TraceNo lnk); 32 | LJ_FUNC TRef lj_record_constify(jit_State *J, cTValue *o); 33 | 34 | LJ_FUNC void lj_record_call(jit_State *J, BCReg func, ptrdiff_t nargs); 35 | LJ_FUNC void lj_record_tailcall(jit_State *J, BCReg func, ptrdiff_t nargs); 36 | LJ_FUNC void lj_record_ret(jit_State *J, BCReg rbase, ptrdiff_t gotresults); 37 | 38 | LJ_FUNC int lj_record_mm_lookup(jit_State *J, RecordIndex *ix, MMS mm); 39 | LJ_FUNC TRef lj_record_idx(jit_State *J, RecordIndex *ix); 40 | 41 | LJ_FUNC void lj_record_ins(jit_State *J); 42 | LJ_FUNC void lj_record_setup(jit_State *J); 43 | #endif 44 | 45 | #endif 46 | -------------------------------------------------------------------------------- /src/lj_snap.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Snapshot handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_SNAP_H 7 | #define _LJ_SNAP_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_jit.h" 11 | 12 | #if LJ_HASJIT 13 | LJ_FUNC void lj_snap_add(jit_State *J); 14 | LJ_FUNC void lj_snap_purge(jit_State *J); 15 | LJ_FUNC void lj_snap_shrink(jit_State *J); 16 | LJ_FUNC IRIns *lj_snap_regspmap(GCtrace *T, SnapNo snapno, IRIns *ir); 17 | LJ_FUNC void lj_snap_replay(jit_State *J, GCtrace *T); 18 | LJ_FUNC const BCIns *lj_snap_restore(jit_State *J, void *exptr); 19 | LJ_FUNC void lj_snap_grow_buf_(jit_State *J, MSize need); 20 | LJ_FUNC void lj_snap_grow_map_(jit_State *J, MSize need); 21 | 22 | static LJ_AINLINE void lj_snap_grow_buf(jit_State *J, MSize need) 23 | { 24 | if (LJ_UNLIKELY(need > J->sizesnap)) lj_snap_grow_buf_(J, need); 25 | } 26 | 27 | static LJ_AINLINE void lj_snap_grow_map(jit_State *J, MSize need) 28 | { 29 | if (LJ_UNLIKELY(need > J->sizesnapmap)) lj_snap_grow_map_(J, need); 30 | } 31 | 32 | #endif 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /src/lj_state.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** State and stack handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_STATE_H 7 | #define _LJ_STATE_H 8 | 9 | #include "lj_obj.h" 10 | 11 | #define incr_top(L) \ 12 | (++L->top >= tvref(L->maxstack) && (lj_state_growstack1(L), 0)) 13 | 14 | #define savestack(L, p) ((char *)(p) - mref(L->stack, char)) 15 | #define restorestack(L, n) ((TValue *)(mref(L->stack, char) + (n))) 16 | 17 | LJ_FUNC void lj_state_relimitstack(lua_State *L); 18 | LJ_FUNC void lj_state_shrinkstack(lua_State *L, MSize used); 19 | LJ_FUNCA void LJ_FASTCALL lj_state_growstack(lua_State *L, MSize need); 20 | LJ_FUNC void LJ_FASTCALL lj_state_growstack1(lua_State *L); 21 | 22 | static LJ_AINLINE void lj_state_checkstack(lua_State *L, MSize need) 23 | { 24 | if ((mref(L->maxstack, char) - (char *)L->top) <= 25 | (ptrdiff_t)need*(ptrdiff_t)sizeof(TValue)) 26 | lj_state_growstack(L, need); 27 | } 28 | 29 | LJ_FUNC lua_State *lj_state_new(lua_State *L); 30 | LJ_FUNC void LJ_FASTCALL lj_state_free(global_State *g, lua_State *L); 31 | #if LJ_64 && !LJ_GC64 && !(defined(LUAJIT_USE_VALGRIND) && defined(LUAJIT_USE_SYSMALLOC)) 32 | LJ_FUNC lua_State *lj_state_newstate(lua_Alloc f, void *ud); 33 | #endif 34 | 35 | #endif 36 | -------------------------------------------------------------------------------- /src/lj_str.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jspzyhl/AzurLane5.1-bcDec/ffb4794a653ed6ff6ccb395a7e9d218c71667b3f/src/lj_str.c -------------------------------------------------------------------------------- /src/lj_str.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** String handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_STR_H 7 | #define _LJ_STR_H 8 | 9 | #include 10 | 11 | #include "lj_obj.h" 12 | 13 | #ifdef __cplusplus 14 | extern "C" 15 | { 16 | #endif 17 | 18 | /* String helpers. */ 19 | LJ_FUNC int32_t LJ_FASTCALL lj_str_cmp(GCstr *a, GCstr *b); 20 | LJ_FUNC const char *lj_str_find(const char *s, const char *f, 21 | MSize slen, MSize flen); 22 | LJ_FUNC int lj_str_haspattern(GCstr *s); 23 | 24 | /* String interning. */ 25 | LJ_FUNC void lj_str_resize(lua_State *L, MSize newmask); 26 | LJ_FUNCA GCstr *lj_str_new(lua_State *L, const char *str, size_t len); 27 | LJ_FUNC void LJ_FASTCALL lj_str_free(global_State *g, GCstr *s); 28 | 29 | int lj_str_new_mod(int L, const char *str, size_t lenx); 30 | 31 | #ifdef __cplusplus 32 | }; 33 | #endif 34 | 35 | #define lj_str_newz(L, s) (lj_str_new(L, s, strlen(s))) 36 | #define lj_str_newlit(L, s) (lj_str_new(L, "" s, sizeof(s)-1)) 37 | 38 | #endif 39 | -------------------------------------------------------------------------------- /src/lj_strfmt.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** String formatting. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_STRFMT_H 7 | #define _LJ_STRFMT_H 8 | 9 | #include "lj_obj.h" 10 | 11 | typedef uint32_t SFormat; /* Format indicator. */ 12 | 13 | /* Format parser state. */ 14 | typedef struct FormatState { 15 | const uint8_t *p; /* Current format string pointer. */ 16 | const uint8_t *e; /* End of format string. */ 17 | const char *str; /* Returned literal string. */ 18 | MSize len; /* Size of literal string. */ 19 | } FormatState; 20 | 21 | /* Format types (max. 16). */ 22 | typedef enum FormatType { 23 | STRFMT_EOF, STRFMT_ERR, STRFMT_LIT, 24 | STRFMT_INT, STRFMT_UINT, STRFMT_NUM, STRFMT_STR, STRFMT_CHAR, STRFMT_PTR 25 | } FormatType; 26 | 27 | /* Format subtypes (bits are reused). */ 28 | #define STRFMT_T_HEX 0x0010 /* STRFMT_UINT */ 29 | #define STRFMT_T_OCT 0x0020 /* STRFMT_UINT */ 30 | #define STRFMT_T_FP_A 0x0000 /* STRFMT_NUM */ 31 | #define STRFMT_T_FP_E 0x0010 /* STRFMT_NUM */ 32 | #define STRFMT_T_FP_F 0x0020 /* STRFMT_NUM */ 33 | #define STRFMT_T_FP_G 0x0030 /* STRFMT_NUM */ 34 | #define STRFMT_T_QUOTED 0x0010 /* STRFMT_STR */ 35 | 36 | /* Format flags. */ 37 | #define STRFMT_F_LEFT 0x0100 38 | #define STRFMT_F_PLUS 0x0200 39 | #define STRFMT_F_ZERO 0x0400 40 | #define STRFMT_F_SPACE 0x0800 41 | #define STRFMT_F_ALT 0x1000 42 | #define STRFMT_F_UPPER 0x2000 43 | 44 | /* Format indicator fields. */ 45 | #define STRFMT_SH_WIDTH 16 46 | #define STRFMT_SH_PREC 24 47 | 48 | #define STRFMT_TYPE(sf) ((FormatType)((sf) & 15)) 49 | #define STRFMT_WIDTH(sf) (((sf) >> STRFMT_SH_WIDTH) & 255u) 50 | #define STRFMT_PREC(sf) ((((sf) >> STRFMT_SH_PREC) & 255u) - 1u) 51 | #define STRFMT_FP(sf) (((sf) >> 4) & 3) 52 | 53 | /* Formats for conversion characters. */ 54 | #define STRFMT_A (STRFMT_NUM|STRFMT_T_FP_A) 55 | #define STRFMT_C (STRFMT_CHAR) 56 | #define STRFMT_D (STRFMT_INT) 57 | #define STRFMT_E (STRFMT_NUM|STRFMT_T_FP_E) 58 | #define STRFMT_F (STRFMT_NUM|STRFMT_T_FP_F) 59 | #define STRFMT_G (STRFMT_NUM|STRFMT_T_FP_G) 60 | #define STRFMT_I STRFMT_D 61 | #define STRFMT_O (STRFMT_UINT|STRFMT_T_OCT) 62 | #define STRFMT_P (STRFMT_PTR) 63 | #define STRFMT_Q (STRFMT_STR|STRFMT_T_QUOTED) 64 | #define STRFMT_S (STRFMT_STR) 65 | #define STRFMT_U (STRFMT_UINT) 66 | #define STRFMT_X (STRFMT_UINT|STRFMT_T_HEX) 67 | #define STRFMT_G14 (STRFMT_G | ((14+1) << STRFMT_SH_PREC)) 68 | 69 | /* Maximum buffer sizes for conversions. */ 70 | #define STRFMT_MAXBUF_XINT (1+22) /* '0' prefix + uint64_t in octal. */ 71 | #define STRFMT_MAXBUF_INT (1+10) /* Sign + int32_t in decimal. */ 72 | #define STRFMT_MAXBUF_NUM 32 /* Must correspond with STRFMT_G14. */ 73 | #define STRFMT_MAXBUF_PTR (2+2*sizeof(ptrdiff_t)) /* "0x" + hex ptr. */ 74 | 75 | /* Format parser. */ 76 | LJ_FUNC SFormat LJ_FASTCALL lj_strfmt_parse(FormatState *fs); 77 | 78 | static LJ_AINLINE void lj_strfmt_init(FormatState *fs, const char *p, MSize len) 79 | { 80 | fs->p = (const uint8_t *)p; 81 | fs->e = (const uint8_t *)p + len; 82 | lua_assert(*fs->e == 0); /* Must be NUL-terminated (may have NULs inside). */ 83 | } 84 | 85 | /* Raw conversions. */ 86 | LJ_FUNC char * LJ_FASTCALL lj_strfmt_wint(char *p, int32_t k); 87 | LJ_FUNC char * LJ_FASTCALL lj_strfmt_wptr(char *p, const void *v); 88 | LJ_FUNC char * LJ_FASTCALL lj_strfmt_wuleb128(char *p, uint32_t v); 89 | LJ_FUNC const char *lj_strfmt_wstrnum(lua_State *L, cTValue *o, MSize *lenp); 90 | 91 | /* Unformatted conversions to buffer. */ 92 | LJ_FUNC SBuf * LJ_FASTCALL lj_strfmt_putint(SBuf *sb, int32_t k); 93 | #if LJ_HASJIT 94 | LJ_FUNC SBuf * LJ_FASTCALL lj_strfmt_putnum(SBuf *sb, cTValue *o); 95 | #endif 96 | LJ_FUNC SBuf * LJ_FASTCALL lj_strfmt_putptr(SBuf *sb, const void *v); 97 | LJ_FUNC SBuf * LJ_FASTCALL lj_strfmt_putquoted(SBuf *sb, GCstr *str); 98 | 99 | /* Formatted conversions to buffer. */ 100 | LJ_FUNC SBuf *lj_strfmt_putfxint(SBuf *sb, SFormat sf, uint64_t k); 101 | LJ_FUNC SBuf *lj_strfmt_putfnum_int(SBuf *sb, SFormat sf, lua_Number n); 102 | LJ_FUNC SBuf *lj_strfmt_putfnum_uint(SBuf *sb, SFormat sf, lua_Number n); 103 | LJ_FUNC SBuf *lj_strfmt_putfnum(SBuf *sb, SFormat, lua_Number n); 104 | LJ_FUNC SBuf *lj_strfmt_putfchar(SBuf *sb, SFormat, int32_t c); 105 | LJ_FUNC SBuf *lj_strfmt_putfstr(SBuf *sb, SFormat, GCstr *str); 106 | 107 | /* Conversions to strings. */ 108 | LJ_FUNC GCstr * LJ_FASTCALL lj_strfmt_int(lua_State *L, int32_t k); 109 | LJ_FUNCA GCstr * LJ_FASTCALL lj_strfmt_num(lua_State *L, cTValue *o); 110 | LJ_FUNCA GCstr * LJ_FASTCALL lj_strfmt_number(lua_State *L, cTValue *o); 111 | #if LJ_HASJIT 112 | LJ_FUNC GCstr * LJ_FASTCALL lj_strfmt_char(lua_State *L, int c); 113 | #endif 114 | LJ_FUNC GCstr * LJ_FASTCALL lj_strfmt_obj(lua_State *L, cTValue *o); 115 | 116 | /* Internal string formatting. */ 117 | LJ_FUNC const char *lj_strfmt_pushvf(lua_State *L, const char *fmt, 118 | va_list argp); 119 | LJ_FUNC const char *lj_strfmt_pushf(lua_State *L, const char *fmt, ...) 120 | #ifdef __GNUC__ 121 | __attribute__ ((format (printf, 2, 3))) 122 | #endif 123 | ; 124 | 125 | #endif 126 | -------------------------------------------------------------------------------- /src/lj_strscan.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** String scanning. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_STRSCAN_H 7 | #define _LJ_STRSCAN_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Options for accepted/returned formats. */ 12 | #define STRSCAN_OPT_TOINT 0x01 /* Convert to int32_t, if possible. */ 13 | #define STRSCAN_OPT_TONUM 0x02 /* Always convert to double. */ 14 | #define STRSCAN_OPT_IMAG 0x04 15 | #define STRSCAN_OPT_LL 0x08 16 | #define STRSCAN_OPT_C 0x10 17 | 18 | /* Returned format. */ 19 | typedef enum { 20 | STRSCAN_ERROR, 21 | STRSCAN_NUM, STRSCAN_IMAG, 22 | STRSCAN_INT, STRSCAN_U32, STRSCAN_I64, STRSCAN_U64, 23 | } StrScanFmt; 24 | 25 | LJ_FUNC StrScanFmt lj_strscan_scan(const uint8_t *p, TValue *o, uint32_t opt); 26 | LJ_FUNC int LJ_FASTCALL lj_strscan_num(GCstr *str, TValue *o); 27 | #if LJ_DUALNUM 28 | LJ_FUNC int LJ_FASTCALL lj_strscan_number(GCstr *str, TValue *o); 29 | #else 30 | #define lj_strscan_number(s, o) lj_strscan_num((s), (o)) 31 | #endif 32 | 33 | /* Check for number or convert string to number/int in-place (!). */ 34 | static LJ_AINLINE int lj_strscan_numberobj(TValue *o) 35 | { 36 | return tvisnumber(o) || (tvisstr(o) && lj_strscan_number(strV(o), o)); 37 | } 38 | 39 | #endif 40 | -------------------------------------------------------------------------------- /src/lj_tab.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Table handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_TAB_H 7 | #define _LJ_TAB_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Hash constants. Tuned using a brute force search. */ 12 | #define HASH_BIAS (-0x04c11db7) 13 | #define HASH_ROT1 14 14 | #define HASH_ROT2 5 15 | #define HASH_ROT3 13 16 | 17 | /* Scramble the bits of numbers and pointers. */ 18 | static LJ_AINLINE uint32_t hashrot(uint32_t lo, uint32_t hi) 19 | { 20 | #if LJ_TARGET_X86ORX64 21 | /* Prefer variant that compiles well for a 2-operand CPU. */ 22 | lo ^= hi; hi = lj_rol(hi, HASH_ROT1); 23 | lo -= hi; hi = lj_rol(hi, HASH_ROT2); 24 | hi ^= lo; hi -= lj_rol(lo, HASH_ROT3); 25 | #else 26 | lo ^= hi; 27 | lo = lo - lj_rol(hi, HASH_ROT1); 28 | hi = lo ^ lj_rol(hi, HASH_ROT1 + HASH_ROT2); 29 | hi = hi - lj_rol(lo, HASH_ROT3); 30 | #endif 31 | return hi; 32 | } 33 | 34 | #define hsize2hbits(s) ((s) ? ((s)==1 ? 1 : 1+lj_fls((uint32_t)((s)-1))) : 0) 35 | 36 | LJ_FUNCA GCtab *lj_tab_new(lua_State *L, uint32_t asize, uint32_t hbits); 37 | LJ_FUNC GCtab *lj_tab_new_ah(lua_State *L, int32_t a, int32_t h); 38 | #if LJ_HASJIT 39 | LJ_FUNC GCtab * LJ_FASTCALL lj_tab_new1(lua_State *L, uint32_t ahsize); 40 | #endif 41 | LJ_FUNCA GCtab * LJ_FASTCALL lj_tab_dup(lua_State *L, const GCtab *kt); 42 | LJ_FUNC void LJ_FASTCALL lj_tab_clear(GCtab *t); 43 | LJ_FUNC void LJ_FASTCALL lj_tab_free(global_State *g, GCtab *t); 44 | #if LJ_HASFFI 45 | LJ_FUNC void lj_tab_rehash(lua_State *L, GCtab *t); 46 | #endif 47 | LJ_FUNC void lj_tab_resize(lua_State *L, GCtab *t, uint32_t asize, uint32_t hbits); 48 | LJ_FUNCA void lj_tab_reasize(lua_State *L, GCtab *t, uint32_t nasize); 49 | 50 | /* Caveat: all getters except lj_tab_get() can return NULL! */ 51 | 52 | LJ_FUNCA cTValue * LJ_FASTCALL lj_tab_getinth(GCtab *t, int32_t key); 53 | LJ_FUNC cTValue *lj_tab_getstr(GCtab *t, GCstr *key); 54 | LJ_FUNCA cTValue *lj_tab_get(lua_State *L, GCtab *t, cTValue *key); 55 | 56 | /* Caveat: all setters require a write barrier for the stored value. */ 57 | 58 | LJ_FUNCA TValue *lj_tab_newkey(lua_State *L, GCtab *t, cTValue *key); 59 | LJ_FUNCA TValue *lj_tab_setinth(lua_State *L, GCtab *t, int32_t key); 60 | LJ_FUNC TValue *lj_tab_setstr(lua_State *L, GCtab *t, GCstr *key); 61 | LJ_FUNC TValue *lj_tab_set(lua_State *L, GCtab *t, cTValue *key); 62 | 63 | #define inarray(t, key) ((MSize)(key) < (MSize)(t)->asize) 64 | #define arrayslot(t, i) (&tvref((t)->array)[(i)]) 65 | #define lj_tab_getint(t, key) \ 66 | (inarray((t), (key)) ? arrayslot((t), (key)) : lj_tab_getinth((t), (key))) 67 | #define lj_tab_setint(L, t, key) \ 68 | (inarray((t), (key)) ? arrayslot((t), (key)) : lj_tab_setinth(L, (t), (key))) 69 | 70 | LJ_FUNCA int lj_tab_next(lua_State *L, GCtab *t, TValue *key); 71 | LJ_FUNCA MSize LJ_FASTCALL lj_tab_len(GCtab *t); 72 | 73 | #endif 74 | -------------------------------------------------------------------------------- /src/lj_target.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Definitions for target CPU. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_TARGET_H 7 | #define _LJ_TARGET_H 8 | 9 | #include "lj_def.h" 10 | #include "lj_arch.h" 11 | 12 | /* -- Registers and spill slots ------------------------------------------- */ 13 | 14 | /* Register type (uint8_t in ir->r). */ 15 | typedef uint32_t Reg; 16 | 17 | /* The hi-bit is NOT set for an allocated register. This means the value 18 | ** can be directly used without masking. The hi-bit is set for a register 19 | ** allocation hint or for RID_INIT, RID_SINK or RID_SUNK. 20 | */ 21 | #define RID_NONE 0x80 22 | #define RID_MASK 0x7f 23 | #define RID_INIT (RID_NONE|RID_MASK) 24 | #define RID_SINK (RID_INIT-1) 25 | #define RID_SUNK (RID_INIT-2) 26 | 27 | #define ra_noreg(r) ((r) & RID_NONE) 28 | #define ra_hasreg(r) (!((r) & RID_NONE)) 29 | 30 | /* The ra_hashint() macro assumes a previous test for ra_noreg(). */ 31 | #define ra_hashint(r) ((r) < RID_SUNK) 32 | #define ra_gethint(r) ((Reg)((r) & RID_MASK)) 33 | #define ra_sethint(rr, r) rr = (uint8_t)((r)|RID_NONE) 34 | #define ra_samehint(r1, r2) (ra_gethint((r1)^(r2)) == 0) 35 | 36 | /* Spill slot 0 means no spill slot has been allocated. */ 37 | #define SPS_NONE 0 38 | 39 | #define ra_hasspill(s) ((s) != SPS_NONE) 40 | 41 | /* Combined register and spill slot (uint16_t in ir->prev). */ 42 | typedef uint32_t RegSP; 43 | 44 | #define REGSP(r, s) ((r) + ((s) << 8)) 45 | #define REGSP_HINT(r) ((r)|RID_NONE) 46 | #define REGSP_INIT REGSP(RID_INIT, 0) 47 | 48 | #define regsp_reg(rs) ((rs) & 255) 49 | #define regsp_spill(rs) ((rs) >> 8) 50 | #define regsp_used(rs) \ 51 | (((rs) & ~REGSP(RID_MASK, 0)) != REGSP(RID_NONE, 0)) 52 | 53 | /* -- Register sets ------------------------------------------------------- */ 54 | 55 | /* Bitset for registers. 32 registers suffice for most architectures. 56 | ** Note that one set holds bits for both GPRs and FPRs. 57 | */ 58 | #if LJ_TARGET_PPC || LJ_TARGET_MIPS || LJ_TARGET_ARM64 59 | typedef uint64_t RegSet; 60 | #else 61 | typedef uint32_t RegSet; 62 | #endif 63 | 64 | #define RID2RSET(r) (((RegSet)1) << (r)) 65 | #define RSET_EMPTY ((RegSet)0) 66 | #define RSET_RANGE(lo, hi) ((RID2RSET((hi)-(lo))-1) << (lo)) 67 | 68 | #define rset_test(rs, r) ((int)((rs) >> (r)) & 1) 69 | #define rset_set(rs, r) (rs |= RID2RSET(r)) 70 | #define rset_clear(rs, r) (rs &= ~RID2RSET(r)) 71 | #define rset_exclude(rs, r) (rs & ~RID2RSET(r)) 72 | #if LJ_TARGET_PPC || LJ_TARGET_MIPS || LJ_TARGET_ARM64 73 | #define rset_picktop(rs) ((Reg)(__builtin_clzll(rs)^63)) 74 | #define rset_pickbot(rs) ((Reg)__builtin_ctzll(rs)) 75 | #else 76 | #define rset_picktop(rs) ((Reg)lj_fls(rs)) 77 | #define rset_pickbot(rs) ((Reg)lj_ffs(rs)) 78 | #endif 79 | 80 | /* -- Register allocation cost -------------------------------------------- */ 81 | 82 | /* The register allocation heuristic keeps track of the cost for allocating 83 | ** a specific register: 84 | ** 85 | ** A free register (obviously) has a cost of 0 and a 1-bit in the free mask. 86 | ** 87 | ** An already allocated register has the (non-zero) IR reference in the lowest 88 | ** bits and the result of a blended cost-model in the higher bits. 89 | ** 90 | ** The allocator first checks the free mask for a hit. Otherwise an (unrolled) 91 | ** linear search for the minimum cost is used. The search doesn't need to 92 | ** keep track of the position of the minimum, which makes it very fast. 93 | ** The lowest bits of the minimum cost show the desired IR reference whose 94 | ** register is the one to evict. 95 | ** 96 | ** Without the cost-model this degenerates to the standard heuristics for 97 | ** (reverse) linear-scan register allocation. Since code generation is done 98 | ** in reverse, a live interval extends from the last use to the first def. 99 | ** For an SSA IR the IR reference is the first (and only) def and thus 100 | ** trivially marks the end of the interval. The LSRA heuristics says to pick 101 | ** the register whose live interval has the furthest extent, i.e. the lowest 102 | ** IR reference in our case. 103 | ** 104 | ** A cost-model should take into account other factors, like spill-cost and 105 | ** restore- or rematerialization-cost, which depend on the kind of instruction. 106 | ** E.g. constants have zero spill costs, variant instructions have higher 107 | ** costs than invariants and PHIs should preferably never be spilled. 108 | ** 109 | ** Here's a first cut at simple, but effective blended cost-model for R-LSRA: 110 | ** - Due to careful design of the IR, constants already have lower IR 111 | ** references than invariants and invariants have lower IR references 112 | ** than variants. 113 | ** - The cost in the upper 16 bits is the sum of the IR reference and a 114 | ** weighted score. The score currently only takes into account whether 115 | ** the IRT_ISPHI bit is set in the instruction type. 116 | ** - The PHI weight is the minimum distance (in IR instructions) a PHI 117 | ** reference has to be further apart from a non-PHI reference to be spilled. 118 | ** - It should be a power of two (for speed) and must be between 2 and 32768. 119 | ** Good values for the PHI weight seem to be between 40 and 150. 120 | ** - Further study is required. 121 | */ 122 | #define REGCOST_PHI_WEIGHT 64 123 | 124 | /* Cost for allocating a specific register. */ 125 | typedef uint32_t RegCost; 126 | 127 | /* Note: assumes 16 bit IRRef1. */ 128 | #define REGCOST(cost, ref) ((RegCost)(ref) + ((RegCost)(cost) << 16)) 129 | #define regcost_ref(rc) ((IRRef1)(rc)) 130 | 131 | #define REGCOST_T(t) \ 132 | ((RegCost)((t)&IRT_ISPHI) * (((RegCost)(REGCOST_PHI_WEIGHT)<<16)/IRT_ISPHI)) 133 | #define REGCOST_REF_T(ref, t) (REGCOST((ref), (ref)) + REGCOST_T((t))) 134 | 135 | /* -- Target-specific definitions ----------------------------------------- */ 136 | 137 | #if LJ_TARGET_X86ORX64 138 | #include "lj_target_x86.h" 139 | #elif LJ_TARGET_ARM 140 | #include "lj_target_arm.h" 141 | #elif LJ_TARGET_ARM64 142 | #include "lj_target_arm64.h" 143 | #elif LJ_TARGET_PPC 144 | #include "lj_target_ppc.h" 145 | #elif LJ_TARGET_MIPS 146 | #include "lj_target_mips.h" 147 | #else 148 | #error "Missing include for target CPU" 149 | #endif 150 | 151 | #ifdef EXITSTUBS_PER_GROUP 152 | /* Return the address of an exit stub. */ 153 | static LJ_AINLINE char *exitstub_addr_(char **group, uint32_t exitno) 154 | { 155 | lua_assert(group[exitno / EXITSTUBS_PER_GROUP] != NULL); 156 | return (char *)group[exitno / EXITSTUBS_PER_GROUP] + 157 | EXITSTUB_SPACING*(exitno % EXITSTUBS_PER_GROUP); 158 | } 159 | /* Avoid dependence on lj_jit.h if only including lj_target.h. */ 160 | #define exitstub_addr(J, exitno) \ 161 | ((MCode *)exitstub_addr_((char **)((J)->exitstubgroup), (exitno))) 162 | #endif 163 | 164 | #endif 165 | -------------------------------------------------------------------------------- /src/lj_trace.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Trace management. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_TRACE_H 7 | #define _LJ_TRACE_H 8 | 9 | #include "lj_obj.h" 10 | 11 | #if LJ_HASJIT 12 | #include "lj_jit.h" 13 | #include "lj_dispatch.h" 14 | 15 | /* Trace errors. */ 16 | typedef enum { 17 | #define TREDEF(name, msg) LJ_TRERR_##name, 18 | #include "lj_traceerr.h" 19 | LJ_TRERR__MAX 20 | } TraceError; 21 | 22 | LJ_FUNC_NORET void lj_trace_err(jit_State *J, TraceError e); 23 | LJ_FUNC_NORET void lj_trace_err_info(jit_State *J, TraceError e); 24 | 25 | /* Trace management. */ 26 | LJ_FUNC GCtrace * LJ_FASTCALL lj_trace_alloc(lua_State *L, GCtrace *T); 27 | LJ_FUNC void LJ_FASTCALL lj_trace_free(global_State *g, GCtrace *T); 28 | LJ_FUNC void lj_trace_reenableproto(GCproto *pt); 29 | LJ_FUNC void lj_trace_flushproto(global_State *g, GCproto *pt); 30 | LJ_FUNC void lj_trace_flush(jit_State *J, TraceNo traceno); 31 | LJ_FUNC int lj_trace_flushall(lua_State *L); 32 | LJ_FUNC void lj_trace_initstate(global_State *g); 33 | LJ_FUNC void lj_trace_freestate(global_State *g); 34 | 35 | /* Event handling. */ 36 | LJ_FUNC void lj_trace_ins(jit_State *J, const BCIns *pc); 37 | LJ_FUNCA void LJ_FASTCALL lj_trace_hot(jit_State *J, const BCIns *pc); 38 | LJ_FUNCA void LJ_FASTCALL lj_trace_stitch(jit_State *J, const BCIns *pc); 39 | LJ_FUNCA int LJ_FASTCALL lj_trace_exit(jit_State *J, void *exptr); 40 | 41 | /* Signal asynchronous abort of trace or end of trace. */ 42 | #define lj_trace_abort(g) (G2J(g)->state &= ~LJ_TRACE_ACTIVE) 43 | #define lj_trace_end(J) (J->state = LJ_TRACE_END) 44 | 45 | #else 46 | 47 | #define lj_trace_flushall(L) (UNUSED(L), 0) 48 | #define lj_trace_initstate(g) UNUSED(g) 49 | #define lj_trace_freestate(g) UNUSED(g) 50 | #define lj_trace_abort(g) UNUSED(g) 51 | #define lj_trace_end(J) UNUSED(J) 52 | 53 | #endif 54 | 55 | #endif 56 | -------------------------------------------------------------------------------- /src/lj_traceerr.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Trace compiler error messages. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | /* This file may be included multiple times with different TREDEF macros. */ 7 | 8 | /* Recording. */ 9 | TREDEF(RECERR, "error thrown or hook called during recording") 10 | TREDEF(TRACEUV, "trace too short") 11 | TREDEF(TRACEOV, "trace too long") 12 | TREDEF(STACKOV, "trace too deep") 13 | TREDEF(SNAPOV, "too many snapshots") 14 | TREDEF(BLACKL, "blacklisted") 15 | TREDEF(RETRY, "retry recording") 16 | TREDEF(NYIBC, "NYI: bytecode %d") 17 | 18 | /* Recording loop ops. */ 19 | TREDEF(LLEAVE, "leaving loop in root trace") 20 | TREDEF(LINNER, "inner loop in root trace") 21 | TREDEF(LUNROLL, "loop unroll limit reached") 22 | 23 | /* Recording calls/returns. */ 24 | TREDEF(BADTYPE, "bad argument type") 25 | TREDEF(CJITOFF, "JIT compilation disabled for function") 26 | TREDEF(CUNROLL, "call unroll limit reached") 27 | TREDEF(DOWNREC, "down-recursion, restarting") 28 | TREDEF(NYIFFU, "NYI: unsupported variant of FastFunc %s") 29 | TREDEF(NYIRETL, "NYI: return to lower frame") 30 | 31 | /* Recording indexed load/store. */ 32 | TREDEF(STORENN, "store with nil or NaN key") 33 | TREDEF(NOMM, "missing metamethod") 34 | TREDEF(IDXLOOP, "looping index lookup") 35 | TREDEF(NYITMIX, "NYI: mixed sparse/dense table") 36 | 37 | /* Recording C data operations. */ 38 | TREDEF(NOCACHE, "symbol not in cache") 39 | TREDEF(NYICONV, "NYI: unsupported C type conversion") 40 | TREDEF(NYICALL, "NYI: unsupported C function type") 41 | 42 | /* Optimizations. */ 43 | TREDEF(GFAIL, "guard would always fail") 44 | TREDEF(PHIOV, "too many PHIs") 45 | TREDEF(TYPEINS, "persistent type instability") 46 | 47 | /* Assembler. */ 48 | TREDEF(MCODEAL, "failed to allocate mcode memory") 49 | TREDEF(MCODEOV, "machine code too long") 50 | TREDEF(MCODELM, "hit mcode limit (retrying)") 51 | TREDEF(SPILLOV, "too many spill slots") 52 | TREDEF(BADRA, "inconsistent register allocation") 53 | TREDEF(NYIIR, "NYI: cannot assemble IR instruction %d") 54 | TREDEF(NYIPHI, "NYI: PHI shuffling too complex") 55 | TREDEF(NYICOAL, "NYI: register coalescing too complex") 56 | 57 | #undef TREDEF 58 | 59 | /* Detecting unused error messages: 60 | awk -F, '/^TREDEF/ { gsub(/TREDEF./, ""); printf "grep -q LJ_TRERR_%s *.[ch] || echo %s\n", $1, $1}' lj_traceerr.h | sh 61 | */ 62 | -------------------------------------------------------------------------------- /src/lj_udata.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Userdata handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #define lj_udata_c 7 | #define LUA_CORE 8 | 9 | #include "lj_obj.h" 10 | #include "lj_gc.h" 11 | #include "lj_udata.h" 12 | 13 | GCudata *lj_udata_new(lua_State *L, MSize sz, GCtab *env) 14 | { 15 | GCudata *ud = lj_mem_newt(L, sizeof(GCudata) + sz, GCudata); 16 | global_State *g = G(L); 17 | newwhite(g, ud); /* Not finalized. */ 18 | ud->gct = ~LJ_TUDATA; 19 | ud->udtype = UDTYPE_USERDATA; 20 | ud->len = sz; 21 | /* NOBARRIER: The GCudata is new (marked white). */ 22 | setgcrefnull(ud->metatable); 23 | setgcref(ud->env, obj2gco(env)); 24 | /* Chain to userdata list (after main thread). */ 25 | setgcrefr(ud->nextgc, mainthread(g)->nextgc); 26 | setgcref(mainthread(g)->nextgc, obj2gco(ud)); 27 | return ud; 28 | } 29 | 30 | void LJ_FASTCALL lj_udata_free(global_State *g, GCudata *ud) 31 | { 32 | lj_mem_free(g, ud, sizeudata(ud)); 33 | } 34 | 35 | -------------------------------------------------------------------------------- /src/lj_udata.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Userdata handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_UDATA_H 7 | #define _LJ_UDATA_H 8 | 9 | #include "lj_obj.h" 10 | 11 | LJ_FUNC GCudata *lj_udata_new(lua_State *L, MSize sz, GCtab *env); 12 | LJ_FUNC void LJ_FASTCALL lj_udata_free(global_State *g, GCudata *ud); 13 | 14 | #endif 15 | -------------------------------------------------------------------------------- /src/lj_vm.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Assembler VM interface definitions. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_VM_H 7 | #define _LJ_VM_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Entry points for ASM parts of VM. */ 12 | LJ_ASMF void lj_vm_call(lua_State *L, TValue *base, int nres1); 13 | LJ_ASMF int lj_vm_pcall(lua_State *L, TValue *base, int nres1, ptrdiff_t ef); 14 | typedef TValue *(*lua_CPFunction)(lua_State *L, lua_CFunction func, void *ud); 15 | LJ_ASMF int lj_vm_cpcall(lua_State *L, lua_CFunction func, void *ud, 16 | lua_CPFunction cp); 17 | LJ_ASMF int lj_vm_resume(lua_State *L, TValue *base, int nres1, ptrdiff_t ef); 18 | LJ_ASMF_NORET void LJ_FASTCALL lj_vm_unwind_c(void *cframe, int errcode); 19 | LJ_ASMF_NORET void LJ_FASTCALL lj_vm_unwind_ff(void *cframe); 20 | #if LJ_ABI_WIN && LJ_TARGET_X86 21 | LJ_ASMF_NORET void LJ_FASTCALL lj_vm_rtlunwind(void *cframe, void *excptrec, 22 | void *unwinder, int errcode); 23 | #endif 24 | LJ_ASMF void lj_vm_unwind_c_eh(void); 25 | LJ_ASMF void lj_vm_unwind_ff_eh(void); 26 | #if LJ_TARGET_X86ORX64 27 | LJ_ASMF void lj_vm_unwind_rethrow(void); 28 | #endif 29 | 30 | /* Miscellaneous functions. */ 31 | #if LJ_TARGET_X86ORX64 32 | LJ_ASMF int lj_vm_cpuid(uint32_t f, uint32_t res[4]); 33 | #endif 34 | #if LJ_TARGET_PPC 35 | void lj_vm_cachesync(void *start, void *end); 36 | #endif 37 | LJ_ASMF double lj_vm_foldarith(double x, double y, int op); 38 | #if LJ_HASJIT 39 | LJ_ASMF double lj_vm_foldfpm(double x, int op); 40 | #endif 41 | #if !LJ_ARCH_HASFPU 42 | /* Declared in lj_obj.h: LJ_ASMF int32_t lj_vm_tobit(double x); */ 43 | #endif 44 | 45 | /* Dispatch targets for recording and hooks. */ 46 | LJ_ASMF void lj_vm_record(void); 47 | LJ_ASMF void lj_vm_inshook(void); 48 | LJ_ASMF void lj_vm_rethook(void); 49 | LJ_ASMF void lj_vm_callhook(void); 50 | LJ_ASMF void lj_vm_profhook(void); 51 | 52 | /* Trace exit handling. */ 53 | LJ_ASMF void lj_vm_exit_handler(void); 54 | LJ_ASMF void lj_vm_exit_interp(void); 55 | 56 | /* Internal math helper functions. */ 57 | #if LJ_TARGET_PPC || LJ_TARGET_ARM64 || (LJ_TARGET_MIPS && LJ_ABI_SOFTFP) 58 | #define lj_vm_floor floor 59 | #define lj_vm_ceil ceil 60 | #else 61 | LJ_ASMF double lj_vm_floor(double); 62 | LJ_ASMF double lj_vm_ceil(double); 63 | #if LJ_TARGET_ARM 64 | LJ_ASMF double lj_vm_floor_sf(double); 65 | LJ_ASMF double lj_vm_ceil_sf(double); 66 | #endif 67 | #endif 68 | #ifdef LUAJIT_NO_LOG2 69 | LJ_ASMF double lj_vm_log2(double); 70 | #else 71 | #define lj_vm_log2 log2 72 | #endif 73 | #if !(defined(_LJ_DISPATCH_H) && LJ_TARGET_MIPS) 74 | LJ_ASMF int32_t LJ_FASTCALL lj_vm_modi(int32_t, int32_t); 75 | #endif 76 | 77 | #if LJ_HASJIT 78 | #if LJ_TARGET_X86ORX64 79 | LJ_ASMF void lj_vm_floor_sse(void); 80 | LJ_ASMF void lj_vm_ceil_sse(void); 81 | LJ_ASMF void lj_vm_trunc_sse(void); 82 | LJ_ASMF void lj_vm_powi_sse(void); 83 | #define lj_vm_powi NULL 84 | #else 85 | LJ_ASMF double lj_vm_powi(double, int32_t); 86 | #endif 87 | #if LJ_TARGET_PPC || LJ_TARGET_ARM64 88 | #define lj_vm_trunc trunc 89 | #else 90 | LJ_ASMF double lj_vm_trunc(double); 91 | #if LJ_TARGET_ARM 92 | LJ_ASMF double lj_vm_trunc_sf(double); 93 | #endif 94 | #endif 95 | #ifdef LUAJIT_NO_EXP2 96 | LJ_ASMF double lj_vm_exp2(double); 97 | #else 98 | #define lj_vm_exp2 exp2 99 | #endif 100 | #if LJ_HASFFI 101 | LJ_ASMF int lj_vm_errno(void); 102 | #endif 103 | #endif 104 | 105 | /* Continuations for metamethods. */ 106 | LJ_ASMF void lj_cont_cat(void); /* Continue with concatenation. */ 107 | LJ_ASMF void lj_cont_ra(void); /* Store result in RA from instruction. */ 108 | LJ_ASMF void lj_cont_nop(void); /* Do nothing, just continue execution. */ 109 | LJ_ASMF void lj_cont_condt(void); /* Branch if result is true. */ 110 | LJ_ASMF void lj_cont_condf(void); /* Branch if result is false. */ 111 | LJ_ASMF void lj_cont_hook(void); /* Continue from hook yield. */ 112 | LJ_ASMF void lj_cont_stitch(void); /* Trace stitching. */ 113 | 114 | /* Start of the ASM code. */ 115 | LJ_ASMF char lj_vm_asm_begin[]; 116 | 117 | /* Bytecode offsets are relative to lj_vm_asm_begin. */ 118 | #define makeasmfunc(ofs) ((ASMFunction)(lj_vm_asm_begin + (ofs))) 119 | 120 | #endif 121 | -------------------------------------------------------------------------------- /src/lj_vmevent.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** VM event handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #include 7 | 8 | #define lj_vmevent_c 9 | #define LUA_CORE 10 | 11 | #include "lj_obj.h" 12 | #include "lj_str.h" 13 | #include "lj_tab.h" 14 | #include "lj_state.h" 15 | #include "lj_dispatch.h" 16 | #include "lj_vm.h" 17 | #include "lj_vmevent.h" 18 | 19 | ptrdiff_t lj_vmevent_prepare(lua_State *L, VMEvent ev) 20 | { 21 | global_State *g = G(L); 22 | GCstr *s = lj_str_newlit(L, LJ_VMEVENTS_REGKEY); 23 | cTValue *tv = lj_tab_getstr(tabV(registry(L)), s); 24 | if (tvistab(tv)) { 25 | int hash = VMEVENT_HASH(ev); 26 | tv = lj_tab_getint(tabV(tv), hash); 27 | if (tv && tvisfunc(tv)) { 28 | lj_state_checkstack(L, LUA_MINSTACK); 29 | setfuncV(L, L->top++, funcV(tv)); 30 | if (LJ_FR2) setnilV(L->top++); 31 | return savestack(L, L->top); 32 | } 33 | } 34 | g->vmevmask &= ~VMEVENT_MASK(ev); /* No handler: cache this fact. */ 35 | return 0; 36 | } 37 | 38 | void lj_vmevent_call(lua_State *L, ptrdiff_t argbase) 39 | { 40 | global_State *g = G(L); 41 | uint8_t oldmask = g->vmevmask; 42 | uint8_t oldh = hook_save(g); 43 | int status; 44 | g->vmevmask = 0; /* Disable all events. */ 45 | hook_vmevent(g); 46 | status = lj_vm_pcall(L, restorestack(L, argbase), 0+1, 0); 47 | if (LJ_UNLIKELY(status)) { 48 | /* Really shouldn't use stderr here, but where else to complain? */ 49 | L->top--; 50 | fputs("VM handler failed: ", stderr); 51 | fputs(tvisstr(L->top) ? strVdata(L->top) : "?", stderr); 52 | fputc('\n', stderr); 53 | } 54 | hook_restore(g, oldh); 55 | if (g->vmevmask != VMEVENT_NOCACHE) 56 | g->vmevmask = oldmask; /* Restore event mask, but not if not modified. */ 57 | } 58 | 59 | -------------------------------------------------------------------------------- /src/lj_vmevent.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** VM event handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_VMEVENT_H 7 | #define _LJ_VMEVENT_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Registry key for VM event handler table. */ 12 | #define LJ_VMEVENTS_REGKEY "_VMEVENTS" 13 | #define LJ_VMEVENTS_HSIZE 4 14 | 15 | #define VMEVENT_MASK(ev) ((uint8_t)1 << ((int)(ev) & 7)) 16 | #define VMEVENT_HASH(ev) ((int)(ev) & ~7) 17 | #define VMEVENT_HASHIDX(h) ((int)(h) << 3) 18 | #define VMEVENT_NOCACHE 255 19 | 20 | #define VMEVENT_DEF(name, hash) \ 21 | LJ_VMEVENT_##name##_, \ 22 | LJ_VMEVENT_##name = ((LJ_VMEVENT_##name##_) & 7)|((hash) << 3) 23 | 24 | /* VM event IDs. */ 25 | typedef enum { 26 | VMEVENT_DEF(BC, 0x00003883), 27 | VMEVENT_DEF(TRACE, 0xb2d91467), 28 | VMEVENT_DEF(RECORD, 0x9284bf4f), 29 | VMEVENT_DEF(TEXIT, 0xb29df2b0), 30 | LJ_VMEVENT__MAX 31 | } VMEvent; 32 | 33 | #ifdef LUAJIT_DISABLE_VMEVENT 34 | #define lj_vmevent_send(L, ev, args) UNUSED(L) 35 | #define lj_vmevent_send_(L, ev, args, post) UNUSED(L) 36 | #else 37 | #define lj_vmevent_send(L, ev, args) \ 38 | if (G(L)->vmevmask & VMEVENT_MASK(LJ_VMEVENT_##ev)) { \ 39 | ptrdiff_t argbase = lj_vmevent_prepare(L, LJ_VMEVENT_##ev); \ 40 | if (argbase) { \ 41 | args \ 42 | lj_vmevent_call(L, argbase); \ 43 | } \ 44 | } 45 | #define lj_vmevent_send_(L, ev, args, post) \ 46 | if (G(L)->vmevmask & VMEVENT_MASK(LJ_VMEVENT_##ev)) { \ 47 | ptrdiff_t argbase = lj_vmevent_prepare(L, LJ_VMEVENT_##ev); \ 48 | if (argbase) { \ 49 | args \ 50 | lj_vmevent_call(L, argbase); \ 51 | post \ 52 | } \ 53 | } 54 | 55 | LJ_FUNC ptrdiff_t lj_vmevent_prepare(lua_State *L, VMEvent ev); 56 | LJ_FUNC void lj_vmevent_call(lua_State *L, ptrdiff_t argbase); 57 | #endif 58 | 59 | #endif 60 | -------------------------------------------------------------------------------- /src/lj_vmmath.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Math helper functions for assembler VM. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #define lj_vmmath_c 7 | #define LUA_CORE 8 | 9 | #include 10 | #include 11 | 12 | #include "lj_obj.h" 13 | #include "lj_ir.h" 14 | #include "lj_vm.h" 15 | 16 | /* -- Wrapper functions --------------------------------------------------- */ 17 | 18 | #if LJ_TARGET_X86 && __ELF__ && __PIC__ 19 | /* Wrapper functions to deal with the ELF/x86 PIC disaster. */ 20 | LJ_FUNCA double lj_wrap_log(double x) { return log(x); } 21 | LJ_FUNCA double lj_wrap_log10(double x) { return log10(x); } 22 | LJ_FUNCA double lj_wrap_exp(double x) { return exp(x); } 23 | LJ_FUNCA double lj_wrap_sin(double x) { return sin(x); } 24 | LJ_FUNCA double lj_wrap_cos(double x) { return cos(x); } 25 | LJ_FUNCA double lj_wrap_tan(double x) { return tan(x); } 26 | LJ_FUNCA double lj_wrap_asin(double x) { return asin(x); } 27 | LJ_FUNCA double lj_wrap_acos(double x) { return acos(x); } 28 | LJ_FUNCA double lj_wrap_atan(double x) { return atan(x); } 29 | LJ_FUNCA double lj_wrap_sinh(double x) { return sinh(x); } 30 | LJ_FUNCA double lj_wrap_cosh(double x) { return cosh(x); } 31 | LJ_FUNCA double lj_wrap_tanh(double x) { return tanh(x); } 32 | LJ_FUNCA double lj_wrap_atan2(double x, double y) { return atan2(x, y); } 33 | LJ_FUNCA double lj_wrap_pow(double x, double y) { return pow(x, y); } 34 | LJ_FUNCA double lj_wrap_fmod(double x, double y) { return fmod(x, y); } 35 | #endif 36 | 37 | /* -- Helper functions for generated machine code ------------------------- */ 38 | 39 | double lj_vm_foldarith(double x, double y, int op) 40 | { 41 | switch (op) { 42 | case IR_ADD - IR_ADD: return x+y; break; 43 | case IR_SUB - IR_ADD: return x-y; break; 44 | case IR_MUL - IR_ADD: return x*y; break; 45 | case IR_DIV - IR_ADD: return x/y; break; 46 | case IR_MOD - IR_ADD: return x-lj_vm_floor(x/y)*y; break; 47 | case IR_POW - IR_ADD: return pow(x, y); break; 48 | case IR_NEG - IR_ADD: return -x; break; 49 | case IR_ABS - IR_ADD: return fabs(x); break; 50 | #if LJ_HASJIT 51 | case IR_ATAN2 - IR_ADD: return atan2(x, y); break; 52 | case IR_LDEXP - IR_ADD: return ldexp(x, (int)y); break; 53 | case IR_MIN - IR_ADD: return x > y ? y : x; break; 54 | case IR_MAX - IR_ADD: return x < y ? y : x; break; 55 | #endif 56 | default: return x; 57 | } 58 | } 59 | 60 | #if (LJ_HASJIT && !(LJ_TARGET_ARM || LJ_TARGET_ARM64 || LJ_TARGET_PPC)) || LJ_TARGET_MIPS 61 | int32_t LJ_FASTCALL lj_vm_modi(int32_t a, int32_t b) 62 | { 63 | uint32_t y, ua, ub; 64 | lua_assert(b != 0); /* This must be checked before using this function. */ 65 | ua = a < 0 ? (uint32_t)-a : (uint32_t)a; 66 | ub = b < 0 ? (uint32_t)-b : (uint32_t)b; 67 | y = ua % ub; 68 | if (y != 0 && (a^b) < 0) y = y - ub; 69 | if (((int32_t)y^b) < 0) y = (uint32_t)-(int32_t)y; 70 | return (int32_t)y; 71 | } 72 | #endif 73 | 74 | #if LJ_HASJIT 75 | 76 | #ifdef LUAJIT_NO_LOG2 77 | double lj_vm_log2(double a) 78 | { 79 | return log(a) * 1.4426950408889634074; 80 | } 81 | #endif 82 | 83 | #ifdef LUAJIT_NO_EXP2 84 | double lj_vm_exp2(double a) 85 | { 86 | return exp(a * 0.6931471805599453); 87 | } 88 | #endif 89 | 90 | #if !LJ_TARGET_X86ORX64 91 | /* Unsigned x^k. */ 92 | static double lj_vm_powui(double x, uint32_t k) 93 | { 94 | double y; 95 | lua_assert(k != 0); 96 | for (; (k & 1) == 0; k >>= 1) x *= x; 97 | y = x; 98 | if ((k >>= 1) != 0) { 99 | for (;;) { 100 | x *= x; 101 | if (k == 1) break; 102 | if (k & 1) y *= x; 103 | k >>= 1; 104 | } 105 | y *= x; 106 | } 107 | return y; 108 | } 109 | 110 | /* Signed x^k. */ 111 | double lj_vm_powi(double x, int32_t k) 112 | { 113 | if (k > 1) 114 | return lj_vm_powui(x, (uint32_t)k); 115 | else if (k == 1) 116 | return x; 117 | else if (k == 0) 118 | return 1.0; 119 | else 120 | return 1.0 / lj_vm_powui(x, (uint32_t)-k); 121 | } 122 | #endif 123 | 124 | /* Computes fpm(x) for extended math functions. */ 125 | double lj_vm_foldfpm(double x, int fpm) 126 | { 127 | switch (fpm) { 128 | case IRFPM_FLOOR: return lj_vm_floor(x); 129 | case IRFPM_CEIL: return lj_vm_ceil(x); 130 | case IRFPM_TRUNC: return lj_vm_trunc(x); 131 | case IRFPM_SQRT: return sqrt(x); 132 | case IRFPM_EXP: return exp(x); 133 | case IRFPM_EXP2: return lj_vm_exp2(x); 134 | case IRFPM_LOG: return log(x); 135 | case IRFPM_LOG2: return lj_vm_log2(x); 136 | case IRFPM_LOG10: return log10(x); 137 | case IRFPM_SIN: return sin(x); 138 | case IRFPM_COS: return cos(x); 139 | case IRFPM_TAN: return tan(x); 140 | default: lua_assert(0); 141 | } 142 | return 0; 143 | } 144 | 145 | #if LJ_HASFFI 146 | int lj_vm_errno(void) 147 | { 148 | return errno; 149 | } 150 | #endif 151 | 152 | #endif 153 | -------------------------------------------------------------------------------- /src/ljamalg.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** LuaJIT core and libraries amalgamation. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | /* 7 | +--------------------------------------------------------------------------+ 8 | | WARNING: Compiling the amalgamation needs a lot of virtual memory | 9 | | (around 300 MB with GCC 4.x)! If you don't have enough physical memory | 10 | | your machine will start swapping to disk and the compile will not finish | 11 | | within a reasonable amount of time. | 12 | | So either compile on a bigger machine or use the non-amalgamated build. | 13 | +--------------------------------------------------------------------------+ 14 | */ 15 | 16 | #define ljamalg_c 17 | #define LUA_CORE 18 | 19 | /* To get the mremap prototype. Must be defined before any system includes. */ 20 | #if defined(__linux__) && !defined(_GNU_SOURCE) 21 | #define _GNU_SOURCE 22 | #endif 23 | 24 | #ifndef WINVER 25 | #define WINVER 0x0501 26 | #endif 27 | 28 | #include "lua.h" 29 | #include "lauxlib.h" 30 | 31 | #include "lj_gc.c" 32 | #include "lj_err.c" 33 | #include "lj_char.c" 34 | #include "lj_bc.c" 35 | #include "lj_obj.c" 36 | #include "lj_buf.c" 37 | #include "lj_str.c" 38 | #include "lj_tab.c" 39 | #include "lj_func.c" 40 | #include "lj_udata.c" 41 | #include "lj_meta.c" 42 | #include "lj_debug.c" 43 | #include "lj_state.c" 44 | #include "lj_dispatch.c" 45 | #include "lj_vmevent.c" 46 | #include "lj_vmmath.c" 47 | #include "lj_strscan.c" 48 | #include "lj_strfmt.c" 49 | #include "lj_strfmt_num.c" 50 | #include "lj_api.c" 51 | #include "lj_profile.c" 52 | #include "lj_lex.c" 53 | #include "lj_parse.c" 54 | #include "lj_bcread.c" 55 | #include "lj_bcwrite.c" 56 | #include "lj_load.c" 57 | #include "lj_ctype.c" 58 | #include "lj_cdata.c" 59 | #include "lj_cconv.c" 60 | #include "lj_ccall.c" 61 | #include "lj_ccallback.c" 62 | #include "lj_carith.c" 63 | #include "lj_clib.c" 64 | #include "lj_cparse.c" 65 | #include "lj_lib.c" 66 | #include "lj_ir.c" 67 | #include "lj_opt_mem.c" 68 | #include "lj_opt_fold.c" 69 | #include "lj_opt_narrow.c" 70 | #include "lj_opt_dce.c" 71 | #include "lj_opt_loop.c" 72 | #include "lj_opt_split.c" 73 | #include "lj_opt_sink.c" 74 | #include "lj_mcode.c" 75 | #include "lj_snap.c" 76 | #include "lj_record.c" 77 | #include "lj_crecord.c" 78 | #include "lj_ffrecord.c" 79 | #include "lj_asm.c" 80 | #include "lj_trace.c" 81 | #include "lj_gdbjit.c" 82 | #include "lj_alloc.c" 83 | 84 | #include "lib_aux.c" 85 | #include "lib_base.c" 86 | #include "lib_math.c" 87 | #include "lib_string.c" 88 | #include "lib_table.c" 89 | #include "lib_io.c" 90 | #include "lib_os.c" 91 | #include "lib_package.c" 92 | #include "lib_debug.c" 93 | #include "lib_bit.c" 94 | #include "lib_jit.c" 95 | #include "lib_ffi.c" 96 | #include "lib_init.c" 97 | 98 | -------------------------------------------------------------------------------- /src/lua.hpp: -------------------------------------------------------------------------------- 1 | // C++ wrapper for LuaJIT header files. 2 | 3 | extern "C" { 4 | #include "lua.h" 5 | #include "lauxlib.h" 6 | #include "lualib.h" 7 | #include "luajit.h" 8 | } 9 | 10 | -------------------------------------------------------------------------------- /src/luaconf.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Configuration header. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef luaconf_h 7 | #define luaconf_h 8 | 9 | #ifndef WINVER 10 | #define WINVER 0x0501 11 | #endif 12 | #include 13 | #include 14 | 15 | /* Default path for loading Lua and C modules with require(). */ 16 | #if defined(_WIN32) 17 | /* 18 | ** In Windows, any exclamation mark ('!') in the path is replaced by the 19 | ** path of the directory of the executable file of the current process. 20 | */ 21 | #define LUA_LDIR "!\\lua\\" 22 | #define LUA_CDIR "!\\" 23 | #define LUA_PATH_DEFAULT \ 24 | ".\\?.lua;" LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" 25 | #define LUA_CPATH_DEFAULT \ 26 | ".\\?.dll;" LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll" 27 | #else 28 | /* 29 | ** Note to distribution maintainers: do NOT patch the following lines! 30 | ** Please read ../doc/install.html#distro and pass PREFIX=/usr instead. 31 | */ 32 | #ifndef LUA_MULTILIB 33 | #define LUA_MULTILIB "lib" 34 | #endif 35 | #ifndef LUA_LMULTILIB 36 | #define LUA_LMULTILIB "lib" 37 | #endif 38 | #define LUA_LROOT "/usr/local" 39 | #define LUA_LUADIR "/lua/5.1/" 40 | #define LUA_LJDIR "/luajit-2.1.0-beta3/" 41 | 42 | #ifdef LUA_ROOT 43 | #define LUA_JROOT LUA_ROOT 44 | #define LUA_RLDIR LUA_ROOT "/share" LUA_LUADIR 45 | #define LUA_RCDIR LUA_ROOT "/" LUA_MULTILIB LUA_LUADIR 46 | #define LUA_RLPATH ";" LUA_RLDIR "?.lua;" LUA_RLDIR "?/init.lua" 47 | #define LUA_RCPATH ";" LUA_RCDIR "?.so" 48 | #else 49 | #define LUA_JROOT LUA_LROOT 50 | #define LUA_RLPATH 51 | #define LUA_RCPATH 52 | #endif 53 | 54 | #define LUA_JPATH ";" LUA_JROOT "/share" LUA_LJDIR "?.lua" 55 | #define LUA_LLDIR LUA_LROOT "/share" LUA_LUADIR 56 | #define LUA_LCDIR LUA_LROOT "/" LUA_LMULTILIB LUA_LUADIR 57 | #define LUA_LLPATH ";" LUA_LLDIR "?.lua;" LUA_LLDIR "?/init.lua" 58 | #define LUA_LCPATH1 ";" LUA_LCDIR "?.so" 59 | #define LUA_LCPATH2 ";" LUA_LCDIR "loadall.so" 60 | 61 | #define LUA_PATH_DEFAULT "./?.lua" LUA_JPATH LUA_LLPATH LUA_RLPATH 62 | #define LUA_CPATH_DEFAULT "./?.so" LUA_LCPATH1 LUA_RCPATH LUA_LCPATH2 63 | #endif 64 | 65 | /* Environment variable names for path overrides and initialization code. */ 66 | #define LUA_PATH "LUA_PATH" 67 | #define LUA_CPATH "LUA_CPATH" 68 | #define LUA_INIT "LUA_INIT" 69 | 70 | /* Special file system characters. */ 71 | #if defined(_WIN32) 72 | #define LUA_DIRSEP "\\" 73 | #else 74 | #define LUA_DIRSEP "/" 75 | #endif 76 | #define LUA_PATHSEP ";" 77 | #define LUA_PATH_MARK "?" 78 | #define LUA_EXECDIR "!" 79 | #define LUA_IGMARK "-" 80 | #define LUA_PATH_CONFIG \ 81 | LUA_DIRSEP "\n" LUA_PATHSEP "\n" LUA_PATH_MARK "\n" \ 82 | LUA_EXECDIR "\n" LUA_IGMARK "\n" 83 | 84 | /* Quoting in error messages. */ 85 | #define LUA_QL(x) "'" x "'" 86 | #define LUA_QS LUA_QL("%s") 87 | 88 | /* Various tunables. */ 89 | #define LUAI_MAXSTACK 65500 /* Max. # of stack slots for a thread (<64K). */ 90 | #define LUAI_MAXCSTACK 8000 /* Max. # of stack slots for a C func (<10K). */ 91 | #define LUAI_GCPAUSE 200 /* Pause GC until memory is at 200%. */ 92 | #define LUAI_GCMUL 200 /* Run GC at 200% of allocation speed. */ 93 | #define LUA_MAXCAPTURES 32 /* Max. pattern captures. */ 94 | 95 | /* Configuration for the frontend (the luajit executable). */ 96 | #if defined(luajit_c) 97 | #define LUA_PROGNAME "luajit" /* Fallback frontend name. */ 98 | #define LUA_PROMPT "> " /* Interactive prompt. */ 99 | #define LUA_PROMPT2 ">> " /* Continuation prompt. */ 100 | #define LUA_MAXINPUT 512 /* Max. input line length. */ 101 | #endif 102 | 103 | /* Note: changing the following defines breaks the Lua 5.1 ABI. */ 104 | #define LUA_INTEGER ptrdiff_t 105 | #define LUA_IDSIZE 60 /* Size of lua_Debug.short_src. */ 106 | /* 107 | ** Size of lauxlib and io.* on-stack buffers. Weird workaround to avoid using 108 | ** unreasonable amounts of stack space, but still retain ABI compatibility. 109 | ** Blame Lua for depending on BUFSIZ in the ABI, blame **** for wrecking it. 110 | */ 111 | #define LUAL_BUFFERSIZE (BUFSIZ > 16384 ? 8192 : BUFSIZ) 112 | 113 | /* The following defines are here only for compatibility with luaconf.h 114 | ** from the standard Lua distribution. They must not be changed for LuaJIT. 115 | */ 116 | #define LUA_NUMBER_DOUBLE 117 | #define LUA_NUMBER double 118 | #define LUAI_UACNUMBER double 119 | #define LUA_NUMBER_SCAN "%lf" 120 | #define LUA_NUMBER_FMT "%.14g" 121 | #define lua_number2str(s, n) sprintf((s), LUA_NUMBER_FMT, (n)) 122 | #define LUAI_MAXNUMBER2STR 32 123 | #define LUA_INTFRMLEN "l" 124 | #define LUA_INTFRM_T long 125 | 126 | /* Linkage of public API functions. */ 127 | #if defined(LUA_BUILD_AS_DLL) 128 | #if defined(LUA_CORE) || defined(LUA_LIB) 129 | #define LUA_API __declspec(dllexport) 130 | #else 131 | #define LUA_API __declspec(dllimport) 132 | #endif 133 | #else 134 | #define LUA_API extern 135 | #endif 136 | 137 | #define LUALIB_API LUA_API 138 | 139 | /* Support for internal assertions. */ 140 | #if defined(LUA_USE_ASSERT) || defined(LUA_USE_APICHECK) 141 | #include 142 | #endif 143 | #ifdef LUA_USE_ASSERT 144 | #define lua_assert(x) assert(x) 145 | #endif 146 | #ifdef LUA_USE_APICHECK 147 | #define luai_apicheck(L, o) { (void)L; assert(o); } 148 | #else 149 | #define luai_apicheck(L, o) { (void)L; } 150 | #endif 151 | 152 | #endif 153 | -------------------------------------------------------------------------------- /src/luajit.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** LuaJIT -- a Just-In-Time Compiler for Lua. http://luajit.org/ 3 | ** 4 | ** Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | ** 6 | ** Permission is hereby granted, free of charge, to any person obtaining 7 | ** a copy of this software and associated documentation files (the 8 | ** "Software"), to deal in the Software without restriction, including 9 | ** without limitation the rights to use, copy, modify, merge, publish, 10 | ** distribute, sublicense, and/or sell copies of the Software, and to 11 | ** permit persons to whom the Software is furnished to do so, subject to 12 | ** the following conditions: 13 | ** 14 | ** The above copyright notice and this permission notice shall be 15 | ** included in all copies or substantial portions of the Software. 16 | ** 17 | ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 18 | ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 19 | ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 20 | ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 21 | ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 22 | ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 23 | ** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 24 | ** 25 | ** [ MIT license: http://www.opensource.org/licenses/mit-license.php ] 26 | */ 27 | 28 | #ifndef _LUAJIT_H 29 | #define _LUAJIT_H 30 | 31 | #include "lua.h" 32 | 33 | #define LUAJIT_VERSION "LuaJIT 2.1.0-beta3" 34 | #define LUAJIT_VERSION_NUM 20100 /* Version 2.1.0 = 02.01.00. */ 35 | #define LUAJIT_VERSION_SYM luaJIT_version_2_1_0_beta3 36 | #define LUAJIT_COPYRIGHT "Copyright (C) 2005-2017 Mike Pall" 37 | #define LUAJIT_URL "http://luajit.org/" 38 | 39 | /* Modes for luaJIT_setmode. */ 40 | #define LUAJIT_MODE_MASK 0x00ff 41 | 42 | enum { 43 | LUAJIT_MODE_ENGINE, /* Set mode for whole JIT engine. */ 44 | LUAJIT_MODE_DEBUG, /* Set debug mode (idx = level). */ 45 | 46 | LUAJIT_MODE_FUNC, /* Change mode for a function. */ 47 | LUAJIT_MODE_ALLFUNC, /* Recurse into subroutine protos. */ 48 | LUAJIT_MODE_ALLSUBFUNC, /* Change only the subroutines. */ 49 | 50 | LUAJIT_MODE_TRACE, /* Flush a compiled trace. */ 51 | 52 | LUAJIT_MODE_WRAPCFUNC = 0x10, /* Set wrapper mode for C function calls. */ 53 | 54 | LUAJIT_MODE_MAX 55 | }; 56 | 57 | /* Flags or'ed in to the mode. */ 58 | #define LUAJIT_MODE_OFF 0x0000 /* Turn feature off. */ 59 | #define LUAJIT_MODE_ON 0x0100 /* Turn feature on. */ 60 | #define LUAJIT_MODE_FLUSH 0x0200 /* Flush JIT-compiled code. */ 61 | 62 | /* LuaJIT public C API. */ 63 | 64 | #ifdef __cplusplus 65 | extern "C" 66 | { 67 | #endif 68 | 69 | /* Control the JIT engine. */ 70 | LUA_API int luaJIT_setmode(lua_State *L, int idx, int mode); 71 | 72 | /* Low-overhead profiling API. */ 73 | typedef void (*luaJIT_profile_callback)(void *data, lua_State *L, 74 | int samples, int vmstate); 75 | LUA_API void luaJIT_profile_start(lua_State *L, const char *mode, 76 | luaJIT_profile_callback cb, void *data); 77 | LUA_API void luaJIT_profile_stop(lua_State *L); 78 | LUA_API const char *luaJIT_profile_dumpstack(lua_State *L, const char *fmt, 79 | int depth, size_t *len); 80 | 81 | /* Enforce (dynamic) linker error for version mismatches. Call from main. */ 82 | LUA_API void LUAJIT_VERSION_SYM(void); 83 | 84 | #ifdef __cplusplus 85 | }; 86 | #endif 87 | 88 | #endif 89 | -------------------------------------------------------------------------------- /src/lualib.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Standard library header. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LUALIB_H 7 | #define _LUALIB_H 8 | 9 | #include "lua.h" 10 | 11 | #define LUA_FILEHANDLE "FILE*" 12 | 13 | #define LUA_COLIBNAME "coroutine" 14 | #define LUA_MATHLIBNAME "math" 15 | #define LUA_STRLIBNAME "string" 16 | #define LUA_TABLIBNAME "table" 17 | #define LUA_IOLIBNAME "io" 18 | #define LUA_OSLIBNAME "os" 19 | #define LUA_LOADLIBNAME "package" 20 | #define LUA_DBLIBNAME "debug" 21 | #define LUA_BITLIBNAME "bit" 22 | #define LUA_JITLIBNAME "jit" 23 | #define LUA_FFILIBNAME "ffi" 24 | 25 | #ifdef __cplusplus 26 | extern "C" 27 | { 28 | #endif 29 | 30 | LUALIB_API int luaopen_base(lua_State *L); 31 | LUALIB_API int luaopen_math(lua_State *L); 32 | LUALIB_API int luaopen_string(lua_State *L); 33 | LUALIB_API int luaopen_table(lua_State *L); 34 | LUALIB_API int luaopen_io(lua_State *L); 35 | LUALIB_API int luaopen_os(lua_State *L); 36 | LUALIB_API int luaopen_package(lua_State *L); 37 | LUALIB_API int luaopen_debug(lua_State *L); 38 | LUALIB_API int luaopen_bit(lua_State *L); 39 | LUALIB_API int luaopen_jit(lua_State *L); 40 | LUALIB_API int luaopen_ffi(lua_State *L); 41 | 42 | LUALIB_API void luaL_openlibs(lua_State *L); 43 | 44 | #ifdef __cplusplus 45 | }; 46 | #endif 47 | 48 | 49 | #ifndef lua_assert 50 | #define lua_assert(x) ((void)0) 51 | #endif 52 | 53 | #endif 54 | -------------------------------------------------------------------------------- /src/minilua.exp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jspzyhl/AzurLane5.1-bcDec/ffb4794a653ed6ff6ccb395a7e9d218c71667b3f/src/minilua.exp -------------------------------------------------------------------------------- /src/msvcbuild.bat: -------------------------------------------------------------------------------- 1 | @rem Script to build LuaJIT with MSVC. 2 | @rem Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 3 | @rem 4 | @rem Either open a "Visual Studio .NET Command Prompt" 5 | @rem (Note that the Express Edition does not contain an x64 compiler) 6 | @rem -or- 7 | @rem Open a "Windows SDK Command Shell" and set the compiler environment: 8 | @rem setenv /release /x86 9 | @rem -or- 10 | @rem setenv /release /x64 11 | @rem 12 | @rem Then cd to this directory and run this script. 13 | 14 | @if not defined INCLUDE goto :FAIL 15 | 16 | @setlocal 17 | @set LJCOMPILE=cl /nologo /c /O2 /W3 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_STDIO_INLINE=__declspec(dllexport)__inline 18 | @set LJLINK=link /nologo 19 | @set LJMT=mt /nologo 20 | @set LJLIB=lib /nologo /nodefaultlib 21 | @set DASMDIR=..\dynasm 22 | @set DASM=%DASMDIR%\dynasm.lua 23 | @set DASC=vm_x86.dasc 24 | @set LJDLLNAME=lua51.dll 25 | @set LJLIBNAME=lua51.lib 26 | @set ALL_LIB=lib_base.c lib_math.c lib_bit.c lib_string.c lib_table.c lib_io.c lib_os.c lib_package.c lib_debug.c lib_jit.c lib_ffi.c 27 | 28 | %LJCOMPILE% host\minilua.c 29 | @if errorlevel 1 goto :BAD 30 | %LJLINK% /out:minilua.exe minilua.obj 31 | @if errorlevel 1 goto :BAD 32 | if exist minilua.exe.manifest^ 33 | %LJMT% -manifest minilua.exe.manifest -outputresource:minilua.exe 34 | 35 | @set DASMFLAGS=-D WIN -D JIT -D FFI -D P64 36 | @set LJARCH=x64 37 | @minilua 38 | @if errorlevel 8 goto :X64 39 | @set DASMFLAGS=-D WIN -D JIT -D FFI 40 | @set LJARCH=x86 41 | @set LJCOMPILE=%LJCOMPILE% /arch:SSE2 42 | :X64 43 | @if "%1" neq "gc64" goto :NOGC64 44 | @shift 45 | @set DASC=vm_x64.dasc 46 | @set LJCOMPILE=%LJCOMPILE% /DLUAJIT_ENABLE_GC64 47 | :NOGC64 48 | minilua %DASM% -LN %DASMFLAGS% -o host\buildvm_arch.h %DASC% 49 | @if errorlevel 1 goto :BAD 50 | 51 | %LJCOMPILE% /I "." /I %DASMDIR% host\buildvm*.c 52 | @if errorlevel 1 goto :BAD 53 | %LJLINK% /out:buildvm.exe buildvm*.obj 54 | @if errorlevel 1 goto :BAD 55 | if exist buildvm.exe.manifest^ 56 | %LJMT% -manifest buildvm.exe.manifest -outputresource:buildvm.exe 57 | 58 | buildvm -m peobj -o lj_vm.obj 59 | @if errorlevel 1 goto :BAD 60 | buildvm -m bcdef -o lj_bcdef.h %ALL_LIB% 61 | @if errorlevel 1 goto :BAD 62 | buildvm -m ffdef -o lj_ffdef.h %ALL_LIB% 63 | @if errorlevel 1 goto :BAD 64 | buildvm -m libdef -o lj_libdef.h %ALL_LIB% 65 | @if errorlevel 1 goto :BAD 66 | buildvm -m recdef -o lj_recdef.h %ALL_LIB% 67 | @if errorlevel 1 goto :BAD 68 | buildvm -m vmdef -o jit\vmdef.lua %ALL_LIB% 69 | @if errorlevel 1 goto :BAD 70 | buildvm -m folddef -o lj_folddef.h lj_opt_fold.c 71 | @if errorlevel 1 goto :BAD 72 | 73 | :MTDLL 74 | if exist %LJDLLNAME%.manifest^ 75 | %LJMT% -manifest %LJDLLNAME%.manifest -outputresource:%LJDLLNAME%;2 76 | 77 | REM %LJCOMPILE% luajit.c 78 | REM @if errorlevel 1 goto :BAD 79 | REM %LJLINK% /out:luajit.exe luajit.obj %LJLIBNAME% 80 | REM @if errorlevel 1 goto :BAD 81 | REM if exist luajit.exe.manifest^ 82 | REM %LJMT% -manifest luajit.exe.manifest -outputresource:luajit.exe 83 | 84 | rename lj_vm.obj lj_vm.obj.bak 85 | @del *.obj *.manifest 86 | rename lj_vm.obj.bak lj_vm.obj 87 | @echo. 88 | @echo === Successfully built LuaJIT for Windows/%LJARCH% === 89 | 90 | @goto :END 91 | :BAD 92 | @echo. 93 | @echo ******************************************************* 94 | @echo *** Build FAILED -- Please check the error messages *** 95 | @echo ******************************************************* 96 | @goto :END 97 | :FAIL 98 | @echo You must open a "Visual Studio .NET Command Prompt" to run this script 99 | :END 100 | -------------------------------------------------------------------------------- /src/ps4build.bat: -------------------------------------------------------------------------------- 1 | @rem Script to build LuaJIT with the PS4 SDK. 2 | @rem Donated to the public domain. 3 | @rem 4 | @rem Open a "Visual Studio .NET Command Prompt" (64 bit host compiler) 5 | @rem or "VS2015 x64 Native Tools Command Prompt". 6 | @rem 7 | @rem Then cd to this directory and run this script. 8 | @rem 9 | @rem Recommended invocation: 10 | @rem 11 | @rem ps4build release build, amalgamated, 64-bit GC 12 | @rem ps4build debug debug build, amalgamated, 64-bit GC 13 | @rem 14 | @rem Additional command-line options (not generally recommended): 15 | @rem 16 | @rem gc32 (before debug) 32-bit GC 17 | @rem noamalg (after debug) non-amalgamated build 18 | 19 | @if not defined INCLUDE goto :FAIL 20 | @if not defined SCE_ORBIS_SDK_DIR goto :FAIL 21 | 22 | @setlocal 23 | @rem ---- Host compiler ---- 24 | @set LJCOMPILE=cl /nologo /c /MD /O2 /W3 /D_CRT_SECURE_NO_DEPRECATE 25 | @set LJLINK=link /nologo 26 | @set LJMT=mt /nologo 27 | @set DASMDIR=..\dynasm 28 | @set DASM=%DASMDIR%\dynasm.lua 29 | @set ALL_LIB=lib_base.c lib_math.c lib_bit.c lib_string.c lib_table.c lib_io.c lib_os.c lib_package.c lib_debug.c lib_jit.c lib_ffi.c 30 | @set GC64=-DLUAJIT_ENABLE_GC64 31 | @set DASC=vm_x64.dasc 32 | 33 | @if "%1" neq "gc32" goto :NOGC32 34 | @shift 35 | @set GC64= 36 | @set DASC=vm_x86.dasc 37 | :NOGC32 38 | 39 | %LJCOMPILE% host\minilua.c 40 | @if errorlevel 1 goto :BAD 41 | %LJLINK% /out:minilua.exe minilua.obj 42 | @if errorlevel 1 goto :BAD 43 | if exist minilua.exe.manifest^ 44 | %LJMT% -manifest minilua.exe.manifest -outputresource:minilua.exe 45 | 46 | @rem Check for 64 bit host compiler. 47 | @minilua 48 | @if not errorlevel 8 goto :FAIL 49 | 50 | @set DASMFLAGS=-D P64 -D NO_UNWIND 51 | minilua %DASM% -LN %DASMFLAGS% -o host\buildvm_arch.h %DASC% 52 | @if errorlevel 1 goto :BAD 53 | 54 | %LJCOMPILE% /I "." /I %DASMDIR% %GC64% -DLUAJIT_TARGET=LUAJIT_ARCH_X64 -DLUAJIT_OS=LUAJIT_OS_OTHER -DLUAJIT_DISABLE_JIT -DLUAJIT_DISABLE_FFI -DLUAJIT_NO_UNWIND host\buildvm*.c 55 | @if errorlevel 1 goto :BAD 56 | %LJLINK% /out:buildvm.exe buildvm*.obj 57 | @if errorlevel 1 goto :BAD 58 | if exist buildvm.exe.manifest^ 59 | %LJMT% -manifest buildvm.exe.manifest -outputresource:buildvm.exe 60 | 61 | buildvm -m elfasm -o lj_vm.s 62 | @if errorlevel 1 goto :BAD 63 | buildvm -m bcdef -o lj_bcdef.h %ALL_LIB% 64 | @if errorlevel 1 goto :BAD 65 | buildvm -m ffdef -o lj_ffdef.h %ALL_LIB% 66 | @if errorlevel 1 goto :BAD 67 | buildvm -m libdef -o lj_libdef.h %ALL_LIB% 68 | @if errorlevel 1 goto :BAD 69 | buildvm -m recdef -o lj_recdef.h %ALL_LIB% 70 | @if errorlevel 1 goto :BAD 71 | buildvm -m vmdef -o jit\vmdef.lua %ALL_LIB% 72 | @if errorlevel 1 goto :BAD 73 | buildvm -m folddef -o lj_folddef.h lj_opt_fold.c 74 | @if errorlevel 1 goto :BAD 75 | 76 | @rem ---- Cross compiler ---- 77 | @set LJCOMPILE="%SCE_ORBIS_SDK_DIR%\host_tools\bin\orbis-clang" -c -Wall -DLUAJIT_DISABLE_FFI %GC64% 78 | @set LJLIB="%SCE_ORBIS_SDK_DIR%\host_tools\bin\orbis-ar" rcus 79 | @set INCLUDE="" 80 | 81 | orbis-as -o lj_vm.o lj_vm.s 82 | 83 | @if "%1" neq "debug" goto :NODEBUG 84 | @shift 85 | @set LJCOMPILE=%LJCOMPILE% -g -O0 86 | @set TARGETLIB=libluajitD_ps4.a 87 | goto :BUILD 88 | :NODEBUG 89 | @set LJCOMPILE=%LJCOMPILE% -O2 90 | @set TARGETLIB=libluajit_ps4.a 91 | :BUILD 92 | del %TARGETLIB% 93 | @if "%1" neq "noamalg" goto :AMALG 94 | for %%f in (lj_*.c lib_*.c) do ( 95 | %LJCOMPILE% %%f 96 | @if errorlevel 1 goto :BAD 97 | ) 98 | 99 | %LJLIB% %TARGETLIB% lj_*.o lib_*.o 100 | @if errorlevel 1 goto :BAD 101 | @goto :NOAMALG 102 | :AMALG 103 | %LJCOMPILE% ljamalg.c 104 | @if errorlevel 1 goto :BAD 105 | %LJLIB% %TARGETLIB% ljamalg.o lj_vm.o 106 | @if errorlevel 1 goto :BAD 107 | :NOAMALG 108 | 109 | @del *.o *.obj *.manifest minilua.exe buildvm.exe 110 | @echo. 111 | @echo === Successfully built LuaJIT for PS4 === 112 | 113 | @goto :END 114 | :BAD 115 | @echo. 116 | @echo ******************************************************* 117 | @echo *** Build FAILED -- Please check the error messages *** 118 | @echo ******************************************************* 119 | @goto :END 120 | :FAIL 121 | @echo To run this script you must open a "Visual Studio .NET Command Prompt" 122 | @echo (64 bit host compiler). The PS4 Orbis SDK must be installed, too. 123 | :END 124 | -------------------------------------------------------------------------------- /src/psvitabuild.bat: -------------------------------------------------------------------------------- 1 | @rem Script to build LuaJIT with the PS Vita SDK. 2 | @rem Donated to the public domain. 3 | @rem 4 | @rem Open a "Visual Studio .NET Command Prompt" (32 bit host compiler) 5 | @rem Then cd to this directory and run this script. 6 | 7 | @if not defined INCLUDE goto :FAIL 8 | @if not defined SCE_PSP2_SDK_DIR goto :FAIL 9 | 10 | @setlocal 11 | @rem ---- Host compiler ---- 12 | @set LJCOMPILE=cl /nologo /c /MD /O2 /W3 /D_CRT_SECURE_NO_DEPRECATE 13 | @set LJLINK=link /nologo 14 | @set LJMT=mt /nologo 15 | @set DASMDIR=..\dynasm 16 | @set DASM=%DASMDIR%\dynasm.lua 17 | @set ALL_LIB=lib_base.c lib_math.c lib_bit.c lib_string.c lib_table.c lib_io.c lib_os.c lib_package.c lib_debug.c lib_jit.c lib_ffi.c 18 | 19 | %LJCOMPILE% host\minilua.c 20 | @if errorlevel 1 goto :BAD 21 | %LJLINK% /out:minilua.exe minilua.obj 22 | @if errorlevel 1 goto :BAD 23 | if exist minilua.exe.manifest^ 24 | %LJMT% -manifest minilua.exe.manifest -outputresource:minilua.exe 25 | 26 | @rem Check for 32 bit host compiler. 27 | @minilua 28 | @if errorlevel 8 goto :FAIL 29 | 30 | @set DASMFLAGS=-D FPU -D HFABI 31 | minilua %DASM% -LN %DASMFLAGS% -o host\buildvm_arch.h vm_arm.dasc 32 | @if errorlevel 1 goto :BAD 33 | 34 | %LJCOMPILE% /I "." /I %DASMDIR% -DLUAJIT_TARGET=LUAJIT_ARCH_ARM -DLUAJIT_OS=LUAJIT_OS_OTHER -DLUAJIT_DISABLE_JIT -DLUAJIT_DISABLE_FFI -DLJ_TARGET_PSVITA=1 host\buildvm*.c 35 | @if errorlevel 1 goto :BAD 36 | %LJLINK% /out:buildvm.exe buildvm*.obj 37 | @if errorlevel 1 goto :BAD 38 | if exist buildvm.exe.manifest^ 39 | %LJMT% -manifest buildvm.exe.manifest -outputresource:buildvm.exe 40 | 41 | buildvm -m elfasm -o lj_vm.s 42 | @if errorlevel 1 goto :BAD 43 | buildvm -m bcdef -o lj_bcdef.h %ALL_LIB% 44 | @if errorlevel 1 goto :BAD 45 | buildvm -m ffdef -o lj_ffdef.h %ALL_LIB% 46 | @if errorlevel 1 goto :BAD 47 | buildvm -m libdef -o lj_libdef.h %ALL_LIB% 48 | @if errorlevel 1 goto :BAD 49 | buildvm -m recdef -o lj_recdef.h %ALL_LIB% 50 | @if errorlevel 1 goto :BAD 51 | buildvm -m vmdef -o jit\vmdef.lua %ALL_LIB% 52 | @if errorlevel 1 goto :BAD 53 | buildvm -m folddef -o lj_folddef.h lj_opt_fold.c 54 | @if errorlevel 1 goto :BAD 55 | 56 | @rem ---- Cross compiler ---- 57 | @set LJCOMPILE="%SCE_PSP2_SDK_DIR%\host_tools\build\bin\psp2snc" -c -w -DLUAJIT_DISABLE_FFI -DLUAJIT_USE_SYSMALLOC 58 | @set LJLIB="%SCE_PSP2_SDK_DIR%\host_tools\build\bin\psp2ld32" -r --output= 59 | @set INCLUDE="" 60 | 61 | "%SCE_PSP2_SDK_DIR%\host_tools\build\bin\psp2as" -o lj_vm.o lj_vm.s 62 | 63 | @if "%1" neq "debug" goto :NODEBUG 64 | @shift 65 | @set LJCOMPILE=%LJCOMPILE% -g -O0 66 | @set TARGETLIB=libluajitD.a 67 | goto :BUILD 68 | :NODEBUG 69 | @set LJCOMPILE=%LJCOMPILE% -O2 70 | @set TARGETLIB=libluajit.a 71 | :BUILD 72 | del %TARGETLIB% 73 | 74 | %LJCOMPILE% ljamalg.c 75 | @if errorlevel 1 goto :BAD 76 | %LJLIB%%TARGETLIB% ljamalg.o lj_vm.o 77 | @if errorlevel 1 goto :BAD 78 | 79 | @del *.o *.obj *.manifest minilua.exe buildvm.exe 80 | @echo. 81 | @echo === Successfully built LuaJIT for PS Vita === 82 | 83 | @goto :END 84 | :BAD 85 | @echo. 86 | @echo ******************************************************* 87 | @echo *** Build FAILED -- Please check the error messages *** 88 | @echo ******************************************************* 89 | @goto :END 90 | :FAIL 91 | @echo To run this script you must open a "Visual Studio .NET Command Prompt" 92 | @echo (32 bit host compiler). The PS Vita SDK must be installed, too. 93 | :END 94 | -------------------------------------------------------------------------------- /src/xb1build.bat: -------------------------------------------------------------------------------- 1 | @rem Script to build LuaJIT with the Xbox One SDK. 2 | @rem Donated to the public domain. 3 | @rem 4 | @rem Open a "Visual Studio .NET Command Prompt" (64 bit host compiler) 5 | @rem Then cd to this directory and run this script. 6 | 7 | @if not defined INCLUDE goto :FAIL 8 | @if not defined DurangoXDK goto :FAIL 9 | 10 | @setlocal 11 | @echo ---- Host compiler ---- 12 | @set LJCOMPILE=cl /nologo /c /MD /O2 /W3 /D_CRT_SECURE_NO_DEPRECATE /DLUAJIT_ENABLE_GC64 13 | @set LJLINK=link /nologo 14 | @set LJMT=mt /nologo 15 | @set DASMDIR=..\dynasm 16 | @set DASM=%DASMDIR%\dynasm.lua 17 | @set ALL_LIB=lib_base.c lib_math.c lib_bit.c lib_string.c lib_table.c lib_io.c lib_os.c lib_package.c lib_debug.c lib_jit.c lib_ffi.c 18 | 19 | %LJCOMPILE% host\minilua.c 20 | @if errorlevel 1 goto :BAD 21 | %LJLINK% /out:minilua.exe minilua.obj 22 | @if errorlevel 1 goto :BAD 23 | if exist minilua.exe.manifest^ 24 | %LJMT% -manifest minilua.exe.manifest -outputresource:minilua.exe 25 | 26 | @rem Error out for 64 bit host compiler 27 | @minilua 28 | @if not errorlevel 8 goto :FAIL 29 | 30 | @set DASMFLAGS=-D WIN -D FFI -D P64 31 | minilua %DASM% -LN %DASMFLAGS% -o host\buildvm_arch.h vm_x64.dasc 32 | @if errorlevel 1 goto :BAD 33 | 34 | %LJCOMPILE% /I "." /I %DASMDIR% /D_DURANGO host\buildvm*.c 35 | @if errorlevel 1 goto :BAD 36 | %LJLINK% /out:buildvm.exe buildvm*.obj 37 | @if errorlevel 1 goto :BAD 38 | if exist buildvm.exe.manifest^ 39 | %LJMT% -manifest buildvm.exe.manifest -outputresource:buildvm.exe 40 | 41 | buildvm -m peobj -o lj_vm.obj 42 | @if errorlevel 1 goto :BAD 43 | buildvm -m bcdef -o lj_bcdef.h %ALL_LIB% 44 | @if errorlevel 1 goto :BAD 45 | buildvm -m ffdef -o lj_ffdef.h %ALL_LIB% 46 | @if errorlevel 1 goto :BAD 47 | buildvm -m libdef -o lj_libdef.h %ALL_LIB% 48 | @if errorlevel 1 goto :BAD 49 | buildvm -m recdef -o lj_recdef.h %ALL_LIB% 50 | @if errorlevel 1 goto :BAD 51 | buildvm -m vmdef -o jit\vmdef.lua %ALL_LIB% 52 | @if errorlevel 1 goto :BAD 53 | buildvm -m folddef -o lj_folddef.h lj_opt_fold.c 54 | @if errorlevel 1 goto :BAD 55 | 56 | @echo ---- Cross compiler ---- 57 | 58 | @set CWD=%cd% 59 | @call "%DurangoXDK%\xdk\DurangoVars.cmd" XDK 60 | @cd /D "%CWD%" 61 | @shift 62 | 63 | @set LJCOMPILE="cl" /nologo /c /W3 /GF /Gm- /GR- /GS- /Gy /openmp- /D_CRT_SECURE_NO_DEPRECATE /D_LIB /D_UNICODE /D_DURANGO 64 | @set LJLIB="lib" /nologo 65 | 66 | @if "%1"=="debug" ( 67 | @shift 68 | @set LJCOMPILE=%LJCOMPILE% /Zi /MDd /Od 69 | @set LJLINK=%LJLINK% /debug 70 | ) else ( 71 | @set LJCOMPILE=%LJCOMPILE% /MD /O2 /DNDEBUG 72 | ) 73 | 74 | @if "%1"=="amalg" goto :AMALG 75 | %LJCOMPILE% /DLUA_BUILD_AS_DLL lj_*.c lib_*.c 76 | @if errorlevel 1 goto :BAD 77 | %LJLIB% /OUT:luajit.lib lj_*.obj lib_*.obj 78 | @if errorlevel 1 goto :BAD 79 | @goto :NOAMALG 80 | :AMALG 81 | %LJCOMPILE% /DLUA_BUILD_AS_DLL ljamalg.c 82 | @if errorlevel 1 goto :BAD 83 | %LJLIB% /OUT:luajit.lib ljamalg.obj lj_vm.obj 84 | @if errorlevel 1 goto :BAD 85 | :NOAMALG 86 | 87 | @del *.obj *.manifest minilua.exe buildvm.exe 88 | @echo. 89 | @echo === Successfully built LuaJIT for Xbox One === 90 | 91 | @goto :END 92 | :BAD 93 | @echo. 94 | @echo ******************************************************* 95 | @echo *** Build FAILED -- Please check the error messages *** 96 | @echo ******************************************************* 97 | @goto :END 98 | :FAIL 99 | @echo To run this script you must open a "Visual Studio .NET Command Prompt" 100 | @echo (64 bit host compiler). The Xbox One SDK must be installed, too. 101 | :END 102 | -------------------------------------------------------------------------------- /src/xedkbuild.bat: -------------------------------------------------------------------------------- 1 | @rem Script to build LuaJIT with the Xbox 360 SDK. 2 | @rem Donated to the public domain. 3 | @rem 4 | @rem Open a "Visual Studio .NET Command Prompt" (32 bit host compiler) 5 | @rem Then cd to this directory and run this script. 6 | 7 | @if not defined INCLUDE goto :FAIL 8 | @if not defined XEDK goto :FAIL 9 | 10 | @setlocal 11 | @rem ---- Host compiler ---- 12 | @set LJCOMPILE=cl /nologo /c /MD /O2 /W3 /D_CRT_SECURE_NO_DEPRECATE 13 | @set LJLINK=link /nologo 14 | @set LJMT=mt /nologo 15 | @set DASMDIR=..\dynasm 16 | @set DASM=%DASMDIR%\dynasm.lua 17 | @set ALL_LIB=lib_base.c lib_math.c lib_bit.c lib_string.c lib_table.c lib_io.c lib_os.c lib_package.c lib_debug.c lib_jit.c lib_ffi.c 18 | 19 | %LJCOMPILE% host\minilua.c 20 | @if errorlevel 1 goto :BAD 21 | %LJLINK% /out:minilua.exe minilua.obj 22 | @if errorlevel 1 goto :BAD 23 | if exist minilua.exe.manifest^ 24 | %LJMT% -manifest minilua.exe.manifest -outputresource:minilua.exe 25 | 26 | @rem Error out for 64 bit host compiler 27 | @minilua 28 | @if errorlevel 8 goto :FAIL 29 | 30 | @set DASMFLAGS=-D GPR64 -D FRAME32 -D PPE -D SQRT -D DUALNUM 31 | minilua %DASM% -LN %DASMFLAGS% -o host\buildvm_arch.h vm_ppc.dasc 32 | @if errorlevel 1 goto :BAD 33 | 34 | %LJCOMPILE% /I "." /I %DASMDIR% /D_XBOX_VER=200 /DLUAJIT_TARGET=LUAJIT_ARCH_PPC host\buildvm*.c 35 | @if errorlevel 1 goto :BAD 36 | %LJLINK% /out:buildvm.exe buildvm*.obj 37 | @if errorlevel 1 goto :BAD 38 | if exist buildvm.exe.manifest^ 39 | %LJMT% -manifest buildvm.exe.manifest -outputresource:buildvm.exe 40 | 41 | buildvm -m peobj -o lj_vm.obj 42 | @if errorlevel 1 goto :BAD 43 | buildvm -m bcdef -o lj_bcdef.h %ALL_LIB% 44 | @if errorlevel 1 goto :BAD 45 | buildvm -m ffdef -o lj_ffdef.h %ALL_LIB% 46 | @if errorlevel 1 goto :BAD 47 | buildvm -m libdef -o lj_libdef.h %ALL_LIB% 48 | @if errorlevel 1 goto :BAD 49 | buildvm -m recdef -o lj_recdef.h %ALL_LIB% 50 | @if errorlevel 1 goto :BAD 51 | buildvm -m vmdef -o jit\vmdef.lua %ALL_LIB% 52 | @if errorlevel 1 goto :BAD 53 | buildvm -m folddef -o lj_folddef.h lj_opt_fold.c 54 | @if errorlevel 1 goto :BAD 55 | 56 | @rem ---- Cross compiler ---- 57 | @set LJCOMPILE="%XEDK%\bin\win32\cl" /nologo /c /MT /O2 /W3 /GF /Gm- /GR- /GS- /Gy /openmp- /D_CRT_SECURE_NO_DEPRECATE /DNDEBUG /D_XBOX /D_LIB /DLUAJIT_USE_SYSMALLOC 58 | @set LJLIB="%XEDK%\bin\win32\lib" /nologo 59 | @set "INCLUDE=%XEDK%\include\xbox" 60 | 61 | @if "%1" neq "debug" goto :NODEBUG 62 | @shift 63 | @set "LJCOMPILE=%LJCOMPILE% /Zi" 64 | :NODEBUG 65 | @if "%1"=="amalg" goto :AMALG 66 | %LJCOMPILE% /DLUA_BUILD_AS_DLL lj_*.c lib_*.c 67 | @if errorlevel 1 goto :BAD 68 | %LJLIB% /OUT:luajit20.lib lj_*.obj lib_*.obj 69 | @if errorlevel 1 goto :BAD 70 | @goto :NOAMALG 71 | :AMALG 72 | %LJCOMPILE% /DLUA_BUILD_AS_DLL ljamalg.c 73 | @if errorlevel 1 goto :BAD 74 | %LJLIB% /OUT:luajit20.lib ljamalg.obj lj_vm.obj 75 | @if errorlevel 1 goto :BAD 76 | :NOAMALG 77 | 78 | @del *.obj *.manifest minilua.exe buildvm.exe 79 | @echo. 80 | @echo === Successfully built LuaJIT for Xbox 360 === 81 | 82 | @goto :END 83 | :BAD 84 | @echo. 85 | @echo ******************************************************* 86 | @echo *** Build FAILED -- Please check the error messages *** 87 | @echo ******************************************************* 88 | @goto :END 89 | :FAIL 90 | @echo To run this script you must open a "Visual Studio .NET Command Prompt" 91 | @echo (32 bit host compiler). The Xbox 360 SDK must be installed, too. 92 | :END 93 | --------------------------------------------------------------------------------