diff options
Diffstat (limited to 'plugins/MirLua/Modules/ffi/src')
36 files changed, 0 insertions, 23089 deletions
diff --git a/plugins/MirLua/Modules/ffi/src/.gitignore b/plugins/MirLua/Modules/ffi/src/.gitignore deleted file mode 100644 index 5d9b232efa..0000000000 --- a/plugins/MirLua/Modules/ffi/src/.gitignore +++ /dev/null @@ -1,23 +0,0 @@ -*.dll
-*.exp
-*.lib
-*.pdb
-*.ilk
-.*.swp
-*.user
-/BuildLog.htm
-*.o
-*.so
-.*.swo
-.DS_Store
-/luaffi.xcodeproj
-*.ncb
-*.sln
-*.suo
-*.dSYM
-*.vcproj
-/luaffi
-/test_includes/
-*.swp
-*.dylib
-/tmp
diff --git a/plugins/MirLua/Modules/ffi/src/CONTRIBUTING.md b/plugins/MirLua/Modules/ffi/src/CONTRIBUTING.md deleted file mode 100644 index 3e7edc59cc..0000000000 --- a/plugins/MirLua/Modules/ffi/src/CONTRIBUTING.md +++ /dev/null @@ -1,30 +0,0 @@ -# Contributing to luaffifb
-We want to make contributing to this project as easy and transparent as
-possible.
-
-## Our Development Process
-... (in particular how this is synced with internal changes to the project)
-
-## Pull Requests
-We actively welcome your pull requests.
-1. Fork the repo and create your branch from `master`.
-2. If you've added code that should be tested, add tests
-3. If you haven't already, complete the Contributor License Agreement ("CLA").
-
-## Contributor License Agreement ("CLA")
-In order to accept your pull request, we need you to submit a CLA. You only need
-to do this once to work on any of Facebook's open source projects.
-
-Complete your CLA here: <https://code.facebook.com/cla>
-
-## Issues
-We use GitHub issues to track public bugs. Please ensure your description is
-clear and has sufficient instructions to be able to reproduce the issue.
-
-## Coding Style
-* Use four spaces for indentation rather than tabs
-* 80 character line length
-
-## License
-By contributing to luaffifb, you agree that your contributions will be licensed
-under its BSD license.
diff --git a/plugins/MirLua/Modules/ffi/src/LICENSE b/plugins/MirLua/Modules/ffi/src/LICENSE deleted file mode 100644 index dbfa937f14..0000000000 --- a/plugins/MirLua/Modules/ffi/src/LICENSE +++ /dev/null @@ -1,58 +0,0 @@ -BSD License
-
-For luaffifb software
-
-Copyright (c) 2015, Facebook, Inc. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
- * Redistributions of source code must retain the above copyright notice, this
- list of conditions and the following disclaimer.
-
- * Redistributions in binary form must reproduce the above copyright notice,
- this list of conditions and the following disclaimer in the documentation
- and/or other materials provided with the distribution.
-
- * Neither the name Facebook nor the names of its contributors may be used to
- endorse or promote products derived from this software without specific
- prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------
-
-This product contains portions of third party software provided under this license:
-
-luaffi software
-
-Copyright (c) 2011 James R. McKaskill
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the "Software"),
-to deal in the Software without restriction, including without limitation
-the rights to use, copy, modify, merge, publish, distribute, sublicense,
-and/or sell copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
-Facebook provides this code under the BSD License above.
diff --git a/plugins/MirLua/Modules/ffi/src/Makefile b/plugins/MirLua/Modules/ffi/src/Makefile deleted file mode 100644 index 0c62c282f3..0000000000 --- a/plugins/MirLua/Modules/ffi/src/Makefile +++ /dev/null @@ -1,32 +0,0 @@ -#
-# Use luarocks to install LuaFFI:
-# > git clone https://github.com/facebook/luaffifb
-# > cd luaffifb && luarocks make
-#
-# To rebuild the call_* headers:
-# > rm call_*.h && make headers
-#
-
-.PHONY: build clean headers
-LUA=lua
-
-build:
- luarocks make
-
-clean:
- rm -f *.o *.so *.dylib
-
-headers:
- $(MAKE) call_x86.h call_x64.h call_x64win.h call_arm.h
-
-call_x86.h: call_x86.dasc dynasm/*.lua
- $(LUA) dynasm/dynasm.lua -LN -o $@ $<
-
-call_x64.h: call_x86.dasc dynasm/*.lua
- $(LUA) dynasm/dynasm.lua -D X64 -LN -o $@ $<
-
-call_x64win.h: call_x86.dasc dynasm/*.lua
- $(LUA) dynasm/dynasm.lua -D X64 -D X64WIN -LN -o $@ $<
-
-call_arm.h: call_arm.dasc dynasm/*.lua
- $(LUA) dynasm/dynasm.lua -LNE -o $@ $<
diff --git a/plugins/MirLua/Modules/ffi/src/PATENTS b/plugins/MirLua/Modules/ffi/src/PATENTS deleted file mode 100644 index ec53abd7c9..0000000000 --- a/plugins/MirLua/Modules/ffi/src/PATENTS +++ /dev/null @@ -1,33 +0,0 @@ -Additional Grant of Patent Rights Version 2
-
-"Software" means the luaffifb software distributed by Facebook, Inc.
-
-Facebook, Inc. ("Facebook") hereby grants to each recipient of the Software
-("you") a perpetual, worldwide, royalty-free, non-exclusive, irrevocable
-(subject to the termination provision below) license under any Necessary
-Claims, to make, have made, use, sell, offer to sell, import, and otherwise
-transfer the Software. For avoidance of doubt, no license is granted under
-Facebookâs rights in any patent claims that are infringed by (i) modifications
-to the Software made by you or any third party or (ii) the Software in
-combination with any software or other technology.
-
-The license granted hereunder will terminate, automatically and without notice,
-if you (or any of your subsidiaries, corporate affiliates or agents) initiate
-directly or indirectly, or take a direct financial interest in, any Patent
-Assertion: (i) against Facebook or any of its subsidiaries or corporate
-affiliates, (ii) against any party if such Patent Assertion arises in whole or
-in part from any software, technology, product or service of Facebook or any of
-its subsidiaries or corporate affiliates, or (iii) against any party relating
-to the Software. Notwithstanding the foregoing, if Facebook or any of its
-subsidiaries or corporate affiliates files a lawsuit alleging patent
-infringement against you in the first instance, and you respond by filing a
-patent infringement counterclaim in that lawsuit against that party that is
-unrelated to the Software, the license granted hereunder will not terminate
-under section (i) of this paragraph due to such counterclaim.
-
-A "Necessary Claim" is a claim of a patent owned by Facebook that is
-necessarily infringed by the Software standing alone.
-
-A "Patent Assertion" is any lawsuit or other action alleging direct, indirect,
-or contributory infringement or inducement to infringe any patent, including a
-cross-claim or counterclaim.
diff --git a/plugins/MirLua/Modules/ffi/src/README.md b/plugins/MirLua/Modules/ffi/src/README.md deleted file mode 100644 index df6ffba165..0000000000 --- a/plugins/MirLua/Modules/ffi/src/README.md +++ /dev/null @@ -1,84 +0,0 @@ -About
------
-This is a library for calling C function and manipulating C types from lua. It
-is designed to be interface compatible with the FFI library in LuaJIT (see
-http://luajit.org/ext_ffi.html). It can parse C function declarations and
-struct definitions that have been directly copied out of C header files and
-into lua source as a string.
-
-This is a fork of https://github.com/jmckaskill/luaffi
-
-Source
-------
-https://github.com/facebook/luaffifb
-
-Platforms
----------
-Currently supported:
-- Linux x86/x64
-- OS X x86/x64
-
-Runs with both Lua 5.1 and Lua 5.2.
-
-Build
------
-In a terminal:
-
-```bash
-git clone https://github.com/facebook/luaffifb
-cd luaffifb
-luarocks make
-```
-
-Documentation
--------------
-This library is designed to be source compatible with LuaJIT's FFI extension. The documentation at http://luajit.org/ext_ffi.html describes the API and semantics.
-
-Pointer Comparison
-------------
-Use `ffi.NULL` instead of `nil` when checking for `NULL` pointers.
-```lua
- ffi.new('void *', 0) == ffi.NULL -- true
-```
-
-Known Issues
-------------
-- Comparing a ctype pointer to `nil` doesn't work the same as in LuaJIT (see above).
- This is unfixable with the current metamethod semantics.
-- Constant expressions can't handle non integer intermediate values (eg
- offsetof won't work because it manipulates pointers)
-- Not all metamethods work with Lua 5.1 (eg char* + number). This is due to
- the way metamethods are looked up with mixed types in Lua 5.1. If you need
-this upgrade to Lua 5.2 or use boxed numbers (uint64_t and uintptr_t).
-- All bitfields are treated as unsigned (does anyone even use signed
- bitfields?). Note that "int s:8" is unsigned on unix x86/x64, but signed on
-windows.
-
-
-How it works
-------------
-Types are represented by a struct ctype structure and an associated user value
-table. The table is shared between all related types for structs, unions, and
-functions. It's members have the types of struct members, function argument
-types, etc. The struct ctype structure then contains the modifications from
-the base type (eg number of pointers, array size, etc).
-
-Types are pushed into lua as a userdata containing the struct ctype with a
-user value (or fenv in 5.1) set to the shared type table.
-
-Boxed cdata types are pushed into lua as a userdata containing the struct
-cdata structure (which contains the struct ctype of the data as its header)
-followed by the boxed data.
-
-The functions in `ffi.C` provide the `cdata` and `ctype` metatables and ffi.*
-functions which manipulate these two types.
-
-C functions (and function pointers) are pushed into lua as a lua c function
-with the function pointer cdata as the first upvalue. The actual code is JITed
-using dynasm (see call_x86.dasc). The JITed code does the following in order:
-
-1. Calls the needed unpack functions in `ffi.C` placing each argument on the HW stack
-2. Updates `errno`
-3. Performs the C call
-4. Retrieves `errno`
-5. Pushes the result back into lua from the HW register or stack
diff --git a/plugins/MirLua/Modules/ffi/src/call.c b/plugins/MirLua/Modules/ffi/src/call.c deleted file mode 100644 index d483d4cc69..0000000000 --- a/plugins/MirLua/Modules/ffi/src/call.c +++ /dev/null @@ -1,274 +0,0 @@ -/* vim: ts=4 sw=4 sts=4 et tw=78
- * Portions copyright (c) 2015-present, Facebook, Inc. All rights reserved.
- * Portions copyright (c) 2011 James R. McKaskill.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-#include "ffi.h"
-
-static cfunction compile(Dst_DECL, lua_State* L, cfunction func, int ref);
-
-static void* reserve_code(struct jit* jit, lua_State* L, size_t sz);
-static void commit_code(struct jit* jit, void* p, size_t sz);
-
-static void push_int(lua_State* L, int val)
-{ lua_pushinteger(L, val); }
-
-static void push_uint(lua_State* L, unsigned int val)
-{ lua_pushinteger(L, val); }
-
-static void push_float(lua_State* L, float val)
-{ lua_pushnumber(L, val); }
-
-#ifndef _WIN32
-static int GetLastError(void)
-{ return errno; }
-static void SetLastError(int err)
-{ errno = err; }
-#endif
-
-#ifdef NDEBUG
-#define shred(a,b,c)
-#else
-#define shred(p,s,e) memset((uint8_t*)(p)+(s),0xCC,(e)-(s))
-#endif
-
-
-#ifdef _WIN64
-#include "dynasm/dasm_x86.h"
-#include "call_x64win.h"
-#elif defined __amd64__
-#include "dynasm/dasm_x86.h"
-#include "call_x64.h"
-#elif defined __arm__ || defined __arm || defined __ARM__ || defined __ARM || defined ARM || defined _ARM_ || defined ARMV4I || defined _M_ARM
-#include "dynasm/dasm_arm.h"
-#include "call_arm.h"
-#else
-#include "dynasm/dasm_x86.h"
-#include "call_x86.h"
-#endif
-
-struct jit_head {
- size_t size;
- int ref;
- uint8_t jump[JUMP_SIZE];
-};
-
-#define LINKTABLE_MAX_SIZE (sizeof(extnames) / sizeof(extnames[0]) * (JUMP_SIZE))
-
-static cfunction compile(struct jit* jit, lua_State* L, cfunction func, int ref)
-{
- struct jit_head* code;
- size_t codesz;
- int err;
-
- dasm_checkstep(jit, -1);
- if ((err = dasm_link(jit, &codesz)) != 0) {
- char buf[32];
- sprintf(buf, "%x", err);
- luaL_error(L, "dasm_link error %s", buf);
- }
-
- codesz += sizeof(struct jit_head);
- code = (struct jit_head*) reserve_code(jit, L, codesz);
- code->ref = ref;
- code->size = codesz;
- compile_extern_jump(jit, L, func, code->jump);
-
- if ((err = dasm_encode(jit, code+1)) != 0) {
- char buf[32];
- sprintf(buf, "%x", err);
- commit_code(jit, code, 0);
- luaL_error(L, "dasm_encode error %s", buf);
- }
-
- commit_code(jit, code, codesz);
- return (cfunction) (code+1);
-}
-
-typedef uint8_t jump_t[JUMP_SIZE];
-
-int get_extern(struct jit* jit, uint8_t* addr, int idx, int type)
-{
- struct page* page = jit->pages[jit->pagenum-1];
- jump_t* jumps = (jump_t*) (page+1);
- struct jit_head* h = (struct jit_head*) ((uint8_t*) page + page->off);
- uint8_t* jmp;
- ptrdiff_t off;
-
- if (idx == jit->function_extern) {
- jmp = h->jump;
- } else {
- jmp = jumps[idx];
- }
-
- /* compensate for room taken up for the offset so that we can work rip
- * relative */
- addr += BRANCH_OFF;
-
- /* see if we can fit the offset in the branch displacement, if not use the
- * jump instruction */
- off = *(uint8_t**) jmp - addr;
-
- if (MIN_BRANCH <= off && off <= MAX_BRANCH) {
- return (int32_t) off;
- } else {
- return (int32_t)(jmp + sizeof(uint8_t*) - addr);
- }
-}
-
-static void* reserve_code(struct jit* jit, lua_State* L, size_t sz)
-{
- struct page* page;
- size_t off = (jit->pagenum > 0) ? jit->pages[jit->pagenum-1]->off : 0;
- size_t size = (jit->pagenum > 0) ? jit->pages[jit->pagenum-1]->size : 0;
-
- if (off + sz >= size) {
- int i;
- uint8_t* pdata;
- cfunction func;
-
- /* need to create a new page */
- jit->pages = (struct page**) realloc(jit->pages, (++jit->pagenum) * sizeof(jit->pages[0]));
-
- size = ALIGN_UP(sz + LINKTABLE_MAX_SIZE + sizeof(struct page), jit->align_page_size);
-
- page = (struct page*) AllocPage(size);
- jit->pages[jit->pagenum-1] = page;
- pdata = (uint8_t*) page;
- page->size = size;
- page->off = sizeof(struct page);
-
- lua_newtable(L);
-
-#define ADDFUNC(DLL, NAME) \
- lua_pushliteral(L, #NAME); \
- func = DLL ? (cfunction) GetProcAddressA(DLL, #NAME) : NULL; \
- func = func ? func : (cfunction) &NAME; \
- lua_pushcfunction(L, (lua_CFunction) func); \
- lua_rawset(L, -3)
-
- ADDFUNC(NULL, check_double);
- ADDFUNC(NULL, check_float);
- ADDFUNC(NULL, check_uint64);
- ADDFUNC(NULL, check_int64);
- ADDFUNC(NULL, check_int32);
- ADDFUNC(NULL, check_uint32);
- ADDFUNC(NULL, check_uintptr);
- ADDFUNC(NULL, check_enum);
- ADDFUNC(NULL, check_typed_pointer);
- ADDFUNC(NULL, check_typed_cfunction);
- ADDFUNC(NULL, check_complex_double);
- ADDFUNC(NULL, check_complex_float);
- ADDFUNC(NULL, unpack_varargs_stack);
- ADDFUNC(NULL, unpack_varargs_stack_skip);
- ADDFUNC(NULL, unpack_varargs_reg);
- ADDFUNC(NULL, unpack_varargs_float);
- ADDFUNC(NULL, unpack_varargs_int);
- ADDFUNC(NULL, push_cdata);
- ADDFUNC(NULL, push_int);
- ADDFUNC(NULL, push_uint);
- ADDFUNC(NULL, push_float);
- ADDFUNC(jit->kernel32_dll, SetLastError);
- ADDFUNC(jit->kernel32_dll, GetLastError);
- ADDFUNC(jit->lua_dll, luaL_error);
- ADDFUNC(jit->lua_dll, lua_pushnumber);
- ADDFUNC(jit->lua_dll, lua_pushboolean);
- ADDFUNC(jit->lua_dll, lua_gettop);
- ADDFUNC(jit->lua_dll, lua_rawgeti);
- ADDFUNC(jit->lua_dll, lua_pushnil);
- ADDFUNC(jit->lua_dll, lua_callk);
- ADDFUNC(jit->lua_dll, lua_settop);
- ADDFUNC(jit->lua_dll, lua_remove);
-#undef ADDFUNC
-
- for (i = 0; extnames[i] != NULL; i++) {
-
- if (strcmp(extnames[i], "FUNCTION") == 0) {
- shred(pdata + page->off, 0, JUMP_SIZE);
- jit->function_extern = i;
-
- } else {
- lua_getfield(L, -1, extnames[i]);
- func = (cfunction) lua_tocfunction(L, -1);
-
- if (func == NULL) {
- luaL_error(L, "internal error: missing link for %s", extnames[i]);
- }
-
- compile_extern_jump(jit, L, func, pdata + page->off);
- lua_pop(L, 1);
- }
-
- page->off += JUMP_SIZE;
- }
-
- page->freed = page->off;
- lua_pop(L, 1);
-
- } else {
- page = jit->pages[jit->pagenum-1];
- EnableWrite(page, page->size);
- }
-
- return (uint8_t*) page + page->off;
-}
-
-static void commit_code(struct jit* jit, void* code, size_t sz)
-{
- struct page* page = jit->pages[jit->pagenum-1];
- page->off += sz;
- EnableExecute(page, page->size);
- {
-#if 0
- FILE* out = fopen("\\Hard Disk\\out.bin", "wb");
- fwrite(page, page->off, 1, out);
- fclose(out);
-#endif
- }
-}
-
-/* push_func_ref pushes a copy of the upval table embedded in the compiled
- * function func.
- */
-void push_func_ref(lua_State* L, cfunction func)
-{
- struct jit_head* h = ((struct jit_head*) func) - 1;
- lua_rawgeti(L, LUA_REGISTRYINDEX, h->ref);
-}
-
-void free_code(struct jit* jit, lua_State* L, cfunction func)
-{
- size_t i;
- struct jit_head* h = ((struct jit_head*) func) - 1;
- for (i = 0; i < jit->pagenum; i++) {
- struct page* p = jit->pages[i];
-
- if ((uint8_t*) h < (uint8_t*) p || (uint8_t*) p + p->size <= (uint8_t*) h) {
- continue;
- }
-
- luaL_unref(L, LUA_REGISTRYINDEX, h->ref);
-
- EnableWrite(p, p->size);
- p->freed += h->size;
-
- shred(h, 0, h->size);
-
- if (p->freed < p->off) {
- EnableExecute(p, p->size);
- return;
- }
-
- FreePage(p, p->size);
- memmove(&jit->pages[i], &jit->pages[i+1], (jit->pagenum - (i+1)) * sizeof(jit->pages[0]));
- jit->pagenum--;
- return;
- }
-
- assert(!"couldn't find func in the jit pages");
-}
-
-
diff --git a/plugins/MirLua/Modules/ffi/src/call_arm.dasc b/plugins/MirLua/Modules/ffi/src/call_arm.dasc deleted file mode 100644 index 9551c18f7e..0000000000 --- a/plugins/MirLua/Modules/ffi/src/call_arm.dasc +++ /dev/null @@ -1,610 +0,0 @@ -/* vim: ts=4 sw=4 sts=4 et tw=78
- * Portions copyright (c) 2015-present, Facebook, Inc. All rights reserved.
- * Portions copyright (c) 2011 James R. McKaskill.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-|.arch arm
-|.actionlist build_actionlist
-|.globalnames globnames
-|.externnames extnames
-
-#define JUMP_SIZE 8
-#define MIN_BRANCH ((INT32_MIN) >> 8)
-#define MAX_BRANCH ((INT32_MAX) >> 8)
-#define BRANCH_OFF 4
-
-static void compile_extern_jump(struct jit* jit, lua_State* L, cfunction func, uint8_t* code)
-{
- /* The jump code is the function pointer followed by a stub to call the
- * function pointer. The stub exists so we can jump to functions with an
- * offset greater than 32MB.
- *
- * Note we have to manually set this up since there are commands buffered
- * in the jit state.
- */
- *(cfunction*) code = func;
- /* ldr pc, [pc - 12] */
- *(uint32_t*) &code[4] = 0xE51FF00CU;
-}
-
-|.define TOP, r4
-|.define L_ARG, r5
-|.define DATA, r6
-|.define DATA2, r7
-
-|.macro load32, reg, val
-| ldr reg, [pc]
-| b >5
-|.long val
-|5:
-|.endmacro
-
-|.macro lcall, func
-| mov r0, L_ARG
-| bl func
-|.endmacro
-
-void compile_globals(struct jit* jit, lua_State* L)
-{
- (void) jit;
-}
-
-cfunction compile_callback(lua_State* L, int fidx, int ct_usr, const struct ctype* ct)
-{
- struct jit* Dst = get_jit(L);;
- int i, nargs, num_upvals, ref;
- const struct ctype* mt;
-
- int top = lua_gettop(L);
-
- ct_usr = lua_absindex(L, ct_usr);
- fidx = lua_absindex(L, fidx);
- nargs = (int) lua_rawlen(L, ct_usr);
-
- dasm_setup(Dst, build_actionlist);
-
- lua_newtable(L);
- lua_pushvalue(L, -1);
- ref = luaL_ref(L, LUA_REGISTRYINDEX);
- num_upvals = 0;
-
- if (ct->has_var_arg) {
- luaL_error(L, "can't create callbacks with varargs");
- }
-
- /* prolog and get the upval table */
- | mov r12, sp
- | push {r0, r1, r2, r3} // do this first so that r0-r3 is right before stack bound arguments
- | push {TOP, L_ARG, DATA, DATA2, r12, lr}
- | sub DATA, r12, #16 // points to r0 on stack
- | ldr L_ARG, [pc, #8]
- | ldr r2, [pc, #8]
- | ldr r1, [pc, #8]
- | b >1
- |.long L, ref, LUA_REGISTRYINDEX
- |1:
- | lcall extern lua_rawgeti
-
- /* get the lua function */
- lua_pushvalue(L, fidx);
- lua_rawseti(L, -2, ++num_upvals);
- | mov r2, #num_upvals
- | mvn r1, #0 // -1
- | lcall extern lua_rawgeti
-
- for (i = 1; i <= nargs; i++) {
- lua_rawgeti(L, ct_usr, i);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mt->pointers || mt->is_reference) {
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
-
- | mov r2, #num_upvals-1 // usr value
- | mvn r1, #i // -i-1, stack is upval table, func, i-1 args
- | lcall extern lua_rawgeti
- | load32 r2, mt
- | mvn r1, #0 // -1
- | lcall extern push_cdata
- | ldr r2, [DATA], #4
- | str r2, [r0]
- | mvn r1, #1 // -2
- | lcall extern lua_remove // remove the usr value
-
- } else {
- switch (mt->type) {
- case INT64_TYPE:
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- | lcall extern lua_pushnil
- | load32 r2, mt
- | mvn r1, #0 // -1
- | lcall extern push_cdata
- | ldr r2, [DATA], #4
- | ldr r3, [DATA], #4
- | str r2, [r0]
- | str r3, [r0, #4]
- | mvn r1, #1 // -2
- | lcall extern lua_remove // remove the nil usr
- break;
-
- case INTPTR_TYPE:
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- | lcall extern lua_pushnil
- | load32 r2, mt
- | mvn r1, #0 // -1
- | lcall extern push_cdata
- | ldr r2, [DATA], #4
- | str r2, [r0]
- | mvn r1, #1 // -2
- | lcall extern lua_remove // remove the nil usr
- break;
-
- case BOOL_TYPE:
- lua_pop(L, 1);
- | ldr r1, [DATA], #4
- | lcall extern lua_pushboolean
- break;
-
- case INT8_TYPE:
- lua_pop(L, 1);
- | ldr r1, [DATA], #4
- | mov r1, r1, lsl #24
- if (mt->is_unsigned) {
- | mov r1, r1, lsr #24
- } else {
- | mov r1, r1, asr #24
- }
- | lcall extern push_int
- break;
-
- case INT16_TYPE:
- lua_pop(L, 1);
- | ldr r1, [DATA], #4
- | mov r1, r1, lsl #16
- if (mt->is_unsigned) {
- | mov r1, r1, lsr #16
- } else {
- | mov r1, r1, asr #16
- }
- | lcall extern push_int
- break;
-
- case ENUM_TYPE:
- case INT32_TYPE:
- lua_pop(L, 1);
- | ldr r1, [DATA], #4
- | lcall extern push_int
- break;
-
- case FLOAT_TYPE:
- lua_pop(L, 1);
- | ldr r1, [DATA], #4
- | lcall extern push_float
- break;
-
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- | ldmia DATA!, {r1, r2}
- | lcall extern lua_pushnumber
- break;
-
- default:
- luaL_error(L, "NYI: callback arg type");
- }
- }
- }
-
- lua_rawgeti(L, ct_usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- | mov r3, #0
- | mov r2, #((mt->pointers || mt->is_reference || mt->type != VOID_TYPE) ? 1 : 0)
- | mov r1, #nargs
- | lcall extern lua_callk
-
- if (mt->pointers || mt->is_reference) {
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
-
- | mov r2, #num_upvals-1 // usr value
- | mvn r1, #1 // -2 stack is (upval table, ret val)
- | lcall extern lua_rawgeti
- | load32 r3, mt
- | mov r2, #0 // -1 - ct_usr
- | mvn r1, #1 // -2 - val
- | lcall extern to_typed_pointer
- | mov DATA, r0
- | mvn r1, #3 // -4 - remove 3 (upval table, ret val, usr value)
- | lcall extern lua_settop
- | mov r0, DATA
- } else {
- switch (mt->type) {
- case ENUM_TYPE:
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
-
- | mov r2, #num_upvals-1 // usr value
- | mvn r1, #1 // -2 stack is (upval table, ret val)
- | lcall extern lua_rawgeti
- | load32 r3, mt
- | mvn r2, #0 // -1 - ct_usr
- | mvn r1, #1 // -2 - val
- | lcall extern to_enum
- | mov DATA, r0
- | mvn r1, #3 // -4 - remove 3 (upval table, ret val, usr value)
- | lcall extern lua_settop
- | mov r0, DATA
- break;
-
- case VOID_TYPE:
- | mvn r1, #1 // -2
- | lcall extern lua_settop
- lua_pop(L, 1);
- break;
-
- case BOOL_TYPE:
- case INT8_TYPE:
- case INT16_TYPE:
- case INT32_TYPE:
- | mvn r1, #0 // -1
- if (mt->is_unsigned) {
- | lcall extern check_uint32
- } else {
- | lcall extern check_int32
- }
- goto single;
-
- case INT64_TYPE:
- | mvn r1, #0 // -1
- if (mt->is_unsigned) {
- | lcall extern check_uint64
- } else {
- | lcall extern check_int64
- }
- goto dual;
-
- case INTPTR_TYPE:
- | mvn r1, #0 // -1
- | lcall extern check_intptr
- goto single;
-
- case FLOAT_TYPE:
- | mvn r1, #0 // -1
- | lcall extern check_float
- goto single;
-
- case DOUBLE_TYPE:
- | mvn r1, #0 // -1
- | lcall extern check_double
- goto dual;
-
- single:
- | mov DATA, r0
- | mvn r1, #2 // -3
- | lcall extern lua_settop
- | mov r0, DATA
- lua_pop(L, 1);
- break;
-
- dual:
- | mov DATA, r0
- | mov DATA2, r1
- | mvn r1, #2 // -3
- | lcall extern lua_settop
- | mov r0, DATA
- | mov r1, DATA2
- lua_pop(L, 1);
- break;
-
- default:
- luaL_error(L, "NYI: callback return type");
- }
- }
-
- | ldmia sp, {TOP, L_ARG, DATA, DATA2, sp, pc}
-
- lua_pop(L, 1); /* upval table - already in registry */
- assert(lua_gettop(L) == top);
-
- {
- void* p;
- struct ctype ft;
- cfunction func;
-
- func = compile(Dst, L, NULL, ref);
-
- ft = *ct;
- ft.is_jitted = 1;
- p = push_cdata(L, ct_usr, &ft);
- *(cfunction*) p = func;
-
- assert(lua_gettop(L) == top + 1);
-
- return func;
- }
-}
-
-void compile_function(lua_State* L, cfunction func, int ct_usr, const struct ctype* ct)
-{
- struct jit* Dst = get_jit(L);;
- int i, nargs, num_upvals;
- const struct ctype* mt;
- void* p;
-
- int top = lua_gettop(L);
-
- ct_usr = lua_absindex(L, ct_usr);
- nargs = (int) lua_rawlen(L, ct_usr);
-
- p = push_cdata(L, ct_usr, ct);
- *(cfunction*) p = func;
- num_upvals = 1;
-
- dasm_setup(Dst, build_actionlist);
-
- | mov r12, sp
- | push {r0}
- | push {TOP, L_ARG, DATA, DATA2, r11, r12, lr}
- | sub r11, r12, #4
- | mov L_ARG, r0
- | lcall extern lua_gettop
- | mov TOP, r0
- | cmp TOP, #nargs
- | // these should really be in globals - but for some reason dynasm breaks when you do that
- if (ct->has_var_arg) {
- | bge >1
- | load32 r1, "too few arguments"
- | lcall extern luaL_error
- |1:
- } else {
- | beq >1
- | load32 r1, "incorrect number of arguments"
- | lcall extern luaL_error
- |1:
- }
-
- /* reserve enough stack space for all of the arguments (8 bytes per
- * argument for double and maintains alignment). Add an extra 16 bytes so
- * that the pop {r0, r1, r2, r3} doesn't clean out our stack frame */
- | sub sp, sp, TOP, lsl #3
- | sub sp, sp, #16
- | mov DATA, sp
-
- for (i = 1; i <= nargs; i++) {
- lua_rawgeti(L, ct_usr, i);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mt->pointers || mt->is_reference || mt->type == FUNCTION_PTR_TYPE || mt->type == ENUM_TYPE) {
- lua_getuservalue(L, -1);
- num_upvals += 2;
-
- | ldr r3, [pc, #4]
- | ldr r2, [pc, #4]
- | b >1
- |.long mt, lua_upvalueindex(num_upvals)
- |1:
- | mov r1, #i
- | mov r0, L_ARG
-
- if (mt->pointers || mt->is_reference) {
- | bl extern to_typed_pointer
- } else if (mt->type == FUNCTION_PTR_TYPE) {
- | bl extern to_typed_function
- } else if (mt->type == ENUM_TYPE) {
- | bl extern to_enum
- }
-
- | str r0, [DATA], #4
-
- } else {
- lua_pop(L, 1);
- | mov r1, #i
-
- switch (mt->type) {
- case INT8_TYPE:
- | lcall extern check_int32
- if (mt->is_unsigned) {
- | and r0, r0, #0xFF
- } else {
- | mov r0, r0, lsl #24
- | mov r0, r0, asr #24
- }
- | str r0, [DATA], #4
- break;
-
- case INT16_TYPE:
- | lcall extern check_int32
- if (mt->is_unsigned) {
- | mov r0, r0, lsl #16
- | mov r0, r0, lsr #16
- } else {
- | mov r0, r0, lsl #16
- | mov r0, r0, asr #16
- }
- | str r0, [DATA], #4
- break;
-
- case INT32_TYPE:
- if (mt->is_unsigned) {
- | lcall extern check_uint32
- } else {
- | lcall extern check_int32
- }
- | str r0, [DATA], #4
- break;
-
- case INT64_TYPE:
- if (mt->is_unsigned) {
- | lcall extern check_uint64
- } else {
- | lcall extern check_int64
- }
- | str r0, [DATA], #4
- | str r1, [DATA], #4
- break;
-
- case DOUBLE_TYPE:
- | lcall extern check_double
- | str r0, [DATA], #4
- | str r1, [DATA], #4
- break;
-
- case INTPTR_TYPE:
- | lcall extern check_intptr
- | str r0, [DATA], #4
- break;
-
- case FLOAT_TYPE:
- | lcall extern check_float
- | str r0, [DATA], #4
- break;
-
- default:
- luaL_error(L, "NYI: call arg type");
- }
- }
- }
-
- if (ct->has_var_arg) {
- | mov r3, DATA
- | mov r2, TOP
- | mov r1, #nargs+1
- | lcall extern unpack_varargs_stack
- }
-
- | load32 r0, &Dst->last_errno
- | ldr r0, [r0]
- | bl extern SetLastError
-
- | pop {r0, r1, r2, r3} // this pop is balanced with the sub sp, #16
- | bl extern FUNCTION
-
- |.macro get_errno
- | bl extern GetLastError
- | load32 r1, &Dst->last_errno
- | str r0, [r1]
- |.endmacro
-
- |.macro return
- | ldmdb r11, {TOP, L_ARG, DATA, r11, sp, pc}
- |.endmacro
-
- lua_rawgeti(L, ct_usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mt->pointers || mt->is_reference) {
- lua_getuservalue(L, -1);
- num_upvals += 2;
- | mov DATA, r0
- | get_errno
- | ldr r2, [pc, #4]
- | ldr r1, [pc, #4]
- | b >1
- |.long mt, lua_upvalueindex(num_upvals)
- |1:
- | lcall extern push_cdata
- | str DATA, [r0]
- | mov r0, #1
- | return
-
- } else {
- switch (mt->type) {
- case INT64_TYPE:
- num_upvals++;
- | mov DATA, r0
- | mov DATA2, r1
- | get_errno
- | lcall extern lua_pushnil
- | load32 r2, mt
- | mvn r1, #0 // -1
- | lcall extern push_cdata
- | str DATA, [r0]
- | str DATA2, [r0, #4]
- | mov r0, #1
- | return
- break;
-
- case INTPTR_TYPE:
- num_upvals++;
- | mov DATA, r0
- | get_errno
- | lcall extern lua_pushnil
- | load32 r2, mt
- | mvn r1, #0 // -1
- | lcall extern push_cdata
- | str DATA, [r0]
- | mov r0, #1
- | return
- break;
-
- case VOID_TYPE:
- lua_pop(L, 1);
- | get_errno
- | mov r0, #0
- | return
- break;
-
- case BOOL_TYPE:
- lua_pop(L, 1);
- | mov DATA, r0
- | get_errno
- | mov r1, DATA
- | lcall extern lua_pushboolean
- | mov r0, #1
- | return
- break;
-
- case INT8_TYPE:
- case INT16_TYPE:
- case INT32_TYPE:
- case ENUM_TYPE:
- lua_pop(L, 1);
- | mov DATA, r0
- | get_errno
- | mov r1, DATA
- if (mt->is_unsigned) {
- | lcall extern push_uint
- } else {
- | lcall extern push_int
- }
- | mov r0, #1
- | return
- break;
-
- case FLOAT_TYPE:
- lua_pop(L, 1);
- | mov DATA, r0
- | get_errno
- | mov r1, DATA
- | lcall extern push_float
- | mov r0, #1
- | return
- break;
-
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- | mov DATA, r0
- | mov DATA2, r1
- | get_errno
- | mov r2, DATA2
- | mov r1, DATA
- | lcall extern lua_pushnumber
- | mov r0, #1
- | return
- break;
-
- default:
- luaL_error(L, "NYI: call return type");
- }
- }
-
- assert(lua_gettop(L) == top + num_upvals);
- lua_pushcclosure(L, (lua_CFunction) compile(Dst, L, func, LUA_NOREF), num_upvals);
-}
-
diff --git a/plugins/MirLua/Modules/ffi/src/call_arm.h b/plugins/MirLua/Modules/ffi/src/call_arm.h deleted file mode 100644 index a84f69e762..0000000000 --- a/plugins/MirLua/Modules/ffi/src/call_arm.h +++ /dev/null @@ -1,1013 +0,0 @@ -/*
-** This file has been pre-processed with DynASM.
-** http://luajit.org/dynasm.html
-** DynASM version 1.3.0, DynASM arm version 1.3.0
-** DO NOT EDIT! The original file is in "call_arm.dasc".
-*/
-
-#if DASM_VERSION != 10300
-#error "Version mismatch between DynASM and included encoding engine"
-#endif
-
-/* vim: ts=4 sw=4 sts=4 et tw=78
- * Portions copyright (c) 2015-present, Facebook, Inc. All rights reserved.
- * Portions copyright (c) 2011 James R. McKaskill.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-static const unsigned int build_actionlist[546] = {
-0xe1a0c00d,
-0xe92d000f,
-0xe92d50f0,
-0xe24c6010,
-0xe59f5008,
-0xe59f2008,
-0xe59f1008,
-0xea000000,
-0x00050001,
-0x00090000,
-0x00090000,
-0x00090000,
-0x0006000b,
-0xe1a00005,
-0xeb000000,
-0x00030000,
-0x00000000,
-0xe3a02000,
-0x000b0000,
-0xe3e01000,
-0xe1a00005,
-0xeb000000,
-0x00030000,
-0x00000000,
-0xe3a02000,
-0x000b0000,
-0xe3e01000,
-0x000b0000,
-0xe1a00005,
-0xeb000000,
-0x00030000,
-0xe59f2000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe3e01000,
-0xe1a00005,
-0xeb000000,
-0x00030001,
-0xe4962004,
-0xe5802000,
-0xe3e01001,
-0xe1a00005,
-0xeb000000,
-0x00030002,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x00030003,
-0xe59f2000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe3e01000,
-0xe1a00005,
-0xeb000000,
-0x00030001,
-0xe4962004,
-0xe4963004,
-0xe5802000,
-0xe5803004,
-0xe3e01001,
-0xe1a00005,
-0xeb000000,
-0x00030002,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x00030003,
-0xe59f2000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe3e01000,
-0xe1a00005,
-0xeb000000,
-0x00030001,
-0xe4962004,
-0xe5802000,
-0xe3e01001,
-0xe1a00005,
-0xeb000000,
-0x00030002,
-0x00000000,
-0xe4961004,
-0xe1a00005,
-0xeb000000,
-0x00030004,
-0x00000000,
-0xe4961004,
-0xe1a01c01,
-0x00000000,
-0xe1a01c21,
-0x00000000,
-0xe1a01c41,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x00030005,
-0x00000000,
-0xe4961004,
-0xe1a01801,
-0x00000000,
-0xe1a01821,
-0x00000000,
-0xe1a01841,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x00030005,
-0x00000000,
-0xe4961004,
-0xe1a00005,
-0xeb000000,
-0x00030005,
-0x00000000,
-0xe4961004,
-0xe1a00005,
-0xeb000000,
-0x00030006,
-0x00000000,
-0xe8b60006,
-0xe1a00005,
-0xeb000000,
-0x00030007,
-0x00000000,
-0xe3a03000,
-0xe3a02000,
-0x000b0000,
-0xe3a01000,
-0x000b0000,
-0xe1a00005,
-0xeb000000,
-0x00030008,
-0x00000000,
-0xe3a02000,
-0x000b0000,
-0xe3e01001,
-0xe1a00005,
-0xeb000000,
-0x00030000,
-0xe59f3000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe3a02000,
-0xe3e01001,
-0xe1a00005,
-0xeb000000,
-0x00030009,
-0xe1a06000,
-0xe3e01003,
-0xe1a00005,
-0xeb000000,
-0x0003000a,
-0xe1a00006,
-0x00000000,
-0xe3a02000,
-0x000b0000,
-0xe3e01001,
-0xe1a00005,
-0xeb000000,
-0x00030000,
-0xe59f3000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe3e02000,
-0xe3e01001,
-0xe1a00005,
-0xeb000000,
-0x0003000b,
-0xe1a06000,
-0xe3e01003,
-0xe1a00005,
-0xeb000000,
-0x0003000a,
-0xe1a00006,
-0x00000000,
-0xe3e01001,
-0xe1a00005,
-0xeb000000,
-0x0003000a,
-0x00000000,
-0xe3e01000,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x0003000c,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x0003000d,
-0x00000000,
-0xe3e01000,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x0003000e,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x0003000f,
-0x00000000,
-0xe3e01000,
-0xe1a00005,
-0xeb000000,
-0x00030010,
-0x00000000,
-0xe3e01000,
-0xe1a00005,
-0xeb000000,
-0x00030011,
-0x00000000,
-0xe3e01000,
-0xe1a00005,
-0xeb000000,
-0x00030012,
-0x00000000,
-0xe1a06000,
-0xe3e01002,
-0xe1a00005,
-0xeb000000,
-0x0003000a,
-0xe1a00006,
-0x00000000,
-0xe1a06000,
-0xe1a07001,
-0xe3e01002,
-0xe1a00005,
-0xeb000000,
-0x0003000a,
-0xe1a00006,
-0xe1a01007,
-0x00000000,
-0xe89da0f0,
-0x00000000,
-0xe1a0c00d,
-0xe92d0001,
-0xe92d58f0,
-0xe24cb004,
-0xe1a05000,
-0xe1a00005,
-0xeb000000,
-0x00030013,
-0xe1a04000,
-0xe3540000,
-0x000b0000,
-0x00000000,
-0xaa000000,
-0x00050001,
-0xe59f1000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe1a00005,
-0xeb000000,
-0x00030014,
-0x0006000b,
-0x00000000,
-0x0a000000,
-0x00050001,
-0xe59f1000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe1a00005,
-0xeb000000,
-0x00030014,
-0x0006000b,
-0x00000000,
-0xe04dd184,
-0xe24dd010,
-0xe1a0600d,
-0x00000000,
-0xe59f3004,
-0xe59f2004,
-0xea000000,
-0x00050001,
-0x00090000,
-0x00090000,
-0x0006000b,
-0xe3a01000,
-0x000b0000,
-0xe1a00005,
-0x00000000,
-0xeb000000,
-0x00030009,
-0x00000000,
-0xeb000000,
-0x00030015,
-0x00000000,
-0xeb000000,
-0x0003000b,
-0x00000000,
-0xe4860004,
-0x00000000,
-0xe3a01000,
-0x000b0000,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x0003000d,
-0x00000000,
-0xe20000ff,
-0x00000000,
-0xe1a00c00,
-0xe1a00c40,
-0x00000000,
-0xe4860004,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x0003000d,
-0x00000000,
-0xe1a00800,
-0xe1a00820,
-0x00000000,
-0xe1a00800,
-0xe1a00840,
-0x00000000,
-0xe4860004,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x0003000c,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x0003000d,
-0x00000000,
-0xe4860004,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x0003000e,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x0003000f,
-0x00000000,
-0xe4860004,
-0xe4861004,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x00030012,
-0xe4860004,
-0xe4861004,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x00030010,
-0xe4860004,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x00030011,
-0xe4860004,
-0x00000000,
-0xe1a03006,
-0xe1a02004,
-0xe3a01000,
-0x000b0000,
-0xe1a00005,
-0xeb000000,
-0x00030016,
-0x00000000,
-0xe59f0000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe5900000,
-0xeb000000,
-0x00030017,
-0x00000000,
-0xe8bd000f,
-0xeb000000,
-0x00030018,
-0x00000000,
-0xe1a06000,
-0xeb000000,
-0x00030019,
-0xe59f1000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe5810000,
-0xe59f2004,
-0xe59f1004,
-0xea000000,
-0x00050001,
-0x00090000,
-0x00090000,
-0x0006000b,
-0xe1a00005,
-0xeb000000,
-0x00030001,
-0xe5806000,
-0xe3a00001,
-0xe91ba870,
-0x00000000,
-0xe1a06000,
-0xe1a07001,
-0xeb000000,
-0x00030019,
-0xe59f1000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe5810000,
-0xe1a00005,
-0xeb000000,
-0x00030003,
-0xe59f2000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe3e01000,
-0xe1a00005,
-0xeb000000,
-0x00030001,
-0xe5806000,
-0xe5807004,
-0xe3a00001,
-0xe91ba870,
-0x00000000,
-0xe1a06000,
-0xeb000000,
-0x00030019,
-0xe59f1000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe5810000,
-0xe1a00005,
-0xeb000000,
-0x00030003,
-0xe59f2000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe3e01000,
-0xe1a00005,
-0xeb000000,
-0x00030001,
-0xe5806000,
-0xe3a00001,
-0xe91ba870,
-0x00000000,
-0xeb000000,
-0x00030019,
-0xe59f1000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe5810000,
-0xe3a00000,
-0xe91ba870,
-0x00000000,
-0xe1a06000,
-0xeb000000,
-0x00030019,
-0xe59f1000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe5810000,
-0xe1a01006,
-0xe1a00005,
-0xeb000000,
-0x00030004,
-0xe3a00001,
-0xe91ba870,
-0x00000000,
-0xe1a06000,
-0xeb000000,
-0x00030019,
-0xe59f1000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe5810000,
-0xe1a01006,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x0003001a,
-0x00000000,
-0xe1a00005,
-0xeb000000,
-0x00030005,
-0x00000000,
-0xe3a00001,
-0xe91ba870,
-0x00000000,
-0xe1a06000,
-0xeb000000,
-0x00030019,
-0xe59f1000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe5810000,
-0xe1a01006,
-0xe1a00005,
-0xeb000000,
-0x00030006,
-0xe3a00001,
-0xe91ba870,
-0x00000000,
-0xe1a06000,
-0xe1a07001,
-0xeb000000,
-0x00030019,
-0xe59f1000,
-0xea000000,
-0x00050005,
-0x00090000,
-0x0006000f,
-0xe5810000,
-0xe1a02007,
-0xe1a01006,
-0xe1a00005,
-0xeb000000,
-0x00030007,
-0xe3a00001,
-0xe91ba870,
-0x00000000
-};
-
-static const char *const globnames[] = {
- (const char *)0
-};
-static const char *const extnames[] = {
- "lua_rawgeti",
- "push_cdata",
- "lua_remove",
- "lua_pushnil",
- "lua_pushboolean",
- "push_int",
- "push_float",
- "lua_pushnumber",
- "lua_callk",
- "to_typed_pointer",
- "lua_settop",
- "to_enum",
- "check_uint32",
- "check_int32",
- "check_uint64",
- "check_int64",
- "check_intptr",
- "check_float",
- "check_double",
- "lua_gettop",
- "luaL_error",
- "to_typed_function",
- "unpack_varargs_stack",
- "SetLastError",
- "FUNCTION",
- "GetLastError",
- "push_uint",
- (const char *)0
-};
-
-#define JUMP_SIZE 8
-#define MIN_BRANCH ((INT32_MIN) >> 8)
-#define MAX_BRANCH ((INT32_MAX) >> 8)
-#define BRANCH_OFF 4
-
-static void compile_extern_jump(struct jit* jit, lua_State* L, cfunction func, uint8_t* code)
-{
- /* The jump code is the function pointer followed by a stub to call the
- * function pointer. The stub exists so we can jump to functions with an
- * offset greater than 32MB.
- *
- * Note we have to manually set this up since there are commands buffered
- * in the jit state.
- */
- *(cfunction*) code = func;
- /* ldr pc, [pc - 12] */
- *(uint32_t*) &code[4] = 0xE51FF00CU;
-}
-
-
-
-
-void compile_globals(struct jit* jit, lua_State* L)
-{
- (void) jit;
-}
-
-cfunction compile_callback(lua_State* L, int fidx, int ct_usr, const struct ctype* ct)
-{
- struct jit* Dst = get_jit(L);;
- int i, nargs, num_upvals, ref;
- const struct ctype* mt;
-
- int top = lua_gettop(L);
-
- ct_usr = lua_absindex(L, ct_usr);
- fidx = lua_absindex(L, fidx);
- nargs = (int) lua_rawlen(L, ct_usr);
-
- dasm_setup(Dst, build_actionlist);
-
- lua_newtable(L);
- lua_pushvalue(L, -1);
- ref = luaL_ref(L, LUA_REGISTRYINDEX);
- num_upvals = 0;
-
- if (ct->has_var_arg) {
- luaL_error(L, "can't create callbacks with varargs");
- }
-
- /* prolog and get the upval table */
- dasm_put(Dst, 0, (uintptr_t)(L), (uintptr_t)(ref), (uintptr_t)(LUA_REGISTRYINDEX));
-
- /* get the lua function */
- lua_pushvalue(L, fidx);
- lua_rawseti(L, -2, ++num_upvals);
- dasm_put(Dst, 17, num_upvals);
-
- for (i = 1; i <= nargs; i++) {
- lua_rawgeti(L, ct_usr, i);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mt->pointers || mt->is_reference) {
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
-
- dasm_put(Dst, 24, num_upvals-1, i, (uintptr_t)(mt));
-
- } else {
- switch (mt->type) {
- case INT64_TYPE:
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- dasm_put(Dst, 47, (uintptr_t)(mt));
- break;
-
- case INTPTR_TYPE:
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- dasm_put(Dst, 68, (uintptr_t)(mt));
- break;
-
- case BOOL_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 87);
- break;
-
- case INT8_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 92);
- if (mt->is_unsigned) {
- dasm_put(Dst, 95);
- } else {
- dasm_put(Dst, 97);
- }
- dasm_put(Dst, 99);
- break;
-
- case INT16_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 103);
- if (mt->is_unsigned) {
- dasm_put(Dst, 106);
- } else {
- dasm_put(Dst, 108);
- }
- dasm_put(Dst, 110);
- break;
-
- case ENUM_TYPE:
- case INT32_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 114);
- break;
-
- case FLOAT_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 119);
- break;
-
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 124);
- break;
-
- default:
- luaL_error(L, "NYI: callback arg type");
- }
- }
- }
-
- lua_rawgeti(L, ct_usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- dasm_put(Dst, 129, ((mt->pointers || mt->is_reference || mt->type != VOID_TYPE) ? 1 : 0), nargs);
-
- if (mt->pointers || mt->is_reference) {
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
-
- dasm_put(Dst, 138, num_upvals-1, (uintptr_t)(mt));
- } else {
- switch (mt->type) {
- case ENUM_TYPE:
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
-
- dasm_put(Dst, 161, num_upvals-1, (uintptr_t)(mt));
- break;
-
- case VOID_TYPE:
- dasm_put(Dst, 184);
- lua_pop(L, 1);
- break;
-
- case BOOL_TYPE:
- case INT8_TYPE:
- case INT16_TYPE:
- case INT32_TYPE:
- dasm_put(Dst, 189);
- if (mt->is_unsigned) {
- dasm_put(Dst, 191);
- } else {
- dasm_put(Dst, 195);
- }
- goto single;
-
- case INT64_TYPE:
- dasm_put(Dst, 199);
- if (mt->is_unsigned) {
- dasm_put(Dst, 201);
- } else {
- dasm_put(Dst, 205);
- }
- goto dual;
-
- case INTPTR_TYPE:
- dasm_put(Dst, 209);
- goto single;
-
- case FLOAT_TYPE:
- dasm_put(Dst, 214);
- goto single;
-
- case DOUBLE_TYPE:
- dasm_put(Dst, 219);
- goto dual;
-
- single:
- dasm_put(Dst, 224);
- lua_pop(L, 1);
- break;
-
- dual:
- dasm_put(Dst, 231);
- lua_pop(L, 1);
- break;
-
- default:
- luaL_error(L, "NYI: callback return type");
- }
- }
-
- dasm_put(Dst, 240);
-
- lua_pop(L, 1); /* upval table - already in registry */
- assert(lua_gettop(L) == top);
-
- {
- void* p;
- struct ctype ft;
- cfunction func;
-
- func = compile(Dst, L, NULL, ref);
-
- ft = *ct;
- ft.is_jitted = 1;
- p = push_cdata(L, ct_usr, &ft);
- *(cfunction*) p = func;
-
- assert(lua_gettop(L) == top + 1);
-
- return func;
- }
-}
-
-void compile_function(lua_State* L, cfunction func, int ct_usr, const struct ctype* ct)
-{
- struct jit* Dst = get_jit(L);;
- int i, nargs, num_upvals;
- const struct ctype* mt;
- void* p;
-
- int top = lua_gettop(L);
-
- ct_usr = lua_absindex(L, ct_usr);
- nargs = (int) lua_rawlen(L, ct_usr);
-
- p = push_cdata(L, ct_usr, ct);
- *(cfunction*) p = func;
- num_upvals = 1;
-
- dasm_setup(Dst, build_actionlist);
-
- dasm_put(Dst, 242, nargs);
- if (ct->has_var_arg) {
- dasm_put(Dst, 254, (uintptr_t)("too few arguments"));
- } else {
- dasm_put(Dst, 266, (uintptr_t)("incorrect number of arguments"));
- }
-
- /* reserve enough stack space for all of the arguments (8 bytes per
- * argument for double and maintains alignment). Add an extra 16 bytes so
- * that the pop {r0, r1, r2, r3} doesn't clean out our stack frame */
- dasm_put(Dst, 278);
-
- for (i = 1; i <= nargs; i++) {
- lua_rawgeti(L, ct_usr, i);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mt->pointers || mt->is_reference || mt->type == FUNCTION_PTR_TYPE || mt->type == ENUM_TYPE) {
- lua_getuservalue(L, -1);
- num_upvals += 2;
-
- dasm_put(Dst, 282, (uintptr_t)(mt), (uintptr_t)(lua_upvalueindex(num_upvals)), i);
-
- if (mt->pointers || mt->is_reference) {
- dasm_put(Dst, 293);
- } else if (mt->type == FUNCTION_PTR_TYPE) {
- dasm_put(Dst, 296);
- } else if (mt->type == ENUM_TYPE) {
- dasm_put(Dst, 299);
- }
-
- dasm_put(Dst, 302);
-
- } else {
- lua_pop(L, 1);
- dasm_put(Dst, 304, i);
-
- switch (mt->type) {
- case INT8_TYPE:
- dasm_put(Dst, 307);
- if (mt->is_unsigned) {
- dasm_put(Dst, 311);
- } else {
- dasm_put(Dst, 313);
- }
- dasm_put(Dst, 316);
- break;
-
- case INT16_TYPE:
- dasm_put(Dst, 318);
- if (mt->is_unsigned) {
- dasm_put(Dst, 322);
- } else {
- dasm_put(Dst, 325);
- }
- dasm_put(Dst, 328);
- break;
-
- case INT32_TYPE:
- if (mt->is_unsigned) {
- dasm_put(Dst, 330);
- } else {
- dasm_put(Dst, 334);
- }
- dasm_put(Dst, 338);
- break;
-
- case INT64_TYPE:
- if (mt->is_unsigned) {
- dasm_put(Dst, 340);
- } else {
- dasm_put(Dst, 344);
- }
- dasm_put(Dst, 348);
- break;
-
- case DOUBLE_TYPE:
- dasm_put(Dst, 351);
- break;
-
- case INTPTR_TYPE:
- dasm_put(Dst, 357);
- break;
-
- case FLOAT_TYPE:
- dasm_put(Dst, 362);
- break;
-
- default:
- luaL_error(L, "NYI: call arg type");
- }
- }
- }
-
- if (ct->has_var_arg) {
- dasm_put(Dst, 367, nargs+1);
- }
-
- dasm_put(Dst, 375, (uintptr_t)(&Dst->last_errno));
-
- dasm_put(Dst, 384);
-
-
-
- lua_rawgeti(L, ct_usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mt->pointers || mt->is_reference) {
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 388, (uintptr_t)(&Dst->last_errno), (uintptr_t)(mt), (uintptr_t)(lua_upvalueindex(num_upvals)));
-
- } else {
- switch (mt->type) {
- case INT64_TYPE:
- num_upvals++;
- dasm_put(Dst, 411, (uintptr_t)(&Dst->last_errno), (uintptr_t)(mt));
- break;
-
- case INTPTR_TYPE:
- num_upvals++;
- dasm_put(Dst, 438, (uintptr_t)(&Dst->last_errno), (uintptr_t)(mt));
- break;
-
- case VOID_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 463, (uintptr_t)(&Dst->last_errno));
- break;
-
- case BOOL_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 474, (uintptr_t)(&Dst->last_errno));
- break;
-
- case INT8_TYPE:
- case INT16_TYPE:
- case INT32_TYPE:
- case ENUM_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 490, (uintptr_t)(&Dst->last_errno));
- if (mt->is_unsigned) {
- dasm_put(Dst, 501);
- } else {
- dasm_put(Dst, 505);
- }
- dasm_put(Dst, 509);
- break;
-
- case FLOAT_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 512, (uintptr_t)(&Dst->last_errno));
- break;
-
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 528, (uintptr_t)(&Dst->last_errno));
- break;
-
- default:
- luaL_error(L, "NYI: call return type");
- }
- }
-
- assert(lua_gettop(L) == top + num_upvals);
- lua_pushcclosure(L, (lua_CFunction) compile(Dst, L, func, LUA_NOREF), num_upvals);
-}
-
diff --git a/plugins/MirLua/Modules/ffi/src/call_x64.h b/plugins/MirLua/Modules/ffi/src/call_x64.h deleted file mode 100644 index 095118ec43..0000000000 --- a/plugins/MirLua/Modules/ffi/src/call_x64.h +++ /dev/null @@ -1,1210 +0,0 @@ -/*
-** This file has been pre-processed with DynASM.
-** http://luajit.org/dynasm.html
-** DynASM version 1.3.0, DynASM x64 version 1.3.0
-** DO NOT EDIT! The original file is in "call_x86.dasc".
-*/
-
-#if DASM_VERSION != 10300
-#error "Version mismatch between DynASM and included encoding engine"
-#endif
-
-/* vim: ts=4 sw=4 sts=4 et tw=78
- * Portions copyright (c) 2015-present, Facebook, Inc. All rights reserved.
- * Portions copyright (c) 2011 James R. McKaskill.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-static const unsigned char build_actionlist[2016] = {
- 248,10,184,1,0,0,0,76,139,109,252,240,76,139,101,252,248,72,137,252,236,93,
- 195,255,248,11,232,251,1,0,72,185,237,237,137,1,184,0,0,0,0,76,139,109,252,
- 240,76,139,101,252,248,72,137,252,236,93,195,255,248,12,102,15,214,68,36,
- 32,232,251,1,0,72,185,237,237,137,1,252,243,15,126,68,36,32,76,137,231,232,
- 251,1,1,252,233,244,10,255,248,13,15,182,192,137,68,36,32,232,251,1,0,72,
- 185,237,237,137,1,139,68,36,32,72,137,198,76,137,231,232,251,1,2,252,233,
- 244,10,255,248,14,137,68,36,32,232,251,1,0,72,185,237,237,137,1,139,68,36,
- 32,72,137,198,76,137,231,232,251,1,3,252,233,244,10,255,248,15,137,68,36,
- 32,232,251,1,0,72,185,237,237,137,1,139,68,36,32,72,137,198,76,137,231,232,
- 251,1,4,252,233,244,10,255,248,16,102,184,0,0,72,190,237,237,76,137,231,232,
- 251,1,5,255,248,17,102,184,0,0,72,190,237,237,76,137,231,232,251,1,5,255,
- 248,18,102,15,214,69,252,240,102,15,214,77,232,102,15,214,85,224,102,15,214,
- 93,216,102,15,214,101,208,102,15,214,109,200,102,15,214,117,192,102,15,214,
- 125,184,72,137,125,176,72,137,117,168,72,137,85,160,72,137,77,152,76,137,
- 69,144,76,137,77,136,195,255,72,139,141,233,255,72,137,132,253,36,233,255,
- 221,133,233,255,217,133,233,255,252,243,15,126,133,233,255,252,243,15,90,
- 133,233,255,221,156,253,36,233,255,217,156,253,36,233,255,102,15,214,132,
- 253,36,233,255,252,242,15,90,192,102,15,214,132,253,36,233,255,252,242,15,
- 90,192,102,15,126,132,253,36,233,255,85,72,137,229,65,84,72,129,252,236,239,
- 232,244,18,255,73,188,237,237,255,72,199,194,237,72,199,198,237,76,137,231,
- 232,251,1,6,255,72,199,194,237,72,199,198,252,255,252,255,252,255,252,255,
- 76,137,231,232,251,1,6,255,72,199,194,237,72,199,198,237,76,137,231,232,251,
- 1,6,72,186,237,237,72,199,198,252,255,252,255,252,255,252,255,76,137,231,
- 232,251,1,7,255,72,137,8,72,199,198,252,254,252,255,252,255,252,255,76,137,
- 231,232,251,1,8,255,72,186,237,237,72,199,198,0,0,0,0,76,137,231,232,251,
- 1,7,255,72,137,8,255,102,15,214,0,255,217,24,255,217,88,4,255,102,15,214,
- 64,8,255,76,137,231,232,251,1,1,255,15,182,201,72,137,206,76,137,231,232,
- 251,1,2,255,15,182,201,255,15,190,201,255,72,137,206,76,137,231,232,251,1,
- 3,255,15,183,201,255,15,191,201,255,72,137,206,76,137,231,232,251,1,4,255,
- 72,185,237,237,72,199,194,237,72,199,198,237,76,137,231,232,251,1,9,255,72,
- 199,194,237,72,199,198,252,254,252,255,252,255,252,255,76,137,231,232,251,
- 1,6,72,185,237,237,72,199,194,252,255,252,255,252,255,252,255,72,199,198,
- 252,254,252,255,252,255,252,255,76,137,231,232,251,1,10,72,137,68,36,32,72,
- 199,198,252,252,252,255,252,255,252,255,76,137,231,232,251,1,11,72,139,68,
- 36,32,255,72,199,194,237,72,199,198,252,254,252,255,252,255,252,255,76,137,
- 231,232,251,1,6,72,185,237,237,72,199,194,252,255,252,255,252,255,252,255,
- 72,199,198,252,254,252,255,252,255,252,255,76,137,231,232,251,1,12,137,68,
- 36,32,72,199,198,252,252,252,255,252,255,252,255,76,137,231,232,251,1,11,
- 139,68,36,32,255,72,199,198,252,254,252,255,252,255,252,255,76,137,231,232,
- 251,1,11,255,72,199,198,252,255,252,255,252,255,252,255,76,137,231,232,251,
- 1,13,255,72,199,198,252,255,252,255,252,255,252,255,76,137,231,232,251,1,
- 14,255,137,68,36,32,72,199,198,252,253,252,255,252,255,252,255,76,137,231,
- 232,251,1,11,139,68,36,32,255,72,199,198,252,255,252,255,252,255,252,255,
- 76,137,231,232,251,1,15,255,72,199,198,252,255,252,255,252,255,252,255,76,
- 137,231,232,251,1,16,255,72,137,68,36,32,72,199,198,252,253,252,255,252,255,
- 252,255,76,137,231,232,251,1,11,72,139,68,36,32,255,72,199,198,252,255,252,
- 255,252,255,252,255,76,137,231,232,251,1,17,72,137,68,36,32,72,199,198,252,
- 253,252,255,252,255,252,255,76,137,231,232,251,1,11,72,139,68,36,32,255,72,
- 199,198,252,255,252,255,252,255,252,255,76,137,231,232,251,1,18,102,15,214,
- 68,36,32,72,199,198,252,253,252,255,252,255,252,255,76,137,231,232,251,1,
- 11,255,252,242,15,90,68,36,32,255,252,243,15,126,68,36,32,255,72,199,198,
- 252,255,252,255,252,255,252,255,76,137,231,232,251,1,19,102,15,214,68,36,
- 32,72,199,198,252,253,252,255,252,255,252,255,76,137,231,232,251,1,11,252,
- 243,15,126,68,36,32,255,72,199,198,252,255,252,255,252,255,252,255,76,137,
- 231,232,251,1,20,102,15,214,68,36,32,102,15,214,76,36,40,72,199,198,252,253,
- 252,255,252,255,252,255,76,137,231,232,251,1,11,252,243,15,126,68,36,32,252,
- 243,15,126,76,36,40,255,72,139,141,233,72,199,194,252,255,252,255,252,255,
- 252,255,76,137,230,72,137,207,232,251,1,20,72,131,252,236,4,72,199,198,252,
- 253,252,255,252,255,252,255,76,137,231,232,251,1,11,255,76,139,101,252,248,
- 72,137,252,236,93,194,236,255,85,72,137,229,65,84,65,85,73,137,252,252,76,
- 137,231,232,251,1,21,73,137,197,72,129,252,248,239,15,140,244,16,255,15,143,
- 244,17,255,72,193,224,4,72,41,196,72,129,252,236,239,255,72,186,237,237,72,
- 199,198,0,0,0,0,76,137,231,232,251,1,7,72,131,252,236,16,255,72,185,237,237,
- 72,199,194,237,72,199,198,237,76,137,231,232,251,1,10,255,72,185,237,237,
- 72,199,194,237,72,199,198,237,76,137,231,232,251,1,22,255,72,185,237,237,
- 72,199,194,237,72,199,198,237,76,137,231,232,251,1,12,255,72,199,198,237,
- 76,137,231,232,251,1,14,255,15,182,192,255,15,190,192,255,15,183,192,255,
- 15,191,192,255,72,199,198,237,76,137,231,232,251,1,14,131,252,248,0,15,149,
- 208,15,182,192,255,72,199,198,237,76,137,231,232,251,1,13,255,72,199,198,
- 237,76,137,231,232,251,1,17,255,72,199,198,237,76,137,231,232,251,1,15,255,
- 72,199,198,237,76,137,231,232,251,1,16,255,72,199,198,237,76,137,231,232,
- 251,1,18,255,72,199,198,237,76,137,231,232,251,1,20,255,252,243,15,126,193,
- 255,72,141,132,253,36,233,72,131,252,236,4,72,199,194,237,76,137,230,72,137,
- 199,232,251,1,20,255,72,199,198,237,76,137,231,232,251,1,19,255,72,199,198,
- 237,76,137,231,232,251,1,19,137,4,36,217,4,36,255,137,20,36,217,4,36,255,
- 72,137,224,72,129,192,239,73,137,192,72,199,193,237,76,137,252,234,72,199,
- 198,237,76,137,231,232,251,1,23,255,72,137,224,72,129,192,239,73,137,192,
- 72,199,193,237,76,137,252,234,72,199,198,237,76,137,231,232,251,1,24,255,
- 72,137,224,72,129,192,239,73,137,193,73,199,192,237,72,199,193,237,76,137,
- 252,234,72,199,198,237,76,137,231,232,251,1,25,255,72,185,237,237,139,1,72,
- 137,199,232,251,1,26,255,72,131,196,32,255,252,243,15,126,188,253,36,233,
- 255,252,243,15,126,180,253,36,233,255,252,243,15,126,172,253,36,233,255,252,
- 243,15,126,164,253,36,233,255,252,243,15,126,156,253,36,233,255,252,243,15,
- 126,148,253,36,233,255,252,243,15,126,140,253,36,233,255,252,243,15,126,132,
- 253,36,233,255,76,139,140,253,36,233,255,76,139,132,253,36,233,255,72,139,
- 140,253,36,233,255,72,139,148,253,36,233,255,72,139,180,253,36,233,255,72,
- 139,60,36,255,72,129,196,239,255,176,8,255,232,251,1,27,72,131,252,236,48,
- 255,72,137,68,36,32,232,251,1,0,72,185,237,237,137,1,72,186,237,237,72,199,
- 198,237,76,137,231,232,251,1,7,72,139,76,36,32,72,137,8,252,233,244,10,255,
- 72,137,68,36,32,232,251,1,0,72,185,237,237,137,1,72,186,237,237,72,199,198,
- 0,0,0,0,76,137,231,232,251,1,7,72,139,76,36,32,72,137,8,252,233,244,10,255,
- 102,15,214,68,36,32,232,251,1,0,72,185,237,237,137,1,72,186,237,237,72,199,
- 198,237,76,137,231,232,251,1,7,72,139,76,36,32,72,137,8,252,233,244,10,255,
- 102,15,214,76,36,40,102,15,214,68,36,32,232,251,1,0,72,185,237,237,137,1,
- 72,186,237,237,72,199,198,237,76,137,231,232,251,1,7,72,139,76,36,40,72,137,
- 72,8,72,139,76,36,32,72,137,8,252,233,244,10,255,252,233,244,11,255,252,233,
- 244,13,255,252,233,244,14,255,252,233,244,15,255,252,243,15,90,192,252,233,
- 244,12,255
-};
-
-static const char *const globnames[] = {
- "lua_return_arg",
- "lua_return_void",
- "lua_return_double",
- "lua_return_bool",
- "lua_return_int",
- "lua_return_uint",
- "too_few_arguments",
- "too_many_arguments",
- "save_registers",
- (const char *)0
-};
-static const char *const extnames[] = {
- "GetLastError",
- "lua_pushnumber",
- "lua_pushboolean",
- "push_int",
- "push_uint",
- "luaL_error",
- "lua_rawgeti",
- "push_cdata",
- "lua_remove",
- "lua_callk",
- "check_typed_pointer",
- "lua_settop",
- "check_enum",
- "check_uint32",
- "check_int32",
- "check_uint64",
- "check_int64",
- "check_uintptr",
- "check_double",
- "check_complex_float",
- "check_complex_double",
- "lua_gettop",
- "check_typed_cfunction",
- "unpack_varargs_float",
- "unpack_varargs_int",
- "unpack_varargs_stack_skip",
- "SetLastError",
- "FUNCTION",
- (const char *)0
-};
-
-
-
-#if defined _WIN64 || defined __amd64__
-#define JUMP_SIZE 14
-#else
-#define JUMP_SIZE 4
-#endif
-
-#define MIN_BRANCH INT32_MIN
-#define MAX_BRANCH INT32_MAX
-#define BRANCH_OFF 4
-
-static void compile_extern_jump(struct jit* jit, lua_State* L, cfunction func, uint8_t* code)
-{
- /* The jump code is the function pointer followed by a stub to call the
- * function pointer. The stub exists in 64 bit so we can jump to functions
- * with an offset greater than 2 GB.
- *
- * Note we have to manually set this up since there are commands buffered
- * in the jit state and dynasm doesn't support rip relative addressing.
- *
- * eg on 64 bit:
- * 0-8: function ptr
- * 8-14: jmp aword [rip-14]
- *
- * for 32 bit we only set the function ptr as it can always fit in a 32
- * bit displacement
- */
-#if defined _WIN64 || defined __amd64__
- *(cfunction*) code = func;
- code[8] = 0xFF; /* FF /4 operand for jmp */
- code[9] = 0x25; /* RIP displacement */
- *(int32_t*) &code[10] = -14;
-#else
- *(cfunction*) code = func;
-#endif
-}
-
-void compile_globals(struct jit* jit, lua_State* L)
-{
- struct jit* Dst = jit;
- int* perr = &jit->last_errno;
- dasm_setup(Dst, build_actionlist);
-
- /* Note: since the return code uses EBP to reset the stack pointer, we
- * don't have to track the amount of stack space used. It also means we
- * can handle stdcall and cdecl with the same code.
- */
-
- /* Note the various call_* functions want 32 bytes of 16 byte aligned
- * stack
- */
-
-
-
-
- /* the general idea for the return functions is:
- * 1) Save return value on stack
- * 2) Call get_errno (this trashes the registers hence #1)
- * 3) Unpack return value from stack
- * 4) Call lua push function
- * 5) Set eax to number of returned args (0 or 1)
- * 6) Call return which pops our stack frame
- */
-
- dasm_put(Dst, 0);
-
- dasm_put(Dst, 24, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32));
-
- dasm_put(Dst, 58, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32));
-
- dasm_put(Dst, 95, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32));
-
- dasm_put(Dst, 133, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32));
-
- dasm_put(Dst, 168, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32));
-
- dasm_put(Dst, 203, (unsigned int)((uintptr_t)(&"too few arguments")), (unsigned int)(((uintptr_t)(&"too few arguments"))>>32));
-
- dasm_put(Dst, 221, (unsigned int)((uintptr_t)(&"too many arguments")), (unsigned int)(((uintptr_t)(&"too many arguments"))>>32));
-
- dasm_put(Dst, 239);
-
- compile(Dst, L, NULL, LUA_NOREF);
-}
-
-int x86_return_size(lua_State* L, int usr, const struct ctype* ct)
-{
- int ret = 0;
- const struct ctype* mt;
-
- if (ct->calling_convention != C_CALL) {
- size_t i;
- size_t argn = lua_rawlen(L, usr);
- for (i = 1; i <= argn; i++) {
- lua_rawgeti(L, usr, (int) i);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mt->pointers || mt->is_reference) {
- ret += sizeof(void*);
- } else {
- switch (mt->type) {
- case DOUBLE_TYPE:
- case COMPLEX_FLOAT_TYPE:
- case INT64_TYPE:
- ret += 8;
- break;
- case COMPLEX_DOUBLE_TYPE:
- ret += 16;
- break;
- case INTPTR_TYPE:
- ret += sizeof(intptr_t);
- break;
- case FUNCTION_PTR_TYPE:
- ret += sizeof(cfunction);
- break;
- case BOOL_TYPE:
- case FLOAT_TYPE:
- case INT8_TYPE:
- case INT16_TYPE:
- case INT32_TYPE:
- case ENUM_TYPE:
- ret += 4;
- break;
- default:
- return luaL_error(L, "NYI - argument type");
- }
- }
-
- lua_pop(L, 1);
- }
- }
-
-#if !defined _WIN64 && !defined __amd64__
- lua_rawgeti(L, usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
- if (!mt->pointers && !mt->is_reference && mt->type == COMPLEX_DOUBLE_TYPE) {
- ret += sizeof(void*);
- }
- lua_pop(L, 1);
-#endif
-
- return ret;
-}
-
-#ifdef _WIN64
-#define MAX_REGISTERS(ct) 4 /* rcx, rdx, r8, r9 */
-
-#elif defined __amd64__
-#define MAX_INT_REGISTERS(ct) 6 /* rdi, rsi, rdx, rcx, r8, r9 */
-#define MAX_FLOAT_REGISTERS(ct) 8 /* xmm0-7 */
-
-#else
-#define MAX_INT_REGISTERS(ct) ((ct)->calling_convention == FAST_CALL ? 2 /* ecx, edx */ : 0)
-#define MAX_FLOAT_REGISTERS(ct) 0
-#endif
-
-struct reg_alloc {
-#ifdef _WIN64
- int regs;
- int is_float[4];
- int is_int[4];
-#else
- int floats;
- int ints;
-#endif
- int off;
-};
-
-#ifdef _WIN64
-#define REGISTER_STACK_SPACE(ct) (4*8)
-#elif defined __amd64__
-#define REGISTER_STACK_SPACE(ct) (14*8)
-#else
-#define REGISTER_STACK_SPACE(ct) ALIGN_UP(((ct)->calling_convention == FAST_CALL ? 2*4 : 0), 15)
-#endif
-
-/* Fastcall:
- * Uses ecx, edx as first two int registers
- * Everything else on stack (include 64bit ints)
- * No overflow stack space
- * Pops the stack before returning
- * Returns int in eax, float in ST0
- * We use the same register allocation logic as posix x64 with 2 int regs and 0 float regs
- */
-
-static void get_int(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_int64)
-{
- /* grab the register from the shadow space */
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- dasm_put(Dst, 308, 16 + 8*reg->regs);
- reg->regs++;
- }
-#elif __amd64__
- if (reg->ints < MAX_INT_REGISTERS(ct)) {
- dasm_put(Dst, 308, - 80 - 8*reg->ints);
- reg->ints++;
- }
-#else
- if (!is_int64 && reg->ints < MAX_INT_REGISTERS(ct)) {
- dasm_put(Dst, 309, - 8 - 4*reg->ints);
- reg->ints++;
- }
-#endif
- else if (is_int64) {
- dasm_put(Dst, 308, reg->off);
- reg->off += 8;
- } else {
- dasm_put(Dst, 309, reg->off);
- reg->off += 4;
- }
-}
-
-static void add_int(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_int64)
-{
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- dasm_put(Dst, 313, 32 + 8*(reg->regs));
- reg->is_int[reg->regs++] = 1;
- }
-#elif __amd64__
- if (reg->ints < MAX_INT_REGISTERS(ct)) {
- dasm_put(Dst, 313, 32 + 8*reg->ints);
- reg->ints++;
- }
-#else
- if (!is_int64 && reg->ints < MAX_INT_REGISTERS(ct)) {
- dasm_put(Dst, 313, 32 + 4*reg->ints);
- reg->ints++;
- }
-#endif
- else {
-#if defined _WIN64 || defined __amd64__
- if (reg->off % 8 != 0) {
- reg->off += 8 - (reg->off % 8);
- }
-#endif
- if (is_int64) {
- dasm_put(Dst, 313, reg->off);
- reg->off += 8;
- } else {
- dasm_put(Dst, 314, reg->off);
- reg->off += 4;
- }
- }
-}
-
-static void get_float(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_double)
-{
-#if !defined _WIN64 && !defined __amd64__
- assert(MAX_FLOAT_REGISTERS(ct) == 0);
- if (is_double) {
- dasm_put(Dst, 320, reg->off);
- reg->off += 8;
- } else {
- dasm_put(Dst, 324, reg->off);
- reg->off += 4;
- }
-#else
- int off;
-
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- off = -16 - 8*reg->regs;
- reg->regs++;
- }
-#else
- if (reg->floats < MAX_FLOAT_REGISTERS(ct)) {
- off = -16 - 8*reg->floats;
- reg->floats++;
- }
-#endif
- else {
- off = reg->off;
- reg->off += is_double ? 8 : 4;
- }
-
- if (is_double) {
- dasm_put(Dst, 328, off);
- } else {
- dasm_put(Dst, 335, off);
- }
-#endif
-}
-
-static void add_float(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_double)
-{
-#if !defined _WIN64 && !defined __amd64__
- assert(MAX_FLOAT_REGISTERS(ct) == 0);
- if (is_double) {
- dasm_put(Dst, 342, reg->off);
- reg->off += 8;
- } else {
- dasm_put(Dst, 348, reg->off);
- reg->off += 4;
- }
-#else
-
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- if (is_double) {
- dasm_put(Dst, 354, 32 + 8*(reg->regs));
- } else {
- dasm_put(Dst, 362, 32 + 8*(reg->regs));
- }
- reg->is_float[reg->regs++] = 1;
- }
-#else
- if (reg->floats < MAX_FLOAT_REGISTERS(ct)) {
- if (is_double) {
- dasm_put(Dst, 354, 32 + 8*(MAX_INT_REGISTERS(ct) + reg->floats));
- } else {
- dasm_put(Dst, 362, 32 + 8*(MAX_INT_REGISTERS(ct) + reg->floats));
- }
- reg->floats++;
- }
-#endif
-
- else if (is_double) {
- dasm_put(Dst, 354, reg->off);
- reg->off += 8;
- } else {
- dasm_put(Dst, 375, reg->off);
- reg->off += 4;
- }
-#endif
-}
-
-#if defined _WIN64 || defined __amd64__
-#define add_pointer(jit, ct, reg) add_int(jit, ct, reg, 1)
-#define get_pointer(jit, ct, reg) get_int(jit, ct, reg, 1)
-#else
-#define add_pointer(jit, ct, reg) add_int(jit, ct, reg, 0)
-#define get_pointer(jit, ct, reg) get_int(jit, ct, reg, 0)
-#endif
-
-cfunction compile_callback(lua_State* L, int fidx, int ct_usr, const struct ctype* ct)
-{
- int i, nargs;
- cfunction* pf;
- struct ctype ct2 = *ct;
- const struct ctype* mt;
- struct reg_alloc reg;
- int num_upvals = 0;
- int top = lua_gettop(L);
- struct jit* Dst = get_jit(L);
- int ref;
- int hidden_arg_off = 0;
-
- ct_usr = lua_absindex(L, ct_usr);
- fidx = lua_absindex(L, fidx);
-
- assert(lua_isnil(L, fidx) || lua_isfunction(L, fidx));
-
- memset(®, 0, sizeof(reg));
-#ifdef _WIN64
- reg.off = 16 + REGISTER_STACK_SPACE(ct); /* stack registers are above the shadow space */
-#elif __amd64__
- reg.off = 16;
-#else
- reg.off = 8;
-#endif
-
- dasm_setup(Dst, build_actionlist);
-
- // add a table to store ctype and function upvalues
- // callback_set assumes the first value is the lua function
- nargs = (int) lua_rawlen(L, ct_usr);
- lua_newtable(L);
- lua_pushvalue(L, -1);
- ref = luaL_ref(L, LUA_REGISTRYINDEX);
-
- if (ct->has_var_arg) {
- luaL_error(L, "can't create callbacks with varargs");
- }
-
- // setup a stack frame to hold args for the call into lua_call
-
- dasm_put(Dst, 388, 8 + 16 + 32 + REGISTER_STACK_SPACE(ct));
- if (ct->calling_convention == FAST_CALL) {
- }
-
- // hardcode the lua_State* value into the assembly
- dasm_put(Dst, 403, (unsigned int)((uintptr_t)(L)), (unsigned int)(((uintptr_t)(L))>>32));
-
- /* get the upval table */
- dasm_put(Dst, 408, ref, LUA_REGISTRYINDEX);
-
- /* get the lua function */
- lua_pushvalue(L, fidx);
- lua_rawseti(L, -2, ++num_upvals);
- assert(num_upvals == CALLBACK_FUNC_USR_IDX);
- dasm_put(Dst, 424, num_upvals);
-
-#if !defined _WIN64 && !defined __amd64__
- lua_rawgeti(L, ct_usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
- if (!mt->pointers && !mt->is_reference && mt->type == COMPLEX_DOUBLE_TYPE) {
- hidden_arg_off = reg.off;
- reg.off += sizeof(void*);
- }
- lua_pop(L, 1);
-#else
- (void) hidden_arg_off;
-#endif
-
- for (i = 1; i <= nargs; i++) {
- lua_rawgeti(L, ct_usr, i);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mt->pointers || mt->is_reference) {
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- /* on the lua stack in the callback:
- * upval tbl, lua func, i-1 args
- */
- dasm_put(Dst, 447, num_upvals-1, -i-1, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
- get_pointer(Dst, ct, ®);
- dasm_put(Dst, 485);
- } else {
- switch (mt->type) {
- case INT64_TYPE:
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* mt */
- lua_pop(L, 1);
- dasm_put(Dst, 507, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
- get_int(Dst, ct, ®, 1);
- dasm_put(Dst, 526);
- break;
-
- case INTPTR_TYPE:
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* mt */
- lua_pop(L, 1);
- dasm_put(Dst, 507, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
- get_pointer(Dst, ct, ®);
- dasm_put(Dst, 526);
- break;
-
- case COMPLEX_FLOAT_TYPE:
- lua_pop(L, 1);
-#if defined _WIN64 || defined __amd64__
- /* complex floats are two floats packed into a double */
- dasm_put(Dst, 507, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
- get_float(Dst, ct, ®, 1);
- dasm_put(Dst, 530);
-#else
- /* complex floats are real followed by imag on the stack */
- dasm_put(Dst, 507, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
- get_float(Dst, ct, ®, 0);
- dasm_put(Dst, 535);
- get_float(Dst, ct, ®, 0);
- dasm_put(Dst, 538);
-#endif
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 507, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
- /* real */
- get_float(Dst, ct, ®, 1);
- dasm_put(Dst, 530);
- /* imag */
- get_float(Dst, ct, ®, 1);
- dasm_put(Dst, 542);
- break;
-
- case FLOAT_TYPE:
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- get_float(Dst, ct, ®, mt->type == DOUBLE_TYPE);
- dasm_put(Dst, 548);
- break;
-
- case BOOL_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- dasm_put(Dst, 556);
- break;
-
- case INT8_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- if (mt->is_unsigned) {
- dasm_put(Dst, 570);
- } else {
- dasm_put(Dst, 574);
- }
- dasm_put(Dst, 578);
- break;
-
- case INT16_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- if (mt->is_unsigned) {
- dasm_put(Dst, 589);
- } else {
- dasm_put(Dst, 593);
- }
- dasm_put(Dst, 578);
- break;
-
- case ENUM_TYPE:
- case INT32_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- if (mt->is_unsigned) {
- dasm_put(Dst, 597);
- } else {
- dasm_put(Dst, 578);
- }
- break;
-
- default:
- luaL_error(L, "NYI: callback arg type");
- }
- }
- }
-
- lua_rawgeti(L, ct_usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- dasm_put(Dst, 608, (unsigned int)((uintptr_t)(0)), (unsigned int)(((uintptr_t)(0))>>32), (mt->pointers || mt->is_reference || mt->type != VOID_TYPE) ? 1 : 0, nargs);
-
- // Unpack the return argument if not "void", also clean-up the lua stack
- // to remove the return argument and bind table. Use lua_settop rather
- // than lua_pop as lua_pop is implemented as a macro.
- if (mt->pointers || mt->is_reference) {
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- dasm_put(Dst, 628, num_upvals-1, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
-
- } else {
- switch (mt->type) {
- case ENUM_TYPE:
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- dasm_put(Dst, 712, num_upvals-1, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
- break;
-
- case VOID_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 794);
- break;
-
- case BOOL_TYPE:
- case INT8_TYPE:
- case INT16_TYPE:
- case INT32_TYPE:
- lua_pop(L, 1);
- if (mt->is_unsigned) {
- dasm_put(Dst, 813);
- } else {
- dasm_put(Dst, 832);
- }
- dasm_put(Dst, 851);
- break;
-
- case INT64_TYPE:
- lua_pop(L, 1);
-
- if (mt->is_unsigned) {
- dasm_put(Dst, 878);
- } else {
- dasm_put(Dst, 897);
- }
-
- dasm_put(Dst, 916);
- break;
-
- case INTPTR_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 945);
- break;
-
- case FLOAT_TYPE:
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 992);
- if (mt->type == FLOAT_TYPE) {
- dasm_put(Dst, 1035);
- } else {
- dasm_put(Dst, 1043);
- }
- break;
-
- case COMPLEX_FLOAT_TYPE:
- lua_pop(L, 1);
-#if !defined HAVE_COMPLEX
- luaL_error(L, "ffi lib compiled without complex number support");
-#endif
- /* on 64 bit complex floats are two floats packed into a double,
- * on 32 bit returned complex floats use eax and edx */
- dasm_put(Dst, 1051);
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- lua_pop(L, 1);
-#if !defined HAVE_COMPLEX
- luaL_error(L, "ffi lib compiled without complex number support");
-#endif
- /* on 64 bit, returned complex doubles use xmm0, xmm1, on 32 bit
- * there is a hidden first parameter that points to 16 bytes where
- * the returned arg is stored which is popped by the called
- * function */
-#if defined _WIN64 || defined __amd64__
- dasm_put(Dst, 1101);
-#else
- dasm_put(Dst, 1164, hidden_arg_off);
-#endif
- break;
-
- default:
- luaL_error(L, "NYI: callback return type");
- }
- }
-
- dasm_put(Dst, 1213, x86_return_size(L, ct_usr, ct));
-
- lua_pop(L, 1); /* upval table - already in registry */
- assert(lua_gettop(L) == top);
-
- ct2.is_jitted = 1;
- pf = (cfunction*) push_cdata(L, ct_usr, &ct2);
- *pf = compile(Dst, L, NULL, ref);
-
- assert(lua_gettop(L) == top + 1);
-
- return *pf;
-}
-
-void compile_function(lua_State* L, cfunction func, int ct_usr, const struct ctype* ct)
-{
- size_t i, nargs;
- int num_upvals;
- const struct ctype* mbr_ct;
- struct jit* Dst = get_jit(L);
- struct reg_alloc reg;
- void* p;
- int top = lua_gettop(L);
- int* perr = &Dst->last_errno;
-
- ct_usr = lua_absindex(L, ct_usr);
-
- memset(®, 0, sizeof(reg));
- reg.off = 32 + REGISTER_STACK_SPACE(ct);
-
- dasm_setup(Dst, build_actionlist);
-
- p = push_cdata(L, ct_usr, ct);
- *(cfunction*) p = func;
- num_upvals = 1;
-
- nargs = lua_rawlen(L, ct_usr);
-
- if (ct->calling_convention != C_CALL && ct->has_var_arg) {
- luaL_error(L, "vararg is only allowed with the c calling convention");
- }
-
- dasm_put(Dst, 1226, nargs);
-
- if (!ct->has_var_arg) {
- dasm_put(Dst, 1258);
- }
-
- /* no need to zero extend eax returned by lua_gettop to rax as x86-64
- * preguarentees that the upper 32 bits will be zero */
- dasm_put(Dst, 1263, 32 + REGISTER_STACK_SPACE(ct));
-
-#if !defined _WIN64 && !defined __amd64__
- /* Returned complex doubles require a hidden first parameter where the
- * data is stored, which is popped by the calling code. */
- lua_rawgeti(L, ct_usr, 0);
- mbr_ct = (const struct ctype*) lua_touserdata(L, -1);
- if (!mbr_ct->pointers && !mbr_ct->is_reference && mbr_ct->type == COMPLEX_DOUBLE_TYPE) {
- /* we can allocate more space for arguments as long as no add_*
- * function has been called yet, mbr_ct will be added as an upvalue in
- * the return processing later */
- dasm_put(Dst, 1276, (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32));
- add_pointer(Dst, ct, ®);
- }
- lua_pop(L, 1);
-#endif
-
- for (i = 1; i <= nargs; i++) {
- lua_rawgeti(L, ct_usr, (int) i);
- mbr_ct = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mbr_ct->pointers || mbr_ct->is_reference) {
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1300, (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32), lua_upvalueindex(num_upvals), i);
- add_pointer(Dst, ct, ®);
- } else {
- switch (mbr_ct->type) {
- case FUNCTION_PTR_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1320, (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32), lua_upvalueindex(num_upvals), i);
- add_pointer(Dst, ct, ®);
- break;
-
- case ENUM_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1340, (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32), lua_upvalueindex(num_upvals), i);
- add_int(Dst, ct, ®, 0);
- break;
-
- case INT8_TYPE:
- dasm_put(Dst, 1360, i);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1372);
- } else {
- dasm_put(Dst, 1376);
- }
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case INT16_TYPE:
- dasm_put(Dst, 1360, i);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1380);
- } else {
- dasm_put(Dst, 1384);
- }
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case BOOL_TYPE:
- dasm_put(Dst, 1388, i);
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case INT32_TYPE:
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1410, i);
- } else {
- dasm_put(Dst, 1360, i);
- }
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case INTPTR_TYPE:
- dasm_put(Dst, 1422, i);
- add_pointer(Dst, ct, ®);
- lua_pop(L, 1);
- break;
-
- case INT64_TYPE:
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1434, i);
- } else {
- dasm_put(Dst, 1446, i);
- }
- add_int(Dst, ct, ®, 1);
- lua_pop(L, 1);
- break;
-
- case DOUBLE_TYPE:
- dasm_put(Dst, 1458, i);
- add_float(Dst, ct, ®, 1);
- lua_pop(L, 1);
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- /* on 64 bit, returned complex doubles use xmm0, xmm1, on 32 bit
- * there is a hidden first parameter that points to 16 bytes where
- * the returned arg is stored (this is popped by the called
- * function) */
-#if defined _WIN64 || defined __amd64__
- dasm_put(Dst, 1470, i);
- add_float(Dst, ct, ®, 1);
- dasm_put(Dst, 1482);
- add_float(Dst, ct, ®, 1);
-#else
- dasm_put(Dst, 1488, reg.off, i);
- reg.off += 16;
-#endif
- lua_pop(L, 1);
- break;
-
- case FLOAT_TYPE:
- dasm_put(Dst, 1458, i);
- add_float(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case COMPLEX_FLOAT_TYPE:
-#if defined _WIN64 || defined __amd64__
- dasm_put(Dst, 1514, i);
- /* complex floats are two floats packed into a double */
- add_float(Dst, ct, ®, 1);
-#else
- /* returned complex floats use eax and edx */
- dasm_put(Dst, 1526, i);
- add_float(Dst, ct, ®, 0);
- dasm_put(Dst, 1544);
- add_float(Dst, ct, ®, 0);
-#endif
- lua_pop(L, 1);
- break;
-
- default:
- luaL_error(L, "NYI: call arg type");
- }
- }
- }
-
- if (ct->has_var_arg) {
-#ifdef _WIN64
- if (reg.regs < MAX_REGISTERS(ct)) {
- assert(reg.regs == nargs);
- } else {
- }
-
- for (i = nargs; i < MAX_REGISTERS(ct); i++) {
- reg.is_int[i] = reg.is_float[i] = 1;
- }
- reg.regs = MAX_REGISTERS(ct);
-#elif defined __amd64__
- if (reg.floats < MAX_FLOAT_REGISTERS(ct)) {
- dasm_put(Dst, 1551, 32 + 8*(MAX_INT_REGISTERS(ct) + reg.floats), MAX_FLOAT_REGISTERS(ct) - reg.floats, nargs+1);
- }
-
- if (reg.ints < MAX_INT_REGISTERS(ct)) {
- dasm_put(Dst, 1581, 32 + 8*(reg.ints), MAX_INT_REGISTERS(ct) - reg.ints, nargs+1);
- }
-
- dasm_put(Dst, 1611, reg.off, MAX_FLOAT_REGISTERS(ct) - reg.floats, MAX_INT_REGISTERS(ct) - reg.ints, nargs+1);
-
- reg.floats = MAX_FLOAT_REGISTERS(ct);
- reg.ints = MAX_INT_REGISTERS(ct);
-#else
-#endif
- }
-
- dasm_put(Dst, 1645, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32));
-
- /* remove the stack space to call local functions */
- dasm_put(Dst, 1659);
-
-#ifdef _WIN64
- switch (reg.regs) {
- case 4:
- if (reg.is_float[3]) {
- }
- if (reg.is_int[3]) {
- }
- case 3:
- if (reg.is_float[2]) {
- }
- if (reg.is_int[2]) {
- }
- case 2:
- if (reg.is_float[1]) {
- }
- if (reg.is_int[1]) {
- }
- case 1:
- if (reg.is_float[0]) {
- }
- if (reg.is_int[0]) {
- }
- case 0:
- break;
- }
-
- /* don't remove the space for the registers as we need 32 bytes of register overflow space */
- assert(REGISTER_STACK_SPACE(ct) == 32);
-
-#elif defined __amd64__
- switch (reg.floats) {
- case 8:
- dasm_put(Dst, 1664, 8*(MAX_INT_REGISTERS(ct)+7));
- case 7:
- dasm_put(Dst, 1673, 8*(MAX_INT_REGISTERS(ct)+6));
- case 6:
- dasm_put(Dst, 1682, 8*(MAX_INT_REGISTERS(ct)+5));
- case 5:
- dasm_put(Dst, 1691, 8*(MAX_INT_REGISTERS(ct)+4));
- case 4:
- dasm_put(Dst, 1700, 8*(MAX_INT_REGISTERS(ct)+3));
- case 3:
- dasm_put(Dst, 1709, 8*(MAX_INT_REGISTERS(ct)+2));
- case 2:
- dasm_put(Dst, 1718, 8*(MAX_INT_REGISTERS(ct)+1));
- case 1:
- dasm_put(Dst, 1727, 8*(MAX_INT_REGISTERS(ct)));
- case 0:
- break;
- }
-
- switch (reg.ints) {
- case 6:
- dasm_put(Dst, 1736, 8*5);
- case 5:
- dasm_put(Dst, 1743, 8*4);
- case 4:
- dasm_put(Dst, 1750, 8*3);
- case 3:
- dasm_put(Dst, 1757, 8*2);
- case 2:
- dasm_put(Dst, 1764, 8*1);
- case 1:
- dasm_put(Dst, 1771);
- case 0:
- break;
- }
-
- dasm_put(Dst, 1776, REGISTER_STACK_SPACE(ct));
-#else
- if (ct->calling_convention == FAST_CALL) {
- switch (reg.ints) {
- case 2:
- case 1:
- case 0:
- break;
- }
-
- }
-#endif
-
-#ifdef __amd64__
- if (ct->has_var_arg) {
- /* al stores an upper limit on the number of float register, note that
- * its allowed to be more than the actual number of float registers used as
- * long as its 0-8 */
- dasm_put(Dst, 1781);
- }
-#endif
-
- dasm_put(Dst, 1784);
-
- /* note on windows X86 the stack may be only aligned to 4 (stdcall will
- * have popped a multiple of 4 bytes), but we don't need 16 byte alignment on
- * that platform
- */
-
- lua_rawgeti(L, ct_usr, 0);
- mbr_ct = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mbr_ct->pointers || mbr_ct->is_reference || mbr_ct->type == INTPTR_TYPE) {
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1794, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32), (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32), lua_upvalueindex(num_upvals));
-
- } else {
- switch (mbr_ct->type) {
- case FUNCTION_PTR_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1794, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32), (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32), lua_upvalueindex(num_upvals));
- break;
-
- case INT64_TYPE:
- num_upvals++;
- dasm_put(Dst, 1837, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32), (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32));
- break;
-
- case COMPLEX_FLOAT_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1883, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32), (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32), lua_upvalueindex(num_upvals));
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1927, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32), (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32), lua_upvalueindex(num_upvals));
- break;
-
- case VOID_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 1986);
- break;
-
- case BOOL_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 1991);
- break;
-
- case INT8_TYPE:
- lua_pop(L, 1);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1372);
- } else {
- dasm_put(Dst, 1376);
- }
- dasm_put(Dst, 1996);
- break;
-
- case INT16_TYPE:
- lua_pop(L, 1);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1380);
- } else {
- dasm_put(Dst, 1384);
- }
- dasm_put(Dst, 1996);
- break;
-
- case INT32_TYPE:
- case ENUM_TYPE:
- lua_pop(L, 1);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 2001);
- } else {
- dasm_put(Dst, 1996);
- }
- break;
-
- case FLOAT_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 2006);
- break;
-
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 2011);
- break;
-
- default:
- luaL_error(L, "NYI: call return type");
- }
- }
-
- assert(lua_gettop(L) == top + num_upvals);
- {
- cfunction f = compile(Dst, L, func, LUA_NOREF);
- /* add a callback as an upval so that the jitted code gets cleaned up when
- * the function gets gc'd */
- push_callback(L, f, func);
- lua_pushcclosure(L, (lua_CFunction) f, num_upvals+1);
- }
-}
-
diff --git a/plugins/MirLua/Modules/ffi/src/call_x64win.h b/plugins/MirLua/Modules/ffi/src/call_x64win.h deleted file mode 100644 index fae36a0f96..0000000000 --- a/plugins/MirLua/Modules/ffi/src/call_x64win.h +++ /dev/null @@ -1,1196 +0,0 @@ -/*
-** This file has been pre-processed with DynASM.
-** http://luajit.org/dynasm.html
-** DynASM version 1.3.0, DynASM x64 version 1.3.0
-** DO NOT EDIT! The original file is in "call_x86.dasc".
-*/
-
-#if DASM_VERSION != 10300
-#error "Version mismatch between DynASM and included encoding engine"
-#endif
-
-/* vim: ts=4 sw=4 sts=4 et tw=78
- * Portions copyright (c) 2015-present, Facebook, Inc. All rights reserved.
- * Portions copyright (c) 2011 James R. McKaskill.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-static const unsigned char build_actionlist[1959] = {
- 248,10,184,1,0,0,0,76,139,109,252,240,76,139,101,252,248,72,137,252,236,93,
- 195,255,248,11,232,251,1,0,72,185,237,237,137,1,184,0,0,0,0,76,139,109,252,
- 240,76,139,101,252,248,72,137,252,236,93,195,255,248,12,102,15,214,68,36,
- 32,232,251,1,0,72,185,237,237,137,1,252,243,15,126,76,36,32,76,137,225,232,
- 251,1,1,252,233,244,10,255,248,13,15,182,192,137,68,36,32,232,251,1,0,72,
- 185,237,237,137,1,139,68,36,32,72,137,194,76,137,225,232,251,1,2,252,233,
- 244,10,255,248,14,137,68,36,32,232,251,1,0,72,185,237,237,137,1,139,68,36,
- 32,72,137,194,76,137,225,232,251,1,3,252,233,244,10,255,248,15,137,68,36,
- 32,232,251,1,0,72,185,237,237,137,1,139,68,36,32,72,137,194,76,137,225,232,
- 251,1,4,252,233,244,10,255,248,16,102,184,0,0,72,186,237,237,76,137,225,232,
- 251,1,5,255,248,17,102,184,0,0,72,186,237,237,76,137,225,232,251,1,5,255,
- 248,18,72,137,77,16,72,137,85,24,76,137,69,32,76,137,77,40,102,15,214,69,
- 252,240,102,15,214,77,232,102,15,214,85,224,102,15,214,93,216,195,255,72,
- 139,141,233,255,72,137,132,253,36,233,255,221,133,233,255,217,133,233,255,
- 252,243,15,126,133,233,255,252,243,15,90,133,233,255,221,156,253,36,233,255,
- 217,156,253,36,233,255,102,15,214,132,253,36,233,255,252,242,15,90,192,102,
- 15,214,132,253,36,233,255,252,242,15,90,192,102,15,126,132,253,36,233,255,
- 85,72,137,229,65,84,72,129,252,236,239,232,244,18,255,73,188,237,237,255,
- 73,199,192,237,72,199,194,237,76,137,225,232,251,1,6,255,73,199,192,237,72,
- 199,194,252,255,252,255,252,255,252,255,76,137,225,232,251,1,6,255,73,199,
- 192,237,72,199,194,237,76,137,225,232,251,1,6,73,184,237,237,72,199,194,252,
- 255,252,255,252,255,252,255,76,137,225,232,251,1,7,255,72,137,8,72,199,194,
- 252,254,252,255,252,255,252,255,76,137,225,232,251,1,8,255,73,184,237,237,
- 72,199,194,0,0,0,0,76,137,225,232,251,1,7,255,72,137,8,255,102,15,214,0,255,
- 217,24,255,217,88,4,255,102,15,214,64,8,255,252,243,15,126,200,76,137,225,
- 232,251,1,1,255,15,182,201,72,137,202,76,137,225,232,251,1,2,255,15,182,201,
- 255,15,190,201,255,72,137,202,76,137,225,232,251,1,3,255,15,183,201,255,15,
- 191,201,255,72,137,202,76,137,225,232,251,1,4,255,73,185,237,237,73,199,192,
- 237,72,199,194,237,76,137,225,232,251,1,9,255,73,199,192,237,72,199,194,252,
- 254,252,255,252,255,252,255,76,137,225,232,251,1,6,73,185,237,237,73,199,
- 192,252,255,252,255,252,255,252,255,72,199,194,252,254,252,255,252,255,252,
- 255,76,137,225,232,251,1,10,72,137,68,36,32,72,199,194,252,252,252,255,252,
- 255,252,255,76,137,225,232,251,1,11,72,139,68,36,32,255,73,199,192,237,72,
- 199,194,252,254,252,255,252,255,252,255,76,137,225,232,251,1,6,73,185,237,
- 237,73,199,192,252,255,252,255,252,255,252,255,72,199,194,252,254,252,255,
- 252,255,252,255,76,137,225,232,251,1,12,137,68,36,32,72,199,194,252,252,252,
- 255,252,255,252,255,76,137,225,232,251,1,11,139,68,36,32,255,72,199,194,252,
- 254,252,255,252,255,252,255,76,137,225,232,251,1,11,255,72,199,194,252,255,
- 252,255,252,255,252,255,76,137,225,232,251,1,13,255,72,199,194,252,255,252,
- 255,252,255,252,255,76,137,225,232,251,1,14,255,137,68,36,32,72,199,194,252,
- 253,252,255,252,255,252,255,76,137,225,232,251,1,11,139,68,36,32,255,72,199,
- 194,252,255,252,255,252,255,252,255,76,137,225,232,251,1,15,255,72,199,194,
- 252,255,252,255,252,255,252,255,76,137,225,232,251,1,16,255,72,137,68,36,
- 32,72,199,194,252,253,252,255,252,255,252,255,76,137,225,232,251,1,11,72,
- 139,68,36,32,255,72,199,194,252,255,252,255,252,255,252,255,76,137,225,232,
- 251,1,17,72,137,68,36,32,72,199,194,252,253,252,255,252,255,252,255,76,137,
- 225,232,251,1,11,72,139,68,36,32,255,72,199,194,252,255,252,255,252,255,252,
- 255,76,137,225,232,251,1,18,102,15,214,68,36,32,72,199,194,252,253,252,255,
- 252,255,252,255,76,137,225,232,251,1,11,255,252,242,15,90,68,36,32,255,252,
- 243,15,126,68,36,32,255,72,199,194,252,255,252,255,252,255,252,255,76,137,
- 225,232,251,1,19,102,15,214,68,36,32,72,199,194,252,253,252,255,252,255,252,
- 255,76,137,225,232,251,1,11,252,243,15,126,68,36,32,255,72,199,194,252,255,
- 252,255,252,255,252,255,76,137,225,232,251,1,20,102,15,214,68,36,32,102,15,
- 214,76,36,40,72,199,194,252,253,252,255,252,255,252,255,76,137,225,232,251,
- 1,11,252,243,15,126,68,36,32,252,243,15,126,76,36,40,255,72,139,141,233,73,
- 199,192,252,255,252,255,252,255,252,255,76,137,226,72,137,201,232,251,1,20,
- 72,131,252,236,4,72,199,194,252,253,252,255,252,255,252,255,76,137,225,232,
- 251,1,11,255,76,139,101,252,248,72,137,252,236,93,194,236,255,85,72,137,229,
- 65,84,65,85,73,137,204,72,131,252,236,32,76,137,225,232,251,1,21,73,137,197,
- 72,129,252,248,239,15,140,244,16,255,15,143,244,17,255,72,193,224,4,72,41,
- 196,72,129,252,236,239,255,73,184,237,237,72,199,194,0,0,0,0,76,137,225,232,
- 251,1,7,72,131,252,236,16,255,73,185,237,237,73,199,192,237,72,199,194,237,
- 76,137,225,232,251,1,10,255,73,185,237,237,73,199,192,237,72,199,194,237,
- 76,137,225,232,251,1,22,255,73,185,237,237,73,199,192,237,72,199,194,237,
- 76,137,225,232,251,1,12,255,72,199,194,237,76,137,225,232,251,1,14,255,15,
- 182,192,255,15,190,192,255,15,183,192,255,15,191,192,255,72,199,194,237,76,
- 137,225,232,251,1,14,131,252,248,0,15,149,208,15,182,192,255,72,199,194,237,
- 76,137,225,232,251,1,13,255,72,199,194,237,76,137,225,232,251,1,17,255,72,
- 199,194,237,76,137,225,232,251,1,15,255,72,199,194,237,76,137,225,232,251,
- 1,16,255,72,199,194,237,76,137,225,232,251,1,18,255,72,199,194,237,76,137,
- 225,232,251,1,20,255,252,243,15,126,193,255,72,141,132,253,36,233,72,131,
- 252,236,4,73,199,192,237,76,137,226,72,137,193,232,251,1,20,255,72,199,194,
- 237,76,137,225,232,251,1,19,255,72,199,194,237,76,137,225,232,251,1,19,137,
- 4,36,217,4,36,255,137,20,36,217,4,36,255,73,129,252,253,239,15,142,244,247,
- 72,137,224,72,129,192,239,73,137,193,77,137,232,72,199,194,237,76,137,225,
- 232,251,1,23,72,137,224,72,129,192,239,73,137,193,73,199,192,237,72,199,194,
- 237,76,137,225,232,251,1,24,252,233,244,248,248,1,72,137,224,72,129,192,239,
- 73,137,193,77,137,232,72,199,194,237,76,137,225,232,251,1,24,248,2,255,72,
- 137,224,72,129,192,239,73,137,193,77,137,232,72,199,194,237,76,137,225,232,
- 251,1,23,255,72,185,237,237,139,1,72,137,193,232,251,1,25,255,72,131,196,
- 32,255,252,243,15,126,156,253,36,233,255,76,139,140,253,36,233,255,252,243,
- 15,126,148,253,36,233,255,76,139,132,253,36,233,255,252,243,15,126,140,253,
- 36,233,255,72,139,148,253,36,233,255,252,243,15,126,4,36,255,72,139,12,36,
- 255,232,251,1,26,72,131,252,236,48,255,72,137,68,36,32,232,251,1,0,72,185,
- 237,237,137,1,73,184,237,237,72,199,194,237,76,137,225,232,251,1,7,72,139,
- 76,36,32,72,137,8,252,233,244,10,255,72,137,68,36,32,232,251,1,0,72,185,237,
- 237,137,1,73,184,237,237,72,199,194,0,0,0,0,76,137,225,232,251,1,7,72,139,
- 76,36,32,72,137,8,252,233,244,10,255,102,15,214,68,36,32,232,251,1,0,72,185,
- 237,237,137,1,73,184,237,237,72,199,194,237,76,137,225,232,251,1,7,72,139,
- 76,36,32,72,137,8,252,233,244,10,255,102,15,214,76,36,40,102,15,214,68,36,
- 32,232,251,1,0,72,185,237,237,137,1,73,184,237,237,72,199,194,237,76,137,
- 225,232,251,1,7,72,139,76,36,40,72,137,72,8,72,139,76,36,32,72,137,8,252,
- 233,244,10,255,252,233,244,11,255,252,233,244,13,255,252,233,244,14,255,252,
- 233,244,15,255,252,243,15,90,192,252,233,244,12,255
-};
-
-static const char *const globnames[] = {
- "lua_return_arg",
- "lua_return_void",
- "lua_return_double",
- "lua_return_bool",
- "lua_return_int",
- "lua_return_uint",
- "too_few_arguments",
- "too_many_arguments",
- "save_registers",
- (const char *)0
-};
-static const char *const extnames[] = {
- "GetLastError",
- "lua_pushnumber",
- "lua_pushboolean",
- "push_int",
- "push_uint",
- "luaL_error",
- "lua_rawgeti",
- "push_cdata",
- "lua_remove",
- "lua_callk",
- "check_typed_pointer",
- "lua_settop",
- "check_enum",
- "check_uint32",
- "check_int32",
- "check_uint64",
- "check_int64",
- "check_uintptr",
- "check_double",
- "check_complex_float",
- "check_complex_double",
- "lua_gettop",
- "check_typed_cfunction",
- "unpack_varargs_stack",
- "unpack_varargs_reg",
- "SetLastError",
- "FUNCTION",
- (const char *)0
-};
-
-
-
-#if defined _WIN64 || defined __amd64__
-#define JUMP_SIZE 14
-#else
-#define JUMP_SIZE 4
-#endif
-
-#define MIN_BRANCH INT32_MIN
-#define MAX_BRANCH INT32_MAX
-#define BRANCH_OFF 4
-
-static void compile_extern_jump(struct jit* jit, lua_State* L, cfunction func, uint8_t* code)
-{
- /* The jump code is the function pointer followed by a stub to call the
- * function pointer. The stub exists in 64 bit so we can jump to functions
- * with an offset greater than 2 GB.
- *
- * Note we have to manually set this up since there are commands buffered
- * in the jit state and dynasm doesn't support rip relative addressing.
- *
- * eg on 64 bit:
- * 0-8: function ptr
- * 8-14: jmp aword [rip-14]
- *
- * for 32 bit we only set the function ptr as it can always fit in a 32
- * bit displacement
- */
-#if defined _WIN64 || defined __amd64__
- *(cfunction*) code = func;
- code[8] = 0xFF; /* FF /4 operand for jmp */
- code[9] = 0x25; /* RIP displacement */
- *(int32_t*) &code[10] = -14;
-#else
- *(cfunction*) code = func;
-#endif
-}
-
-void compile_globals(struct jit* jit, lua_State* L)
-{
- struct jit* Dst = jit;
- int* perr = &jit->last_errno;
- dasm_setup(Dst, build_actionlist);
-
- /* Note: since the return code uses EBP to reset the stack pointer, we
- * don't have to track the amount of stack space used. It also means we
- * can handle stdcall and cdecl with the same code.
- */
-
- /* Note the various call_* functions want 32 bytes of 16 byte aligned
- * stack
- */
-
-
-
-
- /* the general idea for the return functions is:
- * 1) Save return value on stack
- * 2) Call get_errno (this trashes the registers hence #1)
- * 3) Unpack return value from stack
- * 4) Call lua push function
- * 5) Set eax to number of returned args (0 or 1)
- * 6) Call return which pops our stack frame
- */
-
- dasm_put(Dst, 0);
-
- dasm_put(Dst, 24, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32));
-
- dasm_put(Dst, 58, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32));
-
- dasm_put(Dst, 95, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32));
-
- dasm_put(Dst, 133, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32));
-
- dasm_put(Dst, 168, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32));
-
- dasm_put(Dst, 203, (unsigned int)((uintptr_t)(&"too few arguments")), (unsigned int)(((uintptr_t)(&"too few arguments"))>>32));
-
- dasm_put(Dst, 221, (unsigned int)((uintptr_t)(&"too many arguments")), (unsigned int)(((uintptr_t)(&"too many arguments"))>>32));
-
- dasm_put(Dst, 239);
-
- compile(Dst, L, NULL, LUA_NOREF);
-}
-
-int x86_return_size(lua_State* L, int usr, const struct ctype* ct)
-{
- int ret = 0;
- const struct ctype* mt;
-
- if (ct->calling_convention != C_CALL) {
- size_t i;
- size_t argn = lua_rawlen(L, usr);
- for (i = 1; i <= argn; i++) {
- lua_rawgeti(L, usr, (int) i);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mt->pointers || mt->is_reference) {
- ret += sizeof(void*);
- } else {
- switch (mt->type) {
- case DOUBLE_TYPE:
- case COMPLEX_FLOAT_TYPE:
- case INT64_TYPE:
- ret += 8;
- break;
- case COMPLEX_DOUBLE_TYPE:
- ret += 16;
- break;
- case INTPTR_TYPE:
- ret += sizeof(intptr_t);
- break;
- case FUNCTION_PTR_TYPE:
- ret += sizeof(cfunction);
- break;
- case BOOL_TYPE:
- case FLOAT_TYPE:
- case INT8_TYPE:
- case INT16_TYPE:
- case INT32_TYPE:
- case ENUM_TYPE:
- ret += 4;
- break;
- default:
- return luaL_error(L, "NYI - argument type");
- }
- }
-
- lua_pop(L, 1);
- }
- }
-
-#if !defined _WIN64 && !defined __amd64__
- lua_rawgeti(L, usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
- if (!mt->pointers && !mt->is_reference && mt->type == COMPLEX_DOUBLE_TYPE) {
- ret += sizeof(void*);
- }
- lua_pop(L, 1);
-#endif
-
- return ret;
-}
-
-#ifdef _WIN64
-#define MAX_REGISTERS(ct) 4 /* rcx, rdx, r8, r9 */
-
-#elif defined __amd64__
-#define MAX_INT_REGISTERS(ct) 6 /* rdi, rsi, rdx, rcx, r8, r9 */
-#define MAX_FLOAT_REGISTERS(ct) 8 /* xmm0-7 */
-
-#else
-#define MAX_INT_REGISTERS(ct) ((ct)->calling_convention == FAST_CALL ? 2 /* ecx, edx */ : 0)
-#define MAX_FLOAT_REGISTERS(ct) 0
-#endif
-
-struct reg_alloc {
-#ifdef _WIN64
- int regs;
- int is_float[4];
- int is_int[4];
-#else
- int floats;
- int ints;
-#endif
- int off;
-};
-
-#ifdef _WIN64
-#define REGISTER_STACK_SPACE(ct) (4*8)
-#elif defined __amd64__
-#define REGISTER_STACK_SPACE(ct) (14*8)
-#else
-#define REGISTER_STACK_SPACE(ct) ALIGN_UP(((ct)->calling_convention == FAST_CALL ? 2*4 : 0), 15)
-#endif
-
-/* Fastcall:
- * Uses ecx, edx as first two int registers
- * Everything else on stack (include 64bit ints)
- * No overflow stack space
- * Pops the stack before returning
- * Returns int in eax, float in ST0
- * We use the same register allocation logic as posix x64 with 2 int regs and 0 float regs
- */
-
-static void get_int(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_int64)
-{
- /* grab the register from the shadow space */
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- dasm_put(Dst, 280, 16 + 8*reg->regs);
- reg->regs++;
- }
-#elif __amd64__
- if (reg->ints < MAX_INT_REGISTERS(ct)) {
- dasm_put(Dst, 280, - 80 - 8*reg->ints);
- reg->ints++;
- }
-#else
- if (!is_int64 && reg->ints < MAX_INT_REGISTERS(ct)) {
- dasm_put(Dst, 281, - 8 - 4*reg->ints);
- reg->ints++;
- }
-#endif
- else if (is_int64) {
- dasm_put(Dst, 280, reg->off);
- reg->off += 8;
- } else {
- dasm_put(Dst, 281, reg->off);
- reg->off += 4;
- }
-}
-
-static void add_int(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_int64)
-{
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- dasm_put(Dst, 285, 32 + 8*(reg->regs));
- reg->is_int[reg->regs++] = 1;
- }
-#elif __amd64__
- if (reg->ints < MAX_INT_REGISTERS(ct)) {
- dasm_put(Dst, 285, 32 + 8*reg->ints);
- reg->ints++;
- }
-#else
- if (!is_int64 && reg->ints < MAX_INT_REGISTERS(ct)) {
- dasm_put(Dst, 285, 32 + 4*reg->ints);
- reg->ints++;
- }
-#endif
- else {
-#if defined _WIN64 || defined __amd64__
- if (reg->off % 8 != 0) {
- reg->off += 8 - (reg->off % 8);
- }
-#endif
- if (is_int64) {
- dasm_put(Dst, 285, reg->off);
- reg->off += 8;
- } else {
- dasm_put(Dst, 286, reg->off);
- reg->off += 4;
- }
- }
-}
-
-static void get_float(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_double)
-{
-#if !defined _WIN64 && !defined __amd64__
- assert(MAX_FLOAT_REGISTERS(ct) == 0);
- if (is_double) {
- dasm_put(Dst, 292, reg->off);
- reg->off += 8;
- } else {
- dasm_put(Dst, 296, reg->off);
- reg->off += 4;
- }
-#else
- int off;
-
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- off = -16 - 8*reg->regs;
- reg->regs++;
- }
-#else
- if (reg->floats < MAX_FLOAT_REGISTERS(ct)) {
- off = -16 - 8*reg->floats;
- reg->floats++;
- }
-#endif
- else {
- off = reg->off;
- reg->off += is_double ? 8 : 4;
- }
-
- if (is_double) {
- dasm_put(Dst, 300, off);
- } else {
- dasm_put(Dst, 307, off);
- }
-#endif
-}
-
-static void add_float(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_double)
-{
-#if !defined _WIN64 && !defined __amd64__
- assert(MAX_FLOAT_REGISTERS(ct) == 0);
- if (is_double) {
- dasm_put(Dst, 314, reg->off);
- reg->off += 8;
- } else {
- dasm_put(Dst, 320, reg->off);
- reg->off += 4;
- }
-#else
-
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- if (is_double) {
- dasm_put(Dst, 326, 32 + 8*(reg->regs));
- } else {
- dasm_put(Dst, 334, 32 + 8*(reg->regs));
- }
- reg->is_float[reg->regs++] = 1;
- }
-#else
- if (reg->floats < MAX_FLOAT_REGISTERS(ct)) {
- if (is_double) {
- dasm_put(Dst, 326, 32 + 8*(MAX_INT_REGISTERS(ct) + reg->floats));
- } else {
- dasm_put(Dst, 334, 32 + 8*(MAX_INT_REGISTERS(ct) + reg->floats));
- }
- reg->floats++;
- }
-#endif
-
- else if (is_double) {
- dasm_put(Dst, 326, reg->off);
- reg->off += 8;
- } else {
- dasm_put(Dst, 347, reg->off);
- reg->off += 4;
- }
-#endif
-}
-
-#if defined _WIN64 || defined __amd64__
-#define add_pointer(jit, ct, reg) add_int(jit, ct, reg, 1)
-#define get_pointer(jit, ct, reg) get_int(jit, ct, reg, 1)
-#else
-#define add_pointer(jit, ct, reg) add_int(jit, ct, reg, 0)
-#define get_pointer(jit, ct, reg) get_int(jit, ct, reg, 0)
-#endif
-
-cfunction compile_callback(lua_State* L, int fidx, int ct_usr, const struct ctype* ct)
-{
- int i, nargs;
- cfunction* pf;
- struct ctype ct2 = *ct;
- const struct ctype* mt;
- struct reg_alloc reg;
- int num_upvals = 0;
- int top = lua_gettop(L);
- struct jit* Dst = get_jit(L);
- int ref;
- int hidden_arg_off = 0;
-
- ct_usr = lua_absindex(L, ct_usr);
- fidx = lua_absindex(L, fidx);
-
- assert(lua_isnil(L, fidx) || lua_isfunction(L, fidx));
-
- memset(®, 0, sizeof(reg));
-#ifdef _WIN64
- reg.off = 16 + REGISTER_STACK_SPACE(ct); /* stack registers are above the shadow space */
-#elif __amd64__
- reg.off = 16;
-#else
- reg.off = 8;
-#endif
-
- dasm_setup(Dst, build_actionlist);
-
- // add a table to store ctype and function upvalues
- // callback_set assumes the first value is the lua function
- nargs = (int) lua_rawlen(L, ct_usr);
- lua_newtable(L);
- lua_pushvalue(L, -1);
- ref = luaL_ref(L, LUA_REGISTRYINDEX);
-
- if (ct->has_var_arg) {
- luaL_error(L, "can't create callbacks with varargs");
- }
-
- // setup a stack frame to hold args for the call into lua_call
-
- dasm_put(Dst, 360, 8 + 16 + 32 + REGISTER_STACK_SPACE(ct));
- if (ct->calling_convention == FAST_CALL) {
- }
-
- // hardcode the lua_State* value into the assembly
- dasm_put(Dst, 375, (unsigned int)((uintptr_t)(L)), (unsigned int)(((uintptr_t)(L))>>32));
-
- /* get the upval table */
- dasm_put(Dst, 380, ref, LUA_REGISTRYINDEX);
-
- /* get the lua function */
- lua_pushvalue(L, fidx);
- lua_rawseti(L, -2, ++num_upvals);
- assert(num_upvals == CALLBACK_FUNC_USR_IDX);
- dasm_put(Dst, 396, num_upvals);
-
-#if !defined _WIN64 && !defined __amd64__
- lua_rawgeti(L, ct_usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
- if (!mt->pointers && !mt->is_reference && mt->type == COMPLEX_DOUBLE_TYPE) {
- hidden_arg_off = reg.off;
- reg.off += sizeof(void*);
- }
- lua_pop(L, 1);
-#else
- (void) hidden_arg_off;
-#endif
-
- for (i = 1; i <= nargs; i++) {
- lua_rawgeti(L, ct_usr, i);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mt->pointers || mt->is_reference) {
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- /* on the lua stack in the callback:
- * upval tbl, lua func, i-1 args
- */
- dasm_put(Dst, 419, num_upvals-1, -i-1, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
- get_pointer(Dst, ct, ®);
- dasm_put(Dst, 457);
- } else {
- switch (mt->type) {
- case INT64_TYPE:
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* mt */
- lua_pop(L, 1);
- dasm_put(Dst, 479, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
- get_int(Dst, ct, ®, 1);
- dasm_put(Dst, 498);
- break;
-
- case INTPTR_TYPE:
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* mt */
- lua_pop(L, 1);
- dasm_put(Dst, 479, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
- get_pointer(Dst, ct, ®);
- dasm_put(Dst, 498);
- break;
-
- case COMPLEX_FLOAT_TYPE:
- lua_pop(L, 1);
-#if defined _WIN64 || defined __amd64__
- /* complex floats are two floats packed into a double */
- dasm_put(Dst, 479, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
- get_float(Dst, ct, ®, 1);
- dasm_put(Dst, 502);
-#else
- /* complex floats are real followed by imag on the stack */
- dasm_put(Dst, 479, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
- get_float(Dst, ct, ®, 0);
- dasm_put(Dst, 507);
- get_float(Dst, ct, ®, 0);
- dasm_put(Dst, 510);
-#endif
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 479, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
- /* real */
- get_float(Dst, ct, ®, 1);
- dasm_put(Dst, 502);
- /* imag */
- get_float(Dst, ct, ®, 1);
- dasm_put(Dst, 514);
- break;
-
- case FLOAT_TYPE:
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- get_float(Dst, ct, ®, mt->type == DOUBLE_TYPE);
- dasm_put(Dst, 520);
- break;
-
- case BOOL_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- dasm_put(Dst, 533);
- break;
-
- case INT8_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- if (mt->is_unsigned) {
- dasm_put(Dst, 547);
- } else {
- dasm_put(Dst, 551);
- }
- dasm_put(Dst, 555);
- break;
-
- case INT16_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- if (mt->is_unsigned) {
- dasm_put(Dst, 566);
- } else {
- dasm_put(Dst, 570);
- }
- dasm_put(Dst, 555);
- break;
-
- case ENUM_TYPE:
- case INT32_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- if (mt->is_unsigned) {
- dasm_put(Dst, 574);
- } else {
- dasm_put(Dst, 555);
- }
- break;
-
- default:
- luaL_error(L, "NYI: callback arg type");
- }
- }
- }
-
- lua_rawgeti(L, ct_usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- dasm_put(Dst, 585, (unsigned int)((uintptr_t)(0)), (unsigned int)(((uintptr_t)(0))>>32), (mt->pointers || mt->is_reference || mt->type != VOID_TYPE) ? 1 : 0, nargs);
-
- // Unpack the return argument if not "void", also clean-up the lua stack
- // to remove the return argument and bind table. Use lua_settop rather
- // than lua_pop as lua_pop is implemented as a macro.
- if (mt->pointers || mt->is_reference) {
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- dasm_put(Dst, 605, num_upvals-1, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
-
- } else {
- switch (mt->type) {
- case ENUM_TYPE:
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- dasm_put(Dst, 689, num_upvals-1, (unsigned int)((uintptr_t)(mt)), (unsigned int)(((uintptr_t)(mt))>>32));
- break;
-
- case VOID_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 771);
- break;
-
- case BOOL_TYPE:
- case INT8_TYPE:
- case INT16_TYPE:
- case INT32_TYPE:
- lua_pop(L, 1);
- if (mt->is_unsigned) {
- dasm_put(Dst, 790);
- } else {
- dasm_put(Dst, 809);
- }
- dasm_put(Dst, 828);
- break;
-
- case INT64_TYPE:
- lua_pop(L, 1);
-
- if (mt->is_unsigned) {
- dasm_put(Dst, 855);
- } else {
- dasm_put(Dst, 874);
- }
-
- dasm_put(Dst, 893);
- break;
-
- case INTPTR_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 922);
- break;
-
- case FLOAT_TYPE:
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 969);
- if (mt->type == FLOAT_TYPE) {
- dasm_put(Dst, 1012);
- } else {
- dasm_put(Dst, 1020);
- }
- break;
-
- case COMPLEX_FLOAT_TYPE:
- lua_pop(L, 1);
-#if !defined HAVE_COMPLEX
- luaL_error(L, "ffi lib compiled without complex number support");
-#endif
- /* on 64 bit complex floats are two floats packed into a double,
- * on 32 bit returned complex floats use eax and edx */
- dasm_put(Dst, 1028);
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- lua_pop(L, 1);
-#if !defined HAVE_COMPLEX
- luaL_error(L, "ffi lib compiled without complex number support");
-#endif
- /* on 64 bit, returned complex doubles use xmm0, xmm1, on 32 bit
- * there is a hidden first parameter that points to 16 bytes where
- * the returned arg is stored which is popped by the called
- * function */
-#if defined _WIN64 || defined __amd64__
- dasm_put(Dst, 1078);
-#else
- dasm_put(Dst, 1141, hidden_arg_off);
-#endif
- break;
-
- default:
- luaL_error(L, "NYI: callback return type");
- }
- }
-
- dasm_put(Dst, 1190, x86_return_size(L, ct_usr, ct));
-
- lua_pop(L, 1); /* upval table - already in registry */
- assert(lua_gettop(L) == top);
-
- ct2.is_jitted = 1;
- pf = (cfunction*) push_cdata(L, ct_usr, &ct2);
- *pf = compile(Dst, L, NULL, ref);
-
- assert(lua_gettop(L) == top + 1);
-
- return *pf;
-}
-
-void compile_function(lua_State* L, cfunction func, int ct_usr, const struct ctype* ct)
-{
- size_t i, nargs;
- int num_upvals;
- const struct ctype* mbr_ct;
- struct jit* Dst = get_jit(L);
- struct reg_alloc reg;
- void* p;
- int top = lua_gettop(L);
- int* perr = &Dst->last_errno;
-
- ct_usr = lua_absindex(L, ct_usr);
-
- memset(®, 0, sizeof(reg));
- reg.off = 32 + REGISTER_STACK_SPACE(ct);
-
- dasm_setup(Dst, build_actionlist);
-
- p = push_cdata(L, ct_usr, ct);
- *(cfunction*) p = func;
- num_upvals = 1;
-
- nargs = lua_rawlen(L, ct_usr);
-
- if (ct->calling_convention != C_CALL && ct->has_var_arg) {
- luaL_error(L, "vararg is only allowed with the c calling convention");
- }
-
- dasm_put(Dst, 1203, nargs);
-
- if (!ct->has_var_arg) {
- dasm_put(Dst, 1239);
- }
-
- /* no need to zero extend eax returned by lua_gettop to rax as x86-64
- * preguarentees that the upper 32 bits will be zero */
- dasm_put(Dst, 1244, 32 + REGISTER_STACK_SPACE(ct));
-
-#if !defined _WIN64 && !defined __amd64__
- /* Returned complex doubles require a hidden first parameter where the
- * data is stored, which is popped by the calling code. */
- lua_rawgeti(L, ct_usr, 0);
- mbr_ct = (const struct ctype*) lua_touserdata(L, -1);
- if (!mbr_ct->pointers && !mbr_ct->is_reference && mbr_ct->type == COMPLEX_DOUBLE_TYPE) {
- /* we can allocate more space for arguments as long as no add_*
- * function has been called yet, mbr_ct will be added as an upvalue in
- * the return processing later */
- dasm_put(Dst, 1257, (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32));
- add_pointer(Dst, ct, ®);
- }
- lua_pop(L, 1);
-#endif
-
- for (i = 1; i <= nargs; i++) {
- lua_rawgeti(L, ct_usr, (int) i);
- mbr_ct = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mbr_ct->pointers || mbr_ct->is_reference) {
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1281, (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32), lua_upvalueindex(num_upvals), i);
- add_pointer(Dst, ct, ®);
- } else {
- switch (mbr_ct->type) {
- case FUNCTION_PTR_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1301, (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32), lua_upvalueindex(num_upvals), i);
- add_pointer(Dst, ct, ®);
- break;
-
- case ENUM_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1321, (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32), lua_upvalueindex(num_upvals), i);
- add_int(Dst, ct, ®, 0);
- break;
-
- case INT8_TYPE:
- dasm_put(Dst, 1341, i);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1353);
- } else {
- dasm_put(Dst, 1357);
- }
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case INT16_TYPE:
- dasm_put(Dst, 1341, i);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1361);
- } else {
- dasm_put(Dst, 1365);
- }
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case BOOL_TYPE:
- dasm_put(Dst, 1369, i);
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case INT32_TYPE:
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1391, i);
- } else {
- dasm_put(Dst, 1341, i);
- }
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case INTPTR_TYPE:
- dasm_put(Dst, 1403, i);
- add_pointer(Dst, ct, ®);
- lua_pop(L, 1);
- break;
-
- case INT64_TYPE:
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1415, i);
- } else {
- dasm_put(Dst, 1427, i);
- }
- add_int(Dst, ct, ®, 1);
- lua_pop(L, 1);
- break;
-
- case DOUBLE_TYPE:
- dasm_put(Dst, 1439, i);
- add_float(Dst, ct, ®, 1);
- lua_pop(L, 1);
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- /* on 64 bit, returned complex doubles use xmm0, xmm1, on 32 bit
- * there is a hidden first parameter that points to 16 bytes where
- * the returned arg is stored (this is popped by the called
- * function) */
-#if defined _WIN64 || defined __amd64__
- dasm_put(Dst, 1451, i);
- add_float(Dst, ct, ®, 1);
- dasm_put(Dst, 1463);
- add_float(Dst, ct, ®, 1);
-#else
- dasm_put(Dst, 1469, reg.off, i);
- reg.off += 16;
-#endif
- lua_pop(L, 1);
- break;
-
- case FLOAT_TYPE:
- dasm_put(Dst, 1439, i);
- add_float(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case COMPLEX_FLOAT_TYPE:
-#if defined _WIN64 || defined __amd64__
- dasm_put(Dst, 1495, i);
- /* complex floats are two floats packed into a double */
- add_float(Dst, ct, ®, 1);
-#else
- /* returned complex floats use eax and edx */
- dasm_put(Dst, 1507, i);
- add_float(Dst, ct, ®, 0);
- dasm_put(Dst, 1525);
- add_float(Dst, ct, ®, 0);
-#endif
- lua_pop(L, 1);
- break;
-
- default:
- luaL_error(L, "NYI: call arg type");
- }
- }
- }
-
- if (ct->has_var_arg) {
-#ifdef _WIN64
- if (reg.regs < MAX_REGISTERS(ct)) {
- assert(reg.regs == nargs);
- dasm_put(Dst, 1532, MAX_REGISTERS(ct), 32 + 8*MAX_REGISTERS(ct), MAX_REGISTERS(ct)+1, 32 + 8*(reg.regs), MAX_REGISTERS(ct), nargs+1, 32 + 8*(reg.regs), nargs+1);
- } else {
- dasm_put(Dst, 1623, reg.off, nargs+1);
- }
-
- for (i = nargs; i < MAX_REGISTERS(ct); i++) {
- reg.is_int[i] = reg.is_float[i] = 1;
- }
- reg.regs = MAX_REGISTERS(ct);
-#elif defined __amd64__
- if (reg.floats < MAX_FLOAT_REGISTERS(ct)) {
- }
-
- if (reg.ints < MAX_INT_REGISTERS(ct)) {
- }
-
-
- reg.floats = MAX_FLOAT_REGISTERS(ct);
- reg.ints = MAX_INT_REGISTERS(ct);
-#else
-#endif
- }
-
- dasm_put(Dst, 1648, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32));
-
- /* remove the stack space to call local functions */
- dasm_put(Dst, 1662);
-
-#ifdef _WIN64
- switch (reg.regs) {
- case 4:
- if (reg.is_float[3]) {
- dasm_put(Dst, 1667, 8*3);
- }
- if (reg.is_int[3]) {
- dasm_put(Dst, 1676, 8*3);
- }
- case 3:
- if (reg.is_float[2]) {
- dasm_put(Dst, 1683, 8*2);
- }
- if (reg.is_int[2]) {
- dasm_put(Dst, 1692, 8*2);
- }
- case 2:
- if (reg.is_float[1]) {
- dasm_put(Dst, 1699, 8*1);
- }
- if (reg.is_int[1]) {
- dasm_put(Dst, 1708, 8*1);
- }
- case 1:
- if (reg.is_float[0]) {
- dasm_put(Dst, 1715);
- }
- if (reg.is_int[0]) {
- dasm_put(Dst, 1722);
- }
- case 0:
- break;
- }
-
- /* don't remove the space for the registers as we need 32 bytes of register overflow space */
- assert(REGISTER_STACK_SPACE(ct) == 32);
-
-#elif defined __amd64__
- switch (reg.floats) {
- case 8:
- case 7:
- case 6:
- case 5:
- case 4:
- case 3:
- case 2:
- case 1:
- case 0:
- break;
- }
-
- switch (reg.ints) {
- case 6:
- case 5:
- case 4:
- case 3:
- case 2:
- case 1:
- case 0:
- break;
- }
-
-#else
- if (ct->calling_convention == FAST_CALL) {
- switch (reg.ints) {
- case 2:
- case 1:
- case 0:
- break;
- }
-
- }
-#endif
-
-#ifdef __amd64__
- if (ct->has_var_arg) {
- /* al stores an upper limit on the number of float register, note that
- * its allowed to be more than the actual number of float registers used as
- * long as its 0-8 */
- }
-#endif
-
- dasm_put(Dst, 1727);
-
- /* note on windows X86 the stack may be only aligned to 4 (stdcall will
- * have popped a multiple of 4 bytes), but we don't need 16 byte alignment on
- * that platform
- */
-
- lua_rawgeti(L, ct_usr, 0);
- mbr_ct = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mbr_ct->pointers || mbr_ct->is_reference || mbr_ct->type == INTPTR_TYPE) {
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1737, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32), (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32), lua_upvalueindex(num_upvals));
-
- } else {
- switch (mbr_ct->type) {
- case FUNCTION_PTR_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1737, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32), (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32), lua_upvalueindex(num_upvals));
- break;
-
- case INT64_TYPE:
- num_upvals++;
- dasm_put(Dst, 1780, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32), (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32));
- break;
-
- case COMPLEX_FLOAT_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1826, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32), (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32), lua_upvalueindex(num_upvals));
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1870, (unsigned int)((uintptr_t)(perr)), (unsigned int)(((uintptr_t)(perr))>>32), (unsigned int)((uintptr_t)(mbr_ct)), (unsigned int)(((uintptr_t)(mbr_ct))>>32), lua_upvalueindex(num_upvals));
- break;
-
- case VOID_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 1929);
- break;
-
- case BOOL_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 1934);
- break;
-
- case INT8_TYPE:
- lua_pop(L, 1);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1353);
- } else {
- dasm_put(Dst, 1357);
- }
- dasm_put(Dst, 1939);
- break;
-
- case INT16_TYPE:
- lua_pop(L, 1);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1361);
- } else {
- dasm_put(Dst, 1365);
- }
- dasm_put(Dst, 1939);
- break;
-
- case INT32_TYPE:
- case ENUM_TYPE:
- lua_pop(L, 1);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1944);
- } else {
- dasm_put(Dst, 1939);
- }
- break;
-
- case FLOAT_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 1949);
- break;
-
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 1954);
- break;
-
- default:
- luaL_error(L, "NYI: call return type");
- }
- }
-
- assert(lua_gettop(L) == top + num_upvals);
- {
- cfunction f = compile(Dst, L, func, LUA_NOREF);
- /* add a callback as an upval so that the jitted code gets cleaned up when
- * the function gets gc'd */
- push_callback(L, f, func);
- lua_pushcclosure(L, (lua_CFunction) f, num_upvals+1);
- }
-}
-
diff --git a/plugins/MirLua/Modules/ffi/src/call_x86.dasc b/plugins/MirLua/Modules/ffi/src/call_x86.dasc deleted file mode 100644 index ef2ba24e2f..0000000000 --- a/plugins/MirLua/Modules/ffi/src/call_x86.dasc +++ /dev/null @@ -1,1607 +0,0 @@ -/* vim: ts=4 sw=4 sts=4 et tw=78
- * Portions copyright (c) 2015-present, Facebook, Inc. All rights reserved.
- * Portions copyright (c) 2011 James R. McKaskill.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-|.if X64
-|.arch x64
-|.else
-|.arch x86
-|.endif
-
-|.actionlist build_actionlist
-|.globalnames globnames
-|.externnames extnames
-
-|.if not X64
-|.define RET_H, edx // for int64_t returns
-|.define RET_L, eax
-|.endif
-
-|.if X64WIN
-|
-|.macro call_rrrp, func, arg0, arg1, arg2, arg3
-| mov64 r9, arg3
-| mov r8, arg2
-| mov rdx, arg1
-| mov rcx, arg0
-| call func
-|.endmacro
-|.macro call_rrrr, func, arg0, arg1, arg2, arg3
-| mov r9, arg3
-| mov r8, arg2
-| mov rdx, arg1
-| mov rcx, arg0
-| call func
-|.endmacro
-|
-|.macro call_rrp, func, arg0, arg1, arg2
-| mov64 r8, arg2
-| mov rdx, arg1
-| mov rcx, arg0
-| call func
-|.endmacro
-|.macro call_rrr, func, arg0, arg1, arg2
-| mov r8, arg2
-| mov rdx, arg1
-| mov rcx, arg0
-| call func
-|.endmacro
-|
-|.macro call_rp, func, arg0, arg1
-| mov64 rdx, arg1
-| mov rcx, arg0
-| call func
-|.endmacro
-|.macro call_rr, func, arg0, arg1
-| mov rdx, arg1
-| mov rcx, arg0
-| call func
-|.endmacro
-|
-|.macro call_r, func, arg0
-| mov rcx, arg0
-| call func
-|.endmacro
-|
-|.elif X64
-|
-| // the 5 and 6 arg forms are only used on posix x64
-|.macro call_rrrrrr, func, arg0, arg1, arg2, arg3, arg4, arg5
-| mov r9, arg5
-| mov r8, arg4
-| mov rcx, arg3
-| mov rdx, arg2
-| mov rsi, arg1
-| mov rdi, arg0
-| call func
-|.endmacro
-|.macro call_rrrrr, func, arg0, arg1, arg2, arg3, arg4
-| mov r8, arg4
-| mov rcx, arg3
-| mov rdx, arg2
-| mov rsi, arg1
-| mov rdi, arg0
-| call func
-|.endmacro
-|
-|.macro call_rrrp, func, arg0, arg1, arg2, arg3
-| mov64 rcx, arg3
-| mov rdx, arg2
-| mov rsi, arg1
-| mov rdi, arg0
-| call func
-|.endmacro
-|.macro call_rrrr, func, arg0, arg1, arg2, arg3
-| mov rcx, arg3
-| mov rdx, arg2
-| mov rsi, arg1
-| mov rdi, arg0
-| call func
-|.endmacro
-|
-|.macro call_rrp, func, arg0, arg1, arg2
-| mov64 rdx, arg2
-| mov rsi, arg1
-| mov rdi, arg0
-| call func
-|.endmacro
-|.macro call_rrr, func, arg0, arg1, arg2
-| mov rdx, arg2
-| mov rsi, arg1
-| mov rdi, arg0
-| call func
-|.endmacro
-|
-|.macro call_rp, func, arg0, arg1
-| mov64 rsi, arg1
-| mov rdi, arg0
-| call func
-|.endmacro
-|.macro call_rr, func, arg0, arg1
-| mov rsi, arg1
-| mov rdi, arg0
-| call func
-|.endmacro
-|
-|.macro call_r, func, arg0
-| mov rdi, arg0
-| call func
-|.endmacro
-|
-|.else
-| // define the 64bit registers to the 32 bit counterparts, so the common
-| // code can use r*x for all pointers
-|.define rax, eax
-|.define rcx, ecx
-|.define rdx, edx
-|.define rsp, esp
-|.define rbp, ebp
-|.define rdi, edi
-|.define rsi, esi
-|.define mov64, mov
-|
-|.macro call_rrrr, func, arg0, arg1, arg2, arg3
-| mov dword [rsp+12], arg3
-| mov dword [rsp+8], arg2
-| mov dword [rsp+4], arg1
-| mov dword [rsp], arg0
-| call func
-|.endmacro
-|.macro call_rrr, func, arg0, arg1, arg2
-| mov dword [rsp+8], arg2
-| mov dword [rsp+4], arg1
-| mov dword [rsp], arg0
-| call func
-|.endmacro
-|.macro call_rr, func, arg0, arg1
-| mov dword [rsp+4], arg1
-| mov dword [rsp], arg0
-| call func
-|.endmacro
-|.macro call_r, func, arg0
-| mov dword [rsp], arg0
-| call func
-|.endmacro
-|
-|.define call_rrrp, call_rrrr
-|.define call_rrp, call_rrr
-|.define call_rp, call_rr
-|
-|.endif
-
-#if defined _WIN64 || defined __amd64__
-#define JUMP_SIZE 14
-#else
-#define JUMP_SIZE 4
-#endif
-
-#define MIN_BRANCH INT32_MIN
-#define MAX_BRANCH INT32_MAX
-#define BRANCH_OFF 4
-
-static void compile_extern_jump(struct jit* jit, lua_State* L, cfunction func, uint8_t* code)
-{
- /* The jump code is the function pointer followed by a stub to call the
- * function pointer. The stub exists in 64 bit so we can jump to functions
- * with an offset greater than 2 GB.
- *
- * Note we have to manually set this up since there are commands buffered
- * in the jit state and dynasm doesn't support rip relative addressing.
- *
- * eg on 64 bit:
- * 0-8: function ptr
- * 8-14: jmp aword [rip-14]
- *
- * for 32 bit we only set the function ptr as it can always fit in a 32
- * bit displacement
- */
-#if defined _WIN64 || defined __amd64__
- *(cfunction*) code = func;
- code[8] = 0xFF; /* FF /4 operand for jmp */
- code[9] = 0x25; /* RIP displacement */
- *(int32_t*) &code[10] = -14;
-#else
- *(cfunction*) code = func;
-#endif
-}
-
-void compile_globals(struct jit* jit, lua_State* L)
-{
- struct jit* Dst = jit;
- int* perr = &jit->last_errno;
- dasm_setup(Dst, build_actionlist);
-
- /* Note: since the return code uses EBP to reset the stack pointer, we
- * don't have to track the amount of stack space used. It also means we
- * can handle stdcall and cdecl with the same code.
- */
-
- /* Note the various call_* functions want 32 bytes of 16 byte aligned
- * stack
- */
-
- |.if X64
- |.define L_ARG, r12
- |.define TOP, r13
- |.else
- |.define L_ARG, rdi
- |.define TOP, rsi
- |.endif
-
- |.macro epilog
- |.if X64
- | mov TOP, [rbp-16]
- | mov L_ARG, [rbp-8]
- |.else
- | mov TOP, [rbp-8]
- | mov L_ARG, [rbp-4]
- |.endif
- | mov rsp, rbp
- | pop rbp
- | ret
- |.endmacro
-
- |.macro get_errno // note trashes registers
- | call extern GetLastError
- | mov64 rcx, perr
- | mov dword [rcx], eax
- |.endmacro
-
- /* the general idea for the return functions is:
- * 1) Save return value on stack
- * 2) Call get_errno (this trashes the registers hence #1)
- * 3) Unpack return value from stack
- * 4) Call lua push function
- * 5) Set eax to number of returned args (0 or 1)
- * 6) Call return which pops our stack frame
- */
-
- |->lua_return_arg:
- | mov eax, 1
- | epilog
-
- |->lua_return_void:
- | get_errno
- | mov eax, 0
- | epilog
-
- |->lua_return_double:
- |.if X64
- | movq qword [rsp+32], xmm0
- |.else
- | fstp qword [rsp+4] // note get_errno doesn't require any stack on x86
- |.endif
- |
- | get_errno
- |
- |.if X64WIN
- | movq xmm1, qword [rsp+32]
- | mov rcx, L_ARG
- |.elif X64
- | movq xmm0, qword [rsp+32]
- | mov rdi, L_ARG
- |.else
- | mov [rsp], L_ARG
- |.endif
- | call extern lua_pushnumber
- | jmp ->lua_return_arg
-
- |->lua_return_bool:
- | movzx eax, al
- | mov [rsp+32], eax
- | get_errno
- | mov eax, [rsp+32]
- | call_rr extern lua_pushboolean, L_ARG, rax
- | jmp ->lua_return_arg
-
- |->lua_return_int:
- | mov [rsp+32], eax
- | get_errno
- | mov eax, [rsp+32]
- | call_rr extern push_int, L_ARG, rax
- | jmp ->lua_return_arg
-
- |->lua_return_uint:
- | mov [rsp+32], eax
- | get_errno
- | mov eax, [rsp+32]
- | call_rr extern push_uint, L_ARG, rax
- | jmp ->lua_return_arg
-
- |->too_few_arguments:
- | mov ax, 0
- | call_rp extern luaL_error, L_ARG, &"too few arguments"
-
- |->too_many_arguments:
- | mov ax, 0
- | call_rp extern luaL_error, L_ARG, &"too many arguments"
-
- |->save_registers:
- | // use rbp relative so we store values in the outer stack frame
- |.if X64WIN
- | // use the provided shadow space for int registers above prev rbp and
- | // return address
- | mov [rbp+16], rcx
- | mov [rbp+24], rdx
- | mov [rbp+32], r8
- | mov [rbp+40], r9
- | // use the extra space we added for float registers
- | // -16 to store underneath previous value of L_ARG
- | movq qword [rbp-16], xmm0
- | movq qword [rbp-24], xmm1
- | movq qword [rbp-32], xmm2
- | movq qword [rbp-40], xmm3
- |.elif X64
- | movq qword [rbp-16], xmm0
- | movq qword [rbp-24], xmm1
- | movq qword [rbp-32], xmm2
- | movq qword [rbp-40], xmm3
- | movq qword [rbp-48], xmm4
- | movq qword [rbp-56], xmm5
- | movq qword [rbp-64], xmm6
- | movq qword [rbp-72], xmm7
- | mov [rbp-80], rdi
- | mov [rbp-88], rsi
- | mov [rbp-96], rdx
- | mov [rbp-104], rcx
- | mov [rbp-112], r8
- | mov [rbp-120], r9
- |.else
- | // fastcall, -8 to store underneath previous value of L_ARG
- | mov [rbp-8], ecx
- | mov [rbp-12], edx
- |.endif
- | ret
-
- compile(Dst, L, NULL, LUA_NOREF);
-}
-
-int x86_return_size(lua_State* L, int usr, const struct ctype* ct)
-{
- int ret = 0;
- const struct ctype* mt;
-
- if (ct->calling_convention != C_CALL) {
- size_t i;
- size_t argn = lua_rawlen(L, usr);
- for (i = 1; i <= argn; i++) {
- lua_rawgeti(L, usr, (int) i);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mt->pointers || mt->is_reference) {
- ret += sizeof(void*);
- } else {
- switch (mt->type) {
- case DOUBLE_TYPE:
- case COMPLEX_FLOAT_TYPE:
- case INT64_TYPE:
- ret += 8;
- break;
- case COMPLEX_DOUBLE_TYPE:
- ret += 16;
- break;
- case INTPTR_TYPE:
- ret += sizeof(intptr_t);
- break;
- case FUNCTION_PTR_TYPE:
- ret += sizeof(cfunction);
- break;
- case BOOL_TYPE:
- case FLOAT_TYPE:
- case INT8_TYPE:
- case INT16_TYPE:
- case INT32_TYPE:
- case ENUM_TYPE:
- ret += 4;
- break;
- default:
- return luaL_error(L, "NYI - argument type");
- }
- }
-
- lua_pop(L, 1);
- }
- }
-
-#if !defined _WIN64 && !defined __amd64__
- lua_rawgeti(L, usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
- if (!mt->pointers && !mt->is_reference && mt->type == COMPLEX_DOUBLE_TYPE) {
- ret += sizeof(void*);
- }
- lua_pop(L, 1);
-#endif
-
- return ret;
-}
-
-#ifdef _WIN64
-#define MAX_REGISTERS(ct) 4 /* rcx, rdx, r8, r9 */
-
-#elif defined __amd64__
-#define MAX_INT_REGISTERS(ct) 6 /* rdi, rsi, rdx, rcx, r8, r9 */
-#define MAX_FLOAT_REGISTERS(ct) 8 /* xmm0-7 */
-
-#else
-#define MAX_INT_REGISTERS(ct) ((ct)->calling_convention == FAST_CALL ? 2 /* ecx, edx */ : 0)
-#define MAX_FLOAT_REGISTERS(ct) 0
-#endif
-
-struct reg_alloc {
-#ifdef _WIN64
- int regs;
- int is_float[4];
- int is_int[4];
-#else
- int floats;
- int ints;
-#endif
- int off;
-};
-
-#ifdef _WIN64
-#define REGISTER_STACK_SPACE(ct) (4*8)
-#elif defined __amd64__
-#define REGISTER_STACK_SPACE(ct) (14*8)
-#else
-#define REGISTER_STACK_SPACE(ct) ALIGN_UP(((ct)->calling_convention == FAST_CALL ? 2*4 : 0), 15)
-#endif
-
-/* Fastcall:
- * Uses ecx, edx as first two int registers
- * Everything else on stack (include 64bit ints)
- * No overflow stack space
- * Pops the stack before returning
- * Returns int in eax, float in ST0
- * We use the same register allocation logic as posix x64 with 2 int regs and 0 float regs
- */
-
-static void get_int(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_int64)
-{
- /* grab the register from the shadow space */
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- | mov rcx, [rbp + 16 + 8*reg->regs]
- reg->regs++;
- }
-#elif __amd64__
- if (reg->ints < MAX_INT_REGISTERS(ct)) {
- | mov rcx, [rbp - 80 - 8*reg->ints]
- reg->ints++;
- }
-#else
- if (!is_int64 && reg->ints < MAX_INT_REGISTERS(ct)) {
- | mov ecx, [rbp - 8 - 4*reg->ints]
- reg->ints++;
- }
-#endif
- else if (is_int64) {
- |.if X64
- | mov rcx, [rbp + reg->off]
- |.else
- | mov rcx, [rbp + reg->off]
- | mov rdx, [rbp + reg->off + 4]
- |.endif
- reg->off += 8;
- } else {
- | mov ecx, [rbp + reg->off]
- reg->off += 4;
- }
-}
-
-static void add_int(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_int64)
-{
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- | mov [rsp + 32 + 8*(reg->regs)], rax
- reg->is_int[reg->regs++] = 1;
- }
-#elif __amd64__
- if (reg->ints < MAX_INT_REGISTERS(ct)) {
- | mov [rsp + 32 + 8*reg->ints], rax
- reg->ints++;
- }
-#else
- if (!is_int64 && reg->ints < MAX_INT_REGISTERS(ct)) {
- | mov [rsp + 32 + 4*reg->ints], rax
- reg->ints++;
- }
-#endif
- else {
-#if defined _WIN64 || defined __amd64__
- if (reg->off % 8 != 0) {
- reg->off += 8 - (reg->off % 8);
- }
-#endif
- if (is_int64) {
- |.if X64
- | mov [rsp + reg->off], rax
- |.else
- | mov [rsp + reg->off], RET_L
- | mov [rsp + reg->off + 4], RET_H
- |.endif
- reg->off += 8;
- } else {
- | mov [rsp+reg->off], eax
- reg->off += 4;
- }
- }
-}
-
-static void get_float(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_double)
-{
-#if !defined _WIN64 && !defined __amd64__
- assert(MAX_FLOAT_REGISTERS(ct) == 0);
- if (is_double) {
- | fld qword [rbp + reg->off]
- reg->off += 8;
- } else {
- | fld dword [rbp + reg->off]
- reg->off += 4;
- }
-#else
- int off;
-
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- off = -16 - 8*reg->regs;
- reg->regs++;
- }
-#else
- if (reg->floats < MAX_FLOAT_REGISTERS(ct)) {
- off = -16 - 8*reg->floats;
- reg->floats++;
- }
-#endif
- else {
- off = reg->off;
- reg->off += is_double ? 8 : 4;
- }
-
- if (is_double) {
- | movq xmm0, qword [rbp + off]
- } else {
- | cvtss2sd xmm0, dword [rbp + off]
- }
-#endif
-}
-
-static void add_float(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_double)
-{
-#if !defined _WIN64 && !defined __amd64__
- assert(MAX_FLOAT_REGISTERS(ct) == 0);
- if (is_double) {
- | fstp qword [rsp + reg->off]
- reg->off += 8;
- } else {
- | fstp dword [rsp + reg->off]
- reg->off += 4;
- }
-#else
-
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- if (is_double) {
- | movq qword [rsp + 32 + 8*(reg->regs)], xmm0
- } else {
- | cvtsd2ss xmm0, xmm0
- | movq qword [rsp + 32 + 8*(reg->regs)], xmm0
- }
- reg->is_float[reg->regs++] = 1;
- }
-#else
- if (reg->floats < MAX_FLOAT_REGISTERS(ct)) {
- if (is_double) {
- | movq qword [rsp + 32 + 8*(MAX_INT_REGISTERS(ct) + reg->floats)], xmm0
- } else {
- | cvtsd2ss xmm0, xmm0
- | movq qword [rsp + 32 + 8*(MAX_INT_REGISTERS(ct) + reg->floats)], xmm0
- }
- reg->floats++;
- }
-#endif
-
- else if (is_double) {
- | movq qword [rsp + reg->off], xmm0
- reg->off += 8;
- } else {
- | cvtsd2ss xmm0, xmm0
- | movd dword [rsp + reg->off], xmm0
- reg->off += 4;
- }
-#endif
-}
-
-#if defined _WIN64 || defined __amd64__
-#define add_pointer(jit, ct, reg) add_int(jit, ct, reg, 1)
-#define get_pointer(jit, ct, reg) get_int(jit, ct, reg, 1)
-#else
-#define add_pointer(jit, ct, reg) add_int(jit, ct, reg, 0)
-#define get_pointer(jit, ct, reg) get_int(jit, ct, reg, 0)
-#endif
-
-cfunction compile_callback(lua_State* L, int fidx, int ct_usr, const struct ctype* ct)
-{
- int i, nargs;
- cfunction* pf;
- struct ctype ct2 = *ct;
- const struct ctype* mt;
- struct reg_alloc reg;
- int num_upvals = 0;
- int top = lua_gettop(L);
- struct jit* Dst = get_jit(L);
- int ref;
- int hidden_arg_off = 0;
-
- ct_usr = lua_absindex(L, ct_usr);
- fidx = lua_absindex(L, fidx);
-
- assert(lua_isnil(L, fidx) || lua_isfunction(L, fidx));
-
- memset(®, 0, sizeof(reg));
-#ifdef _WIN64
- reg.off = 16 + REGISTER_STACK_SPACE(ct); /* stack registers are above the shadow space */
-#elif __amd64__
- reg.off = 16;
-#else
- reg.off = 8;
-#endif
-
- dasm_setup(Dst, build_actionlist);
-
- // add a table to store ctype and function upvalues
- // callback_set assumes the first value is the lua function
- nargs = (int) lua_rawlen(L, ct_usr);
- lua_newtable(L);
- lua_pushvalue(L, -1);
- ref = luaL_ref(L, LUA_REGISTRYINDEX);
-
- if (ct->has_var_arg) {
- luaL_error(L, "can't create callbacks with varargs");
- }
-
- // setup a stack frame to hold args for the call into lua_call
-
- | push rbp
- | mov rbp, rsp
- | push L_ARG
- | // stack is 4 or 8 (mod 16) (L_ARG, rbp, rip)
- |.if X64
- | // 8 to realign, 16 for return vars, 32 for local calls, rest to save registers
- | sub rsp, 8 + 16 + 32 + REGISTER_STACK_SPACE(ct)
- | call ->save_registers
- |.else
- | // 4 to realign, 16 for return vars, 32 for local calls, rest to save registers
- | sub rsp, 4 + 16 + 32 + REGISTER_STACK_SPACE(ct)
- if (ct->calling_convention == FAST_CALL) {
- | call ->save_registers
- }
- |.endif
-
- // hardcode the lua_State* value into the assembly
- | mov64 L_ARG, L
-
- /* get the upval table */
- | call_rrr extern lua_rawgeti, L_ARG, LUA_REGISTRYINDEX, ref
-
- /* get the lua function */
- lua_pushvalue(L, fidx);
- lua_rawseti(L, -2, ++num_upvals);
- assert(num_upvals == CALLBACK_FUNC_USR_IDX);
- | call_rrr extern lua_rawgeti, L_ARG, -1, num_upvals
-
-#if !defined _WIN64 && !defined __amd64__
- lua_rawgeti(L, ct_usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
- if (!mt->pointers && !mt->is_reference && mt->type == COMPLEX_DOUBLE_TYPE) {
- hidden_arg_off = reg.off;
- reg.off += sizeof(void*);
- }
- lua_pop(L, 1);
-#else
- (void) hidden_arg_off;
-#endif
-
- for (i = 1; i <= nargs; i++) {
- lua_rawgeti(L, ct_usr, i);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mt->pointers || mt->is_reference) {
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- /* on the lua stack in the callback:
- * upval tbl, lua func, i-1 args
- */
- | call_rrr extern lua_rawgeti, L_ARG, -i-1, num_upvals-1
- | call_rrp extern push_cdata, L_ARG, -1, mt
- get_pointer(Dst, ct, ®);
- | mov [rax], rcx
- | call_rr, extern lua_remove, L_ARG, -2
- } else {
- switch (mt->type) {
- case INT64_TYPE:
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* mt */
- lua_pop(L, 1);
- | call_rrp extern push_cdata, L_ARG, 0, mt
- get_int(Dst, ct, ®, 1);
- |.if X64
- | mov [rax], rcx
- |.else
- | mov [rax], ecx
- | mov [rax+4], edx
- |.endif
- break;
-
- case INTPTR_TYPE:
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* mt */
- lua_pop(L, 1);
- | call_rrp extern push_cdata, L_ARG, 0, mt
- get_pointer(Dst, ct, ®);
- | mov [rax], rcx
- break;
-
- case COMPLEX_FLOAT_TYPE:
- lua_pop(L, 1);
-#if defined _WIN64 || defined __amd64__
- /* complex floats are two floats packed into a double */
- | call_rrp extern push_cdata, L_ARG, 0, mt
- get_float(Dst, ct, ®, 1);
- | movq qword [rax], xmm0
-#else
- /* complex floats are real followed by imag on the stack */
- | call_rrp extern push_cdata, L_ARG, 0, mt
- get_float(Dst, ct, ®, 0);
- | fstp dword [rax]
- get_float(Dst, ct, ®, 0);
- | fstp dword [rax+4]
-#endif
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- lua_pop(L, 1);
- | call_rrp extern push_cdata, L_ARG, 0, mt
- /* real */
- get_float(Dst, ct, ®, 1);
- |.if X64
- | movq qword [rax], xmm0
- |.else
- | fstp qword [rax]
- |.endif
- /* imag */
- get_float(Dst, ct, ®, 1);
- |.if X64
- | movq qword [rax+8], xmm0
- |.else
- | fstp qword [rax+8]
- |.endif
- break;
-
- case FLOAT_TYPE:
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- get_float(Dst, ct, ®, mt->type == DOUBLE_TYPE);
- |.if X64WIN
- | movq xmm1, xmm0
- | mov rcx, L_ARG
- |.elif X64
- | // for 64bit xmm0 is already set
- | mov rdi, L_ARG
- |.else
- | fstp qword [rsp+4]
- | mov [rsp], L_ARG
- |.endif
- | call extern lua_pushnumber
- break;
-
- case BOOL_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- | movzx ecx, cl
- | call_rr extern lua_pushboolean, L_ARG, rcx
- break;
-
- case INT8_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- if (mt->is_unsigned) {
- | movzx ecx, cl
- } else {
- | movsx ecx, cl
- }
- | call_rr extern push_int, L_ARG, rcx
- break;
-
- case INT16_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- if (mt->is_unsigned) {
- | movzx ecx, cx
- } else {
- | movsx ecx, cx
- }
- | call_rr extern push_int, L_ARG, rcx
- break;
-
- case ENUM_TYPE:
- case INT32_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- if (mt->is_unsigned) {
- | call_rr extern push_uint, L_ARG, rcx
- } else {
- | call_rr extern push_int, L_ARG, rcx
- }
- break;
-
- default:
- luaL_error(L, "NYI: callback arg type");
- }
- }
- }
-
- lua_rawgeti(L, ct_usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- | call_rrrp extern lua_callk, L_ARG, nargs, (mt->pointers || mt->is_reference || mt->type != VOID_TYPE) ? 1 : 0, 0
-
- // Unpack the return argument if not "void", also clean-up the lua stack
- // to remove the return argument and bind table. Use lua_settop rather
- // than lua_pop as lua_pop is implemented as a macro.
- if (mt->pointers || mt->is_reference) {
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- | call_rrr extern lua_rawgeti, L_ARG, -2, num_upvals-1
- | call_rrrp extern check_typed_pointer, L_ARG, -2, -1, mt
- | mov [rsp+32], rax
- | call_rr extern lua_settop, L_ARG, -4
- | mov rax, [rsp+32]
-
- } else {
- switch (mt->type) {
- case ENUM_TYPE:
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- | call_rrr extern lua_rawgeti, L_ARG, -2, num_upvals-1
- | call_rrrp, extern check_enum, L_ARG, -2, -1, mt
- | mov [rsp+32], eax
- | call_rr extern lua_settop, L_ARG, -4
- | mov eax, [rsp+32]
- break;
-
- case VOID_TYPE:
- lua_pop(L, 1);
- | call_rr extern lua_settop, L_ARG, -2
- break;
-
- case BOOL_TYPE:
- case INT8_TYPE:
- case INT16_TYPE:
- case INT32_TYPE:
- lua_pop(L, 1);
- if (mt->is_unsigned) {
- | call_rr extern check_uint32, L_ARG, -1
- } else {
- | call_rr extern check_int32, L_ARG, -1
- }
- | mov [rsp+32], eax
- | call_rr extern lua_settop, L_ARG, -3
- | mov eax, [rsp+32]
- break;
-
- case INT64_TYPE:
- lua_pop(L, 1);
-
- if (mt->is_unsigned) {
- | call_rr extern check_uint64, L_ARG, -1
- } else {
- | call_rr extern check_int64, L_ARG, -1
- }
-
- |.if X64
- | mov [rsp+32], rax
- |.else
- | mov [rsp+32], RET_L
- | mov [rsp+36], RET_H
- |.endif
- | call_rr extern lua_settop, L_ARG, -3
- |.if X64
- | mov rax, [rsp+32]
- |.else
- | mov RET_L, [rsp+32]
- | mov RET_H, [rsp+36]
- |.endif
- break;
-
- case INTPTR_TYPE:
- lua_pop(L, 1);
- | call_rr extern check_uintptr, L_ARG, -1
- | mov [rsp+32], rax
- | call_rr extern lua_settop, L_ARG, -3
- | mov rax, [rsp+32]
- break;
-
- case FLOAT_TYPE:
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- | call_rr extern check_double, L_ARG, -1
- |.if X64
- | movq qword [rsp+32], xmm0
- | call_rr extern lua_settop, L_ARG, -3
- if (mt->type == FLOAT_TYPE) {
- | cvtsd2ss xmm0, qword [rsp+32]
- } else {
- | movq xmm0, qword [rsp+32]
- }
- |.else
- | fstp qword [rsp+32]
- | call_rr extern lua_settop, L_ARG, -3
- | fld qword [rsp+32]
- |.endif
- break;
-
- case COMPLEX_FLOAT_TYPE:
- lua_pop(L, 1);
-#if !defined HAVE_COMPLEX
- luaL_error(L, "ffi lib compiled without complex number support");
-#endif
- /* on 64 bit complex floats are two floats packed into a double,
- * on 32 bit returned complex floats use eax and edx */
- | call_rr extern check_complex_float, L_ARG, -1
- |
- |.if X64
- | movq qword [rsp+32], xmm0
- |.else
- | mov [rsp+32], eax
- | mov [rsp+36], edx
- |.endif
- |
- | call_rr extern lua_settop, L_ARG, -3
- |
- |.if X64
- | movq xmm0, qword [rsp+32]
- |.else
- | mov eax, [rsp+32]
- | mov edx, [rsp+36]
- |.endif
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- lua_pop(L, 1);
-#if !defined HAVE_COMPLEX
- luaL_error(L, "ffi lib compiled without complex number support");
-#endif
- /* on 64 bit, returned complex doubles use xmm0, xmm1, on 32 bit
- * there is a hidden first parameter that points to 16 bytes where
- * the returned arg is stored which is popped by the called
- * function */
-#if defined _WIN64 || defined __amd64__
- | call_rr extern check_complex_double, L_ARG, -1
- | movq qword [rsp+32], xmm0
- | movq qword [rsp+40], xmm1
- | call_rr extern lua_settop, L_ARG, -3
- | movq xmm0, qword [rsp+32]
- | movq xmm1, qword [rsp+40]
-#else
- | mov rcx, [rbp + hidden_arg_off]
- | call_rrr extern check_complex_double, rcx, L_ARG, -1
- | sub rsp, 4 // to realign from popped hidden arg
- | call_rr extern lua_settop, L_ARG, -3
-#endif
- break;
-
- default:
- luaL_error(L, "NYI: callback return type");
- }
- }
-
- |.if X64
- | mov L_ARG, [rbp-8]
- |.else
- | mov L_ARG, [rbp-4]
- |.endif
- | mov rsp, rbp
- | pop rbp
- | ret x86_return_size(L, ct_usr, ct)
-
- lua_pop(L, 1); /* upval table - already in registry */
- assert(lua_gettop(L) == top);
-
- ct2.is_jitted = 1;
- pf = (cfunction*) push_cdata(L, ct_usr, &ct2);
- *pf = compile(Dst, L, NULL, ref);
-
- assert(lua_gettop(L) == top + 1);
-
- return *pf;
-}
-
-void compile_function(lua_State* L, cfunction func, int ct_usr, const struct ctype* ct)
-{
- size_t i, nargs;
- int num_upvals;
- const struct ctype* mbr_ct;
- struct jit* Dst = get_jit(L);
- struct reg_alloc reg;
- void* p;
- int top = lua_gettop(L);
- int* perr = &Dst->last_errno;
-
- ct_usr = lua_absindex(L, ct_usr);
-
- memset(®, 0, sizeof(reg));
- reg.off = 32 + REGISTER_STACK_SPACE(ct);
-
- dasm_setup(Dst, build_actionlist);
-
- p = push_cdata(L, ct_usr, ct);
- *(cfunction*) p = func;
- num_upvals = 1;
-
- nargs = lua_rawlen(L, ct_usr);
-
- if (ct->calling_convention != C_CALL && ct->has_var_arg) {
- luaL_error(L, "vararg is only allowed with the c calling convention");
- }
-
- | push rbp
- | mov rbp, rsp
- | push L_ARG
- | push TOP
- | // stack is 0 (mod 16) (TOP, L_ARG, rbp, rip)
- |
- | // Get L from our arguments and allocate some stack for lua_gettop
- |.if X64WIN
- | mov L_ARG, rcx
- | sub rsp, 32 // shadow space
- |.elif X64
- | mov L_ARG, rdi
- |.else
- | mov L_ARG, [rbp + 8]
- | sub rsp, 16
- |.endif
- |
- | call_r extern lua_gettop, L_ARG
- | mov TOP, rax // no need for movzxd rax, eax - high word guarenteed to be zero by x86-64
- | cmp rax, nargs
- | jl ->too_few_arguments
-
- if (!ct->has_var_arg) {
- | jg ->too_many_arguments
- }
-
- /* no need to zero extend eax returned by lua_gettop to rax as x86-64
- * preguarentees that the upper 32 bits will be zero */
- | shl rax, 4 // reserve 16 bytes per argument - this maintains the alignment mod 16
- | sub rsp, rax
- | sub rsp, 32 + REGISTER_STACK_SPACE(ct) // reserve an extra 32 to call local functions
-
-#if !defined _WIN64 && !defined __amd64__
- /* Returned complex doubles require a hidden first parameter where the
- * data is stored, which is popped by the calling code. */
- lua_rawgeti(L, ct_usr, 0);
- mbr_ct = (const struct ctype*) lua_touserdata(L, -1);
- if (!mbr_ct->pointers && !mbr_ct->is_reference && mbr_ct->type == COMPLEX_DOUBLE_TYPE) {
- /* we can allocate more space for arguments as long as no add_*
- * function has been called yet, mbr_ct will be added as an upvalue in
- * the return processing later */
- | call_rrp extern push_cdata, L_ARG, 0, mbr_ct
- | sub rsp, 16
- add_pointer(Dst, ct, ®);
- }
- lua_pop(L, 1);
-#endif
-
- for (i = 1; i <= nargs; i++) {
- lua_rawgeti(L, ct_usr, (int) i);
- mbr_ct = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mbr_ct->pointers || mbr_ct->is_reference) {
- lua_getuservalue(L, -1);
- num_upvals += 2;
- | call_rrrp extern check_typed_pointer, L_ARG, i, lua_upvalueindex(num_upvals), mbr_ct
- add_pointer(Dst, ct, ®);
- } else {
- switch (mbr_ct->type) {
- case FUNCTION_PTR_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- | call_rrrp extern check_typed_cfunction, L_ARG, i, lua_upvalueindex(num_upvals), mbr_ct
- add_pointer(Dst, ct, ®);
- break;
-
- case ENUM_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- | call_rrrp, extern check_enum, L_ARG, i, lua_upvalueindex(num_upvals), mbr_ct
- add_int(Dst, ct, ®, 0);
- break;
-
- case INT8_TYPE:
- | call_rr extern check_int32, L_ARG, i
- if (mbr_ct->is_unsigned) {
- | movzx eax, al
- } else {
- | movsx eax, al
- }
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case INT16_TYPE:
- | call_rr extern check_int32, L_ARG, i
- if (mbr_ct->is_unsigned) {
- | movzx eax, ax
- } else {
- | movsx eax, ax
- }
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case BOOL_TYPE:
- | call_rr extern check_int32, L_ARG, i
- | cmp eax, 0
- | setne al
- | movzx eax, al
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case INT32_TYPE:
- if (mbr_ct->is_unsigned) {
- | call_rr extern check_uint32, L_ARG, i
- } else {
- | call_rr extern check_int32, L_ARG, i
- }
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case INTPTR_TYPE:
- | call_rr extern check_uintptr, L_ARG, i
- add_pointer(Dst, ct, ®);
- lua_pop(L, 1);
- break;
-
- case INT64_TYPE:
- if (mbr_ct->is_unsigned) {
- | call_rr extern check_uint64, L_ARG, i
- } else {
- | call_rr extern check_int64, L_ARG, i
- }
- add_int(Dst, ct, ®, 1);
- lua_pop(L, 1);
- break;
-
- case DOUBLE_TYPE:
- | call_rr extern check_double, L_ARG, i
- add_float(Dst, ct, ®, 1);
- lua_pop(L, 1);
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- /* on 64 bit, returned complex doubles use xmm0, xmm1, on 32 bit
- * there is a hidden first parameter that points to 16 bytes where
- * the returned arg is stored (this is popped by the called
- * function) */
-#if defined _WIN64 || defined __amd64__
- | call_rr extern check_complex_double, L_ARG, i
- add_float(Dst, ct, ®, 1);
- | movq xmm0, xmm1
- add_float(Dst, ct, ®, 1);
-#else
- | lea rax, [rsp+reg.off]
- | sub rsp, 4
- | call_rrr extern check_complex_double, rax, L_ARG, i
- reg.off += 16;
-#endif
- lua_pop(L, 1);
- break;
-
- case FLOAT_TYPE:
- | call_rr extern check_double, L_ARG, i
- add_float(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case COMPLEX_FLOAT_TYPE:
-#if defined _WIN64 || defined __amd64__
- | call_rr extern check_complex_float, L_ARG, i
- /* complex floats are two floats packed into a double */
- add_float(Dst, ct, ®, 1);
-#else
- /* returned complex floats use eax and edx */
- | call_rr extern check_complex_float, L_ARG, i
- | mov [rsp], eax
- | fld dword [rsp]
- add_float(Dst, ct, ®, 0);
- | mov [rsp], edx
- | fld dword [rsp]
- add_float(Dst, ct, ®, 0);
-#endif
- lua_pop(L, 1);
- break;
-
- default:
- luaL_error(L, "NYI: call arg type");
- }
- }
- }
-
- if (ct->has_var_arg) {
-#ifdef _WIN64
- |.if X64WIN
- if (reg.regs < MAX_REGISTERS(ct)) {
- assert(reg.regs == nargs);
- | cmp TOP, MAX_REGISTERS(ct)
- | jle >1
- | // unpack onto stack
- | mov rax, rsp
- | add rax, 32 + 8*MAX_REGISTERS(ct)
- | call_rrrr extern unpack_varargs_stack, L_ARG, MAX_REGISTERS(ct)+1, TOP, rax
- | // unpack to registers
- | mov rax, rsp
- | add rax, 32 + 8*(reg.regs)
- | call_rrrr extern unpack_varargs_reg, L_ARG, nargs+1, MAX_REGISTERS(ct), rax
- | jmp >2
- |1:
- | // unpack just to registers
- | mov rax, rsp
- | add rax, 32 + 8*(reg.regs)
- | call_rrrr extern unpack_varargs_reg, L_ARG, nargs+1, TOP, rax
- |2:
- } else {
- | // unpack just to stack
- | mov rax, rsp
- | add rax, reg.off
- | call_rrrr extern unpack_varargs_stack, L_ARG, nargs+1, TOP, rax
- }
-
- for (i = nargs; i < MAX_REGISTERS(ct); i++) {
- reg.is_int[i] = reg.is_float[i] = 1;
- }
- reg.regs = MAX_REGISTERS(ct);
-#elif defined __amd64__
- |.elif X64
- if (reg.floats < MAX_FLOAT_REGISTERS(ct)) {
- | mov rax, rsp
- | add rax, 32 + 8*(MAX_INT_REGISTERS(ct) + reg.floats)
- | call_rrrrr extern unpack_varargs_float, L_ARG, nargs+1, TOP, MAX_FLOAT_REGISTERS(ct) - reg.floats, rax
- }
-
- if (reg.ints < MAX_INT_REGISTERS(ct)) {
- | mov rax, rsp
- | add rax, 32 + 8*(reg.ints)
- | call_rrrrr extern unpack_varargs_int, L_ARG, nargs+1, TOP, MAX_INT_REGISTERS(ct) - reg.ints, rax
- }
-
- | mov rax, rsp
- | add rax, reg.off
- | call_rrrrrr extern unpack_varargs_stack_skip, L_ARG, nargs+1, TOP, MAX_INT_REGISTERS(ct) - reg.ints, MAX_FLOAT_REGISTERS(ct) - reg.floats, rax
-
- reg.floats = MAX_FLOAT_REGISTERS(ct);
- reg.ints = MAX_INT_REGISTERS(ct);
-#else
- |.else
- | mov rax, rsp
- | add rax, reg.off
- | call_rrrr extern unpack_varargs_stack, L_ARG, nargs+1, TOP, rax
- |.endif
-#endif
- }
-
- | mov64 rcx, perr
- | mov eax, dword [rcx]
- | call_r extern SetLastError, rax
-
- /* remove the stack space to call local functions */
- |.if X32WIN
- | add rsp, 28 // SetLastError will have already popped 4
- |.else
- | add rsp, 32
- |.endif
-
-#ifdef _WIN64
- |.if X64WIN
- switch (reg.regs) {
- case 4:
- if (reg.is_float[3]) {
- | movq xmm3, qword [rsp + 8*3]
- }
- if (reg.is_int[3]) {
- | mov r9, [rsp + 8*3]
- }
- case 3:
- if (reg.is_float[2]) {
- | movq xmm2, qword [rsp + 8*2]
- }
- if (reg.is_int[2]) {
- | mov r8, [rsp + 8*2]
- }
- case 2:
- if (reg.is_float[1]) {
- | movq xmm1, qword [rsp + 8*1]
- }
- if (reg.is_int[1]) {
- | mov rdx, [rsp + 8*1]
- }
- case 1:
- if (reg.is_float[0]) {
- | movq xmm0, qword [rsp]
- }
- if (reg.is_int[0]) {
- | mov rcx, [rsp]
- }
- case 0:
- break;
- }
-
- /* don't remove the space for the registers as we need 32 bytes of register overflow space */
- assert(REGISTER_STACK_SPACE(ct) == 32);
-
-#elif defined __amd64__
- |.elif X64
- switch (reg.floats) {
- case 8:
- | movq xmm7, qword [rsp + 8*(MAX_INT_REGISTERS(ct)+7)]
- case 7:
- | movq xmm6, qword [rsp + 8*(MAX_INT_REGISTERS(ct)+6)]
- case 6:
- | movq xmm5, qword [rsp + 8*(MAX_INT_REGISTERS(ct)+5)]
- case 5:
- | movq xmm4, qword [rsp + 8*(MAX_INT_REGISTERS(ct)+4)]
- case 4:
- | movq xmm3, qword [rsp + 8*(MAX_INT_REGISTERS(ct)+3)]
- case 3:
- | movq xmm2, qword [rsp + 8*(MAX_INT_REGISTERS(ct)+2)]
- case 2:
- | movq xmm1, qword [rsp + 8*(MAX_INT_REGISTERS(ct)+1)]
- case 1:
- | movq xmm0, qword [rsp + 8*(MAX_INT_REGISTERS(ct))]
- case 0:
- break;
- }
-
- switch (reg.ints) {
- case 6:
- | mov r9, [rsp + 8*5]
- case 5:
- | mov r8, [rsp + 8*4]
- case 4:
- | mov rcx, [rsp + 8*3]
- case 3:
- | mov rdx, [rsp + 8*2]
- case 2:
- | mov rsi, [rsp + 8*1]
- case 1:
- | mov rdi, [rsp]
- case 0:
- break;
- }
-
- | add rsp, REGISTER_STACK_SPACE(ct)
-#else
- |.else
- if (ct->calling_convention == FAST_CALL) {
- switch (reg.ints) {
- case 2:
- | mov edx, [rsp + 4]
- case 1:
- | mov ecx, [rsp]
- case 0:
- break;
- }
-
- | add rsp, REGISTER_STACK_SPACE(ct)
- }
- |.endif
-#endif
-
-#ifdef __amd64__
- if (ct->has_var_arg) {
- /* al stores an upper limit on the number of float register, note that
- * its allowed to be more than the actual number of float registers used as
- * long as its 0-8 */
- |.if X64 and not X64WIN
- | mov al, 8
- |.endif
- }
-#endif
-
- | call extern FUNCTION
- | sub rsp, 48 // 32 to be able to call local functions, 16 so we can store some local variables
-
- /* note on windows X86 the stack may be only aligned to 4 (stdcall will
- * have popped a multiple of 4 bytes), but we don't need 16 byte alignment on
- * that platform
- */
-
- lua_rawgeti(L, ct_usr, 0);
- mbr_ct = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mbr_ct->pointers || mbr_ct->is_reference || mbr_ct->type == INTPTR_TYPE) {
- lua_getuservalue(L, -1);
- num_upvals += 2;
- | mov [rsp+32], rax // save the pointer
- | get_errno
- | call_rrp extern push_cdata, L_ARG, lua_upvalueindex(num_upvals), mbr_ct
- | mov rcx, [rsp+32]
- | mov [rax], rcx // *(void**) cdata = val
- | jmp ->lua_return_arg
-
- } else {
- switch (mbr_ct->type) {
- case FUNCTION_PTR_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- | mov [rsp+32], rax // save the function pointer
- | get_errno
- | call_rrp extern push_cdata, L_ARG, lua_upvalueindex(num_upvals), mbr_ct
- | mov rcx, [rsp+32]
- | mov [rax], rcx // *(cfunction**) cdata = val
- | jmp ->lua_return_arg
- break;
-
- case INT64_TYPE:
- num_upvals++;
- | // save the return value
- |.if X64
- | mov [rsp+32], rax
- |.else
- | mov [rsp+36], edx // high
- | mov [rsp+32], eax // low
- |.endif
- |
- | get_errno
- | call_rrp extern push_cdata, L_ARG, 0, mbr_ct
- |
- | // *(int64_t*) cdata = val
- |.if X64
- | mov rcx, [rsp+32]
- | mov [rax], rcx
- |.else
- | mov rcx, [rsp+36]
- | mov rdx, [rsp+32]
- | mov [rax+4], rcx
- | mov [rax], rdx
- |.endif
- |
- | jmp ->lua_return_arg
- break;
-
- case COMPLEX_FLOAT_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- |.if X64
- | // complex floats are returned as two floats packed into xmm0
- | movq qword [rsp+32], xmm0
- |.else
- | // complex floats are returned as floats in eax and edx
- | mov [rsp+32], eax
- | mov [rsp+36], edx
- |.endif
- |
- | get_errno
- | call_rrp extern push_cdata, L_ARG, lua_upvalueindex(num_upvals), mbr_ct
- |
- | // ((complex_float*) cdata) = val
- |.if X64
- | mov rcx, [rsp+32]
- | mov [rax], rcx
- |.else
- | mov ecx, [rsp+32]
- | mov [rax], ecx
- | mov ecx, [rsp+36]
- | mov [rax+4], ecx
- |.endif
- |
- | jmp ->lua_return_arg
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- |.if X64
- | // complex doubles are returned as xmm0 and xmm1
- | movq qword [rsp+40], xmm1
- | movq qword [rsp+32], xmm0
- |
- | get_errno
- | call_rrp extern push_cdata, L_ARG, lua_upvalueindex(num_upvals), mbr_ct
- |
- | // ((complex_double*) cdata)->real = val0
- | // ((complex_double*) cdata)->imag = val1
- | mov rcx, [rsp+40]
- | mov [rax+8], rcx
- | mov rcx, [rsp+32]
- | mov [rax], rcx
- |
- |.else
- | // On 32 bit we have already handled this by pushing a new cdata
- | // and handing the cdata ptr in as the hidden first param, but
- | // still need to add mbr_ct as an upval as its used earlier.
- | // Hidden param was popped by called function, we need to realign.
- | sub rsp, 4
- | get_errno
- |.endif
- |
- | jmp ->lua_return_arg
- break;
-
- case VOID_TYPE:
- lua_pop(L, 1);
- | jmp ->lua_return_void
- break;
-
- case BOOL_TYPE:
- lua_pop(L, 1);
- | jmp ->lua_return_bool
- break;
-
- case INT8_TYPE:
- lua_pop(L, 1);
- if (mbr_ct->is_unsigned) {
- | movzx eax, al
- } else {
- | movsx eax, al
- }
- | jmp ->lua_return_int
- break;
-
- case INT16_TYPE:
- lua_pop(L, 1);
- if (mbr_ct->is_unsigned) {
- | movzx eax, ax
- } else {
- | movsx eax, ax
- }
- | jmp ->lua_return_int
- break;
-
- case INT32_TYPE:
- case ENUM_TYPE:
- lua_pop(L, 1);
- if (mbr_ct->is_unsigned) {
- | jmp ->lua_return_uint
- } else {
- | jmp ->lua_return_int
- }
- break;
-
- case FLOAT_TYPE:
- lua_pop(L, 1);
- |.if X64
- | cvtss2sd xmm0, xmm0
- |.endif
- | jmp ->lua_return_double
- break;
-
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- | jmp ->lua_return_double
- break;
-
- default:
- luaL_error(L, "NYI: call return type");
- }
- }
-
- assert(lua_gettop(L) == top + num_upvals);
- {
- cfunction f = compile(Dst, L, func, LUA_NOREF);
- /* add a callback as an upval so that the jitted code gets cleaned up when
- * the function gets gc'd */
- push_callback(L, f, func);
- lua_pushcclosure(L, (lua_CFunction) f, num_upvals+1);
- }
-}
-
diff --git a/plugins/MirLua/Modules/ffi/src/call_x86.h b/plugins/MirLua/Modules/ffi/src/call_x86.h deleted file mode 100644 index 40bad83147..0000000000 --- a/plugins/MirLua/Modules/ffi/src/call_x86.h +++ /dev/null @@ -1,1179 +0,0 @@ -/*
-** This file has been pre-processed with DynASM.
-** http://luajit.org/dynasm.html
-** DynASM version 1.3.0, DynASM x86 version 1.3.0
-** DO NOT EDIT! The original file is in "call_x86.dasc".
-*/
-
-#if DASM_VERSION != 10300
-#error "Version mismatch between DynASM and included encoding engine"
-#endif
-
-/* vim: ts=4 sw=4 sts=4 et tw=78
- * Portions copyright (c) 2015-present, Facebook, Inc. All rights reserved.
- * Portions copyright (c) 2011 James R. McKaskill.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-static const unsigned char build_actionlist[1800] = {
- 248,10,184,1,0,0,0,139,117,252,248,139,125,252,252,137,252,236,93,195,255,
- 248,11,232,251,1,0,185,237,137,1,184,0,0,0,0,139,117,252,248,139,125,252,
- 252,137,252,236,93,195,255,248,12,221,92,36,4,232,251,1,0,185,237,137,1,137,
- 60,36,232,251,1,1,252,233,244,10,255,248,13,15,182,192,137,68,36,32,232,251,
- 1,0,185,237,137,1,139,68,36,32,137,68,36,4,137,60,36,232,251,1,2,252,233,
- 244,10,255,248,14,137,68,36,32,232,251,1,0,185,237,137,1,139,68,36,32,137,
- 68,36,4,137,60,36,232,251,1,3,252,233,244,10,255,248,15,137,68,36,32,232,
- 251,1,0,185,237,137,1,139,68,36,32,137,68,36,4,137,60,36,232,251,1,4,252,
- 233,244,10,255,248,16,102,184,0,0,199,68,36,4,237,137,60,36,232,251,1,5,255,
- 248,17,102,184,0,0,199,68,36,4,237,137,60,36,232,251,1,5,255,248,18,137,77,
- 252,248,137,85,252,244,195,255,139,141,233,255,139,141,233,139,149,233,255,
- 137,132,253,36,233,255,137,132,253,36,233,137,148,253,36,233,255,221,133,
- 233,255,217,133,233,255,252,243,15,126,133,233,255,252,243,15,90,133,233,
- 255,221,156,253,36,233,255,217,156,253,36,233,255,102,15,214,132,253,36,233,
- 255,252,242,15,90,192,102,15,214,132,253,36,233,255,252,242,15,90,192,102,
- 15,126,132,253,36,233,255,85,137,229,87,129,252,236,239,255,232,244,18,255,
- 191,237,255,199,68,36,8,237,199,68,36,4,237,137,60,36,232,251,1,6,255,199,
- 68,36,8,237,199,68,36,4,252,255,252,255,252,255,252,255,137,60,36,232,251,
- 1,6,255,199,68,36,8,237,199,68,36,4,237,137,60,36,232,251,1,6,199,68,36,8,
- 237,199,68,36,4,252,255,252,255,252,255,252,255,137,60,36,232,251,1,7,255,
- 137,8,199,68,36,4,252,254,252,255,252,255,252,255,137,60,36,232,251,1,8,255,
- 199,68,36,8,237,199,68,36,4,0,0,0,0,137,60,36,232,251,1,7,255,137,8,137,80,
- 4,255,137,8,255,102,15,214,0,255,217,24,255,217,88,4,255,221,24,255,221,88,
- 8,255,221,92,36,4,137,60,36,232,251,1,1,255,15,182,201,137,76,36,4,137,60,
- 36,232,251,1,2,255,15,182,201,255,15,190,201,255,137,76,36,4,137,60,36,232,
- 251,1,3,255,15,183,201,255,15,191,201,255,137,76,36,4,137,60,36,232,251,1,
- 4,255,199,68,36,12,0,0,0,0,199,68,36,8,237,199,68,36,4,237,137,60,36,232,
- 251,1,9,255,199,68,36,8,237,199,68,36,4,252,254,252,255,252,255,252,255,137,
- 60,36,232,251,1,6,199,68,36,12,237,199,68,36,8,252,255,252,255,252,255,252,
- 255,199,68,36,4,252,254,252,255,252,255,252,255,137,60,36,232,251,1,10,137,
- 68,36,32,199,68,36,4,252,252,252,255,252,255,252,255,137,60,36,232,251,1,
- 11,139,68,36,32,255,199,68,36,8,237,199,68,36,4,252,254,252,255,252,255,252,
- 255,137,60,36,232,251,1,6,199,68,36,12,237,199,68,36,8,252,255,252,255,252,
- 255,252,255,199,68,36,4,252,254,252,255,252,255,252,255,137,60,36,232,251,
- 1,12,137,68,36,32,199,68,36,4,252,252,252,255,252,255,252,255,137,60,36,232,
- 251,1,11,139,68,36,32,255,199,68,36,4,252,254,252,255,252,255,252,255,137,
- 60,36,232,251,1,11,255,199,68,36,4,252,255,252,255,252,255,252,255,137,60,
- 36,232,251,1,13,255,199,68,36,4,252,255,252,255,252,255,252,255,137,60,36,
- 232,251,1,14,255,137,68,36,32,199,68,36,4,252,253,252,255,252,255,252,255,
- 137,60,36,232,251,1,11,139,68,36,32,255,199,68,36,4,252,255,252,255,252,255,
- 252,255,137,60,36,232,251,1,15,255,199,68,36,4,252,255,252,255,252,255,252,
- 255,137,60,36,232,251,1,16,255,137,68,36,32,137,84,36,36,199,68,36,4,252,
- 253,252,255,252,255,252,255,137,60,36,232,251,1,11,139,68,36,32,139,84,36,
- 36,255,199,68,36,4,252,255,252,255,252,255,252,255,137,60,36,232,251,1,17,
- 137,68,36,32,199,68,36,4,252,253,252,255,252,255,252,255,137,60,36,232,251,
- 1,11,139,68,36,32,255,199,68,36,4,252,255,252,255,252,255,252,255,137,60,
- 36,232,251,1,18,255,221,92,36,32,199,68,36,4,252,253,252,255,252,255,252,
- 255,137,60,36,232,251,1,11,221,68,36,32,255,199,68,36,4,252,255,252,255,252,
- 255,252,255,137,60,36,232,251,1,19,137,68,36,32,137,84,36,36,199,68,36,4,
- 252,253,252,255,252,255,252,255,137,60,36,232,251,1,11,139,68,36,32,139,84,
- 36,36,255,199,68,36,4,252,255,252,255,252,255,252,255,137,60,36,232,251,1,
- 20,102,15,214,68,36,32,102,15,214,76,36,40,199,68,36,4,252,253,252,255,252,
- 255,252,255,137,60,36,232,251,1,11,252,243,15,126,68,36,32,252,243,15,126,
- 76,36,40,255,139,141,233,199,68,36,8,252,255,252,255,252,255,252,255,137,
- 124,36,4,137,12,36,232,251,1,20,131,252,236,4,199,68,36,4,252,253,252,255,
- 252,255,252,255,137,60,36,232,251,1,11,255,139,125,252,252,137,252,236,93,
- 194,236,255,85,137,229,87,86,139,189,233,131,252,236,16,137,60,36,232,251,
- 1,21,137,198,129,252,248,239,15,140,244,16,255,15,143,244,17,255,193,224,
- 4,41,196,129,252,236,239,255,199,68,36,8,237,199,68,36,4,0,0,0,0,137,60,36,
- 232,251,1,7,131,252,236,16,255,199,68,36,12,237,199,68,36,8,237,199,68,36,
- 4,237,137,60,36,232,251,1,10,255,199,68,36,12,237,199,68,36,8,237,199,68,
- 36,4,237,137,60,36,232,251,1,22,255,199,68,36,12,237,199,68,36,8,237,199,
- 68,36,4,237,137,60,36,232,251,1,12,255,199,68,36,4,237,137,60,36,232,251,
- 1,14,255,15,182,192,255,15,190,192,255,15,183,192,255,15,191,192,255,199,
- 68,36,4,237,137,60,36,232,251,1,14,131,252,248,0,15,149,208,15,182,192,255,
- 199,68,36,4,237,137,60,36,232,251,1,13,255,199,68,36,4,237,137,60,36,232,
- 251,1,17,255,199,68,36,4,237,137,60,36,232,251,1,15,255,199,68,36,4,237,137,
- 60,36,232,251,1,16,255,199,68,36,4,237,137,60,36,232,251,1,18,255,199,68,
- 36,4,237,137,60,36,232,251,1,20,255,252,243,15,126,193,255,141,132,253,36,
- 233,131,252,236,4,199,68,36,8,237,137,124,36,4,137,4,36,232,251,1,20,255,
- 199,68,36,4,237,137,60,36,232,251,1,19,255,199,68,36,4,237,137,60,36,232,
- 251,1,19,137,4,36,217,4,36,255,137,20,36,217,4,36,255,137,224,129,192,239,
- 137,68,36,12,137,116,36,8,199,68,36,4,237,137,60,36,232,251,1,23,255,185,
- 237,139,1,137,4,36,232,251,1,24,255,131,196,32,255,139,148,253,36,233,255,
- 139,12,36,255,129,196,239,255,232,251,1,25,131,252,236,48,255,137,68,36,32,
- 232,251,1,0,185,237,137,1,199,68,36,8,237,199,68,36,4,237,137,60,36,232,251,
- 1,7,139,76,36,32,137,8,252,233,244,10,255,137,84,36,36,137,68,36,32,232,251,
- 1,0,185,237,137,1,199,68,36,8,237,199,68,36,4,0,0,0,0,137,60,36,232,251,1,
- 7,139,76,36,36,139,84,36,32,137,72,4,137,16,252,233,244,10,255,137,68,36,
- 32,137,84,36,36,232,251,1,0,185,237,137,1,199,68,36,8,237,199,68,36,4,237,
- 137,60,36,232,251,1,7,139,76,36,32,137,8,139,76,36,36,137,72,4,252,233,244,
- 10,255,131,252,236,4,232,251,1,0,185,237,137,1,252,233,244,10,255,252,233,
- 244,11,255,252,233,244,13,255,252,233,244,14,255,252,233,244,15,255,252,233,
- 244,12,255
-};
-
-static const char *const globnames[] = {
- "lua_return_arg",
- "lua_return_void",
- "lua_return_double",
- "lua_return_bool",
- "lua_return_int",
- "lua_return_uint",
- "too_few_arguments",
- "too_many_arguments",
- "save_registers",
- (const char *)0
-};
-static const char *const extnames[] = {
- "GetLastError",
- "lua_pushnumber",
- "lua_pushboolean",
- "push_int",
- "push_uint",
- "luaL_error",
- "lua_rawgeti",
- "push_cdata",
- "lua_remove",
- "lua_callk",
- "check_typed_pointer",
- "lua_settop",
- "check_enum",
- "check_uint32",
- "check_int32",
- "check_uint64",
- "check_int64",
- "check_uintptr",
- "check_double",
- "check_complex_float",
- "check_complex_double",
- "lua_gettop",
- "check_typed_cfunction",
- "unpack_varargs_stack",
- "SetLastError",
- "FUNCTION",
- (const char *)0
-};
-
-
-
-#if defined _WIN64 || defined __amd64__
-#define JUMP_SIZE 14
-#else
-#define JUMP_SIZE 4
-#endif
-
-#define MIN_BRANCH INT32_MIN
-#define MAX_BRANCH INT32_MAX
-#define BRANCH_OFF 4
-
-static void compile_extern_jump(struct jit* jit, lua_State* L, cfunction func, uint8_t* code)
-{
- /* The jump code is the function pointer followed by a stub to call the
- * function pointer. The stub exists in 64 bit so we can jump to functions
- * with an offset greater than 2 GB.
- *
- * Note we have to manually set this up since there are commands buffered
- * in the jit state and dynasm doesn't support rip relative addressing.
- *
- * eg on 64 bit:
- * 0-8: function ptr
- * 8-14: jmp aword [rip-14]
- *
- * for 32 bit we only set the function ptr as it can always fit in a 32
- * bit displacement
- */
-#if defined _WIN64 || defined __amd64__
- *(cfunction*) code = func;
- code[8] = 0xFF; /* FF /4 operand for jmp */
- code[9] = 0x25; /* RIP displacement */
- *(int32_t*) &code[10] = -14;
-#else
- *(cfunction*) code = func;
-#endif
-}
-
-void compile_globals(struct jit* jit, lua_State* L)
-{
- struct jit* Dst = jit;
- int* perr = &jit->last_errno;
- dasm_setup(Dst, build_actionlist);
-
- /* Note: since the return code uses EBP to reset the stack pointer, we
- * don't have to track the amount of stack space used. It also means we
- * can handle stdcall and cdecl with the same code.
- */
-
- /* Note the various call_* functions want 32 bytes of 16 byte aligned
- * stack
- */
-
-
-
-
- /* the general idea for the return functions is:
- * 1) Save return value on stack
- * 2) Call get_errno (this trashes the registers hence #1)
- * 3) Unpack return value from stack
- * 4) Call lua push function
- * 5) Set eax to number of returned args (0 or 1)
- * 6) Call return which pops our stack frame
- */
-
- dasm_put(Dst, 0);
-
- dasm_put(Dst, 21, perr);
-
- dasm_put(Dst, 50, perr);
-
- dasm_put(Dst, 76, perr);
-
- dasm_put(Dst, 113, perr);
-
- dasm_put(Dst, 147, perr);
-
- dasm_put(Dst, 181, (ptrdiff_t)("too few arguments"));
-
- dasm_put(Dst, 200, (ptrdiff_t)("too many arguments"));
-
- dasm_put(Dst, 219);
-
- compile(Dst, L, NULL, LUA_NOREF);
-}
-
-int x86_return_size(lua_State* L, int usr, const struct ctype* ct)
-{
- int ret = 0;
- const struct ctype* mt;
-
- if (ct->calling_convention != C_CALL) {
- size_t i;
- size_t argn = lua_rawlen(L, usr);
- for (i = 1; i <= argn; i++) {
- lua_rawgeti(L, usr, (int) i);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mt->pointers || mt->is_reference) {
- ret += sizeof(void*);
- } else {
- switch (mt->type) {
- case DOUBLE_TYPE:
- case COMPLEX_FLOAT_TYPE:
- case INT64_TYPE:
- ret += 8;
- break;
- case COMPLEX_DOUBLE_TYPE:
- ret += 16;
- break;
- case INTPTR_TYPE:
- ret += sizeof(intptr_t);
- break;
- case FUNCTION_PTR_TYPE:
- ret += sizeof(cfunction);
- break;
- case BOOL_TYPE:
- case FLOAT_TYPE:
- case INT8_TYPE:
- case INT16_TYPE:
- case INT32_TYPE:
- case ENUM_TYPE:
- ret += 4;
- break;
- default:
- return luaL_error(L, "NYI - argument type");
- }
- }
-
- lua_pop(L, 1);
- }
- }
-
-#if !defined _WIN64 && !defined __amd64__
- lua_rawgeti(L, usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
- if (!mt->pointers && !mt->is_reference && mt->type == COMPLEX_DOUBLE_TYPE) {
- ret += sizeof(void*);
- }
- lua_pop(L, 1);
-#endif
-
- return ret;
-}
-
-#ifdef _WIN64
-#define MAX_REGISTERS(ct) 4 /* rcx, rdx, r8, r9 */
-
-#elif defined __amd64__
-#define MAX_INT_REGISTERS(ct) 6 /* rdi, rsi, rdx, rcx, r8, r9 */
-#define MAX_FLOAT_REGISTERS(ct) 8 /* xmm0-7 */
-
-#else
-#define MAX_INT_REGISTERS(ct) ((ct)->calling_convention == FAST_CALL ? 2 /* ecx, edx */ : 0)
-#define MAX_FLOAT_REGISTERS(ct) 0
-#endif
-
-struct reg_alloc {
-#ifdef _WIN64
- int regs;
- int is_float[4];
- int is_int[4];
-#else
- int floats;
- int ints;
-#endif
- int off;
-};
-
-#ifdef _WIN64
-#define REGISTER_STACK_SPACE(ct) (4*8)
-#elif defined __amd64__
-#define REGISTER_STACK_SPACE(ct) (14*8)
-#else
-#define REGISTER_STACK_SPACE(ct) ALIGN_UP(((ct)->calling_convention == FAST_CALL ? 2*4 : 0), 15)
-#endif
-
-/* Fastcall:
- * Uses ecx, edx as first two int registers
- * Everything else on stack (include 64bit ints)
- * No overflow stack space
- * Pops the stack before returning
- * Returns int in eax, float in ST0
- * We use the same register allocation logic as posix x64 with 2 int regs and 0 float regs
- */
-
-static void get_int(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_int64)
-{
- /* grab the register from the shadow space */
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- dasm_put(Dst, 231, 16 + 8*reg->regs);
- reg->regs++;
- }
-#elif __amd64__
- if (reg->ints < MAX_INT_REGISTERS(ct)) {
- dasm_put(Dst, 231, - 80 - 8*reg->ints);
- reg->ints++;
- }
-#else
- if (!is_int64 && reg->ints < MAX_INT_REGISTERS(ct)) {
- dasm_put(Dst, 231, - 8 - 4*reg->ints);
- reg->ints++;
- }
-#endif
- else if (is_int64) {
- dasm_put(Dst, 235, reg->off, reg->off + 4);
- reg->off += 8;
- } else {
- dasm_put(Dst, 231, reg->off);
- reg->off += 4;
- }
-}
-
-static void add_int(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_int64)
-{
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- dasm_put(Dst, 242, 32 + 8*(reg->regs));
- reg->is_int[reg->regs++] = 1;
- }
-#elif __amd64__
- if (reg->ints < MAX_INT_REGISTERS(ct)) {
- dasm_put(Dst, 242, 32 + 8*reg->ints);
- reg->ints++;
- }
-#else
- if (!is_int64 && reg->ints < MAX_INT_REGISTERS(ct)) {
- dasm_put(Dst, 242, 32 + 4*reg->ints);
- reg->ints++;
- }
-#endif
- else {
-#if defined _WIN64 || defined __amd64__
- if (reg->off % 8 != 0) {
- reg->off += 8 - (reg->off % 8);
- }
-#endif
- if (is_int64) {
- dasm_put(Dst, 248, reg->off, reg->off + 4);
- reg->off += 8;
- } else {
- dasm_put(Dst, 242, reg->off);
- reg->off += 4;
- }
- }
-}
-
-static void get_float(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_double)
-{
-#if !defined _WIN64 && !defined __amd64__
- assert(MAX_FLOAT_REGISTERS(ct) == 0);
- if (is_double) {
- dasm_put(Dst, 259, reg->off);
- reg->off += 8;
- } else {
- dasm_put(Dst, 263, reg->off);
- reg->off += 4;
- }
-#else
- int off;
-
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- off = -16 - 8*reg->regs;
- reg->regs++;
- }
-#else
- if (reg->floats < MAX_FLOAT_REGISTERS(ct)) {
- off = -16 - 8*reg->floats;
- reg->floats++;
- }
-#endif
- else {
- off = reg->off;
- reg->off += is_double ? 8 : 4;
- }
-
- if (is_double) {
- dasm_put(Dst, 267, off);
- } else {
- dasm_put(Dst, 274, off);
- }
-#endif
-}
-
-static void add_float(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_double)
-{
-#if !defined _WIN64 && !defined __amd64__
- assert(MAX_FLOAT_REGISTERS(ct) == 0);
- if (is_double) {
- dasm_put(Dst, 281, reg->off);
- reg->off += 8;
- } else {
- dasm_put(Dst, 287, reg->off);
- reg->off += 4;
- }
-#else
-
-#ifdef _WIN64
- if (reg->regs < MAX_REGISTERS(ct)) {
- if (is_double) {
- dasm_put(Dst, 293, 32 + 8*(reg->regs));
- } else {
- dasm_put(Dst, 301, 32 + 8*(reg->regs));
- }
- reg->is_float[reg->regs++] = 1;
- }
-#else
- if (reg->floats < MAX_FLOAT_REGISTERS(ct)) {
- if (is_double) {
- dasm_put(Dst, 293, 32 + 8*(MAX_INT_REGISTERS(ct) + reg->floats));
- } else {
- dasm_put(Dst, 301, 32 + 8*(MAX_INT_REGISTERS(ct) + reg->floats));
- }
- reg->floats++;
- }
-#endif
-
- else if (is_double) {
- dasm_put(Dst, 293, reg->off);
- reg->off += 8;
- } else {
- dasm_put(Dst, 314, reg->off);
- reg->off += 4;
- }
-#endif
-}
-
-#if defined _WIN64 || defined __amd64__
-#define add_pointer(jit, ct, reg) add_int(jit, ct, reg, 1)
-#define get_pointer(jit, ct, reg) get_int(jit, ct, reg, 1)
-#else
-#define add_pointer(jit, ct, reg) add_int(jit, ct, reg, 0)
-#define get_pointer(jit, ct, reg) get_int(jit, ct, reg, 0)
-#endif
-
-cfunction compile_callback(lua_State* L, int fidx, int ct_usr, const struct ctype* ct)
-{
- int i, nargs;
- cfunction* pf;
- struct ctype ct2 = *ct;
- const struct ctype* mt;
- struct reg_alloc reg;
- int num_upvals = 0;
- int top = lua_gettop(L);
- struct jit* Dst = get_jit(L);
- int ref;
- int hidden_arg_off = 0;
-
- ct_usr = lua_absindex(L, ct_usr);
- fidx = lua_absindex(L, fidx);
-
- assert(lua_isnil(L, fidx) || lua_isfunction(L, fidx));
-
- memset(®, 0, sizeof(reg));
-#ifdef _WIN64
- reg.off = 16 + REGISTER_STACK_SPACE(ct); /* stack registers are above the shadow space */
-#elif __amd64__
- reg.off = 16;
-#else
- reg.off = 8;
-#endif
-
- dasm_setup(Dst, build_actionlist);
-
- // add a table to store ctype and function upvalues
- // callback_set assumes the first value is the lua function
- nargs = (int) lua_rawlen(L, ct_usr);
- lua_newtable(L);
- lua_pushvalue(L, -1);
- ref = luaL_ref(L, LUA_REGISTRYINDEX);
-
- if (ct->has_var_arg) {
- luaL_error(L, "can't create callbacks with varargs");
- }
-
- // setup a stack frame to hold args for the call into lua_call
-
- dasm_put(Dst, 327, 4 + 16 + 32 + REGISTER_STACK_SPACE(ct));
- if (ct->calling_convention == FAST_CALL) {
- dasm_put(Dst, 336);
- }
-
- // hardcode the lua_State* value into the assembly
- dasm_put(Dst, 340, L);
-
- /* get the upval table */
- dasm_put(Dst, 343, ref, LUA_REGISTRYINDEX);
-
- /* get the lua function */
- lua_pushvalue(L, fidx);
- lua_rawseti(L, -2, ++num_upvals);
- assert(num_upvals == CALLBACK_FUNC_USR_IDX);
- dasm_put(Dst, 361, num_upvals);
-
-#if !defined _WIN64 && !defined __amd64__
- lua_rawgeti(L, ct_usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
- if (!mt->pointers && !mt->is_reference && mt->type == COMPLEX_DOUBLE_TYPE) {
- hidden_arg_off = reg.off;
- reg.off += sizeof(void*);
- }
- lua_pop(L, 1);
-#else
- (void) hidden_arg_off;
-#endif
-
- for (i = 1; i <= nargs; i++) {
- lua_rawgeti(L, ct_usr, i);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mt->pointers || mt->is_reference) {
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- /* on the lua stack in the callback:
- * upval tbl, lua func, i-1 args
- */
- dasm_put(Dst, 386, num_upvals-1, -i-1, mt);
- get_pointer(Dst, ct, ®);
- dasm_put(Dst, 428);
- } else {
- switch (mt->type) {
- case INT64_TYPE:
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* mt */
- lua_pop(L, 1);
- dasm_put(Dst, 450, mt);
- get_int(Dst, ct, ®, 1);
- dasm_put(Dst, 471);
- break;
-
- case INTPTR_TYPE:
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* mt */
- lua_pop(L, 1);
- dasm_put(Dst, 450, mt);
- get_pointer(Dst, ct, ®);
- dasm_put(Dst, 477);
- break;
-
- case COMPLEX_FLOAT_TYPE:
- lua_pop(L, 1);
-#if defined _WIN64 || defined __amd64__
- /* complex floats are two floats packed into a double */
- dasm_put(Dst, 450, mt);
- get_float(Dst, ct, ®, 1);
- dasm_put(Dst, 480);
-#else
- /* complex floats are real followed by imag on the stack */
- dasm_put(Dst, 450, mt);
- get_float(Dst, ct, ®, 0);
- dasm_put(Dst, 485);
- get_float(Dst, ct, ®, 0);
- dasm_put(Dst, 488);
-#endif
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 450, mt);
- /* real */
- get_float(Dst, ct, ®, 1);
- dasm_put(Dst, 492);
- /* imag */
- get_float(Dst, ct, ®, 1);
- dasm_put(Dst, 495);
- break;
-
- case FLOAT_TYPE:
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- get_float(Dst, ct, ®, mt->type == DOUBLE_TYPE);
- dasm_put(Dst, 499);
- break;
-
- case BOOL_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- dasm_put(Dst, 511);
- break;
-
- case INT8_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- if (mt->is_unsigned) {
- dasm_put(Dst, 526);
- } else {
- dasm_put(Dst, 530);
- }
- dasm_put(Dst, 534);
- break;
-
- case INT16_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- if (mt->is_unsigned) {
- dasm_put(Dst, 546);
- } else {
- dasm_put(Dst, 550);
- }
- dasm_put(Dst, 534);
- break;
-
- case ENUM_TYPE:
- case INT32_TYPE:
- lua_pop(L, 1);
- get_int(Dst, ct, ®, 0);
- if (mt->is_unsigned) {
- dasm_put(Dst, 554);
- } else {
- dasm_put(Dst, 534);
- }
- break;
-
- default:
- luaL_error(L, "NYI: callback arg type");
- }
- }
- }
-
- lua_rawgeti(L, ct_usr, 0);
- mt = (const struct ctype*) lua_touserdata(L, -1);
-
- dasm_put(Dst, 566, (mt->pointers || mt->is_reference || mt->type != VOID_TYPE) ? 1 : 0, nargs);
-
- // Unpack the return argument if not "void", also clean-up the lua stack
- // to remove the return argument and bind table. Use lua_settop rather
- // than lua_pop as lua_pop is implemented as a macro.
- if (mt->pointers || mt->is_reference) {
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- dasm_put(Dst, 592, num_upvals-1, mt);
-
- } else {
- switch (mt->type) {
- case ENUM_TYPE:
- lua_getuservalue(L, -1);
- lua_rawseti(L, -3, ++num_upvals); /* usr value */
- lua_rawseti(L, -2, ++num_upvals); /* mt */
- dasm_put(Dst, 680, num_upvals-1, mt);
- break;
-
- case VOID_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 768);
- break;
-
- case BOOL_TYPE:
- case INT8_TYPE:
- case INT16_TYPE:
- case INT32_TYPE:
- lua_pop(L, 1);
- if (mt->is_unsigned) {
- dasm_put(Dst, 788);
- } else {
- dasm_put(Dst, 808);
- }
- dasm_put(Dst, 828);
- break;
-
- case INT64_TYPE:
- lua_pop(L, 1);
-
- if (mt->is_unsigned) {
- dasm_put(Dst, 856);
- } else {
- dasm_put(Dst, 876);
- }
-
- dasm_put(Dst, 896);
- break;
-
- case INTPTR_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 932);
- break;
-
- case FLOAT_TYPE:
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 979);
- if (mt->type == FLOAT_TYPE) {
- } else {
- }
- dasm_put(Dst, 999);
- break;
-
- case COMPLEX_FLOAT_TYPE:
- lua_pop(L, 1);
-#if !defined HAVE_COMPLEX
- luaL_error(L, "ffi lib compiled without complex number support");
-#endif
- /* on 64 bit complex floats are two floats packed into a double,
- * on 32 bit returned complex floats use eax and edx */
- dasm_put(Dst, 1027);
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- lua_pop(L, 1);
-#if !defined HAVE_COMPLEX
- luaL_error(L, "ffi lib compiled without complex number support");
-#endif
- /* on 64 bit, returned complex doubles use xmm0, xmm1, on 32 bit
- * there is a hidden first parameter that points to 16 bytes where
- * the returned arg is stored which is popped by the called
- * function */
-#if defined _WIN64 || defined __amd64__
- dasm_put(Dst, 1082);
-#else
- dasm_put(Dst, 1147, hidden_arg_off);
-#endif
- break;
-
- default:
- luaL_error(L, "NYI: callback return type");
- }
- }
-
- dasm_put(Dst, 1197, x86_return_size(L, ct_usr, ct));
-
- lua_pop(L, 1); /* upval table - already in registry */
- assert(lua_gettop(L) == top);
-
- ct2.is_jitted = 1;
- pf = (cfunction*) push_cdata(L, ct_usr, &ct2);
- *pf = compile(Dst, L, NULL, ref);
-
- assert(lua_gettop(L) == top + 1);
-
- return *pf;
-}
-
-void compile_function(lua_State* L, cfunction func, int ct_usr, const struct ctype* ct)
-{
- size_t i, nargs;
- int num_upvals;
- const struct ctype* mbr_ct;
- struct jit* Dst = get_jit(L);
- struct reg_alloc reg;
- void* p;
- int top = lua_gettop(L);
- int* perr = &Dst->last_errno;
-
- ct_usr = lua_absindex(L, ct_usr);
-
- memset(®, 0, sizeof(reg));
- reg.off = 32 + REGISTER_STACK_SPACE(ct);
-
- dasm_setup(Dst, build_actionlist);
-
- p = push_cdata(L, ct_usr, ct);
- *(cfunction*) p = func;
- num_upvals = 1;
-
- nargs = lua_rawlen(L, ct_usr);
-
- if (ct->calling_convention != C_CALL && ct->has_var_arg) {
- luaL_error(L, "vararg is only allowed with the c calling convention");
- }
-
- dasm_put(Dst, 1208, 8, nargs);
-
- if (!ct->has_var_arg) {
- dasm_put(Dst, 1238);
- }
-
- /* no need to zero extend eax returned by lua_gettop to rax as x86-64
- * preguarentees that the upper 32 bits will be zero */
- dasm_put(Dst, 1243, 32 + REGISTER_STACK_SPACE(ct));
-
-#if !defined _WIN64 && !defined __amd64__
- /* Returned complex doubles require a hidden first parameter where the
- * data is stored, which is popped by the calling code. */
- lua_rawgeti(L, ct_usr, 0);
- mbr_ct = (const struct ctype*) lua_touserdata(L, -1);
- if (!mbr_ct->pointers && !mbr_ct->is_reference && mbr_ct->type == COMPLEX_DOUBLE_TYPE) {
- /* we can allocate more space for arguments as long as no add_*
- * function has been called yet, mbr_ct will be added as an upvalue in
- * the return processing later */
- dasm_put(Dst, 1253, mbr_ct);
- add_pointer(Dst, ct, ®);
- }
- lua_pop(L, 1);
-#endif
-
- for (i = 1; i <= nargs; i++) {
- lua_rawgeti(L, ct_usr, (int) i);
- mbr_ct = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mbr_ct->pointers || mbr_ct->is_reference) {
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1278, mbr_ct, lua_upvalueindex(num_upvals), i);
- add_pointer(Dst, ct, ®);
- } else {
- switch (mbr_ct->type) {
- case FUNCTION_PTR_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1301, mbr_ct, lua_upvalueindex(num_upvals), i);
- add_pointer(Dst, ct, ®);
- break;
-
- case ENUM_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1324, mbr_ct, lua_upvalueindex(num_upvals), i);
- add_int(Dst, ct, ®, 0);
- break;
-
- case INT8_TYPE:
- dasm_put(Dst, 1347, i);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1360);
- } else {
- dasm_put(Dst, 1364);
- }
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case INT16_TYPE:
- dasm_put(Dst, 1347, i);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1368);
- } else {
- dasm_put(Dst, 1372);
- }
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case BOOL_TYPE:
- dasm_put(Dst, 1376, i);
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case INT32_TYPE:
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1399, i);
- } else {
- dasm_put(Dst, 1347, i);
- }
- add_int(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case INTPTR_TYPE:
- dasm_put(Dst, 1412, i);
- add_pointer(Dst, ct, ®);
- lua_pop(L, 1);
- break;
-
- case INT64_TYPE:
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1425, i);
- } else {
- dasm_put(Dst, 1438, i);
- }
- add_int(Dst, ct, ®, 1);
- lua_pop(L, 1);
- break;
-
- case DOUBLE_TYPE:
- dasm_put(Dst, 1451, i);
- add_float(Dst, ct, ®, 1);
- lua_pop(L, 1);
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- /* on 64 bit, returned complex doubles use xmm0, xmm1, on 32 bit
- * there is a hidden first parameter that points to 16 bytes where
- * the returned arg is stored (this is popped by the called
- * function) */
-#if defined _WIN64 || defined __amd64__
- dasm_put(Dst, 1464, i);
- add_float(Dst, ct, ®, 1);
- dasm_put(Dst, 1477);
- add_float(Dst, ct, ®, 1);
-#else
- dasm_put(Dst, 1483, reg.off, i);
- reg.off += 16;
-#endif
- lua_pop(L, 1);
- break;
-
- case FLOAT_TYPE:
- dasm_put(Dst, 1451, i);
- add_float(Dst, ct, ®, 0);
- lua_pop(L, 1);
- break;
-
- case COMPLEX_FLOAT_TYPE:
-#if defined _WIN64 || defined __amd64__
- dasm_put(Dst, 1509, i);
- /* complex floats are two floats packed into a double */
- add_float(Dst, ct, ®, 1);
-#else
- /* returned complex floats use eax and edx */
- dasm_put(Dst, 1522, i);
- add_float(Dst, ct, ®, 0);
- dasm_put(Dst, 1541);
- add_float(Dst, ct, ®, 0);
-#endif
- lua_pop(L, 1);
- break;
-
- default:
- luaL_error(L, "NYI: call arg type");
- }
- }
- }
-
- if (ct->has_var_arg) {
-#ifdef _WIN64
- if (reg.regs < MAX_REGISTERS(ct)) {
- assert(reg.regs == nargs);
- } else {
- }
-
- for (i = nargs; i < MAX_REGISTERS(ct); i++) {
- reg.is_int[i] = reg.is_float[i] = 1;
- }
- reg.regs = MAX_REGISTERS(ct);
-#elif defined __amd64__
- if (reg.floats < MAX_FLOAT_REGISTERS(ct)) {
- }
-
- if (reg.ints < MAX_INT_REGISTERS(ct)) {
- }
-
-
- reg.floats = MAX_FLOAT_REGISTERS(ct);
- reg.ints = MAX_INT_REGISTERS(ct);
-#else
- dasm_put(Dst, 1548, reg.off, nargs+1);
-#endif
- }
-
- dasm_put(Dst, 1574, perr);
-
- /* remove the stack space to call local functions */
- dasm_put(Dst, 1586);
-
-#ifdef _WIN64
- switch (reg.regs) {
- case 4:
- if (reg.is_float[3]) {
- }
- if (reg.is_int[3]) {
- }
- case 3:
- if (reg.is_float[2]) {
- }
- if (reg.is_int[2]) {
- }
- case 2:
- if (reg.is_float[1]) {
- }
- if (reg.is_int[1]) {
- }
- case 1:
- if (reg.is_float[0]) {
- }
- if (reg.is_int[0]) {
- }
- case 0:
- break;
- }
-
- /* don't remove the space for the registers as we need 32 bytes of register overflow space */
- assert(REGISTER_STACK_SPACE(ct) == 32);
-
-#elif defined __amd64__
- switch (reg.floats) {
- case 8:
- case 7:
- case 6:
- case 5:
- case 4:
- case 3:
- case 2:
- case 1:
- case 0:
- break;
- }
-
- switch (reg.ints) {
- case 6:
- case 5:
- case 4:
- case 3:
- case 2:
- case 1:
- case 0:
- break;
- }
-
-#else
- if (ct->calling_convention == FAST_CALL) {
- switch (reg.ints) {
- case 2:
- dasm_put(Dst, 1590, 4);
- case 1:
- dasm_put(Dst, 1596);
- case 0:
- break;
- }
-
- dasm_put(Dst, 1600, REGISTER_STACK_SPACE(ct));
- }
-#endif
-
-#ifdef __amd64__
- if (ct->has_var_arg) {
- /* al stores an upper limit on the number of float register, note that
- * its allowed to be more than the actual number of float registers used as
- * long as its 0-8 */
- }
-#endif
-
- dasm_put(Dst, 1604);
-
- /* note on windows X86 the stack may be only aligned to 4 (stdcall will
- * have popped a multiple of 4 bytes), but we don't need 16 byte alignment on
- * that platform
- */
-
- lua_rawgeti(L, ct_usr, 0);
- mbr_ct = (const struct ctype*) lua_touserdata(L, -1);
-
- if (mbr_ct->pointers || mbr_ct->is_reference || mbr_ct->type == INTPTR_TYPE) {
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1613, perr, mbr_ct, lua_upvalueindex(num_upvals));
-
- } else {
- switch (mbr_ct->type) {
- case FUNCTION_PTR_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1613, perr, mbr_ct, lua_upvalueindex(num_upvals));
- break;
-
- case INT64_TYPE:
- num_upvals++;
- dasm_put(Dst, 1653, perr, mbr_ct);
- break;
-
- case COMPLEX_FLOAT_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1707, perr, mbr_ct, lua_upvalueindex(num_upvals));
- break;
-
- case COMPLEX_DOUBLE_TYPE:
- lua_getuservalue(L, -1);
- num_upvals += 2;
- dasm_put(Dst, 1758, perr);
- break;
-
- case VOID_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 1775);
- break;
-
- case BOOL_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 1780);
- break;
-
- case INT8_TYPE:
- lua_pop(L, 1);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1360);
- } else {
- dasm_put(Dst, 1364);
- }
- dasm_put(Dst, 1785);
- break;
-
- case INT16_TYPE:
- lua_pop(L, 1);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1368);
- } else {
- dasm_put(Dst, 1372);
- }
- dasm_put(Dst, 1785);
- break;
-
- case INT32_TYPE:
- case ENUM_TYPE:
- lua_pop(L, 1);
- if (mbr_ct->is_unsigned) {
- dasm_put(Dst, 1790);
- } else {
- dasm_put(Dst, 1785);
- }
- break;
-
- case FLOAT_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 1795);
- break;
-
- case DOUBLE_TYPE:
- lua_pop(L, 1);
- dasm_put(Dst, 1795);
- break;
-
- default:
- luaL_error(L, "NYI: call return type");
- }
- }
-
- assert(lua_gettop(L) == top + num_upvals);
- {
- cfunction f = compile(Dst, L, func, LUA_NOREF);
- /* add a callback as an upval so that the jitted code gets cleaned up when
- * the function gets gc'd */
- push_callback(L, f, func);
- lua_pushcclosure(L, (lua_CFunction) f, num_upvals+1);
- }
-}
-
diff --git a/plugins/MirLua/Modules/ffi/src/ctype.c b/plugins/MirLua/Modules/ffi/src/ctype.c deleted file mode 100644 index 6208937536..0000000000 --- a/plugins/MirLua/Modules/ffi/src/ctype.c +++ /dev/null @@ -1,272 +0,0 @@ -/* vim: ts=4 sw=4 sts=4 et tw=78
- * Portions copyright (c) 2015-present, Facebook, Inc. All rights reserved.
- * Portions copyright (c) 2011 James R. McKaskill.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-#include "ffi.h"
-
-static int to_define_key;
-
-static void update_on_definition(lua_State* L, int ct_usr, int ct_idx)
-{
- ct_usr = lua_absindex(L, ct_usr);
- ct_idx = lua_absindex(L, ct_idx);
-
- lua_pushlightuserdata(L, &to_define_key);
- lua_rawget(L, ct_usr);
-
- if (lua_isnil(L, -1)) {
- lua_pop(L, 1); /* pop the nil */
-
- /* {} */
- lua_newtable(L);
-
- /* {__mode='k'} */
- lua_newtable(L);
- lua_pushliteral(L, "k");
- lua_setfield(L, -2, "__mode");
-
- /* setmetatable({}, {__mode='k'}) */
- lua_setmetatable(L, -2);
-
- /* usr[TO_UPDATE_KEY] = setmetatable({}, {__mode='k'}) */
- lua_pushlightuserdata(L, &to_define_key);
- lua_pushvalue(L, -2);
- lua_rawset(L, ct_usr);
-
- /* leave the table on the stack */
- }
-
- /* to_update[ctype or cdata] = true */
- lua_pushvalue(L, ct_idx);
- lua_pushboolean(L, 1);
- lua_rawset(L, -3);
-
- /* pop the to_update table */
- lua_pop(L, 1);
-}
-
-void set_defined(lua_State* L, int ct_usr, struct ctype* ct)
-{
- ct_usr = lua_absindex(L, ct_usr);
-
- ct->is_defined = 1;
-
- /* update ctypes and cdatas that were created before the definition came in */
- lua_pushlightuserdata(L, &to_define_key);
- lua_rawget(L, ct_usr);
-
- if (!lua_isnil(L, -1)) {
- lua_pushnil(L);
-
- while (lua_next(L, -2)) {
- struct ctype* upd = (struct ctype*) lua_touserdata(L, -2);
- upd->base_size = ct->base_size;
- upd->align_mask = ct->align_mask;
- upd->is_defined = 1;
- upd->is_variable_struct = ct->is_variable_struct;
- upd->variable_increment = ct->variable_increment;
- assert(!upd->variable_size_known);
- lua_pop(L, 1);
- }
-
- lua_pop(L, 1);
- /* usr[TO_UPDATE_KEY] = nil */
- lua_pushlightuserdata(L, &to_define_key);
- lua_pushnil(L);
- lua_rawset(L, ct_usr);
- } else {
- lua_pop(L, 1);
- }
-}
-
-struct ctype* push_ctype(lua_State* L, int ct_usr, const struct ctype* ct)
-{
- struct ctype* ret;
- ct_usr = lua_absindex(L, ct_usr);
-
- ret = (struct ctype*) lua_newuserdata(L, sizeof(struct ctype));
- *ret = *ct;
-
- push_upval(L, &ctype_mt_key);
- lua_setmetatable(L, -2);
-
-#if LUA_VERSION_NUM == 501
- if (!ct_usr || lua_isnil(L, ct_usr)) {
- push_upval(L, &niluv_key);
- lua_setfenv(L, -2);
- }
-#endif
-
- if (ct_usr && !lua_isnil(L, ct_usr)) {
- lua_pushvalue(L, ct_usr);
- lua_setuservalue(L, -2);
- }
-
- if (!ct->is_defined && ct_usr && !lua_isnil(L, ct_usr)) {
- update_on_definition(L, ct_usr, -1);
- }
-
- return ret;
-}
-
-size_t ctype_size(lua_State* L, const struct ctype* ct)
-{
- if (ct->pointers - ct->is_array) {
- return sizeof(void*) * (ct->is_array ? ct->array_size : 1);
-
- } else if (!ct->is_defined || ct->type == VOID_TYPE) {
- return luaL_error(L, "can't calculate size of an undefined type");
-
- } else if (ct->variable_size_known) {
- assert(ct->is_variable_struct && !ct->is_array);
- return ct->base_size + ct->variable_increment;
-
- } else if (ct->is_variable_array || ct->is_variable_struct) {
- return luaL_error(L, "internal error: calc size of variable type with unknown size");
-
- } else {
- return ct->base_size * (ct->is_array ? ct->array_size : 1);
- }
-}
-
-void* push_cdata(lua_State* L, int ct_usr, const struct ctype* ct)
-{
- struct cdata* cd;
- size_t sz = ct->is_reference ? sizeof(void*) : ctype_size(L, ct);
- ct_usr = lua_absindex(L, ct_usr);
-
- /* This is to stop valgrind from complaining. Bitfields are accessed in 8
- * byte chunks so that the code doesn't have to deal with different access
- * patterns, but this means that occasionally it will read past the end of
- * the struct. As its not setting the bits past the end (only reading and
- * then writing the bits back) and the read is aligned its a non-issue,
- * but valgrind complains nonetheless.
- */
- if (ct->has_bitfield) {
- sz = ALIGN_UP(sz, 7);
- }
-
- cd = (struct cdata*) lua_newuserdata(L, sizeof(struct cdata) + sz);
- *(struct ctype*) &cd->type = *ct;
- memset(cd+1, 0, sz);
-
- /* TODO: handle cases where lua_newuserdata returns a pointer that is not
- * aligned */
-#if 0
- assert((uintptr_t) (cd + 1) % 8 == 0);
-#endif
-
-#if LUA_VERSION_NUM == 501
- if (!ct_usr || lua_isnil(L, ct_usr)) {
- push_upval(L, &niluv_key);
- lua_setfenv(L, -2);
- }
-#endif
-
- if (ct_usr && !lua_isnil(L, ct_usr)) {
- lua_pushvalue(L, ct_usr);
- lua_setuservalue(L, -2);
- }
-
- push_upval(L, &cdata_mt_key);
- lua_setmetatable(L, -2);
-
- if (!ct->is_defined && ct_usr && !lua_isnil(L, ct_usr)) {
- update_on_definition(L, ct_usr, -1);
- }
-
- return cd+1;
-}
-
-void push_callback(lua_State* L, cfunction luafunc, cfunction cfunc)
-{
- cfunction* pf = (cfunction*) lua_newuserdata(L, 2 * sizeof(cfunction));
- pf[0] = luafunc;
- pf[1] = cfunc;
-
- push_upval(L, &callback_mt_key);
- lua_setmetatable(L, -2);
-}
-
-/* returns the value as a ctype, pushes the user value onto the stack */
-void check_ctype(lua_State* L, int idx, struct ctype* ct)
-{
- if (lua_isstring(L, idx)) {
- struct parser P;
- P.line = 1;
- P.prev = P.next = lua_tostring(L, idx);
- P.align_mask = DEFAULT_ALIGN_MASK;
- parse_type(L, &P, ct);
- parse_argument(L, &P, -1, ct, NULL, NULL);
- lua_remove(L, -2); /* remove the user value from parse_type */
-
- } else if (lua_getmetatable(L, idx)) {
- if (!equals_upval(L, -1, &ctype_mt_key)
- && !equals_upval(L, -1, &cdata_mt_key)) {
- goto err;
- }
-
- lua_pop(L, 1); /* pop the metatable */
- *ct = *(struct ctype*) lua_touserdata(L, idx);
- lua_getuservalue(L, idx);
-
- } else {
- goto err;
- }
-
- return;
-
-err:
- luaL_error(L, "expected cdata, ctype or string for arg #%d", idx);
-}
-
-/* to_cdata returns the struct cdata* and pushes the user value onto the
- * stack. If the index is not a ctype then ct is set to the zero value such
- * that ct->type is INVALID_TYPE, a nil is pushed, and NULL is returned. */
-void* to_cdata(lua_State* L, int idx, struct ctype* ct)
-{
- struct cdata* cd;
-
- memset(ct, 0, sizeof(struct ctype));
- if (!lua_isuserdata(L, idx) || !lua_getmetatable(L, idx)) {
- lua_pushnil(L);
- return NULL;
- }
-
- if (!equals_upval(L, -1, &cdata_mt_key)) {
- lua_pop(L, 1); /* mt */
- lua_pushnil(L);
- return NULL;
- }
-
- lua_pop(L, 1); /* mt */
- cd = (struct cdata*) lua_touserdata(L, idx);
- *ct = cd->type;
- lua_getuservalue(L, idx);
-
- if (ct->is_reference) {
- return *(void**) (cd+1);
-
- } else if (ct->pointers && !ct->is_array) {
- return *(void**) (cd+1);
-
- } else {
- return cd + 1;
- }
-}
-
-/* check_cdata returns the struct cdata* and pushes the user value onto the
- * stack. Also dereferences references. */
-void* check_cdata(lua_State* L, int idx, struct ctype* ct)
-{
- void* p = to_cdata(L, idx, ct);
- if (ct->type == INVALID_TYPE) {
- luaL_error(L, "expected cdata for arg #%d", idx);
- }
- return p;
-}
-
diff --git a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_arm.h b/plugins/MirLua/Modules/ffi/src/dynasm/dasm_arm.h deleted file mode 100644 index da88199284..0000000000 --- a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_arm.h +++ /dev/null @@ -1,455 +0,0 @@ -/*
-** DynASM ARM encoding engine.
-** Copyright (C) 2005-2011 Mike Pall. All rights reserved.
-** Released under the MIT/X license. See dynasm.lua for full copyright notice.
-*/
-
-#include <stddef.h>
-#include <stdarg.h>
-#include <string.h>
-#include <stdlib.h>
-
-#define DASM_ARCH "arm"
-
-#ifndef DASM_EXTERN
-#define DASM_EXTERN(a,b,c,d) 0
-#endif
-
-/* Action definitions. */
-enum {
- DASM_STOP, DASM_SECTION, DASM_ESC, DASM_REL_EXT,
- /* The following actions need a buffer position. */
- DASM_ALIGN, DASM_REL_LG, DASM_LABEL_LG,
- /* The following actions also have an argument. */
- DASM_REL_PC, DASM_LABEL_PC,
- DASM_LONG, DASM_IMM, DASM_IMM12, DASM_IMM16, DASM_IMML8, DASM_IMML12,
- DASM__MAX
-};
-
-/* Maximum number of section buffer positions for a single dasm_put() call. */
-#define DASM_MAXSECPOS 25
-
-/* DynASM encoder status codes. Action list offset or number are or'ed in. */
-#define DASM_S_OK 0x00000000
-#define DASM_S_NOMEM 0x01000000
-#define DASM_S_PHASE 0x02000000
-#define DASM_S_MATCH_SEC 0x03000000
-#define DASM_S_RANGE_I 0x11000000
-#define DASM_S_RANGE_SEC 0x12000000
-#define DASM_S_RANGE_LG 0x13000000
-#define DASM_S_RANGE_PC 0x14000000
-#define DASM_S_RANGE_REL 0x15000000
-#define DASM_S_UNDEF_LG 0x21000000
-#define DASM_S_UNDEF_PC 0x22000000
-
-/* Macros to convert positions (8 bit section + 24 bit index). */
-#define DASM_POS2IDX(pos) ((pos)&0x00ffffff)
-#define DASM_POS2BIAS(pos) ((pos)&0xff000000)
-#define DASM_SEC2POS(sec) ((sec)<<24)
-#define DASM_POS2SEC(pos) ((pos)>>24)
-#define DASM_POS2PTR(D, pos) (D->sections[DASM_POS2SEC(pos)].rbuf + (pos))
-
-/* Action list type. */
-typedef const unsigned int *dasm_ActList;
-
-/* Per-section structure. */
-typedef struct dasm_Section {
- int *rbuf; /* Biased buffer pointer (negative section bias). */
- int *buf; /* True buffer pointer. */
- size_t bsize; /* Buffer size in bytes. */
- int pos; /* Biased buffer position. */
- int epos; /* End of biased buffer position - max single put. */
- int ofs; /* Byte offset into section. */
-} dasm_Section;
-
-/* Core structure holding the DynASM encoding state. */
-struct dasm_State {
- size_t psize; /* Allocated size of this structure. */
- dasm_ActList actionlist; /* Current actionlist pointer. */
- int *lglabels; /* Local/global chain/pos ptrs. */
- size_t lgsize;
- int *pclabels; /* PC label chains/pos ptrs. */
- size_t pcsize;
- void **globals; /* Array of globals (bias -10). */
- dasm_Section *section; /* Pointer to active section. */
- size_t codesize; /* Total size of all code sections. */
- int maxsection; /* 0 <= sectionidx < maxsection. */
- int status; /* Status code. */
- dasm_Section sections[1]; /* All sections. Alloc-extended. */
-};
-
-/* The size of the core structure depends on the max. number of sections. */
-#define DASM_PSZ(ms) (sizeof(dasm_State)+(ms-1)*sizeof(dasm_Section))
-
-
-/* Initialize DynASM state. */
-void dasm_init(Dst_DECL, int maxsection)
-{
- dasm_State *D;
- size_t psz = 0;
- int i;
- Dst_REF = NULL;
- DASM_M_GROW(Dst, struct dasm_State, Dst_REF, psz, DASM_PSZ(maxsection));
- D = Dst_REF;
- D->psize = psz;
- D->lglabels = NULL;
- D->lgsize = 0;
- D->pclabels = NULL;
- D->pcsize = 0;
- D->globals = NULL;
- D->maxsection = maxsection;
- for (i = 0; i < maxsection; i++) {
- D->sections[i].buf = NULL; /* Need this for pass3. */
- D->sections[i].rbuf = D->sections[i].buf - DASM_SEC2POS(i);
- D->sections[i].bsize = 0;
- D->sections[i].epos = 0; /* Wrong, but is recalculated after resize. */
- }
-}
-
-/* Free DynASM state. */
-void dasm_free(Dst_DECL)
-{
- dasm_State *D = Dst_REF;
- int i;
- for (i = 0; i < D->maxsection; i++)
- if (D->sections[i].buf)
- DASM_M_FREE(Dst, D->sections[i].buf, D->sections[i].bsize);
- if (D->pclabels) DASM_M_FREE(Dst, D->pclabels, D->pcsize);
- if (D->lglabels) DASM_M_FREE(Dst, D->lglabels, D->lgsize);
- DASM_M_FREE(Dst, D, D->psize);
-}
-
-/* Setup global label array. Must be called before dasm_setup(). */
-void dasm_setupglobal(Dst_DECL, void **gl, unsigned int maxgl)
-{
- dasm_State *D = Dst_REF;
- D->globals = gl - 10; /* Negative bias to compensate for locals. */
- DASM_M_GROW(Dst, int, D->lglabels, D->lgsize, (10+maxgl)*sizeof(int));
-}
-
-/* Grow PC label array. Can be called after dasm_setup(), too. */
-void dasm_growpc(Dst_DECL, unsigned int maxpc)
-{
- dasm_State *D = Dst_REF;
- size_t osz = D->pcsize;
- DASM_M_GROW(Dst, int, D->pclabels, D->pcsize, maxpc*sizeof(int));
- memset((void *)(((unsigned char *)D->pclabels)+osz), 0, D->pcsize-osz);
-}
-
-/* Setup encoder. */
-void dasm_setup(Dst_DECL, const void *actionlist)
-{
- dasm_State *D = Dst_REF;
- int i;
- D->actionlist = (dasm_ActList)actionlist;
- D->status = DASM_S_OK;
- D->section = &D->sections[0];
- memset((void *)D->lglabels, 0, D->lgsize);
- if (D->pclabels) memset((void *)D->pclabels, 0, D->pcsize);
- for (i = 0; i < D->maxsection; i++) {
- D->sections[i].pos = DASM_SEC2POS(i);
- D->sections[i].ofs = 0;
- }
-}
-
-
-#ifdef DASM_CHECKS
-#define CK(x, st) \
- do { if (!(x)) { \
- D->status = DASM_S_##st|(p-D->actionlist-1); return; } } while (0)
-#define CKPL(kind, st) \
- do { if ((size_t)((char *)pl-(char *)D->kind##labels) >= D->kind##size) { \
- D->status = DASM_S_RANGE_##st|(p-D->actionlist-1); return; } } while (0)
-#else
-#define CK(x, st) ((void)0)
-#define CKPL(kind, st) ((void)0)
-#endif
-
-static int dasm_imm12(unsigned int n)
-{
- int i;
- for (i = 0; i < 16; i++, n = (n << 2) | (n >> 30))
- if (n <= 255) return (int)(n + (i << 8));
- return -1;
-}
-
-/* Pass 1: Store actions and args, link branches/labels, estimate offsets. */
-void dasm_put(Dst_DECL, int start, ...)
-{
- va_list ap;
- dasm_State *D = Dst_REF;
- dasm_ActList p = D->actionlist + start;
- dasm_Section *sec = D->section;
- int pos = sec->pos, ofs = sec->ofs;
- int *b;
-
- if (pos >= sec->epos) {
- DASM_M_GROW(Dst, int, sec->buf, sec->bsize,
- sec->bsize + 2*DASM_MAXSECPOS*sizeof(int));
- sec->rbuf = sec->buf - DASM_POS2BIAS(pos);
- sec->epos = (int)sec->bsize/sizeof(int) - DASM_MAXSECPOS+DASM_POS2BIAS(pos);
- }
-
- b = sec->rbuf;
- b[pos++] = start;
-
- va_start(ap, start);
- while (1) {
- unsigned int ins = *p++;
- unsigned int action = (ins >> 16);
- if (action >= DASM__MAX) {
- ofs += 4;
- } else {
- int *pl, n = action >= DASM_REL_PC ? va_arg(ap, int) : 0;
- switch (action) {
- case DASM_STOP: goto stop;
- case DASM_SECTION:
- n = (ins & 255); CK(n < D->maxsection, RANGE_SEC);
- D->section = &D->sections[n]; goto stop;
- case DASM_ESC: p++; ofs += 4; break;
- case DASM_REL_EXT: break;
- case DASM_ALIGN: ofs += (ins & 255); b[pos++] = ofs; break;
- case DASM_REL_LG:
- n = (ins & 2047) - 10; pl = D->lglabels + n;
- if (n >= 0) { CKPL(lg, LG); goto putrel; } /* Bkwd rel or global. */
- pl += 10; n = *pl;
- if (n < 0) n = 0; /* Start new chain for fwd rel if label exists. */
- goto linkrel;
- case DASM_REL_PC:
- pl = D->pclabels + n; CKPL(pc, PC);
- putrel:
- n = *pl;
- if (n < 0) { /* Label exists. Get label pos and store it. */
- b[pos] = -n;
- } else {
- linkrel:
- b[pos] = n; /* Else link to rel chain, anchored at label. */
- *pl = pos;
- }
- pos++;
- break;
- case DASM_LABEL_LG:
- pl = D->lglabels + (ins & 2047) - 10; CKPL(lg, LG); goto putlabel;
- case DASM_LABEL_PC:
- pl = D->pclabels + n; CKPL(pc, PC);
- putlabel:
- n = *pl; /* n > 0: Collapse rel chain and replace with label pos. */
- while (n > 0) { int *pb = DASM_POS2PTR(D, n); n = *pb; *pb = pos;
- }
- *pl = -pos; /* Label exists now. */
- b[pos++] = ofs; /* Store pass1 offset estimate. */
- break;
- case DASM_LONG:
- ofs += 4;
- b[pos++] = n;
- break;
- case DASM_IMM:
- case DASM_IMM16:
-#ifdef DASM_CHECKS
- CK((n & ((1<<((ins>>10)&31))-1)) == 0, RANGE_I);
- if ((ins & 0x8000))
- CK(((n + (1<<(((ins>>5)&31)-1)))>>((ins>>5)&31)) == 0, RANGE_I);
- else
- CK((n>>((ins>>5)&31)) == 0, RANGE_I);
-#endif
- b[pos++] = n;
- break;
- case DASM_IMML8:
- case DASM_IMML12:
- CK(n >= 0 ? ((n>>((ins>>5)&31)) == 0) :
- (((-n)>>((ins>>5)&31)) == 0), RANGE_I);
- b[pos++] = n;
- break;
- case DASM_IMM12:
- CK(dasm_imm12((unsigned int)n) != -1, RANGE_I);
- b[pos++] = n;
- break;
- }
- }
- }
-stop:
- va_end(ap);
- sec->pos = pos;
- sec->ofs = ofs;
-}
-#undef CK
-
-/* Pass 2: Link sections, shrink aligns, fix label offsets. */
-int dasm_link(Dst_DECL, size_t *szp)
-{
- dasm_State *D = Dst_REF;
- int secnum;
- int ofs = 0;
-
-#ifdef DASM_CHECKS
- *szp = 0;
- if (D->status != DASM_S_OK) return D->status;
- {
- int pc;
- for (pc = 0; pc*sizeof(int) < D->pcsize; pc++)
- if (D->pclabels[pc] > 0) return DASM_S_UNDEF_PC|pc;
- }
-#endif
-
- { /* Handle globals not defined in this translation unit. */
- int idx;
- for (idx = 20; idx*sizeof(int) < D->lgsize; idx++) {
- int n = D->lglabels[idx];
- /* Undefined label: Collapse rel chain and replace with marker (< 0). */
- while (n > 0) { int *pb = DASM_POS2PTR(D, n); n = *pb; *pb = -idx; }
- }
- }
-
- /* Combine all code sections. No support for data sections (yet). */
- for (secnum = 0; secnum < D->maxsection; secnum++) {
- dasm_Section *sec = D->sections + secnum;
- int *b = sec->rbuf;
- int pos = DASM_SEC2POS(secnum);
- int lastpos = sec->pos;
-
- while (pos != lastpos) {
- dasm_ActList p = D->actionlist + b[pos++];
- while (1) {
- unsigned int ins = *p++;
- unsigned int action = (ins >> 16);
- switch (action) {
- case DASM_STOP: case DASM_SECTION: goto stop;
- case DASM_ESC: p++; break;
- case DASM_REL_EXT: break;
- case DASM_ALIGN: ofs -= (b[pos++] + ofs) & (ins & 255); break;
- case DASM_REL_LG: case DASM_REL_PC: pos++; break;
- case DASM_LABEL_LG: case DASM_LABEL_PC: b[pos++] += ofs; break;
- case DASM_LONG: case DASM_IMM: case DASM_IMM12: case DASM_IMM16:
- case DASM_IMML8: case DASM_IMML12: pos++; break;
- }
- }
- stop: (void)0;
- }
- ofs += sec->ofs; /* Next section starts right after current section. */
- }
-
- D->codesize = ofs; /* Total size of all code sections */
- *szp = ofs;
- return DASM_S_OK;
-}
-
-#ifdef DASM_CHECKS
-#define CK(x, st) \
- do { if (!(x)) return DASM_S_##st|(p-D->actionlist-1); } while (0)
-#else
-#define CK(x, st) ((void)0)
-#endif
-
-/* Pass 3: Encode sections. */
-int dasm_encode(Dst_DECL, void *buffer)
-{
- dasm_State *D = Dst_REF;
- char *base = (char *)buffer;
- unsigned int *cp = (unsigned int *)buffer;
- int secnum;
-
- /* Encode all code sections. No support for data sections (yet). */
- for (secnum = 0; secnum < D->maxsection; secnum++) {
- dasm_Section *sec = D->sections + secnum;
- int *b = sec->buf;
- int *endb = sec->rbuf + sec->pos;
-
- while (b != endb) {
- dasm_ActList p = D->actionlist + *b++;
- while (1) {
- unsigned int ins = *p++;
- unsigned int action = (ins >> 16);
- int n = (action >= DASM_ALIGN && action < DASM__MAX) ? *b++ : 0;
- switch (action) {
- case DASM_STOP: case DASM_SECTION: goto stop;
- case DASM_ESC: *cp++ = *p++; break;
- case DASM_REL_EXT:
- n = DASM_EXTERN(Dst, (unsigned char *)cp, (ins&2047), !(ins&2048));
- goto patchrel;
- case DASM_ALIGN:
- ins &= 255; while ((((char *)cp - base) & ins)) *cp++ = 0xe1a00000;
- break;
- case DASM_REL_LG:
- CK(n >= 0, UNDEF_LG);
- case DASM_REL_PC:
- CK(n >= 0, UNDEF_PC);
- n = *DASM_POS2PTR(D, n) - (int)((char *)cp - base) - 4;
- patchrel:
- if ((ins & 0x800) == 0) {
- CK((n & 3) == 0 && ((n+0x02000000) >> 26) == 0, RANGE_REL);
- cp[-1] |= ((n >> 2) & 0x00ffffff);
- } else if ((ins & 0x1000)) {
- CK((n & 3) == 0 && -256 <= n && n <= 256, RANGE_REL);
- goto patchimml8;
- } else {
- CK((n & 3) == 0 && -4096 <= n && n <= 4096, RANGE_REL);
- goto patchimml12;
- }
- break;
- case DASM_LABEL_LG:
- ins &= 2047; if (ins >= 20) D->globals[ins-10] = (void *)(base + n);
- break;
- case DASM_LABEL_PC: break;
- case DASM_LONG:
- *cp++ = n;
- break;
- case DASM_IMM:
- cp[-1] |= ((n>>((ins>>10)&31)) & ((1<<((ins>>5)&31))-1)) << (ins&31);
- break;
- case DASM_IMM12:
- cp[-1] |= dasm_imm12((unsigned int)n);
- break;
- case DASM_IMM16:
- cp[-1] |= ((n & 0xf000) << 4) | (n & 0x0fff);
- break;
- case DASM_IMML8: patchimml8:
- cp[-1] |= n >= 0 ? (0x00800000 | (n & 0x0f) | ((n & 0xf0) << 4)) :
- ((-n & 0x0f) | ((-n & 0xf0) << 4));
- break;
- case DASM_IMML12: patchimml12:
- cp[-1] |= n >= 0 ? (0x00800000 | n) : (-n);
- break;
- default: *cp++ = ins; break;
- }
- }
- stop: (void)0;
- }
- }
-
- if (base + D->codesize != (char *)cp) /* Check for phase errors. */
- return DASM_S_PHASE;
- return DASM_S_OK;
-}
-#undef CK
-
-/* Get PC label offset. */
-int dasm_getpclabel(Dst_DECL, unsigned int pc)
-{
- dasm_State *D = Dst_REF;
- if (pc*sizeof(int) < D->pcsize) {
- int pos = D->pclabels[pc];
- if (pos < 0) return *DASM_POS2PTR(D, -pos);
- if (pos > 0) return -1; /* Undefined. */
- }
- return -2; /* Unused or out of range. */
-}
-
-#ifdef DASM_CHECKS
-/* Optional sanity checker to call between isolated encoding steps. */
-int dasm_checkstep(Dst_DECL, int secmatch)
-{
- dasm_State *D = Dst_REF;
- if (D->status == DASM_S_OK) {
- int i;
- for (i = 1; i <= 9; i++) {
- if (D->lglabels[i] > 0) { D->status = DASM_S_UNDEF_LG|i; break; }
- D->lglabels[i] = 0;
- }
- }
- if (D->status == DASM_S_OK && secmatch >= 0 &&
- D->section != &D->sections[secmatch])
- D->status = DASM_S_MATCH_SEC|(D->section-D->sections);
- return D->status;
-}
-#endif
-
diff --git a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_arm.lua b/plugins/MirLua/Modules/ffi/src/dynasm/dasm_arm.lua deleted file mode 100644 index 03d3d1ad67..0000000000 --- a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_arm.lua +++ /dev/null @@ -1,952 +0,0 @@ -------------------------------------------------------------------------------
--- DynASM ARM module.
---
--- Copyright (C) 2005-2011 Mike Pall. All rights reserved.
--- See dynasm.lua for full copyright notice.
-------------------------------------------------------------------------------
-
--- Module information:
-local _info = {
- arch = "arm",
- description = "DynASM ARM module",
- version = "1.3.0",
- vernum = 10300,
- release = "2011-05-05",
- author = "Mike Pall",
- license = "MIT",
-}
-
--- Exported glue functions for the arch-specific module.
-local _M = { _info = _info }
-
--- Cache library functions.
-local type, tonumber, pairs, ipairs = type, tonumber, pairs, ipairs
-local assert, setmetatable, rawget = assert, setmetatable, rawget
-local _s = string
-local sub, format, byte, char = _s.sub, _s.format, _s.byte, _s.char
-local match, gmatch, gsub = _s.match, _s.gmatch, _s.gsub
-local concat, sort, insert = table.concat, table.sort, table.insert
-
--- Inherited tables and callbacks.
-local g_opt, g_arch
-local wline, werror, wfatal, wwarn
-
--- Action name list.
--- CHECK: Keep this in sync with the C code!
-local action_names = {
- "STOP", "SECTION", "ESC", "REL_EXT",
- "ALIGN", "REL_LG", "LABEL_LG",
- "REL_PC", "LABEL_PC", "LONG", "IMM", "IMM12", "IMM16", "IMML8", "IMML12",
-}
-
--- Maximum number of section buffer positions for dasm_put().
--- CHECK: Keep this in sync with the C code!
-local maxsecpos = 25 -- Keep this low, to avoid excessively long C lines.
-
--- Action name -> action number.
-local map_action = {}
-for n,name in ipairs(action_names) do
- map_action[name] = n-1
-end
-
--- Action list buffer.
-local actlist = {}
-
--- Argument list for next dasm_put(). Start with offset 0 into action list.
-local actargs = { 0 }
-
--- Current number of section buffer positions for dasm_put().
-local secpos = 1
-
-------------------------------------------------------------------------------
-
--- Return 8 digit hex number.
-local function tohex(x)
- return sub(format("%08x", x), -8) -- Avoid 64 bit portability problem in Lua.
-end
-
--- Dump action names and numbers.
-local function dumpactions(out)
- out:write("DynASM encoding engine action codes:\n")
- for n,name in ipairs(action_names) do
- local num = map_action[name]
- out:write(format(" %-10s %02X %d\n", name, num, num))
- end
- out:write("\n")
-end
-
--- Write action list buffer as a huge static C array.
-local function writeactions(out, name)
- local nn = #actlist
- if nn == 0 then nn = 1; actlist[0] = map_action.STOP end
- out:write("static const unsigned int ", name, "[", nn, "] = {\n")
- for i = 1,nn-1 do
- assert(out:write("0x", tohex(actlist[i]), ",\n"))
- end
- assert(out:write("0x", tohex(actlist[nn]), "\n};\n\n"))
-end
-
-------------------------------------------------------------------------------
-
--- Add word to action list.
-local function wputxw(n)
- assert(n >= 0 and n <= 0xffffffff and n % 1 == 0, "word out of range")
- actlist[#actlist+1] = n
-end
-
--- Add action to list with optional arg. Advance buffer pos, too.
-local function waction(action, val, a, num)
- local w = assert(map_action[action], "bad action name `"..action.."'")
- wputxw(w * 0x10000 + (val or 0))
- if a then actargs[#actargs+1] = a end
- if a or num then secpos = secpos + (num or 1) end
-end
-
--- Flush action list (intervening C code or buffer pos overflow).
-local function wflush(term)
- if #actlist == actargs[1] then return end -- Nothing to flush.
- if not term then waction("STOP") end -- Terminate action list.
- wline(format("dasm_put(Dst, %s);", concat(actargs, ", ")), true)
- actargs = { #actlist } -- Actionlist offset is 1st arg to next dasm_put().
- secpos = 1 -- The actionlist offset occupies a buffer position, too.
-end
-
--- Put escaped word.
-local function wputw(n)
- if n <= 0x000fffff then waction("ESC") end
- wputxw(n)
-end
-
--- Reserve position for word.
-local function wpos()
- local pos = #actlist+1
- actlist[pos] = ""
- return pos
-end
-
--- Store word to reserved position.
-local function wputpos(pos, n)
- assert(n >= 0 and n <= 0xffffffff and n % 1 == 0, "word out of range")
- if n <= 0x000fffff then
- insert(actlist, pos+1, n)
- n = map_action.ESC * 0x10000
- end
- actlist[pos] = n
-end
-
-------------------------------------------------------------------------------
-
--- Global label name -> global label number. With auto assignment on 1st use.
-local next_global = 20
-local map_global = setmetatable({}, { __index = function(t, name)
- if not match(name, "^[%a_][%w_]*$") then werror("bad global label") end
- local n = next_global
- if n > 2047 then werror("too many global labels") end
- next_global = n + 1
- t[name] = n
- return n
-end})
-
--- Dump global labels.
-local function dumpglobals(out, lvl)
- local t = {}
- for name, n in pairs(map_global) do t[n] = name end
- out:write("Global labels:\n")
- for i=20,next_global-1 do
- out:write(format(" %s\n", t[i]))
- end
- out:write("\n")
-end
-
--- Write global label enum.
-local function writeglobals(out, prefix)
- local t = {}
- for name, n in pairs(map_global) do t[n] = name end
- out:write("enum {\n")
- for i=20,next_global-1 do
- out:write(" ", prefix, t[i], ",\n")
- end
- out:write(" ", prefix, "_MAX\n};\n")
-end
-
--- Write global label names.
-local function writeglobalnames(out, name)
- local t = {}
- for name, n in pairs(map_global) do t[n] = name end
- out:write("static const char *const ", name, "[] = {\n")
- for i=20,next_global-1 do
- out:write(" \"", t[i], "\",\n")
- end
- out:write(" (const char *)0\n};\n")
-end
-
-------------------------------------------------------------------------------
-
--- Extern label name -> extern label number. With auto assignment on 1st use.
-local next_extern = 0
-local map_extern_ = {}
-local map_extern = setmetatable({}, { __index = function(t, name)
- -- No restrictions on the name for now.
- local n = next_extern
- if n > 2047 then werror("too many extern labels") end
- next_extern = n + 1
- t[name] = n
- map_extern_[n] = name
- return n
-end})
-
--- Dump extern labels.
-local function dumpexterns(out, lvl)
- out:write("Extern labels:\n")
- for i=0,next_extern-1 do
- out:write(format(" %s\n", map_extern_[i]))
- end
- out:write("\n")
-end
-
--- Write extern label names.
-local function writeexternnames(out, name)
- out:write("static const char *const ", name, "[] = {\n")
- for i=0,next_extern-1 do
- out:write(" \"", map_extern_[i], "\",\n")
- end
- out:write(" (const char *)0\n};\n")
-end
-
-------------------------------------------------------------------------------
-
--- Arch-specific maps.
-
--- Ext. register name -> int. name.
-local map_archdef = { sp = "r13", lr = "r14", pc = "r15", }
-
--- Int. register name -> ext. name.
-local map_reg_rev = { r13 = "sp", r14 = "lr", r15 = "pc", }
-
-local map_type = {} -- Type name -> { ctype, reg }
-local ctypenum = 0 -- Type number (for Dt... macros).
-
--- Reverse defines for registers.
-function _M.revdef(s)
- return map_reg_rev[s] or s
-end
-
-local map_shift = { lsl = 0, lsr = 1, asr = 2, ror = 3, }
-
-local map_cond = {
- eq = 0, ne = 1, cs = 2, cc = 3, mi = 4, pl = 5, vs = 6, vc = 7,
- hi = 8, ls = 9, ge = 10, lt = 11, gt = 12, le = 13, al = 14,
- hs = 2, lo = 3,
-}
-
-------------------------------------------------------------------------------
-
--- Template strings for ARM instructions.
-local map_op = {
- -- Basic data processing instructions.
- and_3 = "e0000000DNPs",
- eor_3 = "e0200000DNPs",
- sub_3 = "e0400000DNPs",
- rsb_3 = "e0600000DNPs",
- add_3 = "e0800000DNPs",
- adc_3 = "e0a00000DNPs",
- sbc_3 = "e0c00000DNPs",
- rsc_3 = "e0e00000DNPs",
- tst_2 = "e1100000NP",
- teq_2 = "e1300000NP",
- cmp_2 = "e1500000NP",
- cmn_2 = "e1700000NP",
- orr_3 = "e1800000DNPs",
- mov_2 = "e1a00000DPs",
- bic_3 = "e1c00000DNPs",
- mvn_2 = "e1e00000DPs",
-
- and_4 = "e0000000DNMps",
- eor_4 = "e0200000DNMps",
- sub_4 = "e0400000DNMps",
- rsb_4 = "e0600000DNMps",
- add_4 = "e0800000DNMps",
- adc_4 = "e0a00000DNMps",
- sbc_4 = "e0c00000DNMps",
- rsc_4 = "e0e00000DNMps",
- tst_3 = "e1100000NMp",
- teq_3 = "e1300000NMp",
- cmp_3 = "e1500000NMp",
- cmn_3 = "e1700000NMp",
- orr_4 = "e1800000DNMps",
- mov_3 = "e1a00000DMps",
- bic_4 = "e1c00000DNMps",
- mvn_3 = "e1e00000DMps",
-
- lsl_3 = "e1a00000DMws",
- lsr_3 = "e1a00020DMws",
- asr_3 = "e1a00040DMws",
- ror_3 = "e1a00060DMws",
- rrx_2 = "e1a00060DMs",
-
- -- Multiply and multiply-accumulate.
- mul_3 = "e0000090NMSs",
- mla_4 = "e0200090NMSDs",
- umaal_4 = "e0400090DNMSs", -- v6
- mls_4 = "e0600090DNMSs", -- v6T2
- umull_4 = "e0800090DNMSs",
- umlal_4 = "e0a00090DNMSs",
- smull_4 = "e0c00090DNMSs",
- smlal_4 = "e0e00090DNMSs",
-
- -- Halfword multiply and multiply-accumulate.
- smlabb_4 = "e1000080NMSD", -- v5TE
- smlatb_4 = "e10000a0NMSD", -- v5TE
- smlabt_4 = "e10000c0NMSD", -- v5TE
- smlatt_4 = "e10000e0NMSD", -- v5TE
- smlawb_4 = "e1200080NMSD", -- v5TE
- smulwb_3 = "e12000a0NMS", -- v5TE
- smlawt_4 = "e12000c0NMSD", -- v5TE
- smulwt_3 = "e12000e0NMS", -- v5TE
- smlalbb_4 = "e1400080NMSD", -- v5TE
- smlaltb_4 = "e14000a0NMSD", -- v5TE
- smlalbt_4 = "e14000c0NMSD", -- v5TE
- smlaltt_4 = "e14000e0NMSD", -- v5TE
- smulbb_3 = "e1600080NMS", -- v5TE
- smultb_3 = "e16000a0NMS", -- v5TE
- smulbt_3 = "e16000c0NMS", -- v5TE
- smultt_3 = "e16000e0NMS", -- v5TE
-
- -- Miscellaneous data processing instructions.
- clz_2 = "e16f0f10DM", -- v5T
- rev_2 = "e6bf0f30DM", -- v6
- rev16_2 = "e6bf0fb0DM", -- v6
- revsh_2 = "e6ff0fb0DM", -- v6
- sel_3 = "e6800fb0DNM", -- v6
- usad8_3 = "e780f010NMS", -- v6
- usada8_4 = "e7800010NMSD", -- v6
- rbit_2 = "e6ff0f30DM", -- v6T2
- movw_2 = "e3000000DW", -- v6T2
- movt_2 = "e3400000DW", -- v6T2
- -- Note: the X encodes width-1, not width.
- sbfx_4 = "e7a00050DMvX", -- v6T2
- ubfx_4 = "e7e00050DMvX", -- v6T2
- -- Note: the X encodes the msb field, not the width.
- bfc_3 = "e7c0001fDvX", -- v6T2
- bfi_4 = "e7c00010DMvX", -- v6T2
-
- -- Packing and unpacking instructions.
- pkhbt_3 = "e6800010DNM", pkhbt_4 = "e6800010DNMv", -- v6
- pkhtb_3 = "e6800050DNM", pkhtb_4 = "e6800050DNMv", -- v6
- sxtab_3 = "e6a00070DNM", sxtab_4 = "e6a00070DNMv", -- v6
- sxtab16_3 = "e6800070DNM", sxtab16_4 = "e6800070DNMv", -- v6
- sxtah_3 = "e6b00070DNM", sxtah_4 = "e6b00070DNMv", -- v6
- sxtb_2 = "e6af0070DM", sxtb_3 = "e6af0070DMv", -- v6
- sxtb16_2 = "e68f0070DM", sxtb16_3 = "e68f0070DMv", -- v6
- sxth_2 = "e6bf0070DM", sxth_3 = "e6bf0070DMv", -- v6
- uxtab_3 = "e6e00070DNM", uxtab_4 = "e6e00070DNMv", -- v6
- uxtab16_3 = "e6c00070DNM", uxtab16_4 = "e6c00070DNMv", -- v6
- uxtah_3 = "e6f00070DNM", uxtah_4 = "e6f00070DNMv", -- v6
- uxtb_2 = "e6ef0070DM", uxtb_3 = "e6ef0070DMv", -- v6
- uxtb16_2 = "e6cf0070DM", uxtb16_3 = "e6cf0070DMv", -- v6
- uxth_2 = "e6ff0070DM", uxth_3 = "e6ff0070DMv", -- v6
-
- -- Saturating instructions.
- qadd_3 = "e1000050DMN", -- v5TE
- qsub_3 = "e1200050DMN", -- v5TE
- qdadd_3 = "e1400050DMN", -- v5TE
- qdsub_3 = "e1600050DMN", -- v5TE
- -- Note: the X for ssat* encodes sat_imm-1, not sat_imm.
- ssat_3 = "e6a00010DXM", ssat_4 = "e6a00010DXMp", -- v6
- usat_3 = "e6e00010DXM", usat_4 = "e6e00010DXMp", -- v6
- ssat16_3 = "e6a00f30DXM", -- v6
- usat16_3 = "e6e00f30DXM", -- v6
-
- -- Parallel addition and subtraction.
- sadd16_3 = "e6100f10DNM", -- v6
- sasx_3 = "e6100f30DNM", -- v6
- ssax_3 = "e6100f50DNM", -- v6
- ssub16_3 = "e6100f70DNM", -- v6
- sadd8_3 = "e6100f90DNM", -- v6
- ssub8_3 = "e6100ff0DNM", -- v6
- qadd16_3 = "e6200f10DNM", -- v6
- qasx_3 = "e6200f30DNM", -- v6
- qsax_3 = "e6200f50DNM", -- v6
- qsub16_3 = "e6200f70DNM", -- v6
- qadd8_3 = "e6200f90DNM", -- v6
- qsub8_3 = "e6200ff0DNM", -- v6
- shadd16_3 = "e6300f10DNM", -- v6
- shasx_3 = "e6300f30DNM", -- v6
- shsax_3 = "e6300f50DNM", -- v6
- shsub16_3 = "e6300f70DNM", -- v6
- shadd8_3 = "e6300f90DNM", -- v6
- shsub8_3 = "e6300ff0DNM", -- v6
- uadd16_3 = "e6500f10DNM", -- v6
- uasx_3 = "e6500f30DNM", -- v6
- usax_3 = "e6500f50DNM", -- v6
- usub16_3 = "e6500f70DNM", -- v6
- uadd8_3 = "e6500f90DNM", -- v6
- usub8_3 = "e6500ff0DNM", -- v6
- uqadd16_3 = "e6600f10DNM", -- v6
- uqasx_3 = "e6600f30DNM", -- v6
- uqsax_3 = "e6600f50DNM", -- v6
- uqsub16_3 = "e6600f70DNM", -- v6
- uqadd8_3 = "e6600f90DNM", -- v6
- uqsub8_3 = "e6600ff0DNM", -- v6
- uhadd16_3 = "e6700f10DNM", -- v6
- uhasx_3 = "e6700f30DNM", -- v6
- uhsax_3 = "e6700f50DNM", -- v6
- uhsub16_3 = "e6700f70DNM", -- v6
- uhadd8_3 = "e6700f90DNM", -- v6
- uhsub8_3 = "e6700ff0DNM", -- v6
-
- -- Load/store instructions.
- str_2 = "e4000000DL", str_3 = "e4000000DL", str_4 = "e4000000DL",
- strb_2 = "e4400000DL", strb_3 = "e4400000DL", strb_4 = "e4400000DL",
- ldr_2 = "e4100000DL", ldr_3 = "e4100000DL", ldr_4 = "e4100000DL",
- ldrb_2 = "e4500000DL", ldrb_3 = "e4500000DL", ldrb_4 = "e4500000DL",
- strh_2 = "e00000b0DL", strh_3 = "e00000b0DL",
- ldrh_2 = "e01000b0DL", ldrh_3 = "e01000b0DL",
- ldrd_2 = "e00000d0DL", ldrd_3 = "e00000d0DL", -- v5TE
- ldrsb_2 = "e01000d0DL", ldrsb_3 = "e01000d0DL",
- strd_2 = "e00000f0DL", strd_3 = "e00000f0DL", -- v5TE
- ldrsh_2 = "e01000f0DL", ldrsh_3 = "e01000f0DL",
-
- ldm_2 = "e8900000nR", ldmia_2 = "e8900000nR", ldmfd_2 = "e8900000nR",
- ldmda_2 = "e8100000nR", ldmfa_2 = "e8100000nR",
- ldmdb_2 = "e9100000nR", ldmea_2 = "e9100000nR",
- ldmib_2 = "e9900000nR", ldmed_2 = "e9900000nR",
- stm_2 = "e8800000nR", stmia_2 = "e8800000nR", stmfd_2 = "e8800000nR",
- stmda_2 = "e8000000nR", stmfa_2 = "e8000000nR",
- stmdb_2 = "e9000000nR", stmea_2 = "e9000000nR",
- stmib_2 = "e9800000nR", stmed_2 = "e9800000nR",
- pop_1 = "e8bd0000R", push_1 = "e92d0000R",
-
- -- Branch instructions.
- b_1 = "ea000000B",
- bl_1 = "eb000000B",
- blx_1 = "e12fff30C",
- bx_1 = "e12fff10M",
-
- -- Miscellaneous instructions.
- nop_0 = "e1a00000",
- mrs_1 = "e10f0000D",
- bkpt_1 = "e1200070K", -- v5T
- svc_1 = "ef000000T", swi_1 = "ef000000T",
- ud_0 = "e7f001f0",
-
- -- NYI: Advanced SIMD and VFP instructions.
-
- -- NYI instructions, since I have no need for them right now:
- -- swp, swpb, strex, ldrex, strexd, ldrexd, strexb, ldrexb, strexh, ldrexh
- -- msr, nopv6, yield, wfe, wfi, sev, dbg, bxj, smc, srs, rfe
- -- cps, setend, pli, pld, pldw, clrex, dsb, dmb, isb
- -- stc, ldc, mcr, mcr2, mrc, mrc2, mcrr, mcrr2, mrrc, mrrc2, cdp, cdp2
-}
-
--- Add mnemonics for "s" variants.
-do
- local t = {}
- for k,v in pairs(map_op) do
- if sub(v, -1) == "s" then
- local v2 = sub(v, 1, 2)..char(byte(v, 3)+1)..sub(v, 4, -2)
- t[sub(k, 1, -3).."s"..sub(k, -2)] = v2
- end
- end
- for k,v in pairs(t) do
- map_op[k] = v
- end
-end
-
-------------------------------------------------------------------------------
-
-local function parse_gpr(expr)
- local tname, ovreg = match(expr, "^([%w_]+):(r1?[0-9])$")
- local tp = map_type[tname or expr]
- if tp then
- local reg = ovreg or tp.reg
- if not reg then
- werror("type `"..(tname or expr).."' needs a register override")
- end
- expr = reg
- end
- local r = match(expr, "^r(1?[0-9])$")
- if r then
- r = tonumber(r)
- if r <= 15 then return r, tp end
- end
- werror("bad register name `"..expr.."'")
-end
-
-local function parse_gpr_pm(expr)
- local pm, expr2 = match(expr, "^([+-]?)(.*)$")
- return parse_gpr(expr2), (pm == "-")
-end
-
-local function parse_reglist(reglist)
- reglist = match(reglist, "^{%s*([^}]*)}$")
- if not reglist then werror("register list expected") end
- local rr = 0
- for p in gmatch(reglist..",", "%s*([^,]*),") do
- local rbit = 2^parse_gpr(gsub(p, "%s+$", ""))
- if ((rr - (rr % rbit)) / rbit) % 2 ~= 0 then
- werror("duplicate register `"..p.."'")
- end
- rr = rr + rbit
- end
- return rr
-end
-
-local function parse_imm(imm, bits, shift, scale, signed)
- imm = match(imm, "^#(.*)$")
- if not imm then werror("expected immediate operand") end
- local n = tonumber(imm)
- if n then
- if n % 2^scale == 0 then
- n = n / 2^scale
- if signed then
- if n >= 0 then
- if n < 2^(bits-1) then return n*2^shift end
- else
- if n >= -(2^(bits-1))-1 then return (n+2^bits)*2^shift end
- end
- else
- if n >= 0 and n <= 2^bits-1 then return n*2^shift end
- end
- end
- werror("out of range immediate `"..imm.."'")
- else
- waction("IMM", (signed and 32768 or 0)+scale*1024+bits*32+shift, imm)
- return 0
- end
-end
-
-local function parse_imm12(imm)
- local n = tonumber(imm)
- if n then
- local m = n
- for i=0,-15,-1 do
- if m >= 0 and m <= 255 and n % 1 == 0 then return m + (i%16) * 256 end
- local t = m % 4
- m = (m - t) / 4 + t * 2^30
- end
- werror("out of range immediate `"..imm.."'")
- else
- waction("IMM12", 0, imm)
- return 0
- end
-end
-
-local function parse_imm16(imm)
- imm = match(imm, "^#(.*)$")
- if not imm then werror("expected immediate operand") end
- local n = tonumber(imm)
- if n then
- if n >= 0 and n <= 65535 and n % 1 == 0 then
- local t = n % 4096
- return (n - t) * 16 + t
- end
- werror("out of range immediate `"..imm.."'")
- else
- waction("IMM16", 32*16, imm)
- return 0
- end
-end
-
-local function parse_imm_load(imm, ext)
- local n = tonumber(imm)
- if n then
- if ext then
- if n >= -255 and n <= 255 then
- local up = 0x00800000
- if n < 0 then n = -n; up = 0 end
- return (n-(n%16))*16+(n%16) + up
- end
- else
- if n >= -4095 and n <= 4095 then
- if n >= 0 then return n+0x00800000 end
- return -n
- end
- end
- werror("out of range immediate `"..imm.."'")
- else
- waction(ext and "IMML8" or "IMML12", 32768 + 32*(ext and 8 or 12), imm)
- return 0
- end
-end
-
-local function parse_shift(shift, gprok)
- if shift == "rrx" then
- return 3 * 32
- else
- local s, s2 = match(shift, "^(%S+)%s*(.*)$")
- s = map_shift[s]
- if not s then werror("expected shift operand") end
- if sub(s2, 1, 1) == "#" then
- return parse_imm(s2, 5, 7, 0, false) + s * 32
- else
- if not gprok then werror("expected immediate shift operand") end
- return parse_gpr(s2) * 256 + s * 32 + 16
- end
- end
-end
-
-local function parse_label(label, def)
- local prefix = sub(label, 1, 2)
- -- =>label (pc label reference)
- if prefix == "=>" then
- return "PC", 0, sub(label, 3)
- end
- -- ->name (global label reference)
- if prefix == "->" then
- return "LG", map_global[sub(label, 3)]
- end
- if def then
- -- [1-9] (local label definition)
- if match(label, "^[1-9]$") then
- return "LG", 10+tonumber(label)
- end
- else
- -- [<>][1-9] (local label reference)
- local dir, lnum = match(label, "^([<>])([1-9])$")
- if dir then -- Fwd: 1-9, Bkwd: 11-19.
- return "LG", lnum + (dir == ">" and 0 or 10)
- end
- -- extern label (extern label reference)
- local extname = match(label, "^extern%s+(%S+)$")
- if extname then
- return "EXT", map_extern[extname]
- end
- end
- werror("bad label `"..label.."'")
-end
-
-local function parse_load(params, nparams, n, op)
- local oplo = op % 256
- local ext, ldrd = (oplo ~= 0), (oplo == 208)
- local d
- if (ldrd or oplo == 240) then
- d = ((op - (op % 4096)) / 4096) % 16
- if d % 2 ~= 0 then werror("odd destination register") end
- end
- local pn = params[n]
- local p1, wb = match(pn, "^%[%s*(.-)%s*%](!?)$")
- local p2 = params[n+1]
- if not p1 then
- if not p2 then
- if match(pn, "^[<>=%-]") or match(pn, "^extern%s+") then
- local mode, n, s = parse_label(pn, false)
- waction("REL_"..mode, n + (ext and 0x1800 or 0x0800), s, 1)
- return op + 15 * 65536 + 0x01000000 + (ext and 0x00400000 or 0)
- end
- local reg, tailr = match(pn, "^([%w_:]+)%s*(.*)$")
- if reg and tailr ~= "" then
- local d, tp = parse_gpr(reg)
- if tp then
- waction(ext and "IMML8" or "IMML12", 32768 + 32*(ext and 8 or 12),
- format(tp.ctypefmt, tailr))
- return op + d * 65536 + 0x01000000 + (ext and 0x00400000 or 0)
- end
- end
- end
- werror("expected address operand")
- end
- if wb == "!" then op = op + 0x00200000 end
- if p2 then
- if wb == "!" then werror("bad use of '!'") end
- local p3 = params[n+2]
- op = op + parse_gpr(p1) * 65536
- local imm = match(p2, "^#(.*)$")
- if imm then
- local m = parse_imm_load(imm, ext)
- if p3 then werror("too many parameters") end
- op = op + m + (ext and 0x00400000 or 0)
- else
- local m, neg = parse_gpr_pm(p2)
- if ldrd and (m == d or m-1 == d) then werror("register conflict") end
- op = op + m + (neg and 0 or 0x00800000) + (ext and 0 or 0x02000000)
- if p3 then op = op + parse_shift(p3) end
- end
- else
- local p1a, p2 = match(p1, "^([^,%s]*)%s*(.*)$")
- op = op + parse_gpr(p1a) * 65536 + 0x01000000
- if p2 ~= "" then
- local imm = match(p2, "^,%s*#(.*)$")
- if imm then
- local m = parse_imm_load(imm, ext)
- op = op + m + (ext and 0x00400000 or 0)
- else
- local p2a, p3 = match(p2, "^,%s*([^,%s]*)%s*,?%s*(.*)$")
- local m, neg = parse_gpr_pm(p2a)
- if ldrd and (m == d or m-1 == d) then werror("register conflict") end
- op = op + m + (neg and 0 or 0x00800000) + (ext and 0 or 0x02000000)
- if p3 ~= "" then
- if ext then werror("too many parameters") end
- op = op + parse_shift(p3)
- end
- end
- else
- if wb == "!" then werror("bad use of '!'") end
- op = op + (ext and 0x00c00000 or 0x00800000)
- end
- end
- return op
-end
-
-------------------------------------------------------------------------------
-
--- Handle opcodes defined with template strings.
-map_op[".template__"] = function(params, template, nparams)
- if not params then return sub(template, 9) end
- local op = tonumber(sub(template, 1, 8), 16)
- local n = 1
-
- -- Limit number of section buffer positions used by a single dasm_put().
- -- A single opcode needs a maximum of 3 positions.
- if secpos+3 > maxsecpos then wflush() end
- local pos = wpos()
-
- -- Process each character.
- for p in gmatch(sub(template, 9), ".") do
- if p == "D" then
- op = op + parse_gpr(params[n]) * 4096; n = n + 1
- elseif p == "N" then
- op = op + parse_gpr(params[n]) * 65536; n = n + 1
- elseif p == "S" then
- op = op + parse_gpr(params[n]) * 256; n = n + 1
- elseif p == "M" then
- op = op + parse_gpr(params[n]); n = n + 1
- elseif p == "P" then
- local imm = match(params[n], "^#(.*)$")
- if imm then
- op = op + parse_imm12(imm) + 0x02000000
- else
- op = op + parse_gpr(params[n])
- end
- n = n + 1
- elseif p == "p" then
- op = op + parse_shift(params[n], true); n = n + 1
- elseif p == "L" then
- op = parse_load(params, nparams, n, op)
- elseif p == "B" then
- local mode, n, s = parse_label(params[n], false)
- waction("REL_"..mode, n, s, 1)
- elseif p == "C" then -- blx gpr vs. blx label.
- local p = params[n]
- if match(p, "^([%w_]+):(r1?[0-9])$") or match(p, "^r(1?[0-9])$") then
- op = op + parse_gpr(p)
- else
- if op < 0xe0000000 then werror("unconditional instruction") end
- local mode, n, s = parse_label(p, false)
- waction("REL_"..mode, n, s, 1)
- op = 0xfa000000
- end
- elseif p == "n" then
- local r, wb = match(params[n], "^([^!]*)(!?)$")
- op = op + parse_gpr(r) * 65536 + (wb == "!" and 0x00200000 or 0)
- n = n + 1
- elseif p == "R" then
- op = op + parse_reglist(params[n]); n = n + 1
- elseif p == "W" then
- op = op + parse_imm16(params[n]); n = n + 1
- elseif p == "v" then
- op = op + parse_imm(params[n], 5, 7, 0, false); n = n + 1
- elseif p == "w" then
- local imm = match(params[n], "^#(.*)$")
- if imm then
- op = op + parse_imm(params[n], 5, 7, 0, false); n = n + 1
- else
- op = op + parse_gpr(params[n]) * 256 + 16
- end
- elseif p == "X" then
- op = op + parse_imm(params[n], 5, 16, 0, false); n = n + 1
- elseif p == "K" then
- local imm = tonumber(match(params[n], "^#(.*)$")); n = n + 1
- if not imm or imm % 1 ~= 0 or imm < 0 or imm > 0xffff then
- werror("bad immediate operand")
- end
- local t = imm % 16
- op = op + (imm - t) * 16 + t
- elseif p == "T" then
- op = op + parse_imm(params[n], 24, 0, 0, false); n = n + 1
- elseif p == "s" then
- -- Ignored.
- else
- assert(false)
- end
- end
- wputpos(pos, op)
-end
-
-------------------------------------------------------------------------------
-
--- Pseudo-opcode to mark the position where the action list is to be emitted.
-map_op[".actionlist_1"] = function(params)
- if not params then return "cvar" end
- local name = params[1] -- No syntax check. You get to keep the pieces.
- wline(function(out) writeactions(out, name) end)
-end
-
--- Pseudo-opcode to mark the position where the global enum is to be emitted.
-map_op[".globals_1"] = function(params)
- if not params then return "prefix" end
- local prefix = params[1] -- No syntax check. You get to keep the pieces.
- wline(function(out) writeglobals(out, prefix) end)
-end
-
--- Pseudo-opcode to mark the position where the global names are to be emitted.
-map_op[".globalnames_1"] = function(params)
- if not params then return "cvar" end
- local name = params[1] -- No syntax check. You get to keep the pieces.
- wline(function(out) writeglobalnames(out, name) end)
-end
-
--- Pseudo-opcode to mark the position where the extern names are to be emitted.
-map_op[".externnames_1"] = function(params)
- if not params then return "cvar" end
- local name = params[1] -- No syntax check. You get to keep the pieces.
- wline(function(out) writeexternnames(out, name) end)
-end
-
-------------------------------------------------------------------------------
-
--- Label pseudo-opcode (converted from trailing colon form).
-map_op[".label_1"] = function(params)
- if not params then return "[1-9] | ->global | =>pcexpr" end
- if secpos+1 > maxsecpos then wflush() end
- local mode, n, s = parse_label(params[1], true)
- if mode == "EXT" then werror("bad label definition") end
- waction("LABEL_"..mode, n, s, 1)
-end
-
-------------------------------------------------------------------------------
-
--- Pseudo-opcodes for data storage.
-map_op[".long_*"] = function(params)
- if not params then return "imm..." end
- for _,p in ipairs(params) do
- local n = tonumber(p)
- if n then
- if n < 0 then n = n + 2^32 end
- wputw(n)
- if secpos+2 > maxsecpos then wflush() end
- else
- waction("LONG", 0, format("(uintptr_t)(%s)", p))
- end
- end
-end
-
--- Alignment pseudo-opcode.
-map_op[".align_1"] = function(params)
- if not params then return "numpow2" end
- if secpos+1 > maxsecpos then wflush() end
- local align = tonumber(params[1])
- if align then
- local x = align
- -- Must be a power of 2 in the range (2 ... 256).
- for i=1,8 do
- x = x / 2
- if x == 1 then
- waction("ALIGN", align-1, nil, 1) -- Action byte is 2**n-1.
- return
- end
- end
- end
- werror("bad alignment")
-end
-
-------------------------------------------------------------------------------
-
--- Pseudo-opcode for (primitive) type definitions (map to C types).
-map_op[".type_3"] = function(params, nparams)
- if not params then
- return nparams == 2 and "name, ctype" or "name, ctype, reg"
- end
- local name, ctype, reg = params[1], params[2], params[3]
- if not match(name, "^[%a_][%w_]*$") then
- werror("bad type name `"..name.."'")
- end
- local tp = map_type[name]
- if tp then
- werror("duplicate type `"..name.."'")
- end
- -- Add #type to defines. A bit unclean to put it in map_archdef.
- map_archdef["#"..name] = "sizeof("..ctype..")"
- -- Add new type and emit shortcut define.
- local num = ctypenum + 1
- map_type[name] = {
- ctype = ctype,
- ctypefmt = format("Dt%X(%%s)", num),
- reg = reg,
- }
- wline(format("#define Dt%X(_V) (int)(ptrdiff_t)&(((%s *)0)_V)", num, ctype))
- ctypenum = num
-end
-map_op[".type_2"] = map_op[".type_3"]
-
--- Dump type definitions.
-local function dumptypes(out, lvl)
- local t = {}
- for name in pairs(map_type) do t[#t+1] = name end
- sort(t)
- out:write("Type definitions:\n")
- for _,name in ipairs(t) do
- local tp = map_type[name]
- local reg = tp.reg or ""
- out:write(format(" %-20s %-20s %s\n", name, tp.ctype, reg))
- end
- out:write("\n")
-end
-
-------------------------------------------------------------------------------
-
--- Set the current section.
-function _M.section(num)
- waction("SECTION", num)
- wflush(true) -- SECTION is a terminal action.
-end
-
-------------------------------------------------------------------------------
-
--- Dump architecture description.
-function _M.dumparch(out)
- out:write(format("DynASM %s version %s, released %s\n\n",
- _info.arch, _info.version, _info.release))
- dumpactions(out)
-end
-
--- Dump all user defined elements.
-function _M.dumpdef(out, lvl)
- dumptypes(out, lvl)
- dumpglobals(out, lvl)
- dumpexterns(out, lvl)
-end
-
-------------------------------------------------------------------------------
-
--- Pass callbacks from/to the DynASM core.
-function _M.passcb(wl, we, wf, ww)
- wline, werror, wfatal, wwarn = wl, we, wf, ww
- return wflush
-end
-
--- Setup the arch-specific module.
-function _M.setup(arch, opt)
- g_arch, g_opt = arch, opt
-end
-
--- Merge the core maps and the arch-specific maps.
-function _M.mergemaps(map_coreop, map_def)
- setmetatable(map_op, { __index = function(t, k)
- local v = map_coreop[k]
- if v then return v end
- local cc = sub(k, -4, -3)
- local cv = map_cond[cc]
- if cv then
- local v = rawget(t, sub(k, 1, -5)..sub(k, -2))
- if type(v) == "string" then return format("%x%s", cv, sub(v, 2)) end
- end
- end })
- setmetatable(map_def, { __index = map_archdef })
- return map_op, map_def
-end
-
-return _M
-
-------------------------------------------------------------------------------
-
diff --git a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_ppc.h b/plugins/MirLua/Modules/ffi/src/dynasm/dasm_ppc.h deleted file mode 100644 index 74e1c7d432..0000000000 --- a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_ppc.h +++ /dev/null @@ -1,408 +0,0 @@ -/*
-** DynASM PPC encoding engine.
-** Copyright (C) 2005-2011 Mike Pall. All rights reserved.
-** Released under the MIT/X license. See dynasm.lua for full copyright notice.
-*/
-
-#include <stddef.h>
-#include <stdarg.h>
-#include <string.h>
-#include <stdlib.h>
-
-#define DASM_ARCH "ppc"
-
-#ifndef DASM_EXTERN
-#define DASM_EXTERN(a,b,c,d) 0
-#endif
-
-/* Action definitions. */
-enum {
- DASM_STOP, DASM_SECTION, DASM_ESC, DASM_REL_EXT,
- /* The following actions need a buffer position. */
- DASM_ALIGN, DASM_REL_LG, DASM_LABEL_LG,
- /* The following actions also have an argument. */
- DASM_REL_PC, DASM_LABEL_PC, DASM_IMM,
- DASM__MAX
-};
-
-/* Maximum number of section buffer positions for a single dasm_put() call. */
-#define DASM_MAXSECPOS 25
-
-/* DynASM encoder status codes. Action list offset or number are or'ed in. */
-#define DASM_S_OK 0x00000000
-#define DASM_S_NOMEM 0x01000000
-#define DASM_S_PHASE 0x02000000
-#define DASM_S_MATCH_SEC 0x03000000
-#define DASM_S_RANGE_I 0x11000000
-#define DASM_S_RANGE_SEC 0x12000000
-#define DASM_S_RANGE_LG 0x13000000
-#define DASM_S_RANGE_PC 0x14000000
-#define DASM_S_RANGE_REL 0x15000000
-#define DASM_S_UNDEF_LG 0x21000000
-#define DASM_S_UNDEF_PC 0x22000000
-
-/* Macros to convert positions (8 bit section + 24 bit index). */
-#define DASM_POS2IDX(pos) ((pos)&0x00ffffff)
-#define DASM_POS2BIAS(pos) ((pos)&0xff000000)
-#define DASM_SEC2POS(sec) ((sec)<<24)
-#define DASM_POS2SEC(pos) ((pos)>>24)
-#define DASM_POS2PTR(D, pos) (D->sections[DASM_POS2SEC(pos)].rbuf + (pos))
-
-/* Action list type. */
-typedef const unsigned int *dasm_ActList;
-
-/* Per-section structure. */
-typedef struct dasm_Section {
- int *rbuf; /* Biased buffer pointer (negative section bias). */
- int *buf; /* True buffer pointer. */
- size_t bsize; /* Buffer size in bytes. */
- int pos; /* Biased buffer position. */
- int epos; /* End of biased buffer position - max single put. */
- int ofs; /* Byte offset into section. */
-} dasm_Section;
-
-/* Core structure holding the DynASM encoding state. */
-struct dasm_State {
- size_t psize; /* Allocated size of this structure. */
- dasm_ActList actionlist; /* Current actionlist pointer. */
- int *lglabels; /* Local/global chain/pos ptrs. */
- size_t lgsize;
- int *pclabels; /* PC label chains/pos ptrs. */
- size_t pcsize;
- void **globals; /* Array of globals (bias -10). */
- dasm_Section *section; /* Pointer to active section. */
- size_t codesize; /* Total size of all code sections. */
- int maxsection; /* 0 <= sectionidx < maxsection. */
- int status; /* Status code. */
- dasm_Section sections[1]; /* All sections. Alloc-extended. */
-};
-
-/* The size of the core structure depends on the max. number of sections. */
-#define DASM_PSZ(ms) (sizeof(dasm_State)+(ms-1)*sizeof(dasm_Section))
-
-
-/* Initialize DynASM state. */
-void dasm_init(Dst_DECL, int maxsection)
-{
- dasm_State *D;
- size_t psz = 0;
- int i;
- Dst_REF = NULL;
- DASM_M_GROW(Dst, struct dasm_State, Dst_REF, psz, DASM_PSZ(maxsection));
- D = Dst_REF;
- D->psize = psz;
- D->lglabels = NULL;
- D->lgsize = 0;
- D->pclabels = NULL;
- D->pcsize = 0;
- D->globals = NULL;
- D->maxsection = maxsection;
- for (i = 0; i < maxsection; i++) {
- D->sections[i].buf = NULL; /* Need this for pass3. */
- D->sections[i].rbuf = D->sections[i].buf - DASM_SEC2POS(i);
- D->sections[i].bsize = 0;
- D->sections[i].epos = 0; /* Wrong, but is recalculated after resize. */
- }
-}
-
-/* Free DynASM state. */
-void dasm_free(Dst_DECL)
-{
- dasm_State *D = Dst_REF;
- int i;
- for (i = 0; i < D->maxsection; i++)
- if (D->sections[i].buf)
- DASM_M_FREE(Dst, D->sections[i].buf, D->sections[i].bsize);
- if (D->pclabels) DASM_M_FREE(Dst, D->pclabels, D->pcsize);
- if (D->lglabels) DASM_M_FREE(Dst, D->lglabels, D->lgsize);
- DASM_M_FREE(Dst, D, D->psize);
-}
-
-/* Setup global label array. Must be called before dasm_setup(). */
-void dasm_setupglobal(Dst_DECL, void **gl, unsigned int maxgl)
-{
- dasm_State *D = Dst_REF;
- D->globals = gl - 10; /* Negative bias to compensate for locals. */
- DASM_M_GROW(Dst, int, D->lglabels, D->lgsize, (10+maxgl)*sizeof(int));
-}
-
-/* Grow PC label array. Can be called after dasm_setup(), too. */
-void dasm_growpc(Dst_DECL, unsigned int maxpc)
-{
- dasm_State *D = Dst_REF;
- size_t osz = D->pcsize;
- DASM_M_GROW(Dst, int, D->pclabels, D->pcsize, maxpc*sizeof(int));
- memset((void *)(((unsigned char *)D->pclabels)+osz), 0, D->pcsize-osz);
-}
-
-/* Setup encoder. */
-void dasm_setup(Dst_DECL, const void *actionlist)
-{
- dasm_State *D = Dst_REF;
- int i;
- D->actionlist = (dasm_ActList)actionlist;
- D->status = DASM_S_OK;
- D->section = &D->sections[0];
- memset((void *)D->lglabels, 0, D->lgsize);
- if (D->pclabels) memset((void *)D->pclabels, 0, D->pcsize);
- for (i = 0; i < D->maxsection; i++) {
- D->sections[i].pos = DASM_SEC2POS(i);
- D->sections[i].ofs = 0;
- }
-}
-
-
-#ifdef DASM_CHECKS
-#define CK(x, st) \
- do { if (!(x)) { \
- D->status = DASM_S_##st|(p-D->actionlist-1); return; } } while (0)
-#define CKPL(kind, st) \
- do { if ((size_t)((char *)pl-(char *)D->kind##labels) >= D->kind##size) { \
- D->status = DASM_S_RANGE_##st|(p-D->actionlist-1); return; } } while (0)
-#else
-#define CK(x, st) ((void)0)
-#define CKPL(kind, st) ((void)0)
-#endif
-
-/* Pass 1: Store actions and args, link branches/labels, estimate offsets. */
-void dasm_put(Dst_DECL, int start, ...)
-{
- va_list ap;
- dasm_State *D = Dst_REF;
- dasm_ActList p = D->actionlist + start;
- dasm_Section *sec = D->section;
- int pos = sec->pos, ofs = sec->ofs;
- int *b;
-
- if (pos >= sec->epos) {
- DASM_M_GROW(Dst, int, sec->buf, sec->bsize,
- sec->bsize + 2*DASM_MAXSECPOS*sizeof(int));
- sec->rbuf = sec->buf - DASM_POS2BIAS(pos);
- sec->epos = (int)sec->bsize/sizeof(int) - DASM_MAXSECPOS+DASM_POS2BIAS(pos);
- }
-
- b = sec->rbuf;
- b[pos++] = start;
-
- va_start(ap, start);
- while (1) {
- unsigned int ins = *p++;
- unsigned int action = (ins >> 16);
- if (action >= DASM__MAX) {
- ofs += 4;
- } else {
- int *pl, n = action >= DASM_REL_PC ? va_arg(ap, int) : 0;
- switch (action) {
- case DASM_STOP: goto stop;
- case DASM_SECTION:
- n = (ins & 255); CK(n < D->maxsection, RANGE_SEC);
- D->section = &D->sections[n]; goto stop;
- case DASM_ESC: p++; ofs += 4; break;
- case DASM_REL_EXT: break;
- case DASM_ALIGN: ofs += (ins & 255); b[pos++] = ofs; break;
- case DASM_REL_LG:
- n = (ins & 2047) - 10; pl = D->lglabels + n;
- if (n >= 0) { CKPL(lg, LG); goto putrel; } /* Bkwd rel or global. */
- pl += 10; n = *pl;
- if (n < 0) n = 0; /* Start new chain for fwd rel if label exists. */
- goto linkrel;
- case DASM_REL_PC:
- pl = D->pclabels + n; CKPL(pc, PC);
- putrel:
- n = *pl;
- if (n < 0) { /* Label exists. Get label pos and store it. */
- b[pos] = -n;
- } else {
- linkrel:
- b[pos] = n; /* Else link to rel chain, anchored at label. */
- *pl = pos;
- }
- pos++;
- break;
- case DASM_LABEL_LG:
- pl = D->lglabels + (ins & 2047) - 10; CKPL(lg, LG); goto putlabel;
- case DASM_LABEL_PC:
- pl = D->pclabels + n; CKPL(pc, PC);
- putlabel:
- n = *pl; /* n > 0: Collapse rel chain and replace with label pos. */
- while (n > 0) { int *pb = DASM_POS2PTR(D, n); n = *pb; *pb = pos;
- }
- *pl = -pos; /* Label exists now. */
- b[pos++] = ofs; /* Store pass1 offset estimate. */
- break;
- case DASM_IMM:
-#ifdef DASM_CHECKS
- CK((n & ((1<<((ins>>10)&31))-1)) == 0, RANGE_I);
- if (ins & 0x8000)
- CK(((n + (1<<(((ins>>5)&31)-1)))>>((ins>>5)&31)) == 0, RANGE_I);
- else
- CK((n>>((ins>>5)&31)) == 0, RANGE_I);
-#endif
- b[pos++] = n;
- break;
- }
- }
- }
-stop:
- va_end(ap);
- sec->pos = pos;
- sec->ofs = ofs;
-}
-#undef CK
-
-/* Pass 2: Link sections, shrink aligns, fix label offsets. */
-int dasm_link(Dst_DECL, size_t *szp)
-{
- dasm_State *D = Dst_REF;
- int secnum;
- int ofs = 0;
-
-#ifdef DASM_CHECKS
- *szp = 0;
- if (D->status != DASM_S_OK) return D->status;
- {
- int pc;
- for (pc = 0; pc*sizeof(int) < D->pcsize; pc++)
- if (D->pclabels[pc] > 0) return DASM_S_UNDEF_PC|pc;
- }
-#endif
-
- { /* Handle globals not defined in this translation unit. */
- int idx;
- for (idx = 20; idx*sizeof(int) < D->lgsize; idx++) {
- int n = D->lglabels[idx];
- /* Undefined label: Collapse rel chain and replace with marker (< 0). */
- while (n > 0) { int *pb = DASM_POS2PTR(D, n); n = *pb; *pb = -idx; }
- }
- }
-
- /* Combine all code sections. No support for data sections (yet). */
- for (secnum = 0; secnum < D->maxsection; secnum++) {
- dasm_Section *sec = D->sections + secnum;
- int *b = sec->rbuf;
- int pos = DASM_SEC2POS(secnum);
- int lastpos = sec->pos;
-
- while (pos != lastpos) {
- dasm_ActList p = D->actionlist + b[pos++];
- while (1) {
- unsigned int ins = *p++;
- unsigned int action = (ins >> 16);
- switch (action) {
- case DASM_STOP: case DASM_SECTION: goto stop;
- case DASM_ESC: p++; break;
- case DASM_REL_EXT: break;
- case DASM_ALIGN: ofs -= (b[pos++] + ofs) & (ins & 255); break;
- case DASM_REL_LG: case DASM_REL_PC: pos++; break;
- case DASM_LABEL_LG: case DASM_LABEL_PC: b[pos++] += ofs; break;
- case DASM_IMM: pos++; break;
- }
- }
- stop: (void)0;
- }
- ofs += sec->ofs; /* Next section starts right after current section. */
- }
-
- D->codesize = ofs; /* Total size of all code sections */
- *szp = ofs;
- return DASM_S_OK;
-}
-
-#ifdef DASM_CHECKS
-#define CK(x, st) \
- do { if (!(x)) return DASM_S_##st|(p-D->actionlist-1); } while (0)
-#else
-#define CK(x, st) ((void)0)
-#endif
-
-/* Pass 3: Encode sections. */
-int dasm_encode(Dst_DECL, void *buffer)
-{
- dasm_State *D = Dst_REF;
- char *base = (char *)buffer;
- unsigned int *cp = (unsigned int *)buffer;
- int secnum;
-
- /* Encode all code sections. No support for data sections (yet). */
- for (secnum = 0; secnum < D->maxsection; secnum++) {
- dasm_Section *sec = D->sections + secnum;
- int *b = sec->buf;
- int *endb = sec->rbuf + sec->pos;
-
- while (b != endb) {
- dasm_ActList p = D->actionlist + *b++;
- while (1) {
- unsigned int ins = *p++;
- unsigned int action = (ins >> 16);
- int n = (action >= DASM_ALIGN && action < DASM__MAX) ? *b++ : 0;
- switch (action) {
- case DASM_STOP: case DASM_SECTION: goto stop;
- case DASM_ESC: *cp++ = *p++; break;
- case DASM_REL_EXT:
- n = DASM_EXTERN(Dst, (unsigned char *)cp, (ins & 2047), 1);
- goto patchrel;
- case DASM_ALIGN:
- ins &= 255; while ((((char *)cp - base) & ins)) *cp++ = 0x60000000;
- break;
- case DASM_REL_LG:
- CK(n >= 0, UNDEF_LG);
- case DASM_REL_PC:
- CK(n >= 0, UNDEF_PC);
- n = *DASM_POS2PTR(D, n) - (int)((char *)cp - base);
- patchrel:
- CK((n & 3) == 0 &&
- (((n+4) + ((ins & 2048) ? 0x00008000 : 0x02000000)) >>
- ((ins & 2048) ? 16 : 26)) == 0, RANGE_REL);
- cp[-1] |= ((n+4) & ((ins & 2048) ? 0x0000fffc: 0x03fffffc));
- break;
- case DASM_LABEL_LG:
- ins &= 2047; if (ins >= 20) D->globals[ins-10] = (void *)(base + n);
- break;
- case DASM_LABEL_PC: break;
- case DASM_IMM:
- cp[-1] |= ((n>>((ins>>10)&31)) & ((1<<((ins>>5)&31))-1)) << (ins&31);
- break;
- default: *cp++ = ins; break;
- }
- }
- stop: (void)0;
- }
- }
-
- if (base + D->codesize != (char *)cp) /* Check for phase errors. */
- return DASM_S_PHASE;
- return DASM_S_OK;
-}
-#undef CK
-
-/* Get PC label offset. */
-int dasm_getpclabel(Dst_DECL, unsigned int pc)
-{
- dasm_State *D = Dst_REF;
- if (pc*sizeof(int) < D->pcsize) {
- int pos = D->pclabels[pc];
- if (pos < 0) return *DASM_POS2PTR(D, -pos);
- if (pos > 0) return -1; /* Undefined. */
- }
- return -2; /* Unused or out of range. */
-}
-
-#ifdef DASM_CHECKS
-/* Optional sanity checker to call between isolated encoding steps. */
-int dasm_checkstep(Dst_DECL, int secmatch)
-{
- dasm_State *D = Dst_REF;
- if (D->status == DASM_S_OK) {
- int i;
- for (i = 1; i <= 9; i++) {
- if (D->lglabels[i] > 0) { D->status = DASM_S_UNDEF_LG|i; break; }
- D->lglabels[i] = 0;
- }
- }
- if (D->status == DASM_S_OK && secmatch >= 0 &&
- D->section != &D->sections[secmatch])
- D->status = DASM_S_MATCH_SEC|(D->section-D->sections);
- return D->status;
-}
-#endif
-
diff --git a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_ppc.lua b/plugins/MirLua/Modules/ffi/src/dynasm/dasm_ppc.lua deleted file mode 100644 index aeaaa2a7b6..0000000000 --- a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_ppc.lua +++ /dev/null @@ -1,1225 +0,0 @@ -------------------------------------------------------------------------------
--- DynASM PPC module.
---
--- Copyright (C) 2005-2011 Mike Pall. All rights reserved.
--- See dynasm.lua for full copyright notice.
-------------------------------------------------------------------------------
-
--- Module information:
-local _info = {
- arch = "ppc",
- description = "DynASM PPC module",
- version = "1.3.0",
- vernum = 10300,
- release = "2011-05-05",
- author = "Mike Pall",
- license = "MIT",
-}
-
--- Exported glue functions for the arch-specific module.
-local _M = { _info = _info }
-
--- Cache library functions.
-local type, tonumber, pairs, ipairs = type, tonumber, pairs, ipairs
-local assert, setmetatable = assert, setmetatable
-local _s = string
-local sub, format, byte, char = _s.sub, _s.format, _s.byte, _s.char
-local match, gmatch = _s.match, _s.gmatch
-local concat, sort = table.concat, table.sort
-
--- Inherited tables and callbacks.
-local g_opt, g_arch
-local wline, werror, wfatal, wwarn
-
--- Action name list.
--- CHECK: Keep this in sync with the C code!
-local action_names = {
- "STOP", "SECTION", "ESC", "REL_EXT",
- "ALIGN", "REL_LG", "LABEL_LG",
- "REL_PC", "LABEL_PC", "IMM",
-}
-
--- Maximum number of section buffer positions for dasm_put().
--- CHECK: Keep this in sync with the C code!
-local maxsecpos = 25 -- Keep this low, to avoid excessively long C lines.
-
--- Action name -> action number.
-local map_action = {}
-for n,name in ipairs(action_names) do
- map_action[name] = n-1
-end
-
--- Action list buffer.
-local actlist = {}
-
--- Argument list for next dasm_put(). Start with offset 0 into action list.
-local actargs = { 0 }
-
--- Current number of section buffer positions for dasm_put().
-local secpos = 1
-
-------------------------------------------------------------------------------
-
--- Return 8 digit hex number.
-local function tohex(x)
- return sub(format("%08x", x), -8) -- Avoid 64 bit portability problem in Lua.
-end
-
--- Dump action names and numbers.
-local function dumpactions(out)
- out:write("DynASM encoding engine action codes:\n")
- for n,name in ipairs(action_names) do
- local num = map_action[name]
- out:write(format(" %-10s %02X %d\n", name, num, num))
- end
- out:write("\n")
-end
-
--- Write action list buffer as a huge static C array.
-local function writeactions(out, name)
- local nn = #actlist
- if nn == 0 then nn = 1; actlist[0] = map_action.STOP end
- out:write("static const unsigned int ", name, "[", nn, "] = {\n")
- for i = 1,nn-1 do
- assert(out:write("0x", tohex(actlist[i]), ",\n"))
- end
- assert(out:write("0x", tohex(actlist[nn]), "\n};\n\n"))
-end
-
-------------------------------------------------------------------------------
-
--- Add word to action list.
-local function wputxw(n)
- assert(n >= 0 and n <= 0xffffffff and n % 1 == 0, "word out of range")
- actlist[#actlist+1] = n
-end
-
--- Add action to list with optional arg. Advance buffer pos, too.
-local function waction(action, val, a, num)
- local w = assert(map_action[action], "bad action name `"..action.."'")
- wputxw(w * 0x10000 + (val or 0))
- if a then actargs[#actargs+1] = a end
- if a or num then secpos = secpos + (num or 1) end
-end
-
--- Flush action list (intervening C code or buffer pos overflow).
-local function wflush(term)
- if #actlist == actargs[1] then return end -- Nothing to flush.
- if not term then waction("STOP") end -- Terminate action list.
- wline(format("dasm_put(Dst, %s);", concat(actargs, ", ")), true)
- actargs = { #actlist } -- Actionlist offset is 1st arg to next dasm_put().
- secpos = 1 -- The actionlist offset occupies a buffer position, too.
-end
-
--- Put escaped word.
-local function wputw(n)
- if n <= 0xffffff then waction("ESC") end
- wputxw(n)
-end
-
--- Reserve position for word.
-local function wpos()
- local pos = #actlist+1
- actlist[pos] = ""
- return pos
-end
-
--- Store word to reserved position.
-local function wputpos(pos, n)
- assert(n >= 0 and n <= 0xffffffff and n % 1 == 0, "word out of range")
- actlist[pos] = n
-end
-
-------------------------------------------------------------------------------
-
--- Global label name -> global label number. With auto assignment on 1st use.
-local next_global = 20
-local map_global = setmetatable({}, { __index = function(t, name)
- if not match(name, "^[%a_][%w_]*$") then werror("bad global label") end
- local n = next_global
- if n > 2047 then werror("too many global labels") end
- next_global = n + 1
- t[name] = n
- return n
-end})
-
--- Dump global labels.
-local function dumpglobals(out, lvl)
- local t = {}
- for name, n in pairs(map_global) do t[n] = name end
- out:write("Global labels:\n")
- for i=20,next_global-1 do
- out:write(format(" %s\n", t[i]))
- end
- out:write("\n")
-end
-
--- Write global label enum.
-local function writeglobals(out, prefix)
- local t = {}
- for name, n in pairs(map_global) do t[n] = name end
- out:write("enum {\n")
- for i=20,next_global-1 do
- out:write(" ", prefix, t[i], ",\n")
- end
- out:write(" ", prefix, "_MAX\n};\n")
-end
-
--- Write global label names.
-local function writeglobalnames(out, name)
- local t = {}
- for name, n in pairs(map_global) do t[n] = name end
- out:write("static const char *const ", name, "[] = {\n")
- for i=20,next_global-1 do
- out:write(" \"", t[i], "\",\n")
- end
- out:write(" (const char *)0\n};\n")
-end
-
-------------------------------------------------------------------------------
-
--- Extern label name -> extern label number. With auto assignment on 1st use.
-local next_extern = 0
-local map_extern_ = {}
-local map_extern = setmetatable({}, { __index = function(t, name)
- -- No restrictions on the name for now.
- local n = next_extern
- if n > 2047 then werror("too many extern labels") end
- next_extern = n + 1
- t[name] = n
- map_extern_[n] = name
- return n
-end})
-
--- Dump extern labels.
-local function dumpexterns(out, lvl)
- out:write("Extern labels:\n")
- for i=0,next_extern-1 do
- out:write(format(" %s\n", map_extern_[i]))
- end
- out:write("\n")
-end
-
--- Write extern label names.
-local function writeexternnames(out, name)
- out:write("static const char *const ", name, "[] = {\n")
- for i=0,next_extern-1 do
- out:write(" \"", map_extern_[i], "\",\n")
- end
- out:write(" (const char *)0\n};\n")
-end
-
-------------------------------------------------------------------------------
-
--- Arch-specific maps.
-local map_archdef = { sp = "r1" } -- Ext. register name -> int. name.
-
-local map_type = {} -- Type name -> { ctype, reg }
-local ctypenum = 0 -- Type number (for Dt... macros).
-
--- Reverse defines for registers.
-function _M.revdef(s)
- if s == "r1" then return "sp" end
- return s
-end
-
-local map_cond = {
- lt = 0, gt = 1, eq = 2, so = 3,
- ge = 4, le = 5, ne = 6, ns = 7,
-}
-
-------------------------------------------------------------------------------
-
--- Template strings for PPC instructions.
-local map_op = {
- tdi_3 = "08000000ARI",
- twi_3 = "0c000000ARI",
- mulli_3 = "1c000000RRI",
- subfic_3 = "20000000RRI",
- cmplwi_3 = "28000000XRU",
- cmplwi_2 = "28000000-RU",
- cmpldi_3 = "28200000XRU",
- cmpldi_2 = "28200000-RU",
- cmpwi_3 = "2c000000XRI",
- cmpwi_2 = "2c000000-RI",
- cmpdi_3 = "2c200000XRI",
- cmpdi_2 = "2c200000-RI",
- addic_3 = "30000000RRI",
- ["addic._3"] = "34000000RRI",
- addi_3 = "38000000RR0I",
- li_2 = "38000000RI",
- la_2 = "38000000RD",
- addis_3 = "3c000000RR0I",
- lis_2 = "3c000000RI",
- lus_2 = "3c000000RU",
- bc_3 = "40000000AAK",
- bcl_3 = "40000001AAK",
- bdnz_1 = "42000000K",
- bdz_1 = "42400000K",
- sc_0 = "44000000",
- b_1 = "48000000J",
- bl_1 = "48000001J",
- rlwimi_5 = "50000000RR~AAA.",
- rlwinm_5 = "54000000RR~AAA.",
- rlwnm_5 = "5c000000RR~RAA.",
- ori_3 = "60000000RR~U",
- nop_0 = "60000000",
- oris_3 = "64000000RR~U",
- xori_3 = "68000000RR~U",
- xoris_3 = "6c000000RR~U",
- ["andi._3"] = "70000000RR~U",
- ["andis._3"] = "74000000RR~U",
- lwz_2 = "80000000RD",
- lwzu_2 = "84000000RD",
- lbz_2 = "88000000RD",
- lbzu_2 = "8c000000RD",
- stw_2 = "90000000RD",
- stwu_2 = "94000000RD",
- stb_2 = "98000000RD",
- stbu_2 = "9c000000RD",
- lhz_2 = "a0000000RD",
- lhzu_2 = "a4000000RD",
- lha_2 = "a8000000RD",
- lhau_2 = "ac000000RD",
- sth_2 = "b0000000RD",
- sthu_2 = "b4000000RD",
- lmw_2 = "b8000000RD",
- stmw_2 = "bc000000RD",
- lfs_2 = "c0000000FD",
- lfsu_2 = "c4000000FD",
- lfd_2 = "c8000000FD",
- lfdu_2 = "cc000000FD",
- stfs_2 = "d0000000FD",
- stfsu_2 = "d4000000FD",
- stfd_2 = "d8000000FD",
- stfdu_2 = "dc000000FD",
- ld_2 = "e8000000RD", -- NYI: displacement must be divisible by 4.
- ldu_2 = "e8000001RD",
- lwa_2 = "e8000002RD",
- std_2 = "f8000000RD",
- stdu_2 = "f8000001RD",
-
- -- Primary opcode 19:
- mcrf_2 = "4c000000XX",
- isync_0 = "4c00012c",
- crnor_3 = "4c000042CCC",
- crnot_2 = "4c000042CC=",
- crandc_3 = "4c000102CCC",
- crxor_3 = "4c000182CCC",
- crclr_1 = "4c000182C==",
- crnand_3 = "4c0001c2CCC",
- crand_3 = "4c000202CCC",
- creqv_3 = "4c000242CCC",
- crset_1 = "4c000242C==",
- crorc_3 = "4c000342CCC",
- cror_3 = "4c000382CCC",
- crmove_2 = "4c000382CC=",
- bclr_2 = "4c000020AA",
- bclrl_2 = "4c000021AA",
- bcctr_2 = "4c000420AA",
- bcctrl_2 = "4c000421AA",
- blr_0 = "4e800020",
- blrl_0 = "4e800021",
- bctr_0 = "4e800420",
- bctrl_0 = "4e800421",
-
- -- Primary opcode 31:
- cmpw_3 = "7c000000XRR",
- cmpw_2 = "7c000000-RR",
- cmpd_3 = "7c200000XRR",
- cmpd_2 = "7c200000-RR",
- tw_3 = "7c000008ARR",
- subfc_3 = "7c000010RRR.",
- subc_3 = "7c000010RRR~.",
- mulhdu_3 = "7c000012RRR.",
- addc_3 = "7c000014RRR.",
- mulhwu_3 = "7c000016RRR.",
- isel_4 = "7c00001eRRRC",
- isellt_3 = "7c00001eRRR",
- iselgt_3 = "7c00005eRRR",
- iseleq_3 = "7c00009eRRR",
- mfcr_1 = "7c000026R",
- -- NYI: mtcrf, mtocrf, mfocrf
- lwarx_3 = "7c000028RR0R",
- ldx_3 = "7c00002aRR0R",
- lwzx_3 = "7c00002eRR0R",
- slw_3 = "7c000030RR~R.",
- cntlzw_2 = "7c000034RR~",
- sld_3 = "7c000036RR~R.",
- and_3 = "7c000038RR~R.",
- cmplw_3 = "7c000040XRR",
- cmplw_2 = "7c000040-RR",
- cmpld_3 = "7c200040XRR",
- cmpld_2 = "7c200040-RR",
- subf_3 = "7c000050RRR.",
- sub_3 = "7c000050RRR~.",
- ldux_3 = "7c00006aRR0R",
- dcbst_2 = "7c00006c-RR",
- lwzux_3 = "7c00006eRR0R",
- cntlzd_2 = "7c000074RR~",
- andc_3 = "7c000078RR~R.",
- td_3 = "7c000088ARR",
- mulhd_3 = "7c000092RRR.",
- mulhw_3 = "7c000096RRR.",
- ldarx_3 = "7c0000a8RR0R",
- dcbf_2 = "7c0000ac-RR",
- lbzx_3 = "7c0000aeRR0R",
- neg_2 = "7c0000d0RR.",
- lbzux_3 = "7c0000eeRR0R",
- popcntb_2 = "7c0000f4RR~",
- not_2 = "7c0000f8RR~%.",
- nor_3 = "7c0000f8RR~R.",
- subfe_3 = "7c000110RRR.",
- sube_3 = "7c000110RRR~.",
- adde_3 = "7c000114RRR.",
- stdx_3 = "7c00012aRR0R",
- stwcx_3 = "7c00012cRR0R.",
- stwx_3 = "7c00012eRR0R",
- prtyw_2 = "7c000134RR~",
- stdux_3 = "7c00016aRR0R",
- stwux_3 = "7c00016eRR0R",
- prtyd_2 = "7c000174RR~",
- subfze_2 = "7c000190RR.",
- addze_2 = "7c000194RR.",
- stdcx_3 = "7c0001acRR0R.",
- stbx_3 = "7c0001aeRR0R",
- subfme_2 = "7c0001d0RR.",
- mulld_3 = "7c0001d2RRR.",
- addme_2 = "7c0001d4RR.",
- mullw_3 = "7c0001d6RRR.",
- dcbtst_2 = "7c0001ec-RR",
- stbux_3 = "7c0001eeRR0R",
- add_3 = "7c000214RRR.",
- dcbt_2 = "7c00022c-RR",
- lhzx_3 = "7c00022eRR0R",
- eqv_3 = "7c000238RR~R.",
- eciwx_3 = "7c00026cRR0R",
- lhzux_3 = "7c00026eRR0R",
- xor_3 = "7c000278RR~R.",
- mfspefscr_1 = "7c0082a6R",
- mfxer_1 = "7c0102a6R",
- mflr_1 = "7c0802a6R",
- mfctr_1 = "7c0902a6R",
- lwax_3 = "7c0002aaRR0R",
- lhax_3 = "7c0002aeRR0R",
- mftb_1 = "7c0c42e6R",
- mftbu_1 = "7c0d42e6R",
- lwaux_3 = "7c0002eaRR0R",
- lhaux_3 = "7c0002eeRR0R",
- sthx_3 = "7c00032eRR0R",
- orc_3 = "7c000338RR~R.",
- ecowx_3 = "7c00036cRR0R",
- sthux_3 = "7c00036eRR0R",
- or_3 = "7c000378RR~R.",
- mr_2 = "7c000378RR~%.",
- divdu_3 = "7c000392RRR.",
- divwu_3 = "7c000396RRR.",
- mtspefscr_1 = "7c0083a6R",
- mtxer_1 = "7c0103a6R",
- mtlr_1 = "7c0803a6R",
- mtctr_1 = "7c0903a6R",
- dcbi_2 = "7c0003ac-RR",
- nand_3 = "7c0003b8RR~R.",
- divd_3 = "7c0003d2RRR.",
- divw_3 = "7c0003d6RRR.",
- cmpb_3 = "7c0003f8RR~R.",
- mcrxr_1 = "7c000400X",
- subfco_3 = "7c000410RRR.",
- subco_3 = "7c000410RRR~.",
- addco_3 = "7c000414RRR.",
- ldbrx_3 = "7c000428RR0R",
- lswx_3 = "7c00042aRR0R",
- lwbrx_3 = "7c00042cRR0R",
- lfsx_3 = "7c00042eFR0R",
- srw_3 = "7c000430RR~R.",
- srd_3 = "7c000436RR~R.",
- subfo_3 = "7c000450RRR.",
- subo_3 = "7c000450RRR~.",
- lfsux_3 = "7c00046eFR0R",
- lswi_3 = "7c0004aaRR0A",
- sync_0 = "7c0004ac",
- lwsync_0 = "7c2004ac",
- ptesync_0 = "7c4004ac",
- lfdx_3 = "7c0004aeFR0R",
- nego_2 = "7c0004d0RR.",
- lfdux_3 = "7c0004eeFR0R",
- subfeo_3 = "7c000510RRR.",
- subeo_3 = "7c000510RRR~.",
- addeo_3 = "7c000514RRR.",
- stdbrx_3 = "7c000528RR0R",
- stswx_3 = "7c00052aRR0R",
- stwbrx_3 = "7c00052cRR0R",
- stfsx_3 = "7c00052eFR0R",
- stfsux_3 = "7c00056eFR0R",
- subfzeo_2 = "7c000590RR.",
- addzeo_2 = "7c000594RR.",
- stswi_3 = "7c0005aaRR0A",
- stfdx_3 = "7c0005aeFR0R",
- subfmeo_2 = "7c0005d0RR.",
- mulldo_3 = "7c0005d2RRR.",
- addmeo_2 = "7c0005d4RR.",
- mullwo_3 = "7c0005d6RRR.",
- dcba_2 = "7c0005ec-RR",
- stfdux_3 = "7c0005eeFR0R",
- addo_3 = "7c000614RRR.",
- lhbrx_3 = "7c00062cRR0R",
- sraw_3 = "7c000630RR~R.",
- srad_3 = "7c000634RR~R.",
- srawi_3 = "7c000670RR~A.",
- eieio_0 = "7c0006ac",
- lfiwax_3 = "7c0006aeFR0R",
- sthbrx_3 = "7c00072cRR0R",
- extsh_2 = "7c000734RR~.",
- extsb_2 = "7c000774RR~.",
- divduo_3 = "7c000792RRR.",
- divwou_3 = "7c000796RRR.",
- icbi_2 = "7c0007ac-RR",
- stfiwx_3 = "7c0007aeFR0R",
- extsw_2 = "7c0007b4RR~.",
- divdo_3 = "7c0007d2RRR.",
- divwo_3 = "7c0007d6RRR.",
- dcbz_2 = "7c0007ec-RR",
-
- -- Primary opcode 59:
- fdivs_3 = "ec000024FFF.",
- fsubs_3 = "ec000028FFF.",
- fadds_3 = "ec00002aFFF.",
- fsqrts_2 = "ec00002cF-F.",
- fres_2 = "ec000030F-F.",
- fmuls_3 = "ec000032FF-F.",
- frsqrtes_2 = "ec000034F-F.",
- fmsubs_4 = "ec000038FFFF~.",
- fmadds_4 = "ec00003aFFFF~.",
- fnmsubs_4 = "ec00003cFFFF~.",
- fnmadds_4 = "ec00003eFFFF~.",
-
- -- Primary opcode 63:
- fdiv_3 = "fc000024FFF.",
- fsub_3 = "fc000028FFF.",
- fadd_3 = "fc00002aFFF.",
- fsqrt_2 = "fc00002cF-F.",
- fsel_4 = "fc00002eFFFF~.",
- fre_2 = "fc000030F-F.",
- fmul_3 = "fc000032FF-F.",
- frsqrte_2 = "fc000034F-F.",
- fmsub_4 = "fc000038FFFF~.",
- fmadd_4 = "fc00003aFFFF~.",
- fnmsub_4 = "fc00003cFFFF~.",
- fnmadd_4 = "fc00003eFFFF~.",
- fcmpu_3 = "fc000000XFF",
- fcpsgn_3 = "fc000010FFF.",
- fcmpo_3 = "fc000040XFF",
- mtfsb1_1 = "fc00004cA",
- fneg_2 = "fc000050F-F.",
- mcrfs_2 = "fc000080XX",
- mtfsb0_1 = "fc00008cA",
- fmr_2 = "fc000090F-F.",
- frsp_2 = "fc000018F-F.",
- fctiw_2 = "fc00001cF-F.",
- fctiwz_2 = "fc00001eF-F.",
- mtfsfi_2 = "fc00010cAA", -- NYI: upshift.
- fnabs_2 = "fc000110F-F.",
- fabs_2 = "fc000210F-F.",
- frin_2 = "fc000310F-F.",
- friz_2 = "fc000350F-F.",
- frip_2 = "fc000390F-F.",
- frim_2 = "fc0003d0F-F.",
- mffs_1 = "fc00048eF.",
- mtfsf_1 = "fc00058eF.",
- fctid_2 = "fc00065cF-F.",
- fctidz_2 = "fc00065eF-F.",
- fcfid_2 = "fc00069cF-F.",
-
- -- Primary opcode 4, SPE APU extension:
- evaddw_3 = "10000200RRR",
- evaddiw_3 = "10000202RAR~",
- evsubw_3 = "10000204RRR~",
- evsubiw_3 = "10000206RAR~",
- evabs_2 = "10000208RR",
- evneg_2 = "10000209RR",
- evextsb_2 = "1000020aRR",
- evextsh_2 = "1000020bRR",
- evrndw_2 = "1000020cRR",
- evcntlzw_2 = "1000020dRR",
- evcntlsw_2 = "1000020eRR",
- brinc_3 = "1000020fRRR",
- evand_3 = "10000211RRR",
- evandc_3 = "10000212RRR",
- evxor_3 = "10000216RRR",
- evor_3 = "10000217RRR",
- evmr_2 = "10000217RR=",
- evnor_3 = "10000218RRR",
- evnot_2 = "10000218RR=",
- eveqv_3 = "10000219RRR",
- evorc_3 = "1000021bRRR",
- evnand_3 = "1000021eRRR",
- evsrwu_3 = "10000220RRR",
- evsrws_3 = "10000221RRR",
- evsrwiu_3 = "10000222RRA",
- evsrwis_3 = "10000223RRA",
- evslw_3 = "10000224RRR",
- evslwi_3 = "10000226RRA",
- evrlw_3 = "10000228RRR",
- evsplati_2 = "10000229RS",
- evrlwi_3 = "1000022aRRA",
- evsplatfi_2 = "1000022bRS",
- evmergehi_3 = "1000022cRRR",
- evmergelo_3 = "1000022dRRR",
- evcmpgtu_3 = "10000230XRR",
- evcmpgtu_2 = "10000230-RR",
- evcmpgts_3 = "10000231XRR",
- evcmpgts_2 = "10000231-RR",
- evcmpltu_3 = "10000232XRR",
- evcmpltu_2 = "10000232-RR",
- evcmplts_3 = "10000233XRR",
- evcmplts_2 = "10000233-RR",
- evcmpeq_3 = "10000234XRR",
- evcmpeq_2 = "10000234-RR",
- evsel_4 = "10000278RRRW",
- evsel_3 = "10000278RRR",
- evfsadd_3 = "10000280RRR",
- evfssub_3 = "10000281RRR",
- evfsabs_2 = "10000284RR",
- evfsnabs_2 = "10000285RR",
- evfsneg_2 = "10000286RR",
- evfsmul_3 = "10000288RRR",
- evfsdiv_3 = "10000289RRR",
- evfscmpgt_3 = "1000028cXRR",
- evfscmpgt_2 = "1000028c-RR",
- evfscmplt_3 = "1000028dXRR",
- evfscmplt_2 = "1000028d-RR",
- evfscmpeq_3 = "1000028eXRR",
- evfscmpeq_2 = "1000028e-RR",
- evfscfui_2 = "10000290R-R",
- evfscfsi_2 = "10000291R-R",
- evfscfuf_2 = "10000292R-R",
- evfscfsf_2 = "10000293R-R",
- evfsctui_2 = "10000294R-R",
- evfsctsi_2 = "10000295R-R",
- evfsctuf_2 = "10000296R-R",
- evfsctsf_2 = "10000297R-R",
- evfsctuiz_2 = "10000298R-R",
- evfsctsiz_2 = "1000029aR-R",
- evfststgt_3 = "1000029cXRR",
- evfststgt_2 = "1000029c-RR",
- evfststlt_3 = "1000029dXRR",
- evfststlt_2 = "1000029d-RR",
- evfststeq_3 = "1000029eXRR",
- evfststeq_2 = "1000029e-RR",
- efsadd_3 = "100002c0RRR",
- efssub_3 = "100002c1RRR",
- efsabs_2 = "100002c4RR",
- efsnabs_2 = "100002c5RR",
- efsneg_2 = "100002c6RR",
- efsmul_3 = "100002c8RRR",
- efsdiv_3 = "100002c9RRR",
- efscmpgt_3 = "100002ccXRR",
- efscmpgt_2 = "100002cc-RR",
- efscmplt_3 = "100002cdXRR",
- efscmplt_2 = "100002cd-RR",
- efscmpeq_3 = "100002ceXRR",
- efscmpeq_2 = "100002ce-RR",
- efscfd_2 = "100002cfR-R",
- efscfui_2 = "100002d0R-R",
- efscfsi_2 = "100002d1R-R",
- efscfuf_2 = "100002d2R-R",
- efscfsf_2 = "100002d3R-R",
- efsctui_2 = "100002d4R-R",
- efsctsi_2 = "100002d5R-R",
- efsctuf_2 = "100002d6R-R",
- efsctsf_2 = "100002d7R-R",
- efsctuiz_2 = "100002d8R-R",
- efsctsiz_2 = "100002daR-R",
- efststgt_3 = "100002dcXRR",
- efststgt_2 = "100002dc-RR",
- efststlt_3 = "100002ddXRR",
- efststlt_2 = "100002dd-RR",
- efststeq_3 = "100002deXRR",
- efststeq_2 = "100002de-RR",
- efdadd_3 = "100002e0RRR",
- efdsub_3 = "100002e1RRR",
- efdcfuid_2 = "100002e2R-R",
- efdcfsid_2 = "100002e3R-R",
- efdabs_2 = "100002e4RR",
- efdnabs_2 = "100002e5RR",
- efdneg_2 = "100002e6RR",
- efdmul_3 = "100002e8RRR",
- efddiv_3 = "100002e9RRR",
- efdctuidz_2 = "100002eaR-R",
- efdctsidz_2 = "100002ebR-R",
- efdcmpgt_3 = "100002ecXRR",
- efdcmpgt_2 = "100002ec-RR",
- efdcmplt_3 = "100002edXRR",
- efdcmplt_2 = "100002ed-RR",
- efdcmpeq_3 = "100002eeXRR",
- efdcmpeq_2 = "100002ee-RR",
- efdcfs_2 = "100002efR-R",
- efdcfui_2 = "100002f0R-R",
- efdcfsi_2 = "100002f1R-R",
- efdcfuf_2 = "100002f2R-R",
- efdcfsf_2 = "100002f3R-R",
- efdctui_2 = "100002f4R-R",
- efdctsi_2 = "100002f5R-R",
- efdctuf_2 = "100002f6R-R",
- efdctsf_2 = "100002f7R-R",
- efdctuiz_2 = "100002f8R-R",
- efdctsiz_2 = "100002faR-R",
- efdtstgt_3 = "100002fcXRR",
- efdtstgt_2 = "100002fc-RR",
- efdtstlt_3 = "100002fdXRR",
- efdtstlt_2 = "100002fd-RR",
- efdtsteq_3 = "100002feXRR",
- efdtsteq_2 = "100002fe-RR",
- evlddx_3 = "10000300RR0R",
- evldd_2 = "10000301R8",
- evldwx_3 = "10000302RR0R",
- evldw_2 = "10000303R8",
- evldhx_3 = "10000304RR0R",
- evldh_2 = "10000305R8",
- evlwhex_3 = "10000310RR0R",
- evlwhe_2 = "10000311R4",
- evlwhoux_3 = "10000314RR0R",
- evlwhou_2 = "10000315R4",
- evlwhosx_3 = "10000316RR0R",
- evlwhos_2 = "10000317R4",
- evstddx_3 = "10000320RR0R",
- evstdd_2 = "10000321R8",
- evstdwx_3 = "10000322RR0R",
- evstdw_2 = "10000323R8",
- evstdhx_3 = "10000324RR0R",
- evstdh_2 = "10000325R8",
- evstwhex_3 = "10000330RR0R",
- evstwhe_2 = "10000331R4",
- evstwhox_3 = "10000334RR0R",
- evstwho_2 = "10000335R4",
- evstwwex_3 = "10000338RR0R",
- evstwwe_2 = "10000339R4",
- evstwwox_3 = "1000033cRR0R",
- evstwwo_2 = "1000033dR4",
- evmhessf_3 = "10000403RRR",
- evmhossf_3 = "10000407RRR",
- evmheumi_3 = "10000408RRR",
- evmhesmi_3 = "10000409RRR",
- evmhesmf_3 = "1000040bRRR",
- evmhoumi_3 = "1000040cRRR",
- evmhosmi_3 = "1000040dRRR",
- evmhosmf_3 = "1000040fRRR",
- evmhessfa_3 = "10000423RRR",
- evmhossfa_3 = "10000427RRR",
- evmheumia_3 = "10000428RRR",
- evmhesmia_3 = "10000429RRR",
- evmhesmfa_3 = "1000042bRRR",
- evmhoumia_3 = "1000042cRRR",
- evmhosmia_3 = "1000042dRRR",
- evmhosmfa_3 = "1000042fRRR",
- evmwhssf_3 = "10000447RRR",
- evmwlumi_3 = "10000448RRR",
- evmwhumi_3 = "1000044cRRR",
- evmwhsmi_3 = "1000044dRRR",
- evmwhsmf_3 = "1000044fRRR",
- evmwssf_3 = "10000453RRR",
- evmwumi_3 = "10000458RRR",
- evmwsmi_3 = "10000459RRR",
- evmwsmf_3 = "1000045bRRR",
- evmwhssfa_3 = "10000467RRR",
- evmwlumia_3 = "10000468RRR",
- evmwhumia_3 = "1000046cRRR",
- evmwhsmia_3 = "1000046dRRR",
- evmwhsmfa_3 = "1000046fRRR",
- evmwssfa_3 = "10000473RRR",
- evmwumia_3 = "10000478RRR",
- evmwsmia_3 = "10000479RRR",
- evmwsmfa_3 = "1000047bRRR",
- evmra_2 = "100004c4RR",
- evdivws_3 = "100004c6RRR",
- evdivwu_3 = "100004c7RRR",
- evmwssfaa_3 = "10000553RRR",
- evmwumiaa_3 = "10000558RRR",
- evmwsmiaa_3 = "10000559RRR",
- evmwsmfaa_3 = "1000055bRRR",
- evmwssfan_3 = "100005d3RRR",
- evmwumian_3 = "100005d8RRR",
- evmwsmian_3 = "100005d9RRR",
- evmwsmfan_3 = "100005dbRRR",
- evmergehilo_3 = "1000022eRRR",
- evmergelohi_3 = "1000022fRRR",
- evlhhesplatx_3 = "10000308RR0R",
- evlhhesplat_2 = "10000309R2",
- evlhhousplatx_3 = "1000030cRR0R",
- evlhhousplat_2 = "1000030dR2",
- evlhhossplatx_3 = "1000030eRR0R",
- evlhhossplat_2 = "1000030fR2",
- evlwwsplatx_3 = "10000318RR0R",
- evlwwsplat_2 = "10000319R4",
- evlwhsplatx_3 = "1000031cRR0R",
- evlwhsplat_2 = "1000031dR4",
- evaddusiaaw_2 = "100004c0RR",
- evaddssiaaw_2 = "100004c1RR",
- evsubfusiaaw_2 = "100004c2RR",
- evsubfssiaaw_2 = "100004c3RR",
- evaddumiaaw_2 = "100004c8RR",
- evaddsmiaaw_2 = "100004c9RR",
- evsubfumiaaw_2 = "100004caRR",
- evsubfsmiaaw_2 = "100004cbRR",
- evmheusiaaw_3 = "10000500RRR",
- evmhessiaaw_3 = "10000501RRR",
- evmhessfaaw_3 = "10000503RRR",
- evmhousiaaw_3 = "10000504RRR",
- evmhossiaaw_3 = "10000505RRR",
- evmhossfaaw_3 = "10000507RRR",
- evmheumiaaw_3 = "10000508RRR",
- evmhesmiaaw_3 = "10000509RRR",
- evmhesmfaaw_3 = "1000050bRRR",
- evmhoumiaaw_3 = "1000050cRRR",
- evmhosmiaaw_3 = "1000050dRRR",
- evmhosmfaaw_3 = "1000050fRRR",
- evmhegumiaa_3 = "10000528RRR",
- evmhegsmiaa_3 = "10000529RRR",
- evmhegsmfaa_3 = "1000052bRRR",
- evmhogumiaa_3 = "1000052cRRR",
- evmhogsmiaa_3 = "1000052dRRR",
- evmhogsmfaa_3 = "1000052fRRR",
- evmwlusiaaw_3 = "10000540RRR",
- evmwlssiaaw_3 = "10000541RRR",
- evmwlumiaaw_3 = "10000548RRR",
- evmwlsmiaaw_3 = "10000549RRR",
- evmheusianw_3 = "10000580RRR",
- evmhessianw_3 = "10000581RRR",
- evmhessfanw_3 = "10000583RRR",
- evmhousianw_3 = "10000584RRR",
- evmhossianw_3 = "10000585RRR",
- evmhossfanw_3 = "10000587RRR",
- evmheumianw_3 = "10000588RRR",
- evmhesmianw_3 = "10000589RRR",
- evmhesmfanw_3 = "1000058bRRR",
- evmhoumianw_3 = "1000058cRRR",
- evmhosmianw_3 = "1000058dRRR",
- evmhosmfanw_3 = "1000058fRRR",
- evmhegumian_3 = "100005a8RRR",
- evmhegsmian_3 = "100005a9RRR",
- evmhegsmfan_3 = "100005abRRR",
- evmhogumian_3 = "100005acRRR",
- evmhogsmian_3 = "100005adRRR",
- evmhogsmfan_3 = "100005afRRR",
- evmwlusianw_3 = "100005c0RRR",
- evmwlssianw_3 = "100005c1RRR",
- evmwlumianw_3 = "100005c8RRR",
- evmwlsmianw_3 = "100005c9RRR",
-
- -- NYI: some 64 bit PowerPC and Book E instructions:
- -- rldicl, rldicr, rldic, rldimi, rldcl, rldcr, sradi, 64 bit ext. add/sub,
- -- extended addressing branches, cache management, loads and stores
-}
-
--- Add mnemonics for "." variants.
-do
- local t = {}
- for k,v in pairs(map_op) do
- if sub(v, -1) == "." then
- local v2 = sub(v, 1, 7)..char(byte(v, 8)+1)..sub(v, 9, -2)
- t[sub(k, 1, -3).."."..sub(k, -2)] = v2
- end
- end
- for k,v in pairs(t) do
- map_op[k] = v
- end
-end
-
--- Add more branch mnemonics.
-for cond,c in pairs(map_cond) do
- local b1 = "b"..cond
- local c1 = (c%4)*0x00010000 + (c < 4 and 0x01000000 or 0)
- -- bX[l]
- map_op[b1.."_1"] = tohex(0x40800000 + c1).."K"
- map_op[b1.."l_1"] = tohex(0x40800001 + c1).."K"
- map_op[b1.."_2"] = tohex(0x40800000 + c1).."-XK"
- map_op[b1.."l_2"] = tohex(0x40800001 + c1).."-XK"
- -- bXlr[l]
- map_op[b1.."lr_0"] = tohex(0x4c800020 + c1)
- map_op[b1.."lrl_0"] = tohex(0x4c800021 + c1)
- map_op[b1.."ctr_0"] = tohex(0x4c800420 + c1)
- map_op[b1.."ctrl_0"] = tohex(0x4c800421 + c1)
- -- bXctr[l]
- map_op[b1.."lr_1"] = tohex(0x4c800020 + c1).."-X"
- map_op[b1.."lrl_1"] = tohex(0x4c800021 + c1).."-X"
- map_op[b1.."ctr_1"] = tohex(0x4c800420 + c1).."-X"
- map_op[b1.."ctrl_1"] = tohex(0x4c800421 + c1).."-X"
-end
-
-------------------------------------------------------------------------------
-
-local function parse_gpr(expr)
- local tname, ovreg = match(expr, "^([%w_]+):(r[1-3]?[0-9])$")
- local tp = map_type[tname or expr]
- if tp then
- local reg = ovreg or tp.reg
- if not reg then
- werror("type `"..(tname or expr).."' needs a register override")
- end
- expr = reg
- end
- local r = match(expr, "^r([1-3]?[0-9])$")
- if r then
- r = tonumber(r)
- if r <= 31 then return r, tp end
- end
- werror("bad register name `"..expr.."'")
-end
-
-local function parse_fpr(expr)
- local r = match(expr, "^f([1-3]?[0-9])$")
- if r then
- r = tonumber(r)
- if r <= 31 then return r end
- end
- werror("bad register name `"..expr.."'")
-end
-
-local function parse_cr(expr)
- local r = match(expr, "^cr([0-7])$")
- if r then return tonumber(r) end
- werror("bad condition register name `"..expr.."'")
-end
-
-local function parse_cond(expr)
- local r, cond = match(expr, "^4%*cr([0-7])%+(%w%w)$")
- if r then
- r = tonumber(r)
- local c = map_cond[cond]
- if c and c < 4 then return r*4+c end
- end
- werror("bad condition bit name `"..expr.."'")
-end
-
-local function parse_imm(imm, bits, shift, scale, signed)
- local n = tonumber(imm)
- if n then
- if n % 2^scale == 0 then
- n = n / 2^scale
- if signed then
- if n >= 0 then
- if n < 2^(bits-1) then return n*2^shift end
- else
- if n >= -(2^(bits-1))-1 then return (n+2^bits)*2^shift end
- end
- else
- if n >= 0 and n <= 2^bits-1 then return n*2^shift end
- end
- end
- werror("out of range immediate `"..imm.."'")
- elseif match(imm, "^r([1-3]?[0-9])$") or
- match(imm, "^([%w_]+):(r[1-3]?[0-9])$") then
- werror("expected immediate operand, got register")
- else
- waction("IMM", (signed and 32768 or 0)+scale*1024+bits*32+shift, imm)
- return 0
- end
-end
-
-local function parse_disp(disp)
- local imm, reg = match(disp, "^(.*)%(([%w_:]+)%)$")
- if imm then
- local r = parse_gpr(reg)
- if r == 0 then werror("cannot use r0 in displacement") end
- return r*65536 + parse_imm(imm, 16, 0, 0, true)
- end
- local reg, tailr = match(disp, "^([%w_:]+)%s*(.*)$")
- if reg and tailr ~= "" then
- local r, tp = parse_gpr(reg)
- if r == 0 then werror("cannot use r0 in displacement") end
- if tp then
- waction("IMM", 32768+16*32, format(tp.ctypefmt, tailr))
- return r*65536
- end
- end
- werror("bad displacement `"..disp.."'")
-end
-
-local function parse_u5disp(disp, scale)
- local imm, reg = match(disp, "^(.*)%(([%w_:]+)%)$")
- if imm then
- local r = parse_gpr(reg)
- if r == 0 then werror("cannot use r0 in displacement") end
- return r*65536 + parse_imm(imm, 5, 11, scale, false)
- end
- local reg, tailr = match(disp, "^([%w_:]+)%s*(.*)$")
- if reg and tailr ~= "" then
- local r, tp = parse_gpr(reg)
- if r == 0 then werror("cannot use r0 in displacement") end
- if tp then
- waction("IMM", scale*1024+5*32+11, format(tp.ctypefmt, tailr))
- return r*65536
- end
- end
- werror("bad displacement `"..disp.."'")
-end
-
-local function parse_label(label, def)
- local prefix = sub(label, 1, 2)
- -- =>label (pc label reference)
- if prefix == "=>" then
- return "PC", 0, sub(label, 3)
- end
- -- ->name (global label reference)
- if prefix == "->" then
- return "LG", map_global[sub(label, 3)]
- end
- if def then
- -- [1-9] (local label definition)
- if match(label, "^[1-9]$") then
- return "LG", 10+tonumber(label)
- end
- else
- -- [<>][1-9] (local label reference)
- local dir, lnum = match(label, "^([<>])([1-9])$")
- if dir then -- Fwd: 1-9, Bkwd: 11-19.
- return "LG", lnum + (dir == ">" and 0 or 10)
- end
- -- extern label (extern label reference)
- local extname = match(label, "^extern%s+(%S+)$")
- if extname then
- return "EXT", map_extern[extname]
- end
- end
- werror("bad label `"..label.."'")
-end
-
-------------------------------------------------------------------------------
-
--- Handle opcodes defined with template strings.
-map_op[".template__"] = function(params, template, nparams)
- if not params then return sub(template, 9) end
- local op = tonumber(sub(template, 1, 8), 16)
- local n, rs = 1, 26
-
- -- Limit number of section buffer positions used by a single dasm_put().
- -- A single opcode needs a maximum of 3 positions (rlwinm).
- if secpos+3 > maxsecpos then wflush() end
- local pos = wpos()
-
- -- Process each character.
- for p in gmatch(sub(template, 9), ".") do
- if p == "R" then
- rs = rs - 5; op = op + parse_gpr(params[n]) * 2^rs; n = n + 1
- elseif p == "F" then
- rs = rs - 5; op = op + parse_fpr(params[n]) * 2^rs; n = n + 1
- elseif p == "A" then
- rs = rs - 5; op = op + parse_imm(params[n], 5, rs, 0, false); n = n + 1
- elseif p == "S" then
- rs = rs - 5; op = op + parse_imm(params[n], 5, rs, 0, true); n = n + 1
- elseif p == "I" then
- op = op + parse_imm(params[n], 16, 0, 0, true); n = n + 1
- elseif p == "U" then
- op = op + parse_imm(params[n], 16, 0, 0, false); n = n + 1
- elseif p == "D" then
- op = op + parse_disp(params[n]); n = n + 1
- elseif p == "2" then
- op = op + parse_u5disp(params[n], 1); n = n + 1
- elseif p == "4" then
- op = op + parse_u5disp(params[n], 2); n = n + 1
- elseif p == "8" then
- op = op + parse_u5disp(params[n], 3); n = n + 1
- elseif p == "C" then
- rs = rs - 5; op = op + parse_cond(params[n]) * 2^rs; n = n + 1
- elseif p == "X" then
- rs = rs - 5; op = op + parse_cr(params[n]) * 2^(rs+2); n = n + 1
- elseif p == "W" then
- op = op + parse_cr(params[n]); n = n + 1
- elseif p == "J" or p == "K" then
- local mode, n, s = parse_label(params[n], false)
- if p == "K" then n = n + 2048 end
- waction("REL_"..mode, n, s, 1)
- n = n + 1
- elseif p == "0" then
- local mm = 2^rs
- local t = op % mm
- if ((op - t) / mm) % 32 == 0 then werror("cannot use r0") end
- elseif p == "=" or p == "%" then
- local mm = 2^(rs + (p == "%" and 5 or 0))
- local t = ((op - op % mm) / mm) % 32
- rs = rs - 5
- op = op + t * 2^rs
- elseif p == "~" then
- local mm = 2^rs
- local t1l = op % mm
- local t1h = (op - t1l) / mm
- local t2l = t1h % 32
- local t2h = (t1h - t2l) / 32
- local t3l = t2h % 32
- op = ((t2h - t3l + t2l)*32 + t3l)*mm + t1l
- elseif p == "-" then
- rs = rs - 5
- elseif p == "." then
- -- Ignored.
- else
- assert(false)
- end
- end
- wputpos(pos, op)
-end
-
-------------------------------------------------------------------------------
-
--- Pseudo-opcode to mark the position where the action list is to be emitted.
-map_op[".actionlist_1"] = function(params)
- if not params then return "cvar" end
- local name = params[1] -- No syntax check. You get to keep the pieces.
- wline(function(out) writeactions(out, name) end)
-end
-
--- Pseudo-opcode to mark the position where the global enum is to be emitted.
-map_op[".globals_1"] = function(params)
- if not params then return "prefix" end
- local prefix = params[1] -- No syntax check. You get to keep the pieces.
- wline(function(out) writeglobals(out, prefix) end)
-end
-
--- Pseudo-opcode to mark the position where the global names are to be emitted.
-map_op[".globalnames_1"] = function(params)
- if not params then return "cvar" end
- local name = params[1] -- No syntax check. You get to keep the pieces.
- wline(function(out) writeglobalnames(out, name) end)
-end
-
--- Pseudo-opcode to mark the position where the extern names are to be emitted.
-map_op[".externnames_1"] = function(params)
- if not params then return "cvar" end
- local name = params[1] -- No syntax check. You get to keep the pieces.
- wline(function(out) writeexternnames(out, name) end)
-end
-
-------------------------------------------------------------------------------
-
--- Label pseudo-opcode (converted from trailing colon form).
-map_op[".label_1"] = function(params)
- if not params then return "[1-9] | ->global | =>pcexpr" end
- if secpos+1 > maxsecpos then wflush() end
- local mode, n, s = parse_label(params[1], true)
- if mode == "EXT" then werror("bad label definition") end
- waction("LABEL_"..mode, n, s, 1)
-end
-
-------------------------------------------------------------------------------
-
--- Pseudo-opcodes for data storage.
-map_op[".long_*"] = function(params)
- if not params then return "imm..." end
- for _,p in ipairs(params) do
- local n = tonumber(p)
- if not n then werror("bad immediate `"..p.."'") end
- if n < 0 then n = n + 2^32 end
- wputw(n)
- if secpos+2 > maxsecpos then wflush() end
- end
-end
-
--- Alignment pseudo-opcode.
-map_op[".align_1"] = function(params)
- if not params then return "numpow2" end
- if secpos+1 > maxsecpos then wflush() end
- local align = tonumber(params[1])
- if align then
- local x = align
- -- Must be a power of 2 in the range (2 ... 256).
- for i=1,8 do
- x = x / 2
- if x == 1 then
- waction("ALIGN", align-1, nil, 1) -- Action byte is 2**n-1.
- return
- end
- end
- end
- werror("bad alignment")
-end
-
-------------------------------------------------------------------------------
-
--- Pseudo-opcode for (primitive) type definitions (map to C types).
-map_op[".type_3"] = function(params, nparams)
- if not params then
- return nparams == 2 and "name, ctype" or "name, ctype, reg"
- end
- local name, ctype, reg = params[1], params[2], params[3]
- if not match(name, "^[%a_][%w_]*$") then
- werror("bad type name `"..name.."'")
- end
- local tp = map_type[name]
- if tp then
- werror("duplicate type `"..name.."'")
- end
- -- Add #type to defines. A bit unclean to put it in map_archdef.
- map_archdef["#"..name] = "sizeof("..ctype..")"
- -- Add new type and emit shortcut define.
- local num = ctypenum + 1
- map_type[name] = {
- ctype = ctype,
- ctypefmt = format("Dt%X(%%s)", num),
- reg = reg,
- }
- wline(format("#define Dt%X(_V) (int)(ptrdiff_t)&(((%s *)0)_V)", num, ctype))
- ctypenum = num
-end
-map_op[".type_2"] = map_op[".type_3"]
-
--- Dump type definitions.
-local function dumptypes(out, lvl)
- local t = {}
- for name in pairs(map_type) do t[#t+1] = name end
- sort(t)
- out:write("Type definitions:\n")
- for _,name in ipairs(t) do
- local tp = map_type[name]
- local reg = tp.reg or ""
- out:write(format(" %-20s %-20s %s\n", name, tp.ctype, reg))
- end
- out:write("\n")
-end
-
-------------------------------------------------------------------------------
-
--- Set the current section.
-function _M.section(num)
- waction("SECTION", num)
- wflush(true) -- SECTION is a terminal action.
-end
-
-------------------------------------------------------------------------------
-
--- Dump architecture description.
-function _M.dumparch(out)
- out:write(format("DynASM %s version %s, released %s\n\n",
- _info.arch, _info.version, _info.release))
- dumpactions(out)
-end
-
--- Dump all user defined elements.
-function _M.dumpdef(out, lvl)
- dumptypes(out, lvl)
- dumpglobals(out, lvl)
- dumpexterns(out, lvl)
-end
-
-------------------------------------------------------------------------------
-
--- Pass callbacks from/to the DynASM core.
-function _M.passcb(wl, we, wf, ww)
- wline, werror, wfatal, wwarn = wl, we, wf, ww
- return wflush
-end
-
--- Setup the arch-specific module.
-function _M.setup(arch, opt)
- g_arch, g_opt = arch, opt
-end
-
--- Merge the core maps and the arch-specific maps.
-function _M.mergemaps(map_coreop, map_def)
- setmetatable(map_op, { __index = map_coreop })
- setmetatable(map_def, { __index = map_archdef })
- return map_op, map_def
-end
-
-return _M
-
-------------------------------------------------------------------------------
-
diff --git a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_proto.h b/plugins/MirLua/Modules/ffi/src/dynasm/dasm_proto.h deleted file mode 100644 index 94a79a163d..0000000000 --- a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_proto.h +++ /dev/null @@ -1,83 +0,0 @@ -/*
-** DynASM encoding engine prototypes.
-** Copyright (C) 2005-2011 Mike Pall. All rights reserved.
-** Released under the MIT/X license. See dynasm.lua for full copyright notice.
-*/
-
-#ifndef _DASM_PROTO_H
-#define _DASM_PROTO_H
-
-#include <stddef.h>
-#include <stdarg.h>
-
-#define DASM_IDENT "DynASM 1.3.0"
-#define DASM_VERSION 10300 /* 1.3.0 */
-
-#ifndef Dst_DECL
-#define Dst_DECL dasm_State **Dst
-#endif
-
-#ifndef Dst_REF
-#define Dst_REF (*Dst)
-#endif
-
-#ifndef DASM_FDEF
-#define DASM_FDEF extern
-#endif
-
-#ifndef DASM_M_GROW
-#define DASM_M_GROW(ctx, t, p, sz, need) \
- do { \
- size_t _sz = (sz), _need = (need); \
- if (_sz < _need) { \
- if (_sz < 16) _sz = 16; \
- while (_sz < _need) _sz += _sz; \
- (p) = (t *)realloc((p), _sz); \
- if ((p) == NULL) exit(1); \
- (sz) = _sz; \
- } \
- } while(0)
-#endif
-
-#ifndef DASM_M_FREE
-#define DASM_M_FREE(ctx, p, sz) free(p)
-#endif
-
-/* Internal DynASM encoder state. */
-typedef struct dasm_State dasm_State;
-
-
-/* Initialize and free DynASM state. */
-DASM_FDEF void dasm_init(Dst_DECL, int maxsection);
-DASM_FDEF void dasm_free(Dst_DECL);
-
-/* Setup global array. Must be called before dasm_setup(). */
-DASM_FDEF void dasm_setupglobal(Dst_DECL, void **gl, unsigned int maxgl);
-
-/* Grow PC label array. Can be called after dasm_setup(), too. */
-DASM_FDEF void dasm_growpc(Dst_DECL, unsigned int maxpc);
-
-/* Setup encoder. */
-DASM_FDEF void dasm_setup(Dst_DECL, const void *actionlist);
-
-/* Feed encoder with actions. Calls are generated by pre-processor. */
-DASM_FDEF void dasm_put(Dst_DECL, int start, ...);
-
-/* Link sections and return the resulting size. */
-DASM_FDEF int dasm_link(Dst_DECL, size_t *szp);
-
-/* Encode sections into buffer. */
-DASM_FDEF int dasm_encode(Dst_DECL, void *buffer);
-
-/* Get PC label offset. */
-DASM_FDEF int dasm_getpclabel(Dst_DECL, unsigned int pc);
-
-#ifdef DASM_CHECKS
-/* Optional sanity checker to call between isolated encoding steps. */
-DASM_FDEF int dasm_checkstep(Dst_DECL, int secmatch);
-#else
-#define dasm_checkstep(a, b) 0
-#endif
-
-
-#endif /* _DASM_PROTO_H */
diff --git a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_x64.lua b/plugins/MirLua/Modules/ffi/src/dynasm/dasm_x64.lua deleted file mode 100644 index 36b7e5bd93..0000000000 --- a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_x64.lua +++ /dev/null @@ -1,12 +0,0 @@ -------------------------------------------------------------------------------
--- DynASM x64 module.
---
--- Copyright (C) 2005-2011 Mike Pall. All rights reserved.
--- See dynasm.lua for full copyright notice.
-------------------------------------------------------------------------------
--- This module just sets 64 bit mode for the combined x86/x64 module.
--- All the interesting stuff is there.
-------------------------------------------------------------------------------
-
-x64 = true -- Using a global is an ugly, but effective solution.
-return require("dasm_x86")
diff --git a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_x86.h b/plugins/MirLua/Modules/ffi/src/dynasm/dasm_x86.h deleted file mode 100644 index 83c6eb5a0f..0000000000 --- a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_x86.h +++ /dev/null @@ -1,470 +0,0 @@ -/*
-** DynASM x86 encoding engine.
-** Copyright (C) 2005-2011 Mike Pall. All rights reserved.
-** Released under the MIT/X license. See dynasm.lua for full copyright notice.
-*/
-
-#include <stddef.h>
-#include <stdarg.h>
-#include <string.h>
-#include <stdlib.h>
-
-#define DASM_ARCH "x86"
-
-#ifndef DASM_EXTERN
-#define DASM_EXTERN(a,b,c,d) 0
-#endif
-
-/* Action definitions. DASM_STOP must be 255. */
-enum {
- DASM_DISP = 233,
- DASM_IMM_S, DASM_IMM_B, DASM_IMM_W, DASM_IMM_D, DASM_IMM_WB, DASM_IMM_DB,
- DASM_VREG, DASM_SPACE, DASM_SETLABEL, DASM_REL_A, DASM_REL_LG, DASM_REL_PC,
- DASM_IMM_LG, DASM_IMM_PC, DASM_LABEL_LG, DASM_LABEL_PC, DASM_ALIGN,
- DASM_EXTERN, DASM_ESC, DASM_MARK, DASM_SECTION, DASM_STOP
-};
-
-/* Maximum number of section buffer positions for a single dasm_put() call. */
-#define DASM_MAXSECPOS 25
-
-/* DynASM encoder status codes. Action list offset or number are or'ed in. */
-#define DASM_S_OK 0x00000000
-#define DASM_S_NOMEM 0x01000000
-#define DASM_S_PHASE 0x02000000
-#define DASM_S_MATCH_SEC 0x03000000
-#define DASM_S_RANGE_I 0x11000000
-#define DASM_S_RANGE_SEC 0x12000000
-#define DASM_S_RANGE_LG 0x13000000
-#define DASM_S_RANGE_PC 0x14000000
-#define DASM_S_RANGE_VREG 0x15000000
-#define DASM_S_UNDEF_L 0x21000000
-#define DASM_S_UNDEF_PC 0x22000000
-
-/* Macros to convert positions (8 bit section + 24 bit index). */
-#define DASM_POS2IDX(pos) ((pos)&0x00ffffff)
-#define DASM_POS2BIAS(pos) ((pos)&0xff000000)
-#define DASM_SEC2POS(sec) ((sec)<<24)
-#define DASM_POS2SEC(pos) ((pos)>>24)
-#define DASM_POS2PTR(D, pos) (D->sections[DASM_POS2SEC(pos)].rbuf + (pos))
-
-/* Action list type. */
-typedef const unsigned char *dasm_ActList;
-
-/* Per-section structure. */
-typedef struct dasm_Section {
- int *rbuf; /* Biased buffer pointer (negative section bias). */
- int *buf; /* True buffer pointer. */
- size_t bsize; /* Buffer size in bytes. */
- int pos; /* Biased buffer position. */
- int epos; /* End of biased buffer position - max single put. */
- int ofs; /* Byte offset into section. */
-} dasm_Section;
-
-/* Core structure holding the DynASM encoding state. */
-struct dasm_State {
- size_t psize; /* Allocated size of this structure. */
- dasm_ActList actionlist; /* Current actionlist pointer. */
- int *lglabels; /* Local/global chain/pos ptrs. */
- size_t lgsize;
- int *pclabels; /* PC label chains/pos ptrs. */
- size_t pcsize;
- void **globals; /* Array of globals (bias -10). */
- dasm_Section *section; /* Pointer to active section. */
- size_t codesize; /* Total size of all code sections. */
- int maxsection; /* 0 <= sectionidx < maxsection. */
- int status; /* Status code. */
- dasm_Section sections[1]; /* All sections. Alloc-extended. */
-};
-
-/* The size of the core structure depends on the max. number of sections. */
-#define DASM_PSZ(ms) (sizeof(dasm_State)+(ms-1)*sizeof(dasm_Section))
-
-
-/* Initialize DynASM state. */
-void dasm_init(Dst_DECL, int maxsection)
-{
- dasm_State *D;
- size_t psz = 0;
- int i;
- Dst_REF = NULL;
- DASM_M_GROW(Dst, struct dasm_State, Dst_REF, psz, DASM_PSZ(maxsection));
- D = Dst_REF;
- D->psize = psz;
- D->lglabels = NULL;
- D->lgsize = 0;
- D->pclabels = NULL;
- D->pcsize = 0;
- D->globals = NULL;
- D->maxsection = maxsection;
- for (i = 0; i < maxsection; i++) {
- D->sections[i].buf = NULL; /* Need this for pass3. */
- D->sections[i].rbuf = D->sections[i].buf - DASM_SEC2POS(i);
- D->sections[i].bsize = 0;
- D->sections[i].epos = 0; /* Wrong, but is recalculated after resize. */
- }
-}
-
-/* Free DynASM state. */
-void dasm_free(Dst_DECL)
-{
- dasm_State *D = Dst_REF;
- int i;
- for (i = 0; i < D->maxsection; i++)
- if (D->sections[i].buf)
- DASM_M_FREE(Dst, D->sections[i].buf, D->sections[i].bsize);
- if (D->pclabels) DASM_M_FREE(Dst, D->pclabels, D->pcsize);
- if (D->lglabels) DASM_M_FREE(Dst, D->lglabels, D->lgsize);
- DASM_M_FREE(Dst, D, D->psize);
-}
-
-/* Setup global label array. Must be called before dasm_setup(). */
-void dasm_setupglobal(Dst_DECL, void **gl, unsigned int maxgl)
-{
- dasm_State *D = Dst_REF;
- D->globals = gl - 10; /* Negative bias to compensate for locals. */
- DASM_M_GROW(Dst, int, D->lglabels, D->lgsize, (10+maxgl)*sizeof(int));
-}
-
-/* Grow PC label array. Can be called after dasm_setup(), too. */
-void dasm_growpc(Dst_DECL, unsigned int maxpc)
-{
- dasm_State *D = Dst_REF;
- size_t osz = D->pcsize;
- DASM_M_GROW(Dst, int, D->pclabels, D->pcsize, maxpc*sizeof(int));
- memset((void *)(((unsigned char *)D->pclabels)+osz), 0, D->pcsize-osz);
-}
-
-/* Setup encoder. */
-void dasm_setup(Dst_DECL, const void *actionlist)
-{
- dasm_State *D = Dst_REF;
- int i;
- D->actionlist = (dasm_ActList)actionlist;
- D->status = DASM_S_OK;
- D->section = &D->sections[0];
- memset((void *)D->lglabels, 0, D->lgsize);
- if (D->pclabels) memset((void *)D->pclabels, 0, D->pcsize);
- for (i = 0; i < D->maxsection; i++) {
- D->sections[i].pos = DASM_SEC2POS(i);
- D->sections[i].ofs = 0;
- }
-}
-
-
-#ifdef DASM_CHECKS
-#define CK(x, st) \
- do { if (!(x)) { \
- D->status = DASM_S_##st|(int)(p-D->actionlist-1); return; } } while (0)
-#define CKPL(kind, st) \
- do { if ((size_t)((char *)pl-(char *)D->kind##labels) >= D->kind##size) { \
- D->status=DASM_S_RANGE_##st|(int)(p-D->actionlist-1); return; } } while (0)
-#else
-#define CK(x, st) ((void)0)
-#define CKPL(kind, st) ((void)0)
-#endif
-
-/* Pass 1: Store actions and args, link branches/labels, estimate offsets. */
-void dasm_put(Dst_DECL, int start, ...)
-{
- va_list ap;
- dasm_State *D = Dst_REF;
- dasm_ActList p = D->actionlist + start;
- dasm_Section *sec = D->section;
- int pos = sec->pos, ofs = sec->ofs, mrm = 4;
- int *b;
-
- if (pos >= sec->epos) {
- DASM_M_GROW(Dst, int, sec->buf, sec->bsize,
- sec->bsize + 2*DASM_MAXSECPOS*sizeof(int));
- sec->rbuf = sec->buf - DASM_POS2BIAS(pos);
- sec->epos = (int)sec->bsize/sizeof(int) - DASM_MAXSECPOS+DASM_POS2BIAS(pos);
- }
-
- b = sec->rbuf;
- b[pos++] = start;
-
- va_start(ap, start);
- while (1) {
- int action = *p++;
- if (action < DASM_DISP) {
- ofs++;
- } else if (action <= DASM_REL_A) {
- int n = va_arg(ap, int);
- b[pos++] = n;
- switch (action) {
- case DASM_DISP:
- if (n == 0) { if ((mrm&7) == 4) mrm = p[-2]; if ((mrm&7) != 5) break; }
- case DASM_IMM_DB: if (((n+128)&-256) == 0) goto ob;
- case DASM_REL_A: /* Assumes ptrdiff_t is int. !x64 */
- case DASM_IMM_D: ofs += 4; break;
- case DASM_IMM_S: CK(((n+128)&-256) == 0, RANGE_I); goto ob;
- case DASM_IMM_B: CK((n&-256) == 0, RANGE_I); ob: ofs++; break;
- case DASM_IMM_WB: if (((n+128)&-256) == 0) goto ob;
- case DASM_IMM_W: CK((n&-65536) == 0, RANGE_I); ofs += 2; break;
- case DASM_SPACE: p++; ofs += n; break;
- case DASM_SETLABEL: b[pos-2] = -0x40000000; break; /* Neg. label ofs. */
- case DASM_VREG: CK((n&-8) == 0 && (n != 4 || (*p&1) == 0), RANGE_VREG);
- if (*p++ == 1 && *p == DASM_DISP) mrm = n; continue;
- }
- mrm = 4;
- } else {
- int *pl, n;
- switch (action) {
- case DASM_REL_LG:
- case DASM_IMM_LG:
- n = *p++; pl = D->lglabels + n;
- if (n <= 246) { CKPL(lg, LG); goto putrel; } /* Bkwd rel or global. */
- pl -= 246; n = *pl;
- if (n < 0) n = 0; /* Start new chain for fwd rel if label exists. */
- goto linkrel;
- case DASM_REL_PC:
- case DASM_IMM_PC: pl = D->pclabels + va_arg(ap, int); CKPL(pc, PC);
- putrel:
- n = *pl;
- if (n < 0) { /* Label exists. Get label pos and store it. */
- b[pos] = -n;
- } else {
- linkrel:
- b[pos] = n; /* Else link to rel chain, anchored at label. */
- *pl = pos;
- }
- pos++;
- ofs += 4; /* Maximum offset needed. */
- if (action == DASM_REL_LG || action == DASM_REL_PC)
- b[pos++] = ofs; /* Store pass1 offset estimate. */
- break;
- case DASM_LABEL_LG: pl = D->lglabels + *p++; CKPL(lg, LG); goto putlabel;
- case DASM_LABEL_PC: pl = D->pclabels + va_arg(ap, int); CKPL(pc, PC);
- putlabel:
- n = *pl; /* n > 0: Collapse rel chain and replace with label pos. */
- while (n > 0) { int *pb = DASM_POS2PTR(D, n); n = *pb; *pb = pos; }
- *pl = -pos; /* Label exists now. */
- b[pos++] = ofs; /* Store pass1 offset estimate. */
- break;
- case DASM_ALIGN:
- ofs += *p++; /* Maximum alignment needed (arg is 2**n-1). */
- b[pos++] = ofs; /* Store pass1 offset estimate. */
- break;
- case DASM_EXTERN: p += 2; ofs += 4; break;
- case DASM_ESC: p++; ofs++; break;
- case DASM_MARK: mrm = p[-2]; break;
- case DASM_SECTION:
- n = *p; CK(n < D->maxsection, RANGE_SEC); D->section = &D->sections[n];
- case DASM_STOP: goto stop;
- }
- }
- }
-stop:
- va_end(ap);
- sec->pos = pos;
- sec->ofs = ofs;
-}
-#undef CK
-
-/* Pass 2: Link sections, shrink branches/aligns, fix label offsets. */
-int dasm_link(Dst_DECL, size_t *szp)
-{
- dasm_State *D = Dst_REF;
- int secnum;
- int ofs = 0;
-
-#ifdef DASM_CHECKS
- *szp = 0;
- if (D->status != DASM_S_OK) return D->status;
- {
- int pc;
- for (pc = 0; pc*sizeof(int) < D->pcsize; pc++)
- if (D->pclabels[pc] > 0) return DASM_S_UNDEF_PC|pc;
- }
-#endif
-
- { /* Handle globals not defined in this translation unit. */
- int idx;
- for (idx = 10; idx*sizeof(int) < D->lgsize; idx++) {
- int n = D->lglabels[idx];
- /* Undefined label: Collapse rel chain and replace with marker (< 0). */
- while (n > 0) { int *pb = DASM_POS2PTR(D, n); n = *pb; *pb = -idx; }
- }
- }
-
- /* Combine all code sections. No support for data sections (yet). */
- for (secnum = 0; secnum < D->maxsection; secnum++) {
- dasm_Section *sec = D->sections + secnum;
- int *b = sec->rbuf;
- int pos = DASM_SEC2POS(secnum);
- int lastpos = sec->pos;
-
- while (pos != lastpos) {
- dasm_ActList p = D->actionlist + b[pos++];
- while (1) {
- int op, action = *p++;
- switch (action) {
- case DASM_REL_LG: p++; op = p[-3]; goto rel_pc;
- case DASM_REL_PC: op = p[-2]; rel_pc: {
- int shrink = op == 0xe9 ? 3 : ((op&0xf0) == 0x80 ? 4 : 0);
- if (shrink) { /* Shrinkable branch opcode? */
- int lofs, lpos = b[pos];
- if (lpos < 0) goto noshrink; /* Ext global? */
- lofs = *DASM_POS2PTR(D, lpos);
- if (lpos > pos) { /* Fwd label: add cumulative section offsets. */
- int i;
- for (i = secnum; i < DASM_POS2SEC(lpos); i++)
- lofs += D->sections[i].ofs;
- } else {
- lofs -= ofs; /* Bkwd label: unfix offset. */
- }
- lofs -= b[pos+1]; /* Short branch ok? */
- if (lofs >= -128-shrink && lofs <= 127) ofs -= shrink; /* Yes. */
- else { noshrink: shrink = 0; } /* No, cannot shrink op. */
- }
- b[pos+1] = shrink;
- pos += 2;
- break;
- }
- case DASM_SPACE: case DASM_IMM_LG: case DASM_VREG: p++;
- case DASM_DISP: case DASM_IMM_S: case DASM_IMM_B: case DASM_IMM_W:
- case DASM_IMM_D: case DASM_IMM_WB: case DASM_IMM_DB:
- case DASM_SETLABEL: case DASM_REL_A: case DASM_IMM_PC: pos++; break;
- case DASM_LABEL_LG: p++;
- case DASM_LABEL_PC: b[pos++] += ofs; break; /* Fix label offset. */
- case DASM_ALIGN: ofs -= (b[pos++]+ofs)&*p++; break; /* Adjust ofs. */
- case DASM_EXTERN: p += 2; break;
- case DASM_ESC: p++; break;
- case DASM_MARK: break;
- case DASM_SECTION: case DASM_STOP: goto stop;
- }
- }
- stop: (void)0;
- }
- ofs += sec->ofs; /* Next section starts right after current section. */
- }
-
- D->codesize = ofs; /* Total size of all code sections */
- *szp = ofs;
- return DASM_S_OK;
-}
-
-#define dasmb(x) *cp++ = (unsigned char)(x)
-#ifndef DASM_ALIGNED_WRITES
-#define dasmw(x) \
- do { *((unsigned short *)cp) = (unsigned short)(x); cp+=2; } while (0)
-#define dasmd(x) \
- do { *((unsigned int *)cp) = (unsigned int)(x); cp+=4; } while (0)
-#else
-#define dasmw(x) do { dasmb(x); dasmb((x)>>8); } while (0)
-#define dasmd(x) do { dasmw(x); dasmw((x)>>16); } while (0)
-#endif
-
-/* Pass 3: Encode sections. */
-int dasm_encode(Dst_DECL, void *buffer)
-{
- dasm_State *D = Dst_REF;
- unsigned char *base = (unsigned char *)buffer;
- unsigned char *cp = base;
- int secnum;
-
- /* Encode all code sections. No support for data sections (yet). */
- for (secnum = 0; secnum < D->maxsection; secnum++) {
- dasm_Section *sec = D->sections + secnum;
- int *b = sec->buf;
- int *endb = sec->rbuf + sec->pos;
-
- while (b != endb) {
- dasm_ActList p = D->actionlist + *b++;
- unsigned char *mark = NULL;
- while (1) {
- int action = *p++;
- int n = (action >= DASM_DISP && action <= DASM_ALIGN) ? *b++ : 0;
- switch (action) {
- case DASM_DISP: if (!mark) mark = cp; {
- unsigned char *mm = mark;
- if (*p != DASM_IMM_DB && *p != DASM_IMM_WB) mark = NULL;
- if (n == 0) { int mrm = mm[-1]&7; if (mrm == 4) mrm = mm[0]&7;
- if (mrm != 5) { mm[-1] -= 0x80; break; } }
- if (((n+128) & -256) != 0) goto wd; else mm[-1] -= 0x40;
- }
- case DASM_IMM_S: case DASM_IMM_B: wb: dasmb(n); break;
- case DASM_IMM_DB: if (((n+128)&-256) == 0) {
- db: if (!mark) mark = cp; mark[-2] += 2; mark = NULL; goto wb;
- } else mark = NULL;
- case DASM_IMM_D: wd: dasmd(n); break;
- case DASM_IMM_WB: if (((n+128)&-256) == 0) goto db; else mark = NULL;
- case DASM_IMM_W: dasmw(n); break;
- case DASM_VREG: { int t = *p++; if (t >= 2) n<<=3; cp[-1] |= n; break; }
- case DASM_REL_LG: p++; if (n >= 0) goto rel_pc;
- b++; n = (int)(ptrdiff_t)D->globals[-n];
- case DASM_REL_A: rel_a: n -= (int)(ptrdiff_t)(cp+4); goto wd; /* !x64 */
- case DASM_REL_PC: rel_pc: {
- int shrink = *b++;
- int *pb = DASM_POS2PTR(D, n); if (*pb < 0) { n = pb[1]; goto rel_a; }
- n = *pb - ((int)(cp-base) + 4-shrink);
- if (shrink == 0) goto wd;
- if (shrink == 4) { cp--; cp[-1] = *cp-0x10; } else cp[-1] = 0xeb;
- goto wb;
- }
- case DASM_IMM_LG:
- p++; if (n < 0) { n = (int)(ptrdiff_t)D->globals[-n]; goto wd; }
- case DASM_IMM_PC: {
- int *pb = DASM_POS2PTR(D, n);
- n = *pb < 0 ? pb[1] : (*pb + (int)(ptrdiff_t)base);
- goto wd;
- }
- case DASM_LABEL_LG: {
- int idx = *p++;
- if (idx >= 10)
- D->globals[idx] = (void *)(base + (*p == DASM_SETLABEL ? *b : n));
- break;
- }
- case DASM_LABEL_PC: case DASM_SETLABEL: break;
- case DASM_SPACE: { int fill = *p++; while (n--) *cp++ = fill; break; }
- case DASM_ALIGN:
- n = *p++;
- while (((cp-base) & n)) *cp++ = 0x90; /* nop */
- break;
- case DASM_EXTERN: n = DASM_EXTERN(Dst, cp, p[1], *p); p += 2; goto wd;
- case DASM_MARK: mark = cp; break;
- case DASM_ESC: action = *p++;
- default: *cp++ = action; break;
- case DASM_SECTION: case DASM_STOP: goto stop;
- }
- }
- stop: (void)0;
- }
- }
-
- if (base + D->codesize != cp) /* Check for phase errors. */
- return DASM_S_PHASE;
- return DASM_S_OK;
-}
-
-/* Get PC label offset. */
-int dasm_getpclabel(Dst_DECL, unsigned int pc)
-{
- dasm_State *D = Dst_REF;
- if (pc*sizeof(int) < D->pcsize) {
- int pos = D->pclabels[pc];
- if (pos < 0) return *DASM_POS2PTR(D, -pos);
- if (pos > 0) return -1; /* Undefined. */
- }
- return -2; /* Unused or out of range. */
-}
-
-#ifdef DASM_CHECKS
-/* Optional sanity checker to call between isolated encoding steps. */
-int dasm_checkstep(Dst_DECL, int secmatch)
-{
- dasm_State *D = Dst_REF;
- if (D->status == DASM_S_OK) {
- int i;
- for (i = 1; i <= 9; i++) {
- if (D->lglabels[i] > 0) { D->status = DASM_S_UNDEF_L|i; break; }
- D->lglabels[i] = 0;
- }
- }
- if (D->status == DASM_S_OK && secmatch >= 0 &&
- D->section != &D->sections[secmatch])
- D->status = DASM_S_MATCH_SEC|(int)(D->section-D->sections);
- return D->status;
-}
-#endif
-
diff --git a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_x86.lua b/plugins/MirLua/Modules/ffi/src/dynasm/dasm_x86.lua deleted file mode 100644 index efaa290441..0000000000 --- a/plugins/MirLua/Modules/ffi/src/dynasm/dasm_x86.lua +++ /dev/null @@ -1,1931 +0,0 @@ -------------------------------------------------------------------------------
--- DynASM x86/x64 module.
---
--- Copyright (C) 2005-2011 Mike Pall. All rights reserved.
--- See dynasm.lua for full copyright notice.
-------------------------------------------------------------------------------
-
-local x64 = x64
-
--- Module information:
-local _info = {
- arch = x64 and "x64" or "x86",
- description = "DynASM x86/x64 module",
- version = "1.3.0",
- vernum = 10300,
- release = "2011-05-05",
- author = "Mike Pall",
- license = "MIT",
-}
-
--- Exported glue functions for the arch-specific module.
-local _M = { _info = _info }
-
--- Cache library functions.
-local type, tonumber, pairs, ipairs = type, tonumber, pairs, ipairs
-local assert, unpack, setmetatable = assert, unpack or table.unpack, setmetatable
-local _s = string
-local sub, format, byte, char = _s.sub, _s.format, _s.byte, _s.char
-local find, match, gmatch, gsub = _s.find, _s.match, _s.gmatch, _s.gsub
-local concat, sort = table.concat, table.sort
-
--- Inherited tables and callbacks.
-local g_opt, g_arch
-local wline, werror, wfatal, wwarn
-
--- Action name list.
--- CHECK: Keep this in sync with the C code!
-local action_names = {
- -- int arg, 1 buffer pos:
- "DISP", "IMM_S", "IMM_B", "IMM_W", "IMM_D", "IMM_WB", "IMM_DB",
- -- action arg (1 byte), int arg, 1 buffer pos (reg/num):
- "VREG", "SPACE", -- !x64: VREG support NYI.
- -- ptrdiff_t arg, 1 buffer pos (address): !x64
- "SETLABEL", "REL_A",
- -- action arg (1 byte) or int arg, 2 buffer pos (link, offset):
- "REL_LG", "REL_PC",
- -- action arg (1 byte) or int arg, 1 buffer pos (link):
- "IMM_LG", "IMM_PC",
- -- action arg (1 byte) or int arg, 1 buffer pos (offset):
- "LABEL_LG", "LABEL_PC",
- -- action arg (1 byte), 1 buffer pos (offset):
- "ALIGN",
- -- action args (2 bytes), no buffer pos.
- "EXTERN",
- -- action arg (1 byte), no buffer pos.
- "ESC",
- -- no action arg, no buffer pos.
- "MARK",
- -- action arg (1 byte), no buffer pos, terminal action:
- "SECTION",
- -- no args, no buffer pos, terminal action:
- "STOP"
-}
-
--- Maximum number of section buffer positions for dasm_put().
--- CHECK: Keep this in sync with the C code!
-local maxsecpos = 25 -- Keep this low, to avoid excessively long C lines.
-
--- Action name -> action number (dynamically generated below).
-local map_action = {}
--- First action number. Everything below does not need to be escaped.
-local actfirst = 256-#action_names
-
--- Action list buffer and string (only used to remove dupes).
-local actlist = {}
-local actstr = ""
-
--- Argument list for next dasm_put(). Start with offset 0 into action list.
-local actargs = { 0 }
-
--- Current number of section buffer positions for dasm_put().
-local secpos = 1
-
-------------------------------------------------------------------------------
-
--- Compute action numbers for action names.
-for n,name in ipairs(action_names) do
- local num = actfirst + n - 1
- map_action[name] = num
-end
-
--- Dump action names and numbers.
-local function dumpactions(out)
- out:write("DynASM encoding engine action codes:\n")
- for n,name in ipairs(action_names) do
- local num = map_action[name]
- out:write(format(" %-10s %02X %d\n", name, num, num))
- end
- out:write("\n")
-end
-
--- Write action list buffer as a huge static C array.
-local function writeactions(out, name)
- local nn = #actlist
- local last = actlist[nn] or 255
- actlist[nn] = nil -- Remove last byte.
- if nn == 0 then nn = 1 end
- out:write("static const unsigned char ", name, "[", nn, "] = {\n")
- local s = " "
- for n,b in ipairs(actlist) do
- s = s..b..","
- if #s >= 75 then
- assert(out:write(s, "\n"))
- s = " "
- end
- end
- out:write(s, last, "\n};\n\n") -- Add last byte back.
-end
-
-------------------------------------------------------------------------------
-
--- Add byte to action list.
-local function wputxb(n)
- assert(n >= 0 and n <= 255 and n % 1 == 0, "byte out of range")
- actlist[#actlist+1] = n
-end
-
--- Add action to list with optional arg. Advance buffer pos, too.
-local function waction(action, a, num)
- wputxb(assert(map_action[action], "bad action name `"..action.."'"))
- if a then actargs[#actargs+1] = a end
- if a or num then secpos = secpos + (num or 1) end
-end
-
--- Add call to embedded DynASM C code.
-local function wcall(func, args)
- wline(format("dasm_%s(Dst, %s);", func, concat(args, ", ")), true)
-end
-
--- Delete duplicate action list chunks. A tad slow, but so what.
-local function dedupechunk(offset)
- local al, as = actlist, actstr
- local chunk = char(unpack(al, offset+1, #al))
- local orig = find(as, chunk, 1, true)
- if orig then
- actargs[1] = orig-1 -- Replace with original offset.
- for i=offset+1,#al do al[i] = nil end -- Kill dupe.
- else
- actstr = as..chunk
- end
-end
-
--- Flush action list (intervening C code or buffer pos overflow).
-local function wflush(term)
- local offset = actargs[1]
- if #actlist == offset then return end -- Nothing to flush.
- if not term then waction("STOP") end -- Terminate action list.
- dedupechunk(offset)
- wcall("put", actargs) -- Add call to dasm_put().
- actargs = { #actlist } -- Actionlist offset is 1st arg to next dasm_put().
- secpos = 1 -- The actionlist offset occupies a buffer position, too.
-end
-
--- Put escaped byte.
-local function wputb(n)
- if n >= actfirst then waction("ESC") end -- Need to escape byte.
- wputxb(n)
-end
-
-------------------------------------------------------------------------------
-
--- Global label name -> global label number. With auto assignment on 1st use.
-local next_global = 10
-local map_global = setmetatable({}, { __index = function(t, name)
- if not match(name, "^[%a_][%w_@]*$") then werror("bad global label") end
- local n = next_global
- if n > 246 then werror("too many global labels") end
- next_global = n + 1
- t[name] = n
- return n
-end})
-
--- Dump global labels.
-local function dumpglobals(out, lvl)
- local t = {}
- for name, n in pairs(map_global) do t[n] = name end
- out:write("Global labels:\n")
- for i=10,next_global-1 do
- out:write(format(" %s\n", t[i]))
- end
- out:write("\n")
-end
-
--- Write global label enum.
-local function writeglobals(out, prefix)
- local t = {}
- for name, n in pairs(map_global) do t[n] = name end
- out:write("enum {\n")
- for i=10,next_global-1 do
- out:write(" ", prefix, gsub(t[i], "@.*", ""), ",\n")
- end
- out:write(" ", prefix, "_MAX\n};\n")
-end
-
--- Write global label names.
-local function writeglobalnames(out, name)
- local t = {}
- for name, n in pairs(map_global) do t[n] = name end
- out:write("static const char *const ", name, "[] = {\n")
- for i=10,next_global-1 do
- out:write(" \"", t[i], "\",\n")
- end
- out:write(" (const char *)0\n};\n")
-end
-
-------------------------------------------------------------------------------
-
--- Extern label name -> extern label number. With auto assignment on 1st use.
-local next_extern = -1
-local map_extern = setmetatable({}, { __index = function(t, name)
- -- No restrictions on the name for now.
- local n = next_extern
- if n < -256 then werror("too many extern labels") end
- next_extern = n - 1
- t[name] = n
- return n
-end})
-
--- Dump extern labels.
-local function dumpexterns(out, lvl)
- local t = {}
- for name, n in pairs(map_extern) do t[-n] = name end
- out:write("Extern labels:\n")
- for i=1,-next_extern-1 do
- out:write(format(" %s\n", t[i]))
- end
- out:write("\n")
-end
-
--- Write extern label names.
-local function writeexternnames(out, name)
- local t = {}
- for name, n in pairs(map_extern) do t[-n] = name end
- out:write("static const char *const ", name, "[] = {\n")
- for i=1,-next_extern-1 do
- out:write(" \"", t[i], "\",\n")
- end
- out:write(" (const char *)0\n};\n")
-end
-
-------------------------------------------------------------------------------
-
--- Arch-specific maps.
-local map_archdef = {} -- Ext. register name -> int. name.
-local map_reg_rev = {} -- Int. register name -> ext. name.
-local map_reg_num = {} -- Int. register name -> register number.
-local map_reg_opsize = {} -- Int. register name -> operand size.
-local map_reg_valid_base = {} -- Int. register name -> valid base register?
-local map_reg_valid_index = {} -- Int. register name -> valid index register?
-local map_reg_needrex = {} -- Int. register name -> need rex vs. no rex.
-local reg_list = {} -- Canonical list of int. register names.
-
-local map_type = {} -- Type name -> { ctype, reg }
-local ctypenum = 0 -- Type number (for _PTx macros).
-
-local addrsize = x64 and "q" or "d" -- Size for address operands.
-
--- Helper functions to fill register maps.
-local function mkrmap(sz, cl, names)
- local cname = format("@%s", sz)
- reg_list[#reg_list+1] = cname
- map_archdef[cl] = cname
- map_reg_rev[cname] = cl
- map_reg_num[cname] = -1
- map_reg_opsize[cname] = sz
- if sz == addrsize or sz == "d" then
- map_reg_valid_base[cname] = true
- map_reg_valid_index[cname] = true
- end
- if names then
- for n,name in ipairs(names) do
- local iname = format("@%s%x", sz, n-1)
- reg_list[#reg_list+1] = iname
- map_archdef[name] = iname
- map_reg_rev[iname] = name
- map_reg_num[iname] = n-1
- map_reg_opsize[iname] = sz
- if sz == "b" and n > 4 then map_reg_needrex[iname] = false end
- if sz == addrsize or sz == "d" then
- map_reg_valid_base[iname] = true
- map_reg_valid_index[iname] = true
- end
- end
- end
- for i=0,(x64 and sz ~= "f") and 15 or 7 do
- local needrex = sz == "b" and i > 3
- local iname = format("@%s%x%s", sz, i, needrex and "R" or "")
- if needrex then map_reg_needrex[iname] = true end
- local name
- if sz == "o" then name = format("xmm%d", i)
- elseif sz == "f" then name = format("st%d", i)
- else name = format("r%d%s", i, sz == addrsize and "" or sz) end
- map_archdef[name] = iname
- if not map_reg_rev[iname] then
- reg_list[#reg_list+1] = iname
- map_reg_rev[iname] = name
- map_reg_num[iname] = i
- map_reg_opsize[iname] = sz
- if sz == addrsize or sz == "d" then
- map_reg_valid_base[iname] = true
- map_reg_valid_index[iname] = true
- end
- end
- end
- reg_list[#reg_list+1] = ""
-end
-
--- Integer registers (qword, dword, word and byte sized).
-if x64 then
- mkrmap("q", "Rq", {"rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi"})
-end
-mkrmap("d", "Rd", {"eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi"})
-mkrmap("w", "Rw", {"ax", "cx", "dx", "bx", "sp", "bp", "si", "di"})
-mkrmap("b", "Rb", {"al", "cl", "dl", "bl", "ah", "ch", "dh", "bh"})
-map_reg_valid_index[map_archdef.esp] = false
-if x64 then map_reg_valid_index[map_archdef.rsp] = false end
-map_archdef["Ra"] = "@"..addrsize
-
--- FP registers (internally tword sized, but use "f" as operand size).
-mkrmap("f", "Rf")
-
--- SSE registers (oword sized, but qword and dword accessible).
-mkrmap("o", "xmm")
-
--- Operand size prefixes to codes.
-local map_opsize = {
- byte = "b", word = "w", dword = "d", qword = "q", oword = "o", tword = "t",
- aword = addrsize,
-}
-
--- Operand size code to number.
-local map_opsizenum = {
- b = 1, w = 2, d = 4, q = 8, o = 16, t = 10,
-}
-
--- Operand size code to name.
-local map_opsizename = {
- b = "byte", w = "word", d = "dword", q = "qword", o = "oword", t = "tword",
- f = "fpword",
-}
-
--- Valid index register scale factors.
-local map_xsc = {
- ["1"] = 0, ["2"] = 1, ["4"] = 2, ["8"] = 3,
-}
-
--- Condition codes.
-local map_cc = {
- o = 0, no = 1, b = 2, nb = 3, e = 4, ne = 5, be = 6, nbe = 7,
- s = 8, ns = 9, p = 10, np = 11, l = 12, nl = 13, le = 14, nle = 15,
- c = 2, nae = 2, nc = 3, ae = 3, z = 4, nz = 5, na = 6, a = 7,
- pe = 10, po = 11, nge = 12, ge = 13, ng = 14, g = 15,
-}
-
-
--- Reverse defines for registers.
-function _M.revdef(s)
- return gsub(s, "@%w+", map_reg_rev)
-end
-
--- Dump register names and numbers
-local function dumpregs(out)
- out:write("Register names, sizes and internal numbers:\n")
- for _,reg in ipairs(reg_list) do
- if reg == "" then
- out:write("\n")
- else
- local name = map_reg_rev[reg]
- local num = map_reg_num[reg]
- local opsize = map_opsizename[map_reg_opsize[reg]]
- out:write(format(" %-5s %-8s %s\n", name, opsize,
- num < 0 and "(variable)" or num))
- end
- end
-end
-
-------------------------------------------------------------------------------
-
--- Put action for label arg (IMM_LG, IMM_PC, REL_LG, REL_PC).
-local function wputlabel(aprefix, imm, num)
- if type(imm) == "number" then
- if imm < 0 then
- waction("EXTERN")
- wputxb(aprefix == "IMM_" and 0 or 1)
- imm = -imm-1
- else
- waction(aprefix.."LG", nil, num);
- end
- wputxb(imm)
- else
- waction(aprefix.."PC", imm, num)
- end
-end
-
--- Put signed byte or arg.
-local function wputsbarg(n)
- if type(n) == "number" then
- if n < -128 or n > 127 then
- werror("signed immediate byte out of range")
- end
- if n < 0 then n = n + 256 end
- wputb(n)
- else waction("IMM_S", n) end
-end
-
--- Put unsigned byte or arg.
-local function wputbarg(n)
- if type(n) == "number" then
- if n < 0 or n > 255 then
- werror("unsigned immediate byte out of range")
- end
- wputb(n)
- else waction("IMM_B", n) end
-end
-
--- Put unsigned word or arg.
-local function wputwarg(n)
- if type(n) == "number" then
- if n < 0 or n > 65535 then
- werror("unsigned immediate word out of range")
- end
- local r = n%256; n = (n-r)/256; wputb(r); wputb(n);
- else waction("IMM_W", n) end
-end
-
--- Put signed or unsigned dword or arg.
-local function wputdarg(n)
- local tn = type(n)
- if tn == "number" then
- if n < 0 then n = n + 4294967296 end
- local r = n%256; n = (n-r)/256; wputb(r);
- r = n%256; n = (n-r)/256; wputb(r);
- r = n%256; n = (n-r)/256; wputb(r); wputb(n);
- elseif tn == "table" then
- wputlabel("IMM_", n[1], 1)
- else
- waction("IMM_D", n)
- end
-end
-
--- Put operand-size dependent number or arg (defaults to dword).
-local function wputszarg(sz, n)
- if not sz or sz == "d" or sz == "q" then wputdarg(n)
- elseif sz == "w" then wputwarg(n)
- elseif sz == "b" then wputbarg(n)
- elseif sz == "s" then wputsbarg(n)
- else werror("bad operand size") end
-end
-
--- Put multi-byte opcode with operand-size dependent modifications.
-local function wputop(sz, op, rex)
- local r
- if rex ~= 0 and not x64 then werror("bad operand size") end
- if sz == "w" then wputb(102) end
- -- Needs >32 bit numbers, but only for crc32 eax, word [ebx]
- if op >= 4294967296 then r = op%4294967296 wputb((op-r)/4294967296) op = r end
- if op >= 16777216 then r = op % 16777216 wputb((op-r) / 16777216) op = r end
- if op >= 65536 then
- if rex ~= 0 then
- local opc3 = op - op % 256
- if opc3 == 0x0f3a00 or opc3 == 0x0f3800 then
- wputb(64 + rex % 16); rex = 0
- end
- end
- r = op % 65536 wputb((op-r) / 65536) op = r
- end
- if op >= 256 then
- r = op % 256
- local b = (op-r) / 256
- if b == 15 and rex ~= 0 then wputb(64 + rex % 16); rex = 0 end
- wputb(b)
- op = r
- end
- if rex ~= 0 then wputb(64 + rex % 16) end
- if sz == "b" then op = op - 1 end
- wputb(op)
-end
-
--- Put ModRM or SIB formatted byte.
-local function wputmodrm(m, s, rm, vs, vrm)
- assert(m < 4 and s < 16 and rm < 16, "bad modrm operands")
- wputb(64*m + 8*(s%8) + (rm%8))
-end
-
--- Put ModRM/SIB plus optional displacement.
-local function wputmrmsib(t, imark, s, vsreg)
- local vreg, vxreg
- local reg, xreg = t.reg, t.xreg
- if reg and reg < 0 then reg = 0; vreg = t.vreg end
- if xreg and xreg < 0 then xreg = 0; vxreg = t.vxreg end
- if s < 0 then s = 0 end
-
- -- Register mode.
- if sub(t.mode, 1, 1) == "r" then
- wputmodrm(3, s, reg)
- if vsreg then waction("VREG", vsreg); wputxb(2) end
- if vreg then waction("VREG", vreg); wputxb(0) end
- return
- end
-
- local disp = t.disp
- local tdisp = type(disp)
- -- No base register?
- if not reg then
- local riprel = false
- if xreg then
- -- Indexed mode with index register only.
- -- [xreg*xsc+disp] -> (0, s, esp) (xsc, xreg, ebp)
- wputmodrm(0, s, 4)
- if imark == "I" then waction("MARK") end
- if vsreg then waction("VREG", vsreg); wputxb(2) end
- wputmodrm(t.xsc, xreg, 5)
- if vxreg then waction("VREG", vxreg); wputxb(3) end
- else
- -- Pure 32 bit displacement.
- if x64 and tdisp ~= "table" then
- wputmodrm(0, s, 4) -- [disp] -> (0, s, esp) (0, esp, ebp)
- if imark == "I" then waction("MARK") end
- wputmodrm(0, 4, 5)
- else
- riprel = x64
- wputmodrm(0, s, 5) -- [disp|rip-label] -> (0, s, ebp)
- if imark == "I" then waction("MARK") end
- end
- if vsreg then waction("VREG", vsreg); wputxb(2) end
- end
- if riprel then -- Emit rip-relative displacement.
- if match("UWSiI", imark) then
- werror("NYI: rip-relative displacement followed by immediate")
- end
- -- The previous byte in the action buffer cannot be 0xe9 or 0x80-0x8f.
- wputlabel("REL_", disp[1], 2)
- else
- wputdarg(disp)
- end
- return
- end
-
- local m
- if tdisp == "number" then -- Check displacement size at assembly time.
- if disp == 0 and (reg%8) ~= 5 then -- [ebp] -> [ebp+0] (in SIB, too)
- if not vreg then m = 0 end -- Force DISP to allow [Rd(5)] -> [ebp+0]
- elseif disp >= -128 and disp <= 127 then m = 1
- else m = 2 end
- elseif tdisp == "table" then
- m = 2
- end
-
- -- Index register present or esp as base register: need SIB encoding.
- if xreg or (reg%8) == 4 then
- wputmodrm(m or 2, s, 4) -- ModRM.
- if m == nil or imark == "I" then waction("MARK") end
- if vsreg then waction("VREG", vsreg); wputxb(2) end
- wputmodrm(t.xsc or 0, xreg or 4, reg) -- SIB.
- if vxreg then waction("VREG", vxreg); wputxb(3) end
- if vreg then waction("VREG", vreg); wputxb(1) end
- else
- wputmodrm(m or 2, s, reg) -- ModRM.
- if (imark == "I" and (m == 1 or m == 2)) or
- (m == nil and (vsreg or vreg)) then waction("MARK") end
- if vsreg then waction("VREG", vsreg); wputxb(2) end
- if vreg then waction("VREG", vreg); wputxb(1) end
- end
-
- -- Put displacement.
- if m == 1 then wputsbarg(disp)
- elseif m == 2 then wputdarg(disp)
- elseif m == nil then waction("DISP", disp) end
-end
-
-------------------------------------------------------------------------------
-
--- Return human-readable operand mode string.
-local function opmodestr(op, args)
- local m = {}
- for i=1,#args do
- local a = args[i]
- m[#m+1] = sub(a.mode, 1, 1)..(a.opsize or "?")
- end
- return op.." "..concat(m, ",")
-end
-
--- Convert number to valid integer or nil.
-local function toint(expr)
- local n = tonumber(expr)
- if n then
- if n % 1 ~= 0 or n < -2147483648 or n > 4294967295 then
- werror("bad integer number `"..expr.."'")
- end
- return n
- end
-end
-
--- Parse immediate expression.
-local function immexpr(expr)
- -- &expr (pointer)
- if sub(expr, 1, 1) == "&" then
- return "iPJ", format("(ptrdiff_t)(%s)", sub(expr,2))
- end
-
- local prefix = sub(expr, 1, 2)
- -- =>expr (pc label reference)
- if prefix == "=>" then
- return "iJ", sub(expr, 3)
- end
- -- ->name (global label reference)
- if prefix == "->" then
- return "iJ", map_global[sub(expr, 3)]
- end
-
- -- [<>][1-9] (local label reference)
- local dir, lnum = match(expr, "^([<>])([1-9])$")
- if dir then -- Fwd: 247-255, Bkwd: 1-9.
- return "iJ", lnum + (dir == ">" and 246 or 0)
- end
-
- local extname = match(expr, "^extern%s+(%S+)$")
- if extname then
- return "iJ", map_extern[extname]
- end
-
- -- expr (interpreted as immediate)
- return "iI", expr
-end
-
--- Parse displacement expression: +-num, +-expr, +-opsize*num
-local function dispexpr(expr)
- local disp = expr == "" and 0 or toint(expr)
- if disp then return disp end
- local c, dispt = match(expr, "^([+-])%s*(.+)$")
- if c == "+" then
- expr = dispt
- elseif not c then
- werror("bad displacement expression `"..expr.."'")
- end
- local opsize, tailops = match(dispt, "^(%w+)%s*%*%s*(.+)$")
- local ops, imm = map_opsize[opsize], toint(tailops)
- if ops and imm then
- if c == "-" then imm = -imm end
- return imm*map_opsizenum[ops]
- end
- local mode, iexpr = immexpr(dispt)
- if mode == "iJ" then
- if c == "-" then werror("cannot invert label reference") end
- return { iexpr }
- end
- return expr -- Need to return original signed expression.
-end
-
--- Parse register or type expression.
-local function rtexpr(expr)
- if not expr then return end
- local tname, ovreg = match(expr, "^([%w_]+):(@[%w_]+)$")
- local tp = map_type[tname or expr]
- if tp then
- local reg = ovreg or tp.reg
- local rnum = map_reg_num[reg]
- if not rnum then
- werror("type `"..(tname or expr).."' needs a register override")
- end
- if not map_reg_valid_base[reg] then
- werror("bad base register override `"..(map_reg_rev[reg] or reg).."'")
- end
- return reg, rnum, tp
- end
- return expr, map_reg_num[expr]
-end
-
--- Parse operand and return { mode, opsize, reg, xreg, xsc, disp, imm }.
-local function parseoperand(param)
- local t = {}
-
- local expr = param
- local opsize, tailops = match(param, "^(%w+)%s*(.+)$")
- if opsize then
- t.opsize = map_opsize[opsize]
- if t.opsize then expr = tailops end
- end
-
- local br = match(expr, "^%[%s*(.-)%s*%]$")
- repeat
- if br then
- t.mode = "xm"
-
- -- [disp]
- t.disp = toint(br)
- if t.disp then
- t.mode = x64 and "xm" or "xmO"
- break
- end
-
- -- [reg...]
- local tp
- local reg, tailr = match(br, "^([@%w_:]+)%s*(.*)$")
- reg, t.reg, tp = rtexpr(reg)
- if not t.reg then
- -- [expr]
- t.mode = x64 and "xm" or "xmO"
- t.disp = dispexpr("+"..br)
- break
- end
-
- if t.reg == -1 then
- t.vreg, tailr = match(tailr, "^(%b())(.*)$")
- if not t.vreg then werror("bad variable register expression") end
- end
-
- -- [xreg*xsc] or [xreg*xsc+-disp] or [xreg*xsc+-expr]
- local xsc, tailsc = match(tailr, "^%*%s*([1248])%s*(.*)$")
- if xsc then
- if not map_reg_valid_index[reg] then
- werror("bad index register `"..map_reg_rev[reg].."'")
- end
- t.xsc = map_xsc[xsc]
- t.xreg = t.reg
- t.vxreg = t.vreg
- t.reg = nil
- t.vreg = nil
- t.disp = dispexpr(tailsc)
- break
- end
- if not map_reg_valid_base[reg] then
- werror("bad base register `"..map_reg_rev[reg].."'")
- end
-
- -- [reg] or [reg+-disp]
- t.disp = toint(tailr) or (tailr == "" and 0)
- if t.disp then break end
-
- -- [reg+xreg...]
- local xreg, tailx = match(tailr, "^+%s*([@%w_:]+)%s*(.*)$")
- xreg, t.xreg, tp = rtexpr(xreg)
- if not t.xreg then
- -- [reg+-expr]
- t.disp = dispexpr(tailr)
- break
- end
- if not map_reg_valid_index[xreg] then
- werror("bad index register `"..map_reg_rev[xreg].."'")
- end
-
- if t.xreg == -1 then
- t.vxreg, tailx = match(tailx, "^(%b())(.*)$")
- if not t.vxreg then werror("bad variable register expression") end
- end
-
- -- [reg+xreg*xsc...]
- local xsc, tailsc = match(tailx, "^%*%s*([1248])%s*(.*)$")
- if xsc then
- t.xsc = map_xsc[xsc]
- tailx = tailsc
- end
-
- -- [...] or [...+-disp] or [...+-expr]
- t.disp = dispexpr(tailx)
- else
- -- imm or opsize*imm
- local imm = toint(expr)
- if not imm and sub(expr, 1, 1) == "*" and t.opsize then
- imm = toint(sub(expr, 2))
- if imm then
- imm = imm * map_opsizenum[t.opsize]
- t.opsize = nil
- end
- end
- if imm then
- if t.opsize then werror("bad operand size override") end
- local m = "i"
- if imm == 1 then m = m.."1" end
- if imm >= 4294967168 and imm <= 4294967295 then imm = imm-4294967296 end
- if imm >= -128 and imm <= 127 then m = m.."S" end
- t.imm = imm
- t.mode = m
- break
- end
-
- local tp
- local reg, tailr = match(expr, "^([@%w_:]+)%s*(.*)$")
- reg, t.reg, tp = rtexpr(reg)
- if t.reg then
- if t.reg == -1 then
- t.vreg, tailr = match(tailr, "^(%b())(.*)$")
- if not t.vreg then werror("bad variable register expression") end
- end
- -- reg
- if tailr == "" then
- if t.opsize then werror("bad operand size override") end
- t.opsize = map_reg_opsize[reg]
- if t.opsize == "f" then
- t.mode = t.reg == 0 and "fF" or "f"
- else
- if reg == "@w4" or (x64 and reg == "@d4") then
- wwarn("bad idea, try again with `"..(x64 and "rsp'" or "esp'"))
- end
- t.mode = t.reg == 0 and "rmR" or (reg == "@b1" and "rmC" or "rm")
- end
- t.needrex = map_reg_needrex[reg]
- break
- end
-
- -- type[idx], type[idx].field, type->field -> [reg+offset_expr]
- if not tp then werror("bad operand `"..param.."'") end
- t.mode = "xm"
- t.disp = format(tp.ctypefmt, tailr)
- else
- t.mode, t.imm = immexpr(expr)
- if sub(t.mode, -1) == "J" then
- if t.opsize and t.opsize ~= addrsize then
- werror("bad operand size override")
- end
- t.opsize = addrsize
- end
- end
- end
- until true
- return t
-end
-
-------------------------------------------------------------------------------
--- x86 Template String Description
--- ===============================
---
--- Each template string is a list of [match:]pattern pairs,
--- separated by "|". The first match wins. No match means a
--- bad or unsupported combination of operand modes or sizes.
---
--- The match part and the ":" is omitted if the operation has
--- no operands. Otherwise the first N characters are matched
--- against the mode strings of each of the N operands.
---
--- The mode string for each operand type is (see parseoperand()):
--- Integer register: "rm", +"R" for eax, ax, al, +"C" for cl
--- FP register: "f", +"F" for st0
--- Index operand: "xm", +"O" for [disp] (pure offset)
--- Immediate: "i", +"S" for signed 8 bit, +"1" for 1,
--- +"I" for arg, +"P" for pointer
--- Any: +"J" for valid jump targets
---
--- So a match character "m" (mixed) matches both an integer register
--- and an index operand (to be encoded with the ModRM/SIB scheme).
--- But "r" matches only a register and "x" only an index operand
--- (e.g. for FP memory access operations).
---
--- The operand size match string starts right after the mode match
--- characters and ends before the ":". "dwb" or "qdwb" is assumed, if empty.
--- The effective data size of the operation is matched against this list.
---
--- If only the regular "b", "w", "d", "q", "t" operand sizes are
--- present, then all operands must be the same size. Unspecified sizes
--- are ignored, but at least one operand must have a size or the pattern
--- won't match (use the "byte", "word", "dword", "qword", "tword"
--- operand size overrides. E.g.: mov dword [eax], 1).
---
--- If the list has a "1" or "2" prefix, the operand size is taken
--- from the respective operand and any other operand sizes are ignored.
--- If the list contains only ".", all operand sizes are ignored.
--- If the list has a "/" prefix, the concatenated (mixed) operand sizes
--- are compared to the match.
---
--- E.g. "rrdw" matches for either two dword registers or two word
--- registers. "Fx2dq" matches an st0 operand plus an index operand
--- pointing to a dword (float) or qword (double).
---
--- Every character after the ":" is part of the pattern string:
--- Hex chars are accumulated to form the opcode (left to right).
--- "n" disables the standard opcode mods
--- (otherwise: -1 for "b", o16 prefix for "w", rex.w for "q")
--- "X" Force REX.W.
--- "r"/"R" adds the reg. number from the 1st/2nd operand to the opcode.
--- "m"/"M" generates ModRM/SIB from the 1st/2nd operand.
--- The spare 3 bits are either filled with the last hex digit or
--- the result from a previous "r"/"R". The opcode is restored.
---
--- All of the following characters force a flush of the opcode:
--- "o"/"O" stores a pure 32 bit disp (offset) from the 1st/2nd operand.
--- "S" stores a signed 8 bit immediate from the last operand.
--- "U" stores an unsigned 8 bit immediate from the last operand.
--- "W" stores an unsigned 16 bit immediate from the last operand.
--- "i" stores an operand sized immediate from the last operand.
--- "I" dito, but generates an action code to optionally modify
--- the opcode (+2) for a signed 8 bit immediate.
--- "J" generates one of the REL action codes from the last operand.
---
-------------------------------------------------------------------------------
-
--- Template strings for x86 instructions. Ordered by first opcode byte.
--- Unimplemented opcodes (deliberate omissions) are marked with *.
-local map_op = {
- -- 00-05: add...
- -- 06: *push es
- -- 07: *pop es
- -- 08-0D: or...
- -- 0E: *push cs
- -- 0F: two byte opcode prefix
- -- 10-15: adc...
- -- 16: *push ss
- -- 17: *pop ss
- -- 18-1D: sbb...
- -- 1E: *push ds
- -- 1F: *pop ds
- -- 20-25: and...
- es_0 = "26",
- -- 27: *daa
- -- 28-2D: sub...
- cs_0 = "2E",
- -- 2F: *das
- -- 30-35: xor...
- ss_0 = "36",
- -- 37: *aaa
- -- 38-3D: cmp...
- ds_0 = "3E",
- -- 3F: *aas
- inc_1 = x64 and "m:FF0m" or "rdw:40r|m:FF0m",
- dec_1 = x64 and "m:FF1m" or "rdw:48r|m:FF1m",
- push_1 = (x64 and "rq:n50r|rw:50r|mq:nFF6m|mw:FF6m" or
- "rdw:50r|mdw:FF6m").."|S.:6AS|ib:n6Ai|i.:68i",
- pop_1 = x64 and "rq:n58r|rw:58r|mq:n8F0m|mw:8F0m" or "rdw:58r|mdw:8F0m",
- -- 60: *pusha, *pushad, *pushaw
- -- 61: *popa, *popad, *popaw
- -- 62: *bound rdw,x
- -- 63: x86: *arpl mw,rw
- movsxd_2 = x64 and "rm/qd:63rM",
- fs_0 = "64",
- gs_0 = "65",
- o16_0 = "66",
- a16_0 = not x64 and "67" or nil,
- a32_0 = x64 and "67",
- -- 68: push idw
- -- 69: imul rdw,mdw,idw
- -- 6A: push ib
- -- 6B: imul rdw,mdw,S
- -- 6C: *insb
- -- 6D: *insd, *insw
- -- 6E: *outsb
- -- 6F: *outsd, *outsw
- -- 70-7F: jcc lb
- -- 80: add... mb,i
- -- 81: add... mdw,i
- -- 82: *undefined
- -- 83: add... mdw,S
- test_2 = "mr:85Rm|rm:85rM|Ri:A9ri|mi:F70mi",
- -- 86: xchg rb,mb
- -- 87: xchg rdw,mdw
- -- 88: mov mb,r
- -- 89: mov mdw,r
- -- 8A: mov r,mb
- -- 8B: mov r,mdw
- -- 8C: *mov mdw,seg
- lea_2 = "rx1dq:8DrM",
- -- 8E: *mov seg,mdw
- -- 8F: pop mdw
- nop_0 = "90",
- xchg_2 = "Rrqdw:90R|rRqdw:90r|rm:87rM|mr:87Rm",
- cbw_0 = "6698",
- cwde_0 = "98",
- cdqe_0 = "4898",
- cwd_0 = "6699",
- cdq_0 = "99",
- cqo_0 = "4899",
- -- 9A: *call iw:idw
- wait_0 = "9B",
- fwait_0 = "9B",
- pushf_0 = "9C",
- pushfd_0 = not x64 and "9C",
- pushfq_0 = x64 and "9C",
- popf_0 = "9D",
- popfd_0 = not x64 and "9D",
- popfq_0 = x64 and "9D",
- sahf_0 = "9E",
- lahf_0 = "9F",
- mov_2 = "OR:A3o|RO:A1O|mr:89Rm|rm:8BrM|rib:nB0ri|ridw:B8ri|mi:C70mi",
- movsb_0 = "A4",
- movsw_0 = "66A5",
- movsd_0 = "A5",
- cmpsb_0 = "A6",
- cmpsw_0 = "66A7",
- cmpsd_0 = "A7",
- -- A8: test Rb,i
- -- A9: test Rdw,i
- stosb_0 = "AA",
- stosw_0 = "66AB",
- stosd_0 = "AB",
- lodsb_0 = "AC",
- lodsw_0 = "66AD",
- lodsd_0 = "AD",
- scasb_0 = "AE",
- scasw_0 = "66AF",
- scasd_0 = "AF",
- -- B0-B7: mov rb,i
- -- B8-BF: mov rdw,i
- -- C0: rol... mb,i
- -- C1: rol... mdw,i
- ret_1 = "i.:nC2W",
- ret_0 = "C3",
- -- C4: *les rdw,mq
- -- C5: *lds rdw,mq
- -- C6: mov mb,i
- -- C7: mov mdw,i
- -- C8: *enter iw,ib
- leave_0 = "C9",
- -- CA: *retf iw
- -- CB: *retf
- int3_0 = "CC",
- int_1 = "i.:nCDU",
- into_0 = "CE",
- -- CF: *iret
- -- D0: rol... mb,1
- -- D1: rol... mdw,1
- -- D2: rol... mb,cl
- -- D3: rol... mb,cl
- -- D4: *aam ib
- -- D5: *aad ib
- -- D6: *salc
- -- D7: *xlat
- -- D8-DF: floating point ops
- -- E0: *loopne
- -- E1: *loope
- -- E2: *loop
- -- E3: *jcxz, *jecxz
- -- E4: *in Rb,ib
- -- E5: *in Rdw,ib
- -- E6: *out ib,Rb
- -- E7: *out ib,Rdw
- call_1 = x64 and "mq:nFF2m|J.:E8nJ" or "md:FF2m|J.:E8J",
- jmp_1 = x64 and "mq:nFF4m|J.:E9nJ" or "md:FF4m|J.:E9J", -- short: EB
- -- EA: *jmp iw:idw
- -- EB: jmp ib
- -- EC: *in Rb,dx
- -- ED: *in Rdw,dx
- -- EE: *out dx,Rb
- -- EF: *out dx,Rdw
- -- F0: *lock
- int1_0 = "F1",
- repne_0 = "F2",
- repnz_0 = "F2",
- rep_0 = "F3",
- repe_0 = "F3",
- repz_0 = "F3",
- -- F4: *hlt
- cmc_0 = "F5",
- -- F6: test... mb,i; div... mb
- -- F7: test... mdw,i; div... mdw
- clc_0 = "F8",
- stc_0 = "F9",
- -- FA: *cli
- cld_0 = "FC",
- std_0 = "FD",
- -- FE: inc... mb
- -- FF: inc... mdw
-
- -- misc ops
- not_1 = "m:F72m",
- neg_1 = "m:F73m",
- mul_1 = "m:F74m",
- imul_1 = "m:F75m",
- div_1 = "m:F76m",
- idiv_1 = "m:F77m",
-
- imul_2 = "rmqdw:0FAFrM|rIqdw:69rmI|rSqdw:6BrmS|riqdw:69rmi",
- imul_3 = "rmIqdw:69rMI|rmSqdw:6BrMS|rmiqdw:69rMi",
-
- movzx_2 = "rm/db:0FB6rM|rm/qb:|rm/wb:0FB6rM|rm/dw:0FB7rM|rm/qw:",
- movsx_2 = "rm/db:0FBErM|rm/qb:|rm/wb:0FBErM|rm/dw:0FBFrM|rm/qw:",
-
- bswap_1 = "rqd:0FC8r",
- bsf_2 = "rmqdw:0FBCrM",
- bsr_2 = "rmqdw:0FBDrM",
- bt_2 = "mrqdw:0FA3Rm|miqdw:0FBA4mU",
- btc_2 = "mrqdw:0FBBRm|miqdw:0FBA7mU",
- btr_2 = "mrqdw:0FB3Rm|miqdw:0FBA6mU",
- bts_2 = "mrqdw:0FABRm|miqdw:0FBA5mU",
-
- rdtsc_0 = "0F31", -- P1+
- cpuid_0 = "0FA2", -- P1+
-
- -- floating point ops
- fst_1 = "ff:DDD0r|xd:D92m|xq:nDD2m",
- fstp_1 = "ff:DDD8r|xd:D93m|xq:nDD3m|xt:DB7m",
- fld_1 = "ff:D9C0r|xd:D90m|xq:nDD0m|xt:DB5m",
-
- fpop_0 = "DDD8", -- Alias for fstp st0.
-
- fist_1 = "xw:nDF2m|xd:DB2m",
- fistp_1 = "xw:nDF3m|xd:DB3m|xq:nDF7m",
- fild_1 = "xw:nDF0m|xd:DB0m|xq:nDF5m",
-
- fxch_0 = "D9C9",
- fxch_1 = "ff:D9C8r",
- fxch_2 = "fFf:D9C8r|Fff:D9C8R",
-
- fucom_1 = "ff:DDE0r",
- fucom_2 = "Fff:DDE0R",
- fucomp_1 = "ff:DDE8r",
- fucomp_2 = "Fff:DDE8R",
- fucomi_1 = "ff:DBE8r", -- P6+
- fucomi_2 = "Fff:DBE8R", -- P6+
- fucomip_1 = "ff:DFE8r", -- P6+
- fucomip_2 = "Fff:DFE8R", -- P6+
- fcomi_1 = "ff:DBF0r", -- P6+
- fcomi_2 = "Fff:DBF0R", -- P6+
- fcomip_1 = "ff:DFF0r", -- P6+
- fcomip_2 = "Fff:DFF0R", -- P6+
- fucompp_0 = "DAE9",
- fcompp_0 = "DED9",
-
- fldcw_1 = "xw:nD95m",
- fstcw_1 = "xw:n9BD97m",
- fnstcw_1 = "xw:nD97m",
- fstsw_1 = "Rw:n9BDFE0|xw:n9BDD7m",
- fnstsw_1 = "Rw:nDFE0|xw:nDD7m",
- fclex_0 = "9BDBE2",
- fnclex_0 = "DBE2",
-
- fnop_0 = "D9D0",
- -- D9D1-D9DF: unassigned
-
- fchs_0 = "D9E0",
- fabs_0 = "D9E1",
- -- D9E2: unassigned
- -- D9E3: unassigned
- ftst_0 = "D9E4",
- fxam_0 = "D9E5",
- -- D9E6: unassigned
- -- D9E7: unassigned
- fld1_0 = "D9E8",
- fldl2t_0 = "D9E9",
- fldl2e_0 = "D9EA",
- fldpi_0 = "D9EB",
- fldlg2_0 = "D9EC",
- fldln2_0 = "D9ED",
- fldz_0 = "D9EE",
- -- D9EF: unassigned
-
- f2xm1_0 = "D9F0",
- fyl2x_0 = "D9F1",
- fptan_0 = "D9F2",
- fpatan_0 = "D9F3",
- fxtract_0 = "D9F4",
- fprem1_0 = "D9F5",
- fdecstp_0 = "D9F6",
- fincstp_0 = "D9F7",
- fprem_0 = "D9F8",
- fyl2xp1_0 = "D9F9",
- fsqrt_0 = "D9FA",
- fsincos_0 = "D9FB",
- frndint_0 = "D9FC",
- fscale_0 = "D9FD",
- fsin_0 = "D9FE",
- fcos_0 = "D9FF",
-
- -- SSE, SSE2
- andnpd_2 = "rmo:660F55rM",
- andnps_2 = "rmo:0F55rM",
- andpd_2 = "rmo:660F54rM",
- andps_2 = "rmo:0F54rM",
- clflush_1 = "x.:0FAE7m",
- cmppd_3 = "rmio:660FC2rMU",
- cmpps_3 = "rmio:0FC2rMU",
- cmpsd_3 = "rrio:F20FC2rMU|rxi/oq:",
- cmpss_3 = "rrio:F30FC2rMU|rxi/od:",
- comisd_2 = "rro:660F2FrM|rx/oq:",
- comiss_2 = "rro:0F2FrM|rx/od:",
- cvtdq2pd_2 = "rro:F30FE6rM|rx/oq:",
- cvtdq2ps_2 = "rmo:0F5BrM",
- cvtpd2dq_2 = "rmo:F20FE6rM",
- cvtpd2ps_2 = "rmo:660F5ArM",
- cvtpi2pd_2 = "rx/oq:660F2ArM",
- cvtpi2ps_2 = "rx/oq:0F2ArM",
- cvtps2dq_2 = "rmo:660F5BrM",
- cvtps2pd_2 = "rro:0F5ArM|rx/oq:",
- cvtsd2si_2 = "rr/do:F20F2DrM|rr/qo:|rx/dq:|rxq:",
- cvtsd2ss_2 = "rro:F20F5ArM|rx/oq:",
- cvtsi2sd_2 = "rm/od:F20F2ArM|rm/oq:F20F2ArXM",
- cvtsi2ss_2 = "rm/od:F30F2ArM|rm/oq:F30F2ArXM",
- cvtss2sd_2 = "rro:F30F5ArM|rx/od:",
- cvtss2si_2 = "rr/do:F20F2CrM|rr/qo:|rxd:|rx/qd:",
- cvttpd2dq_2 = "rmo:660FE6rM",
- cvttps2dq_2 = "rmo:F30F5BrM",
- cvttsd2si_2 = "rr/do:F20F2CrM|rr/qo:|rx/dq:|rxq:",
- cvttss2si_2 = "rr/do:F30F2CrM|rr/qo:|rxd:|rx/qd:",
- ldmxcsr_1 = "xd:0FAE2m",
- lfence_0 = "0FAEE8",
- maskmovdqu_2 = "rro:660FF7rM",
- mfence_0 = "0FAEF0",
- movapd_2 = "rmo:660F28rM|mro:660F29Rm",
- movaps_2 = "rmo:0F28rM|mro:0F29Rm",
- movd_2 = "rm/od:660F6ErM|rm/oq:660F6ErXM|mr/do:660F7ERm|mr/qo:",
- movdqa_2 = "rmo:660F6FrM|mro:660F7FRm",
- movdqu_2 = "rmo:F30F6FrM|mro:F30F7FRm",
- movhlps_2 = "rro:0F12rM",
- movhpd_2 = "rx/oq:660F16rM|xr/qo:n660F17Rm",
- movhps_2 = "rx/oq:0F16rM|xr/qo:n0F17Rm",
- movlhps_2 = "rro:0F16rM",
- movlpd_2 = "rx/oq:660F12rM|xr/qo:n660F13Rm",
- movlps_2 = "rx/oq:0F12rM|xr/qo:n0F13Rm",
- movmskpd_2 = "rr/do:660F50rM",
- movmskps_2 = "rr/do:0F50rM",
- movntdq_2 = "xro:660FE7Rm",
- movnti_2 = "xrqd:0FC3Rm",
- movntpd_2 = "xro:660F2BRm",
- movntps_2 = "xro:0F2BRm",
- movq_2 = "rro:F30F7ErM|rx/oq:|xr/qo:n660FD6Rm",
- movsd_2 = "rro:F20F10rM|rx/oq:|xr/qo:nF20F11Rm",
- movss_2 = "rro:F30F10rM|rx/od:|xr/do:F30F11Rm",
- movupd_2 = "rmo:660F10rM|mro:660F11Rm",
- movups_2 = "rmo:0F10rM|mro:0F11Rm",
- orpd_2 = "rmo:660F56rM",
- orps_2 = "rmo:0F56rM",
- packssdw_2 = "rmo:660F6BrM",
- packsswb_2 = "rmo:660F63rM",
- packuswb_2 = "rmo:660F67rM",
- paddb_2 = "rmo:660FFCrM",
- paddd_2 = "rmo:660FFErM",
- paddq_2 = "rmo:660FD4rM",
- paddsb_2 = "rmo:660FECrM",
- paddsw_2 = "rmo:660FEDrM",
- paddusb_2 = "rmo:660FDCrM",
- paddusw_2 = "rmo:660FDDrM",
- paddw_2 = "rmo:660FFDrM",
- pand_2 = "rmo:660FDBrM",
- pandn_2 = "rmo:660FDFrM",
- pause_0 = "F390",
- pavgb_2 = "rmo:660FE0rM",
- pavgw_2 = "rmo:660FE3rM",
- pcmpeqb_2 = "rmo:660F74rM",
- pcmpeqd_2 = "rmo:660F76rM",
- pcmpeqw_2 = "rmo:660F75rM",
- pcmpgtb_2 = "rmo:660F64rM",
- pcmpgtd_2 = "rmo:660F66rM",
- pcmpgtw_2 = "rmo:660F65rM",
- pextrw_3 = "rri/do:660FC5rMU|xri/wo:660F3A15nrMU", -- Mem op: SSE4.1 only.
- pinsrw_3 = "rri/od:660FC4rMU|rxi/ow:",
- pmaddwd_2 = "rmo:660FF5rM",
- pmaxsw_2 = "rmo:660FEErM",
- pmaxub_2 = "rmo:660FDErM",
- pminsw_2 = "rmo:660FEArM",
- pminub_2 = "rmo:660FDArM",
- pmovmskb_2 = "rr/do:660FD7rM",
- pmulhuw_2 = "rmo:660FE4rM",
- pmulhw_2 = "rmo:660FE5rM",
- pmullw_2 = "rmo:660FD5rM",
- pmuludq_2 = "rmo:660FF4rM",
- por_2 = "rmo:660FEBrM",
- prefetchnta_1 = "xb:n0F180m",
- prefetcht0_1 = "xb:n0F181m",
- prefetcht1_1 = "xb:n0F182m",
- prefetcht2_1 = "xb:n0F183m",
- psadbw_2 = "rmo:660FF6rM",
- pshufd_3 = "rmio:660F70rMU",
- pshufhw_3 = "rmio:F30F70rMU",
- pshuflw_3 = "rmio:F20F70rMU",
- pslld_2 = "rmo:660FF2rM|rio:660F726mU",
- pslldq_2 = "rio:660F737mU",
- psllq_2 = "rmo:660FF3rM|rio:660F736mU",
- psllw_2 = "rmo:660FF1rM|rio:660F716mU",
- psrad_2 = "rmo:660FE2rM|rio:660F724mU",
- psraw_2 = "rmo:660FE1rM|rio:660F714mU",
- psrld_2 = "rmo:660FD2rM|rio:660F722mU",
- psrldq_2 = "rio:660F733mU",
- psrlq_2 = "rmo:660FD3rM|rio:660F732mU",
- psrlw_2 = "rmo:660FD1rM|rio:660F712mU",
- psubb_2 = "rmo:660FF8rM",
- psubd_2 = "rmo:660FFArM",
- psubq_2 = "rmo:660FFBrM",
- psubsb_2 = "rmo:660FE8rM",
- psubsw_2 = "rmo:660FE9rM",
- psubusb_2 = "rmo:660FD8rM",
- psubusw_2 = "rmo:660FD9rM",
- psubw_2 = "rmo:660FF9rM",
- punpckhbw_2 = "rmo:660F68rM",
- punpckhdq_2 = "rmo:660F6ArM",
- punpckhqdq_2 = "rmo:660F6DrM",
- punpckhwd_2 = "rmo:660F69rM",
- punpcklbw_2 = "rmo:660F60rM",
- punpckldq_2 = "rmo:660F62rM",
- punpcklqdq_2 = "rmo:660F6CrM",
- punpcklwd_2 = "rmo:660F61rM",
- pxor_2 = "rmo:660FEFrM",
- rcpps_2 = "rmo:0F53rM",
- rcpss_2 = "rro:F30F53rM|rx/od:",
- rsqrtps_2 = "rmo:0F52rM",
- rsqrtss_2 = "rmo:F30F52rM",
- sfence_0 = "0FAEF8",
- shufpd_3 = "rmio:660FC6rMU",
- shufps_3 = "rmio:0FC6rMU",
- stmxcsr_1 = "xd:0FAE3m",
- ucomisd_2 = "rro:660F2ErM|rx/oq:",
- ucomiss_2 = "rro:0F2ErM|rx/od:",
- unpckhpd_2 = "rmo:660F15rM",
- unpckhps_2 = "rmo:0F15rM",
- unpcklpd_2 = "rmo:660F14rM",
- unpcklps_2 = "rmo:0F14rM",
- xorpd_2 = "rmo:660F57rM",
- xorps_2 = "rmo:0F57rM",
-
- -- SSE3 ops
- fisttp_1 = "xw:nDF1m|xd:DB1m|xq:nDD1m",
- addsubpd_2 = "rmo:660FD0rM",
- addsubps_2 = "rmo:F20FD0rM",
- haddpd_2 = "rmo:660F7CrM",
- haddps_2 = "rmo:F20F7CrM",
- hsubpd_2 = "rmo:660F7DrM",
- hsubps_2 = "rmo:F20F7DrM",
- lddqu_2 = "rxo:F20FF0rM",
- movddup_2 = "rmo:F20F12rM",
- movshdup_2 = "rmo:F30F16rM",
- movsldup_2 = "rmo:F30F12rM",
-
- -- SSSE3 ops
- pabsb_2 = "rmo:660F381CrM",
- pabsd_2 = "rmo:660F381ErM",
- pabsw_2 = "rmo:660F381DrM",
- palignr_3 = "rmio:660F3A0FrMU",
- phaddd_2 = "rmo:660F3802rM",
- phaddsw_2 = "rmo:660F3803rM",
- phaddw_2 = "rmo:660F3801rM",
- phsubd_2 = "rmo:660F3806rM",
- phsubsw_2 = "rmo:660F3807rM",
- phsubw_2 = "rmo:660F3805rM",
- pmaddubsw_2 = "rmo:660F3804rM",
- pmulhrsw_2 = "rmo:660F380BrM",
- pshufb_2 = "rmo:660F3800rM",
- psignb_2 = "rmo:660F3808rM",
- psignd_2 = "rmo:660F380ArM",
- psignw_2 = "rmo:660F3809rM",
-
- -- SSE4.1 ops
- blendpd_3 = "rmio:660F3A0DrMU",
- blendps_3 = "rmio:660F3A0CrMU",
- blendvpd_3 = "rmRo:660F3815rM",
- blendvps_3 = "rmRo:660F3814rM",
- dppd_3 = "rmio:660F3A41rMU",
- dpps_3 = "rmio:660F3A40rMU",
- extractps_3 = "mri/do:660F3A17RmU|rri/qo:660F3A17RXmU",
- insertps_3 = "rrio:660F3A41rMU|rxi/od:",
- movntdqa_2 = "rmo:660F382ArM",
- mpsadbw_3 = "rmio:660F3A42rMU",
- packusdw_2 = "rmo:660F382BrM",
- pblendvb_3 = "rmRo:660F3810rM",
- pblendw_3 = "rmio:660F3A0ErMU",
- pcmpeqq_2 = "rmo:660F3829rM",
- pextrb_3 = "rri/do:660F3A14nRmU|rri/qo:|xri/bo:",
- pextrd_3 = "mri/do:660F3A16RmU",
- pextrq_3 = "mri/qo:660F3A16RmU",
- -- pextrw is SSE2, mem operand is SSE4.1 only
- phminposuw_2 = "rmo:660F3841rM",
- pinsrb_3 = "rri/od:660F3A20nrMU|rxi/ob:",
- pinsrd_3 = "rmi/od:660F3A22rMU",
- pinsrq_3 = "rmi/oq:660F3A22rXMU",
- pmaxsb_2 = "rmo:660F383CrM",
- pmaxsd_2 = "rmo:660F383DrM",
- pmaxud_2 = "rmo:660F383FrM",
- pmaxuw_2 = "rmo:660F383ErM",
- pminsb_2 = "rmo:660F3838rM",
- pminsd_2 = "rmo:660F3839rM",
- pminud_2 = "rmo:660F383BrM",
- pminuw_2 = "rmo:660F383ArM",
- pmovsxbd_2 = "rro:660F3821rM|rx/od:",
- pmovsxbq_2 = "rro:660F3822rM|rx/ow:",
- pmovsxbw_2 = "rro:660F3820rM|rx/oq:",
- pmovsxdq_2 = "rro:660F3825rM|rx/oq:",
- pmovsxwd_2 = "rro:660F3823rM|rx/oq:",
- pmovsxwq_2 = "rro:660F3824rM|rx/od:",
- pmovzxbd_2 = "rro:660F3831rM|rx/od:",
- pmovzxbq_2 = "rro:660F3832rM|rx/ow:",
- pmovzxbw_2 = "rro:660F3830rM|rx/oq:",
- pmovzxdq_2 = "rro:660F3835rM|rx/oq:",
- pmovzxwd_2 = "rro:660F3833rM|rx/oq:",
- pmovzxwq_2 = "rro:660F3834rM|rx/od:",
- pmuldq_2 = "rmo:660F3828rM",
- pmulld_2 = "rmo:660F3840rM",
- ptest_2 = "rmo:660F3817rM",
- roundpd_3 = "rmio:660F3A09rMU",
- roundps_3 = "rmio:660F3A08rMU",
- roundsd_3 = "rrio:660F3A0BrMU|rxi/oq:",
- roundss_3 = "rrio:660F3A0ArMU|rxi/od:",
-
- -- SSE4.2 ops
- crc32_2 = "rmqd:F20F38F1rM|rm/dw:66F20F38F1rM|rm/db:F20F38F0rM|rm/qb:",
- pcmpestri_3 = "rmio:660F3A61rMU",
- pcmpestrm_3 = "rmio:660F3A60rMU",
- pcmpgtq_2 = "rmo:660F3837rM",
- pcmpistri_3 = "rmio:660F3A63rMU",
- pcmpistrm_3 = "rmio:660F3A62rMU",
- popcnt_2 = "rmqdw:F30FB8rM",
-
- -- SSE4a
- extrq_2 = "rro:660F79rM",
- extrq_3 = "riio:660F780mUU",
- insertq_2 = "rro:F20F79rM",
- insertq_4 = "rriio:F20F78rMUU",
- lzcnt_2 = "rmqdw:F30FBDrM",
- movntsd_2 = "xr/qo:nF20F2BRm",
- movntss_2 = "xr/do:F30F2BRm",
- -- popcnt is also in SSE4.2
-}
-
-------------------------------------------------------------------------------
-
--- Arithmetic ops.
-for name,n in pairs{ add = 0, ["or"] = 1, adc = 2, sbb = 3,
- ["and"] = 4, sub = 5, xor = 6, cmp = 7 } do
- local n8 = n * 8
- map_op[name.."_2"] = format(
- "mr:%02XRm|rm:%02XrM|mI1qdw:81%XmI|mS1qdw:83%XmS|Ri1qdwb:%02Xri|mi1qdwb:81%Xmi",
- 1+n8, 3+n8, n, n, 5+n8, n)
-end
-
--- Shift ops.
-for name,n in pairs{ rol = 0, ror = 1, rcl = 2, rcr = 3,
- shl = 4, shr = 5, sar = 7, sal = 4 } do
- map_op[name.."_2"] = format("m1:D1%Xm|mC1qdwb:D3%Xm|mi:C1%XmU", n, n, n)
-end
-
--- Conditional ops.
-for cc,n in pairs(map_cc) do
- map_op["j"..cc.."_1"] = format("J.:n0F8%XJ", n) -- short: 7%X
- map_op["set"..cc.."_1"] = format("mb:n0F9%X2m", n)
- map_op["cmov"..cc.."_2"] = format("rmqdw:0F4%XrM", n) -- P6+
-end
-
--- FP arithmetic ops.
-for name,n in pairs{ add = 0, mul = 1, com = 2, comp = 3,
- sub = 4, subr = 5, div = 6, divr = 7 } do
- local nc = 192 + n * 8
- local nr = nc + (n < 4 and 0 or (n % 2 == 0 and 8 or -8))
- local fn = "f"..name
- map_op[fn.."_1"] = format("ff:D8%02Xr|xd:D8%Xm|xq:nDC%Xm", nc, n, n)
- if n == 2 or n == 3 then
- map_op[fn.."_2"] = format("Fff:D8%02XR|Fx2d:D8%XM|Fx2q:nDC%XM", nc, n, n)
- else
- map_op[fn.."_2"] = format("Fff:D8%02XR|fFf:DC%02Xr|Fx2d:D8%XM|Fx2q:nDC%XM", nc, nr, n, n)
- map_op[fn.."p_1"] = format("ff:DE%02Xr", nr)
- map_op[fn.."p_2"] = format("fFf:DE%02Xr", nr)
- end
- map_op["fi"..name.."_1"] = format("xd:DA%Xm|xw:nDE%Xm", n, n)
-end
-
--- FP conditional moves.
-for cc,n in pairs{ b=0, e=1, be=2, u=3, nb=4, ne=5, nbe=6, nu=7 } do
- local n4 = n % 4
- local nc = 56000 + n4 * 8 + (n-n4) * 64
- map_op["fcmov"..cc.."_1"] = format("ff:%04Xr", nc) -- P6+
- map_op["fcmov"..cc.."_2"] = format("Fff:%04XR", nc) -- P6+
-end
-
--- SSE FP arithmetic ops.
-for name,n in pairs{ sqrt = 1, add = 8, mul = 9,
- sub = 12, min = 13, div = 14, max = 15 } do
- map_op[name.."ps_2"] = format("rmo:0F5%XrM", n)
- map_op[name.."ss_2"] = format("rro:F30F5%XrM|rx/od:", n)
- map_op[name.."pd_2"] = format("rmo:660F5%XrM", n)
- map_op[name.."sd_2"] = format("rro:F20F5%XrM|rx/oq:", n)
-end
-
-------------------------------------------------------------------------------
-
--- Process pattern string.
-local function dopattern(pat, args, sz, op, needrex)
- local digit, addin
- local opcode = 0
- local szov = sz
- local narg = 1
- local rex = 0
-
- -- Limit number of section buffer positions used by a single dasm_put().
- -- A single opcode needs a maximum of 5 positions.
- if secpos+5 > maxsecpos then wflush() end
-
- -- Process each character.
- for c in gmatch(pat.."|", ".") do
- if match(c, "%x") then -- Hex digit.
- digit = byte(c) - 48
- if digit > 48 then digit = digit - 39
- elseif digit > 16 then digit = digit - 7 end
- opcode = opcode*16 + digit
- addin = nil
- elseif c == "n" then -- Disable operand size mods for opcode.
- szov = nil
- elseif c == "X" then -- Force REX.W.
- rex = 8
- elseif c == "r" then -- Merge 1st operand regno. into opcode.
- addin = args[1]; opcode = opcode + (addin.reg % 8)
- if narg < 2 then narg = 2 end
- elseif c == "R" then -- Merge 2nd operand regno. into opcode.
- addin = args[2]; opcode = opcode + (addin.reg % 8)
- narg = 3
- elseif c == "m" or c == "M" then -- Encode ModRM/SIB.
- local s
- if addin then
- s = addin.reg
- opcode = opcode - (s%8) -- Undo regno opcode merge.
- else
- s = opcode % 16 -- Undo last digit.
- opcode = (opcode - s) / 16
- end
- local nn = c == "m" and 1 or 2
- local t = args[nn]
- if narg <= nn then narg = nn + 1 end
- if szov == "q" and rex == 0 then rex = rex + 8 end
- if t.reg and t.reg > 7 then rex = rex + 1 end
- if t.xreg and t.xreg > 7 then rex = rex + 2 end
- if s > 7 then rex = rex + 4 end
- if needrex then rex = rex + 16 end
- wputop(szov, opcode, rex); opcode = nil
- local imark = sub(pat, -1) -- Force a mark (ugly).
- -- Put ModRM/SIB with regno/last digit as spare.
- wputmrmsib(t, imark, s, addin and addin.vreg)
- addin = nil
- else
- if opcode then -- Flush opcode.
- if szov == "q" and rex == 0 then rex = rex + 8 end
- if needrex then rex = rex + 16 end
- if addin and addin.reg == -1 then
- wputop(szov, opcode - 7, rex)
- waction("VREG", addin.vreg); wputxb(0)
- else
- if addin and addin.reg > 7 then rex = rex + 1 end
- wputop(szov, opcode, rex)
- end
- opcode = nil
- end
- if c == "|" then break end
- if c == "o" then -- Offset (pure 32 bit displacement).
- wputdarg(args[1].disp); if narg < 2 then narg = 2 end
- elseif c == "O" then
- wputdarg(args[2].disp); narg = 3
- else
- -- Anything else is an immediate operand.
- local a = args[narg]
- narg = narg + 1
- local mode, imm = a.mode, a.imm
- if mode == "iJ" and not match("iIJ", c) then
- werror("bad operand size for label")
- end
- if c == "S" then
- wputsbarg(imm)
- elseif c == "U" then
- wputbarg(imm)
- elseif c == "W" then
- wputwarg(imm)
- elseif c == "i" or c == "I" then
- if mode == "iJ" then
- wputlabel("IMM_", imm, 1)
- elseif mode == "iI" and c == "I" then
- waction(sz == "w" and "IMM_WB" or "IMM_DB", imm)
- else
- wputszarg(sz, imm)
- end
- elseif c == "J" then
- if mode == "iPJ" then
- waction("REL_A", imm) -- !x64 (secpos)
- else
- wputlabel("REL_", imm, 2)
- end
- else
- werror("bad char `"..c.."' in pattern `"..pat.."' for `"..op.."'")
- end
- end
- end
- end
-end
-
-------------------------------------------------------------------------------
-
--- Mapping of operand modes to short names. Suppress output with '#'.
-local map_modename = {
- r = "reg", R = "eax", C = "cl", x = "mem", m = "mrm", i = "imm",
- f = "stx", F = "st0", J = "lbl", ["1"] = "1",
- I = "#", S = "#", O = "#",
-}
-
--- Return a table/string showing all possible operand modes.
-local function templatehelp(template, nparams)
- if nparams == 0 then return "" end
- local t = {}
- for tm in gmatch(template, "[^%|]+") do
- local s = map_modename[sub(tm, 1, 1)]
- s = s..gsub(sub(tm, 2, nparams), ".", function(c)
- return ", "..map_modename[c]
- end)
- if not match(s, "#") then t[#t+1] = s end
- end
- return t
-end
-
--- Match operand modes against mode match part of template.
-local function matchtm(tm, args)
- for i=1,#args do
- if not match(args[i].mode, sub(tm, i, i)) then return end
- end
- return true
-end
-
--- Handle opcodes defined with template strings.
-map_op[".template__"] = function(params, template, nparams)
- if not params then return templatehelp(template, nparams) end
- local args = {}
-
- -- Zero-operand opcodes have no match part.
- if #params == 0 then
- dopattern(template, args, "d", params.op, nil)
- return
- end
-
- -- Determine common operand size (coerce undefined size) or flag as mixed.
- local sz, szmix, needrex
- for i,p in ipairs(params) do
- args[i] = parseoperand(p)
- local nsz = args[i].opsize
- if nsz then
- if sz and sz ~= nsz then szmix = true else sz = nsz end
- end
- local nrex = args[i].needrex
- if nrex ~= nil then
- if needrex == nil then
- needrex = nrex
- elseif needrex ~= nrex then
- werror("bad mix of byte-addressable registers")
- end
- end
- end
-
- -- Try all match:pattern pairs (separated by '|').
- local gotmatch, lastpat
- for tm in gmatch(template, "[^%|]+") do
- -- Split off size match (starts after mode match) and pattern string.
- local szm, pat = match(tm, "^(.-):(.*)$", #args+1)
- if pat == "" then pat = lastpat else lastpat = pat end
- if matchtm(tm, args) then
- local prefix = sub(szm, 1, 1)
- if prefix == "/" then -- Match both operand sizes.
- if args[1].opsize == sub(szm, 2, 2) and
- args[2].opsize == sub(szm, 3, 3) then
- dopattern(pat, args, sz, params.op, needrex) -- Process pattern.
- return
- end
- else -- Match common operand size.
- local szp = sz
- if szm == "" then szm = x64 and "qdwb" or "dwb" end -- Default sizes.
- if prefix == "1" then szp = args[1].opsize; szmix = nil
- elseif prefix == "2" then szp = args[2].opsize; szmix = nil end
- if not szmix and (prefix == "." or match(szm, szp or "#")) then
- dopattern(pat, args, szp, params.op, needrex) -- Process pattern.
- return
- end
- end
- gotmatch = true
- end
- end
-
- local msg = "bad operand mode"
- if gotmatch then
- if szmix then
- msg = "mixed operand size"
- else
- msg = sz and "bad operand size" or "missing operand size"
- end
- end
-
- werror(msg.." in `"..opmodestr(params.op, args).."'")
-end
-
-------------------------------------------------------------------------------
-
--- x64-specific opcode for 64 bit immediates and displacements.
-if x64 then
- function map_op.mov64_2(params)
- if not params then return { "reg, imm", "reg, [disp]", "[disp], reg" } end
- if secpos+2 > maxsecpos then wflush() end
- local opcode, op64, sz, rex
- local op64 = match(params[1], "^%[%s*(.-)%s*%]$")
- if op64 then
- local a = parseoperand(params[2])
- if a.mode ~= "rmR" then werror("bad operand mode") end
- sz = a.opsize
- rex = sz == "q" and 8 or 0
- opcode = 0xa3
- else
- op64 = match(params[2], "^%[%s*(.-)%s*%]$")
- local a = parseoperand(params[1])
- if op64 then
- if a.mode ~= "rmR" then werror("bad operand mode") end
- sz = a.opsize
- rex = sz == "q" and 8 or 0
- opcode = 0xa1
- else
- if sub(a.mode, 1, 1) ~= "r" or a.opsize ~= "q" then
- werror("bad operand mode")
- end
- op64 = params[2]
- opcode = 0xb8 + (a.reg%8) -- !x64: no VREG support.
- rex = a.reg > 7 and 9 or 8
- end
- end
- wputop(sz, opcode, rex)
- waction("IMM_D", format("(unsigned int)((uintptr_t)(%s))", op64))
- waction("IMM_D", format("(unsigned int)(((uintptr_t)(%s))>>32)", op64))
- end
-end
-
-------------------------------------------------------------------------------
-
--- Pseudo-opcodes for data storage.
-local function op_data(params)
- if not params then return "imm..." end
- local sz = sub(params.op, 2, 2)
- if sz == "a" then sz = addrsize end
- for _,p in ipairs(params) do
- local a = parseoperand(p)
- if sub(a.mode, 1, 1) ~= "i" or (a.opsize and a.opsize ~= sz) then
- werror("bad mode or size in `"..p.."'")
- end
- if a.mode == "iJ" then
- wputlabel("IMM_", a.imm, 1)
- else
- wputszarg(sz, a.imm)
- end
- if secpos+2 > maxsecpos then wflush() end
- end
-end
-
-map_op[".byte_*"] = op_data
-map_op[".sbyte_*"] = op_data
-map_op[".word_*"] = op_data
-map_op[".dword_*"] = op_data
-map_op[".aword_*"] = op_data
-
-------------------------------------------------------------------------------
-
--- Pseudo-opcode to mark the position where the action list is to be emitted.
-map_op[".actionlist_1"] = function(params)
- if not params then return "cvar" end
- local name = params[1] -- No syntax check. You get to keep the pieces.
- wline(function(out) writeactions(out, name) end)
-end
-
--- Pseudo-opcode to mark the position where the global enum is to be emitted.
-map_op[".globals_1"] = function(params)
- if not params then return "prefix" end
- local prefix = params[1] -- No syntax check. You get to keep the pieces.
- wline(function(out) writeglobals(out, prefix) end)
-end
-
--- Pseudo-opcode to mark the position where the global names are to be emitted.
-map_op[".globalnames_1"] = function(params)
- if not params then return "cvar" end
- local name = params[1] -- No syntax check. You get to keep the pieces.
- wline(function(out) writeglobalnames(out, name) end)
-end
-
--- Pseudo-opcode to mark the position where the extern names are to be emitted.
-map_op[".externnames_1"] = function(params)
- if not params then return "cvar" end
- local name = params[1] -- No syntax check. You get to keep the pieces.
- wline(function(out) writeexternnames(out, name) end)
-end
-
-------------------------------------------------------------------------------
-
--- Label pseudo-opcode (converted from trailing colon form).
-map_op[".label_2"] = function(params)
- if not params then return "[1-9] | ->global | =>pcexpr [, addr]" end
- if secpos+2 > maxsecpos then wflush() end
- local a = parseoperand(params[1])
- local mode, imm = a.mode, a.imm
- if type(imm) == "number" and (mode == "iJ" or (imm >= 1 and imm <= 9)) then
- -- Local label (1: ... 9:) or global label (->global:).
- waction("LABEL_LG", nil, 1)
- wputxb(imm)
- elseif mode == "iJ" then
- -- PC label (=>pcexpr:).
- waction("LABEL_PC", imm)
- else
- werror("bad label definition")
- end
- -- SETLABEL must immediately follow LABEL_LG/LABEL_PC.
- local addr = params[2]
- if addr then
- local a = parseoperand(addr)
- if a.mode == "iPJ" then
- waction("SETLABEL", a.imm)
- else
- werror("bad label assignment")
- end
- end
-end
-map_op[".label_1"] = map_op[".label_2"]
-
-------------------------------------------------------------------------------
-
--- Alignment pseudo-opcode.
-map_op[".align_1"] = function(params)
- if not params then return "numpow2" end
- if secpos+1 > maxsecpos then wflush() end
- local align = tonumber(params[1]) or map_opsizenum[map_opsize[params[1]]]
- if align then
- local x = align
- -- Must be a power of 2 in the range (2 ... 256).
- for i=1,8 do
- x = x / 2
- if x == 1 then
- waction("ALIGN", nil, 1)
- wputxb(align-1) -- Action byte is 2**n-1.
- return
- end
- end
- end
- werror("bad alignment")
-end
-
--- Spacing pseudo-opcode.
-map_op[".space_2"] = function(params)
- if not params then return "num [, filler]" end
- if secpos+1 > maxsecpos then wflush() end
- waction("SPACE", params[1])
- local fill = params[2]
- if fill then
- fill = tonumber(fill)
- if not fill or fill < 0 or fill > 255 then werror("bad filler") end
- end
- wputxb(fill or 0)
-end
-map_op[".space_1"] = map_op[".space_2"]
-
-------------------------------------------------------------------------------
-
--- Pseudo-opcode for (primitive) type definitions (map to C types).
-map_op[".type_3"] = function(params, nparams)
- if not params then
- return nparams == 2 and "name, ctype" or "name, ctype, reg"
- end
- local name, ctype, reg = params[1], params[2], params[3]
- if not match(name, "^[%a_][%w_]*$") then
- werror("bad type name `"..name.."'")
- end
- local tp = map_type[name]
- if tp then
- werror("duplicate type `"..name.."'")
- end
- if reg and not map_reg_valid_base[reg] then
- werror("bad base register `"..(map_reg_rev[reg] or reg).."'")
- end
- -- Add #type to defines. A bit unclean to put it in map_archdef.
- map_archdef["#"..name] = "sizeof("..ctype..")"
- -- Add new type and emit shortcut define.
- local num = ctypenum + 1
- map_type[name] = {
- ctype = ctype,
- ctypefmt = format("Dt%X(%%s)", num),
- reg = reg,
- }
- wline(format("#define Dt%X(_V) (int)(ptrdiff_t)&(((%s *)0)_V)", num, ctype))
- ctypenum = num
-end
-map_op[".type_2"] = map_op[".type_3"]
-
--- Dump type definitions.
-local function dumptypes(out, lvl)
- local t = {}
- for name in pairs(map_type) do t[#t+1] = name end
- sort(t)
- out:write("Type definitions:\n")
- for _,name in ipairs(t) do
- local tp = map_type[name]
- local reg = tp.reg and map_reg_rev[tp.reg] or ""
- out:write(format(" %-20s %-20s %s\n", name, tp.ctype, reg))
- end
- out:write("\n")
-end
-
-------------------------------------------------------------------------------
-
--- Set the current section.
-function _M.section(num)
- waction("SECTION")
- wputxb(num)
- wflush(true) -- SECTION is a terminal action.
-end
-
-------------------------------------------------------------------------------
-
--- Dump architecture description.
-function _M.dumparch(out)
- out:write(format("DynASM %s version %s, released %s\n\n",
- _info.arch, _info.version, _info.release))
- dumpregs(out)
- dumpactions(out)
-end
-
--- Dump all user defined elements.
-function _M.dumpdef(out, lvl)
- dumptypes(out, lvl)
- dumpglobals(out, lvl)
- dumpexterns(out, lvl)
-end
-
-------------------------------------------------------------------------------
-
--- Pass callbacks from/to the DynASM core.
-function _M.passcb(wl, we, wf, ww)
- wline, werror, wfatal, wwarn = wl, we, wf, ww
- return wflush
-end
-
--- Setup the arch-specific module.
-function _M.setup(arch, opt)
- g_arch, g_opt = arch, opt
-end
-
--- Merge the core maps and the arch-specific maps.
-function _M.mergemaps(map_coreop, map_def)
- setmetatable(map_op, { __index = map_coreop })
- setmetatable(map_def, { __index = map_archdef })
- return map_op, map_def
-end
-
-return _M
-
-------------------------------------------------------------------------------
-
diff --git a/plugins/MirLua/Modules/ffi/src/dynasm/dynasm.lua b/plugins/MirLua/Modules/ffi/src/dynasm/dynasm.lua deleted file mode 100644 index 8226dccd5d..0000000000 --- a/plugins/MirLua/Modules/ffi/src/dynasm/dynasm.lua +++ /dev/null @@ -1,1096 +0,0 @@ -------------------------------------------------------------------------------
--- DynASM. A dynamic assembler for code generation engines.
--- Originally designed and implemented for LuaJIT.
---
--- Copyright (C) 2005-2011 Mike Pall. All rights reserved.
--- See below for full copyright notice.
-------------------------------------------------------------------------------
-
--- Application information.
-local _info = {
- name = "DynASM",
- description = "A dynamic assembler for code generation engines",
- version = "1.3.0",
- vernum = 10300,
- release = "2011-05-05",
- author = "Mike Pall",
- url = "http://luajit.org/dynasm.html",
- license = "MIT",
- copyright = [[
-Copyright (C) 2005-2011 Mike Pall. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-[ MIT license: http://www.opensource.org/licenses/mit-license.php ]
-]],
-}
-
--- Cache library functions.
-local type, pairs, ipairs = type, pairs, ipairs
-local pcall, error, assert = pcall, error, assert
-local _s = string
-local sub, match, gmatch, gsub = _s.sub, _s.match, _s.gmatch, _s.gsub
-local format, rep, upper = _s.format, _s.rep, _s.upper
-local _t = table
-local insert, remove, concat, sort = _t.insert, _t.remove, _t.concat, _t.sort
-local exit = os.exit
-local io = io
-local stdin, stdout, stderr = io.stdin, io.stdout, io.stderr
-
-------------------------------------------------------------------------------
-
--- Program options.
-local g_opt = {}
-
--- Global state for current file.
-local g_fname, g_curline, g_indent, g_lineno, g_synclineno, g_arch
-local g_errcount = 0
-
--- Write buffer for output file.
-local g_wbuffer, g_capbuffer
-
-------------------------------------------------------------------------------
-
--- Write an output line (or callback function) to the buffer.
-local function wline(line, needindent)
- local buf = g_capbuffer or g_wbuffer
- buf[#buf+1] = needindent and g_indent..line or line
- g_synclineno = g_synclineno + 1
-end
-
--- Write assembler line as a comment, if requestd.
-local function wcomment(aline)
- if g_opt.comment then
- wline(g_opt.comment..aline..g_opt.endcomment, true)
- end
-end
-
--- Resync CPP line numbers.
-local function wsync()
- if g_synclineno ~= g_lineno and g_opt.cpp then
- wline("# "..g_lineno..' "'..g_fname..'"')
- g_synclineno = g_lineno
- end
-end
-
--- Dummy action flush function. Replaced with arch-specific function later.
-local function wflush(term)
-end
-
--- Dump all buffered output lines.
-local function wdumplines(out, buf)
- for _,line in ipairs(buf) do
- if type(line) == "string" then
- assert(out:write(line, "\n"))
- else
- -- Special callback to dynamically insert lines after end of processing.
- line(out)
- end
- end
-end
-
-------------------------------------------------------------------------------
-
--- Emit an error. Processing continues with next statement.
-local function werror(msg)
- if g_opt.vserror then
- error(format("%s(%s) : error: %s:\n%s", g_fname, g_lineno, msg, g_curline), 0)
- else
- error(format("%s:%s: error: %s:\n%s", g_fname, g_lineno, msg, g_curline), 0)
- end
-end
-
--- Emit a fatal error. Processing stops.
-local function wfatal(msg)
- g_errcount = "fatal"
- werror(msg)
-end
-
--- Print a warning. Processing continues.
-local function wwarn(msg)
- stderr:write(format("%s:%s: warning: %s:\n%s\n",
- g_fname, g_lineno, msg, g_curline))
-end
-
--- Print caught error message. But suppress excessive errors.
-local function wprinterr(...)
- if type(g_errcount) == "number" then
- -- Regular error.
- g_errcount = g_errcount + 1
- if g_errcount < 21 then -- Seems to be a reasonable limit.
- stderr:write(...)
- elseif g_errcount == 21 then
- stderr:write(g_fname,
- ":*: warning: too many errors (suppressed further messages).\n")
- end
- else
- -- Fatal error.
- stderr:write(...)
- return true -- Stop processing.
- end
-end
-
-------------------------------------------------------------------------------
-
--- Map holding all option handlers.
-local opt_map = {}
-local opt_current
-
--- Print error and exit with error status.
-local function opterror(...)
- stderr:write("dynasm.lua: ERROR: ", ...)
- stderr:write("\n")
- exit(1)
-end
-
--- Get option parameter.
-local function optparam(args)
- local argn = args.argn
- local p = args[argn]
- if not p then
- opterror("missing parameter for option `", opt_current, "'.")
- end
- args.argn = argn + 1
- return p
-end
-
-------------------------------------------------------------------------------
-
--- Core pseudo-opcodes.
-local map_coreop = {}
--- Dummy opcode map. Replaced by arch-specific map.
-local map_op = {}
-
--- Forward declarations.
-local dostmt
-local readfile
-
-------------------------------------------------------------------------------
-
--- Map for defines (initially empty, chains to arch-specific map).
-local map_def = {}
-
--- Pseudo-opcode to define a substitution.
-map_coreop[".define_2"] = function(params, nparams)
- if not params then return nparams == 1 and "name" or "name, subst" end
- local name, def = params[1], params[2] or "1"
- if not match(name, "^[%a_][%w_]*$") then werror("bad or duplicate define") end
- map_def[name] = def
-end
-map_coreop[".define_1"] = map_coreop[".define_2"]
-
--- Define a substitution on the command line.
-function opt_map.D(args)
- local namesubst = optparam(args)
- local name, subst = match(namesubst, "^([%a_][%w_]*)=(.*)$")
- if name then
- map_def[name] = subst
- elseif match(namesubst, "^[%a_][%w_]*$") then
- map_def[namesubst] = "1"
- else
- opterror("bad define")
- end
-end
-
--- Undefine a substitution on the command line.
-function opt_map.U(args)
- local name = optparam(args)
- if match(name, "^[%a_][%w_]*$") then
- map_def[name] = nil
- else
- opterror("bad define")
- end
-end
-
--- Helper for definesubst.
-local gotsubst
-
-local function definesubst_one(word)
- local subst = map_def[word]
- if subst then gotsubst = word; return subst else return word end
-end
-
--- Iteratively substitute defines.
-local function definesubst(stmt)
- -- Limit number of iterations.
- for i=1,100 do
- gotsubst = false
- stmt = gsub(stmt, "#?[%w_]+", definesubst_one)
- if not gotsubst then break end
- end
- if gotsubst then wfatal("recursive define involving `"..gotsubst.."'") end
- return stmt
-end
-
--- Dump all defines.
-local function dumpdefines(out, lvl)
- local t = {}
- for name in pairs(map_def) do
- t[#t+1] = name
- end
- sort(t)
- out:write("Defines:\n")
- for _,name in ipairs(t) do
- local subst = map_def[name]
- if g_arch then subst = g_arch.revdef(subst) end
- out:write(format(" %-20s %s\n", name, subst))
- end
- out:write("\n")
-end
-
-------------------------------------------------------------------------------
-
--- Support variables for conditional assembly.
-local condlevel = 0
-local condstack = {}
-
-local function loadin(source, env)
- if setfenv then
- local func, err = loadstring(source)
- if func then
- setfenv(func, env)
- end
- return func, err
- else
- return load(source, nil, nil, env)
- end
-end
-
--- Evaluate condition with a Lua expression. Substitutions already performed.
-local function cond_eval(cond)
- -- No globals. All unknown identifiers evaluate to nil.
- local func, err = loadin("return "..cond, {})
- if func then
- local ok, res = pcall(func)
- if ok then
- if res == 0 then return false end -- Oh well.
- return not not res
- end
- err = res
- end
- wfatal("bad condition: "..err)
-end
-
--- Skip statements until next conditional pseudo-opcode at the same level.
-local function stmtskip()
- local dostmt_save = dostmt
- local lvl = 0
- dostmt = function(stmt)
- local op = match(stmt, "^%s*(%S+)")
- if op == ".if" then
- lvl = lvl + 1
- elseif lvl ~= 0 then
- if op == ".endif" then lvl = lvl - 1 end
- elseif op == ".elif" or op == ".else" or op == ".endif" then
- dostmt = dostmt_save
- dostmt(stmt)
- end
- end
-end
-
--- Pseudo-opcodes for conditional assembly.
-map_coreop[".if_1"] = function(params)
- if not params then return "condition" end
- local lvl = condlevel + 1
- local res = cond_eval(params[1])
- condlevel = lvl
- condstack[lvl] = res
- if not res then stmtskip() end
-end
-
-map_coreop[".elif_1"] = function(params)
- if not params then return "condition" end
- if condlevel == 0 then wfatal(".elif without .if") end
- local lvl = condlevel
- local res = condstack[lvl]
- if res then
- if res == "else" then wfatal(".elif after .else") end
- else
- res = cond_eval(params[1])
- if res then
- condstack[lvl] = res
- return
- end
- end
- stmtskip()
-end
-
-map_coreop[".else_0"] = function(params)
- if condlevel == 0 then wfatal(".else without .if") end
- local lvl = condlevel
- local res = condstack[lvl]
- condstack[lvl] = "else"
- if res then
- if res == "else" then wfatal(".else after .else") end
- stmtskip()
- end
-end
-
-map_coreop[".endif_0"] = function(params)
- local lvl = condlevel
- if lvl == 0 then wfatal(".endif without .if") end
- condlevel = lvl - 1
-end
-
--- Check for unfinished conditionals.
-local function checkconds()
- if g_errcount ~= "fatal" and condlevel ~= 0 then
- wprinterr(g_fname, ":*: error: unbalanced conditional\n")
- end
-end
-
-------------------------------------------------------------------------------
-
--- Search for a file in the given path and open it for reading.
-local function pathopen(path, name)
- local dirsep = match(package.path, "\\") and "\\" or "/"
- for _,p in ipairs(path) do
- local fullname = p == "" and name or p..dirsep..name
- local fin = io.open(fullname, "r")
- if fin then
- g_fname = fullname
- return fin
- end
- end
-end
-
--- Include a file.
-map_coreop[".include_1"] = function(params)
- if not params then return "filename" end
- local name = params[1]
- -- Save state. Ugly, I know. but upvalues are fast.
- local gf, gl, gcl, gi = g_fname, g_lineno, g_curline, g_indent
- -- Read the included file.
- local fatal = readfile(pathopen(g_opt.include, name) or
- wfatal("include file `"..name.."' not found"))
- -- Restore state.
- g_synclineno = -1
- g_fname, g_lineno, g_curline, g_indent = gf, gl, gcl, gi
- if fatal then wfatal("in include file") end
-end
-
--- Make .include and conditionals initially available, too.
-map_op[".include_1"] = map_coreop[".include_1"]
-map_op[".if_1"] = map_coreop[".if_1"]
-map_op[".elif_1"] = map_coreop[".elif_1"]
-map_op[".else_0"] = map_coreop[".else_0"]
-map_op[".endif_0"] = map_coreop[".endif_0"]
-
-------------------------------------------------------------------------------
-
--- Support variables for macros.
-local mac_capture, mac_lineno, mac_name
-local mac_active = {}
-local mac_list = {}
-
--- Pseudo-opcode to define a macro.
-map_coreop[".macro_*"] = function(mparams)
- if not mparams then return "name [, params...]" end
- -- Split off and validate macro name.
- local name = remove(mparams, 1)
- if not name then werror("missing macro name") end
- if not (match(name, "^[%a_][%w_%.]*$") or match(name, "^%.[%w_%.]+$")) then
- wfatal("bad macro name `"..name.."'")
- end
- -- Validate macro parameter names.
- local mdup = {}
- for _,mp in ipairs(mparams) do
- if not match(mp, "^[%a_][%w_]*$") then
- wfatal("bad macro parameter name `"..mp.."'")
- end
- if mdup[mp] then wfatal("duplicate macro parameter name `"..mp.."'") end
- mdup[mp] = true
- end
- -- Check for duplicate or recursive macro definitions.
- local opname = name.."_"..#mparams
- if map_op[opname] or map_op[name.."_*"] then
- wfatal("duplicate macro `"..name.."' ("..#mparams.." parameters)")
- end
- if mac_capture then wfatal("recursive macro definition") end
-
- -- Enable statement capture.
- local lines = {}
- mac_lineno = g_lineno
- mac_name = name
- mac_capture = function(stmt) -- Statement capture function.
- -- Stop macro definition with .endmacro pseudo-opcode.
- if not match(stmt, "^%s*.endmacro%s*$") then
- lines[#lines+1] = stmt
- return
- end
- mac_capture = nil
- mac_lineno = nil
- mac_name = nil
- mac_list[#mac_list+1] = opname
- -- Add macro-op definition.
- map_op[opname] = function(params)
- if not params then return mparams, lines end
- -- Protect against recursive macro invocation.
- if mac_active[opname] then wfatal("recursive macro invocation") end
- mac_active[opname] = true
- -- Setup substitution map.
- local subst = {}
- for i,mp in ipairs(mparams) do subst[mp] = params[i] end
- local mcom
- if g_opt.maccomment and g_opt.comment then
- mcom = " MACRO "..name.." ("..#mparams..")"
- wcomment("{"..mcom)
- end
- -- Loop through all captured statements
- for _,stmt in ipairs(lines) do
- -- Substitute macro parameters.
- local st = gsub(stmt, "[%w_]+", subst)
- st = definesubst(st)
- st = gsub(st, "%s*%.%.%s*", "") -- Token paste a..b.
- if mcom and sub(st, 1, 1) ~= "|" then wcomment(st) end
- -- Emit statement. Use a protected call for better diagnostics.
- local ok, err = pcall(dostmt, st)
- if not ok then
- -- Add the captured statement to the error.
- wprinterr(err, "\n", g_indent, "| ", stmt,
- "\t[MACRO ", name, " (", #mparams, ")]\n")
- end
- end
- if mcom then wcomment("}"..mcom) end
- mac_active[opname] = nil
- end
- end
-end
-
--- An .endmacro pseudo-opcode outside of a macro definition is an error.
-map_coreop[".endmacro_0"] = function(params)
- wfatal(".endmacro without .macro")
-end
-
--- Dump all macros and their contents (with -PP only).
-local function dumpmacros(out, lvl)
- sort(mac_list)
- out:write("Macros:\n")
- for _,opname in ipairs(mac_list) do
- local name = sub(opname, 1, -3)
- local params, lines = map_op[opname]()
- out:write(format(" %-20s %s\n", name, concat(params, ", ")))
- if lvl > 1 then
- for _,line in ipairs(lines) do
- out:write(" |", line, "\n")
- end
- out:write("\n")
- end
- end
- out:write("\n")
-end
-
--- Check for unfinished macro definitions.
-local function checkmacros()
- if mac_capture then
- wprinterr(g_fname, ":", mac_lineno,
- ": error: unfinished .macro `", mac_name ,"'\n")
- end
-end
-
-------------------------------------------------------------------------------
-
--- Support variables for captures.
-local cap_lineno, cap_name
-local cap_buffers = {}
-local cap_used = {}
-
--- Start a capture.
-map_coreop[".capture_1"] = function(params)
- if not params then return "name" end
- wflush()
- local name = params[1]
- if not match(name, "^[%a_][%w_]*$") then
- wfatal("bad capture name `"..name.."'")
- end
- if cap_name then
- wfatal("already capturing to `"..cap_name.."' since line "..cap_lineno)
- end
- cap_name = name
- cap_lineno = g_lineno
- -- Create or continue a capture buffer and start the output line capture.
- local buf = cap_buffers[name]
- if not buf then buf = {}; cap_buffers[name] = buf end
- g_capbuffer = buf
- g_synclineno = 0
-end
-
--- Stop a capture.
-map_coreop[".endcapture_0"] = function(params)
- wflush()
- if not cap_name then wfatal(".endcapture without a valid .capture") end
- cap_name = nil
- cap_lineno = nil
- g_capbuffer = nil
- g_synclineno = 0
-end
-
--- Dump a capture buffer.
-map_coreop[".dumpcapture_1"] = function(params)
- if not params then return "name" end
- wflush()
- local name = params[1]
- if not match(name, "^[%a_][%w_]*$") then
- wfatal("bad capture name `"..name.."'")
- end
- cap_used[name] = true
- wline(function(out)
- local buf = cap_buffers[name]
- if buf then wdumplines(out, buf) end
- end)
- g_synclineno = 0
-end
-
--- Dump all captures and their buffers (with -PP only).
-local function dumpcaptures(out, lvl)
- out:write("Captures:\n")
- for name,buf in pairs(cap_buffers) do
- out:write(format(" %-20s %4s)\n", name, "("..#buf))
- if lvl > 1 then
- local bar = rep("=", 76)
- out:write(" ", bar, "\n")
- for _,line in ipairs(buf) do
- out:write(" ", line, "\n")
- end
- out:write(" ", bar, "\n\n")
- end
- end
- out:write("\n")
-end
-
--- Check for unfinished or unused captures.
-local function checkcaptures()
- if cap_name then
- wprinterr(g_fname, ":", cap_lineno,
- ": error: unfinished .capture `", cap_name,"'\n")
- return
- end
- for name in pairs(cap_buffers) do
- if not cap_used[name] then
- wprinterr(g_fname, ":*: error: missing .dumpcapture ", name ,"\n")
- end
- end
-end
-
-------------------------------------------------------------------------------
-
--- Sections names.
-local map_sections = {}
-
--- Pseudo-opcode to define code sections.
--- TODO: Data sections, BSS sections. Needs extra C code and API.
-map_coreop[".section_*"] = function(params)
- if not params then return "name..." end
- if #map_sections > 0 then werror("duplicate section definition") end
- wflush()
- for sn,name in ipairs(params) do
- local opname = "."..name.."_0"
- if not match(name, "^[%a][%w_]*$") or
- map_op[opname] or map_op["."..name.."_*"] then
- werror("bad section name `"..name.."'")
- end
- map_sections[#map_sections+1] = name
- wline(format("#define DASM_SECTION_%s\t%d", upper(name), sn-1))
- map_op[opname] = function(params) g_arch.section(sn-1) end
- end
- wline(format("#define DASM_MAXSECTION\t\t%d", #map_sections))
-end
-
--- Dump all sections.
-local function dumpsections(out, lvl)
- out:write("Sections:\n")
- for _,name in ipairs(map_sections) do
- out:write(format(" %s\n", name))
- end
- out:write("\n")
-end
-
-------------------------------------------------------------------------------
-
--- Load architecture-specific module.
-local function loadarch(arch)
- if not match(arch, "^[%w_]+$") then return "bad arch name" end
- local ok, m_arch = pcall(require, "dasm_"..arch)
- if not ok then return "cannot load module: "..m_arch end
- g_arch = m_arch
- wflush = m_arch.passcb(wline, werror, wfatal, wwarn)
- m_arch.setup(arch, g_opt)
- map_op, map_def = m_arch.mergemaps(map_coreop, map_def)
-end
-
--- Dump architecture description.
-function opt_map.dumparch(args)
- local name = optparam(args)
- if not g_arch then
- local err = loadarch(name)
- if err then opterror(err) end
- end
-
- local t = {}
- for name in pairs(map_coreop) do t[#t+1] = name end
- for name in pairs(map_op) do t[#t+1] = name end
- sort(t)
-
- local out = stdout
- local _arch = g_arch._info
- out:write(format("%s version %s, released %s, %s\n",
- _info.name, _info.version, _info.release, _info.url))
- g_arch.dumparch(out)
-
- local pseudo = true
- out:write("Pseudo-Opcodes:\n")
- for _,sname in ipairs(t) do
- local name, nparam = match(sname, "^(.+)_([0-9%*])$")
- if name then
- if pseudo and sub(name, 1, 1) ~= "." then
- out:write("\nOpcodes:\n")
- pseudo = false
- end
- local f = map_op[sname]
- local s
- if nparam ~= "*" then nparam = nparam + 0 end
- if nparam == 0 then
- s = ""
- elseif type(f) == "string" then
- s = map_op[".template__"](nil, f, nparam)
- else
- s = f(nil, nparam)
- end
- if type(s) == "table" then
- for _,s2 in ipairs(s) do
- out:write(format(" %-12s %s\n", name, s2))
- end
- else
- out:write(format(" %-12s %s\n", name, s))
- end
- end
- end
- out:write("\n")
- exit(0)
-end
-
--- Pseudo-opcode to set the architecture.
--- Only initially available (map_op is replaced when called).
-map_op[".arch_1"] = function(params)
- if not params then return "name" end
- local err = loadarch(params[1])
- if err then wfatal(err) end
-end
-
--- Dummy .arch pseudo-opcode to improve the error report.
-map_coreop[".arch_1"] = function(params)
- if not params then return "name" end
- wfatal("duplicate .arch statement")
-end
-
-------------------------------------------------------------------------------
-
--- Dummy pseudo-opcode. Don't confuse '.nop' with 'nop'.
-map_coreop[".nop_*"] = function(params)
- if not params then return "[ignored...]" end
-end
-
--- Pseudo-opcodes to raise errors.
-map_coreop[".error_1"] = function(params)
- if not params then return "message" end
- werror(params[1])
-end
-
-map_coreop[".fatal_1"] = function(params)
- if not params then return "message" end
- wfatal(params[1])
-end
-
--- Dump all user defined elements.
-local function dumpdef(out)
- local lvl = g_opt.dumpdef
- if lvl == 0 then return end
- dumpsections(out, lvl)
- dumpdefines(out, lvl)
- if g_arch then g_arch.dumpdef(out, lvl) end
- dumpmacros(out, lvl)
- dumpcaptures(out, lvl)
-end
-
-------------------------------------------------------------------------------
-
--- Helper for splitstmt.
-local splitlvl
-
-local function splitstmt_one(c)
- if c == "(" then
- splitlvl = ")"..splitlvl
- elseif c == "[" then
- splitlvl = "]"..splitlvl
- elseif c == "{" then
- splitlvl = "}"..splitlvl
- elseif c == ")" or c == "]" or c == "}" then
- if sub(splitlvl, 1, 1) ~= c then werror("unbalanced (), [] or {}") end
- splitlvl = sub(splitlvl, 2)
- elseif splitlvl == "" then
- return " \0 "
- end
- return c
-end
-
--- Split statement into (pseudo-)opcode and params.
-local function splitstmt(stmt)
- -- Convert label with trailing-colon into .label statement.
- local label = match(stmt, "^%s*(.+):%s*$")
- if label then return ".label", {label} end
-
- -- Split at commas and equal signs, but obey parentheses and brackets.
- splitlvl = ""
- stmt = gsub(stmt, "[,%(%)%[%]{}]", splitstmt_one)
- if splitlvl ~= "" then werror("unbalanced () or []") end
-
- -- Split off opcode.
- local op, other = match(stmt, "^%s*([^%s%z]+)%s*(.*)$")
- if not op then werror("bad statement syntax") end
-
- -- Split parameters.
- local params = {}
- for p in gmatch(other, "%s*(%Z+)%z?") do
- params[#params+1] = gsub(p, "%s+$", "")
- end
- if #params > 16 then werror("too many parameters") end
-
- params.op = op
- return op, params
-end
-
--- Process a single statement.
-dostmt = function(stmt)
- -- Ignore empty statements.
- if match(stmt, "^%s*$") then return end
-
- -- Capture macro defs before substitution.
- if mac_capture then return mac_capture(stmt) end
- stmt = definesubst(stmt)
-
- -- Emit C code without parsing the line.
- if sub(stmt, 1, 1) == "|" then
- local tail = sub(stmt, 2)
- wflush()
- if sub(tail, 1, 2) == "//" then wcomment(tail) else wline(tail, true) end
- return
- end
-
- -- Split into (pseudo-)opcode and params.
- local op, params = splitstmt(stmt)
-
- -- Get opcode handler (matching # of parameters or generic handler).
- local f = map_op[op.."_"..#params] or map_op[op.."_*"]
- if not f then
- if not g_arch then wfatal("first statement must be .arch") end
- -- Improve error report.
- for i=0,9 do
- if map_op[op.."_"..i] then
- werror("wrong number of parameters for `"..op.."'")
- end
- end
- werror("unknown statement `"..op.."'")
- end
-
- -- Call opcode handler or special handler for template strings.
- if type(f) == "string" then
- map_op[".template__"](params, f)
- else
- f(params)
- end
-end
-
--- Process a single line.
-local function doline(line)
- if g_opt.flushline then wflush() end
-
- -- Assembler line?
- local indent, aline = match(line, "^(%s*)%|(.*)$")
- if not aline then
- -- No, plain C code line, need to flush first.
- wflush()
- wsync()
- wline(line, false)
- return
- end
-
- g_indent = indent -- Remember current line indentation.
-
- -- Emit C code (even from macros). Avoids echo and line parsing.
- if sub(aline, 1, 1) == "|" then
- if not mac_capture then
- wsync()
- elseif g_opt.comment then
- wsync()
- wcomment(aline)
- end
- dostmt(aline)
- return
- end
-
- -- Echo assembler line as a comment.
- if g_opt.comment then
- wsync()
- wcomment(aline)
- end
-
- -- Strip assembler comments.
- aline = gsub(aline, "//.*$", "")
-
- -- Split line into statements at semicolons.
- if match(aline, ";") then
- for stmt in gmatch(aline, "[^;]+") do dostmt(stmt) end
- else
- dostmt(aline)
- end
-end
-
-------------------------------------------------------------------------------
-
--- Write DynASM header.
-local function dasmhead(out)
- out:write(format([[
-/*
-** This file has been pre-processed with DynASM.
-** %s
-** DynASM version %s, DynASM %s version %s
-** DO NOT EDIT! The original file is in "%s".
-*/
-
-#if DASM_VERSION != %d
-#error "Version mismatch between DynASM and included encoding engine"
-#endif
-
-]], _info.url,
- _info.version, g_arch._info.arch, g_arch._info.version,
- g_fname, _info.vernum))
-end
-
--- Read input file.
-readfile = function(fin)
- g_indent = ""
- g_lineno = 0
- g_synclineno = -1
-
- -- Process all lines.
- for line in fin:lines() do
- g_lineno = g_lineno + 1
- g_curline = line
- local ok, err = pcall(doline, line)
- if not ok and wprinterr(err, "\n") then return true end
- end
- wflush()
-
- -- Close input file.
- assert(fin == stdin or fin:close())
-end
-
--- Write output file.
-local function writefile(outfile)
- local fout
-
- -- Open output file.
- if outfile == nil or outfile == "-" then
- fout = stdout
- else
- fout = assert(io.open(outfile, "w"))
- end
-
- -- Write all buffered lines
- wdumplines(fout, g_wbuffer)
-
- -- Close output file.
- assert(fout == stdout or fout:close())
-
- -- Optionally dump definitions.
- dumpdef(fout == stdout and stderr or stdout)
-end
-
--- Translate an input file to an output file.
-local function translate(infile, outfile)
- g_wbuffer = {}
- g_indent = ""
- g_lineno = 0
- g_synclineno = -1
-
- -- Put header.
- wline(dasmhead)
-
- -- Read input file.
- local fin
- if infile == "-" then
- g_fname = "(stdin)"
- fin = stdin
- else
- g_fname = infile
- fin = assert(io.open(infile, "r"))
- end
- readfile(fin)
-
- -- Check for errors.
- if not g_arch then
- wprinterr(g_fname, ":*: error: missing .arch directive\n")
- end
- checkconds()
- checkmacros()
- checkcaptures()
-
- if g_errcount ~= 0 then
- stderr:write(g_fname, ":*: info: ", g_errcount, " error",
- (type(g_errcount) == "number" and g_errcount > 1) and "s" or "",
- " in input file -- no output file generated.\n")
- dumpdef(stderr)
- exit(1)
- end
-
- -- Write output file.
- writefile(outfile)
-end
-
-------------------------------------------------------------------------------
-
--- Print help text.
-function opt_map.help()
- stdout:write("DynASM -- ", _info.description, ".\n")
- stdout:write("DynASM ", _info.version, " ", _info.release, " ", _info.url, "\n")
- stdout:write[[
-
-Usage: dynasm [OPTION]... INFILE.dasc|-
-
- -h, --help Display this help text.
- -V, --version Display version and copyright information.
-
- -o, --outfile FILE Output file name (default is stdout).
- -I, --include DIR Add directory to the include search path.
-
- -c, --ccomment Use /* */ comments for assembler lines.
- -C, --cppcomment Use // comments for assembler lines (default).
- -N, --nocomment Suppress assembler lines in output.
- -M, --maccomment Show macro expansions as comments (default off).
-
- -L, --nolineno Suppress CPP line number information in output.
- -F, --flushline Flush action list for every line.
-
- -E, --vserror Use Visual Studio style errors file(line) vs file:line
-
- -D NAME[=SUBST] Define a substitution.
- -U NAME Undefine a substitution.
-
- -P, --dumpdef Dump defines, macros, etc. Repeat for more output.
- -A, --dumparch ARCH Load architecture ARCH and dump description.
-]]
- exit(0)
-end
-
--- Print version information.
-function opt_map.version()
- stdout:write(format("%s version %s, released %s\n%s\n\n%s",
- _info.name, _info.version, _info.release, _info.url, _info.copyright))
- exit(0)
-end
-
--- Misc. options.
-function opt_map.outfile(args) g_opt.outfile = optparam(args) end
-function opt_map.include(args) insert(g_opt.include, 1, optparam(args)) end
-function opt_map.ccomment() g_opt.comment = "/*|"; g_opt.endcomment = " */" end
-function opt_map.cppcomment() g_opt.comment = "//|"; g_opt.endcomment = "" end
-function opt_map.nocomment() g_opt.comment = false end
-function opt_map.maccomment() g_opt.maccomment = true end
-function opt_map.nolineno() g_opt.cpp = false end
-function opt_map.flushline() g_opt.flushline = true end
-function opt_map.vserror() g_opt.vserror = true end
-function opt_map.dumpdef() g_opt.dumpdef = g_opt.dumpdef + 1 end
-
-------------------------------------------------------------------------------
-
--- Short aliases for long options.
-local opt_alias = {
- h = "help", ["?"] = "help", V = "version",
- o = "outfile", I = "include",
- c = "ccomment", C = "cppcomment", N = "nocomment", M = "maccomment",
- L = "nolineno", F = "flushline",
- E = "vserror",
- P = "dumpdef", A = "dumparch",
-}
-
--- Parse single option.
-local function parseopt(opt, args)
- opt_current = #opt == 1 and "-"..opt or "--"..opt
- local f = opt_map[opt] or opt_map[opt_alias[opt]]
- if not f then
- opterror("unrecognized option `", opt_current, "'. Try `--help'.\n")
- end
- f(args)
-end
-
--- Parse arguments.
-local function parseargs(args)
- -- Default options.
- g_opt.comment = "//|"
- g_opt.endcomment = ""
- g_opt.cpp = true
- g_opt.dumpdef = 0
- g_opt.include = { "" }
-
- -- Process all option arguments.
- args.argn = 1
- repeat
- local a = args[args.argn]
- if not a then break end
- local lopt, opt = match(a, "^%-(%-?)(.+)")
- if not opt then break end
- args.argn = args.argn + 1
- if lopt == "" then
- -- Loop through short options.
- for o in gmatch(opt, ".") do parseopt(o, args) end
- else
- -- Long option.
- parseopt(opt, args)
- end
- until false
-
- -- Check for proper number of arguments.
- local nargs = #args - args.argn + 1
- if nargs ~= 1 then
- if nargs == 0 then
- if g_opt.dumpdef > 0 then return dumpdef(stdout) end
- end
- opt_map.help()
- end
-
- -- Translate a single input file to a single output file
- -- TODO: Handle multiple files?
- translate(args[args.argn], g_opt.outfile)
-end
-
-------------------------------------------------------------------------------
-
--- Add the directory dynasm.lua resides in to the Lua module search path.
-local arg = arg
-if arg and arg[0] then
- local prefix = match(arg[0], "^(.*[/\\])")
- if prefix then package.path = prefix.."?.lua;"..package.path end
-end
-
--- Start DynASM.
-parseargs{...}
-
-------------------------------------------------------------------------------
-
diff --git a/plugins/MirLua/Modules/ffi/src/ffi.c b/plugins/MirLua/Modules/ffi/src/ffi.c deleted file mode 100644 index 20dcfbdc49..0000000000 --- a/plugins/MirLua/Modules/ffi/src/ffi.c +++ /dev/null @@ -1,3554 +0,0 @@ -/* vim: ts=4 sw=4 sts=4 et tw=78
- * Portions copyright (c) 2015-present, Facebook, Inc. All rights reserved.
- * Portions copyright (c) 2011 James R. McKaskill.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-#include "ffi.h"
-#include <math.h>
-
-/* Set to 1 to get extra debugging on print */
-#define DEBUG_TOSTRING 0
-
-int jit_key;
-int ctype_mt_key;
-int cdata_mt_key;
-int callback_mt_key;
-int cmodule_mt_key;
-int constants_key;
-int types_key;
-int gc_key;
-int callbacks_key;
-int functions_key;
-int abi_key;
-int next_unnamed_key;
-int niluv_key;
-int asmname_key;
-
-void push_upval(lua_State* L, int* key)
-{
- lua_pushlightuserdata(L, key);
- lua_rawget(L, LUA_REGISTRYINDEX);
-}
-
-void set_upval(lua_State* L, int* key)
-{
- lua_pushlightuserdata(L, key);
- lua_insert(L, -2);
- lua_rawset(L, LUA_REGISTRYINDEX);
-}
-
-int equals_upval(lua_State* L, int idx, int* key)
-{
- int ret;
- lua_pushvalue(L, idx);
- push_upval(L, key);
- ret = lua_rawequal(L, -2, -1);
- lua_pop(L, 2);
- return ret;
-}
-
-struct jit* get_jit(lua_State* L)
-{
- struct jit* jit;
- push_upval(L, &jit_key);
- jit = (struct jit*) lua_touserdata(L, -1);
- jit->L = L;
- lua_pop(L, 1); /* still in registry */
- return jit;
-}
-
-static int type_error(lua_State* L, int idx, const char* to_type, int to_usr, const struct ctype* to_ct)
-{
- luaL_Buffer B;
- struct ctype ft;
-
- assert(to_type || (to_usr && to_ct));
- if (to_usr) {
- to_usr = lua_absindex(L, to_usr);
- }
-
- idx = lua_absindex(L, idx);
-
- luaL_buffinit(L, &B);
- to_cdata(L, idx, &ft);
-
- if (ft.type != INVALID_TYPE) {
- push_type_name(L, -1, &ft);
- lua_pushfstring(L, "unable to convert argument %d from cdata<%s> to cdata<", idx, lua_tostring(L, -1));
- lua_remove(L, -2);
- luaL_addvalue(&B);
- } else {
- lua_pushfstring(L, "unable to convert argument %d from lua<%s> to cdata<", idx, luaL_typename(L, idx));
- luaL_addvalue(&B);
- }
-
- if (to_ct) {
- push_type_name(L, to_usr, to_ct);
- luaL_addvalue(&B);
- } else {
- luaL_addstring(&B, to_type);
- }
-
- luaL_addchar(&B, '>');
-
- luaL_pushresult(&B);
- return lua_error(L);
-}
-
-static void* userdata_toptr(lua_State* L, int idx)
-{
- void* ptr = lua_touserdata(L, idx);
- int isfile = 0;
-
- // check for FILE*
- lua_getmetatable(L, idx);
- luaL_getmetatable(L, LUA_FILEHANDLE);
- isfile = lua_rawequal(L, -1, -2);
- lua_pop(L, 2);
-
- if (isfile) {
-#if LUA_VERSION_NUM == 501
- FILE** stream = (FILE**) ptr;
- return *stream;
-#else
- luaL_Stream* stream = (luaL_Stream*) ptr;
- return stream->f;
-#endif
- }
-
- return ptr;
-}
-
-static int cdata_tointeger(lua_State* L, int idx, ptrdiff_t* val)
-{
- struct ctype ct;
- void* addr = to_cdata(L, idx, &ct);
- lua_pop(L, 1);
-
- if (ct.pointers) {
- return 0;
- }
-
- switch (ct.type) {
- case INT8_TYPE:
- *val = *(int8_t*)addr;
- return 1;
- case INT16_TYPE:
- *val = *(int16_t*)addr;
- return 1;
- case INT32_TYPE:
- *val = *(int32_t*)addr;
- return 1;
- case INT64_TYPE:
- *val = *(int64_t*)addr;
- return 1;
- default:
- return 0;
- }
-}
-
-static int64_t check_intptr(lua_State* L, int idx, void* p, struct ctype* ct)
-{
- if (ct->type == INVALID_TYPE) {
- int64_t ret;
- memset(ct, 0, sizeof(*ct));
- ct->base_size = 8;
- ct->type = INT64_TYPE;
- ct->is_defined = 1;
- ret = luaL_checknumber(L, idx);
- return ret;
-
- } else if (ct->pointers) {
- return (intptr_t) p;
- }
-
- switch (ct->type) {
- case INTPTR_TYPE:
- case FUNCTION_PTR_TYPE:
- return *(intptr_t*) p;
-
- case INT64_TYPE:
- return *(int64_t*) p;
-
- case INT32_TYPE:
- return ct->is_unsigned ? (int64_t) *(uint32_t*) p : (int64_t) *(int32_t*) p;
-
- case INT16_TYPE:
- return ct->is_unsigned ? (int64_t) *(uint16_t*) p : (int64_t) *(int16_t*) p;
-
- case INT8_TYPE:
- return ct->is_unsigned ? (int64_t) *(uint8_t*) p : (int64_t) *(int8_t*) p;
-
- default:
- type_error(L, idx, "intptr_t", 0, NULL);
- return 0;
- }
-}
-
-static int get_cfunction_address(lua_State* L, int idx, cfunction* addr);
-
-#define TO_NUMBER(TYPE, ALLOW_POINTERS) \
- TYPE ret = 0; \
- void* p; \
- struct ctype ct; \
- cfunction f; \
- \
- switch (lua_type(L, idx)) { \
- case LUA_TBOOLEAN: \
- ret = (TYPE) lua_toboolean(L, idx); \
- break; \
- \
- case LUA_TNUMBER: \
- ret = (TYPE) lua_tonumber(L, idx); \
- break; \
- \
- case LUA_TSTRING: \
- if (!ALLOW_POINTERS) { \
- type_error(L, idx, #TYPE, 0, NULL); \
- } \
- ret = (TYPE) (intptr_t) lua_tostring(L, idx); \
- break; \
- \
- case LUA_TLIGHTUSERDATA: \
- if (!ALLOW_POINTERS) { \
- type_error(L, idx, #TYPE, 0, NULL); \
- } \
- ret = (TYPE) (intptr_t) lua_topointer(L, idx); \
- break; \
- \
- case LUA_TFUNCTION: \
- if (!ALLOW_POINTERS) { \
- type_error(L, idx, #TYPE, 0, NULL); \
- } \
- if (!get_cfunction_address(L, idx, &f)) { \
- type_error(L, idx, #TYPE, 0, NULL); \
- } \
- ret = (TYPE) (intptr_t) f; \
- break; \
- \
- case LUA_TUSERDATA: \
- p = to_cdata(L, idx, &ct); \
- \
- if (ct.type == INVALID_TYPE) { \
- if (!ALLOW_POINTERS) { \
- type_error(L, idx, #TYPE, 0, NULL); \
- } \
- ret = (TYPE) (intptr_t) userdata_toptr(L, idx); \
- } else if (ct.pointers || ct.type == STRUCT_TYPE || ct.type == UNION_TYPE) {\
- if (!ALLOW_POINTERS) { \
- type_error(L, idx, #TYPE, 0, NULL); \
- } \
- ret = (TYPE) (intptr_t) p; \
- } else if (ct.type == COMPLEX_DOUBLE_TYPE) { \
- ret = (TYPE) creal(*(complex_double*) p); \
- } else if (ct.type == COMPLEX_FLOAT_TYPE) { \
- ret = (TYPE) crealf(*(complex_float*) p); \
- } else if (ct.type == DOUBLE_TYPE) { \
- ret = (TYPE) *(double*) p; \
- } else if (ct.type == FLOAT_TYPE) { \
- ret = (TYPE) *(float*) p; \
- } else { \
- ret = check_intptr(L, idx, p, &ct); \
- } \
- lua_pop(L, 1); \
- break; \
- \
- case LUA_TNIL: \
- ret = (TYPE) 0; \
- break; \
- \
- default: \
- type_error(L, idx, #TYPE, 0, NULL); \
- } \
-
-static int64_t cast_int64(lua_State* L, int idx, int is_cast)
-{ TO_NUMBER(int64_t, is_cast); return ret; }
-
-static uint64_t cast_uint64(lua_State* L, int idx, int is_cast)
-{ TO_NUMBER(uint64_t, is_cast); return ret; }
-
-int32_t check_int32(lua_State* L, int idx)
-{ return (int32_t) cast_int64(L, idx, 0); }
-
-uint32_t check_uint32(lua_State* L, int idx)
-{ return (uint32_t) cast_uint64(L, idx, 0); }
-
-int64_t check_int64(lua_State* L, int idx)
-{ return cast_int64(L, idx, 0); }
-
-uint64_t check_uint64(lua_State* L, int idx)
-{ return cast_uint64(L, idx, 0); }
-
-double check_double(lua_State* L, int idx)
-{ TO_NUMBER(double, 0); return ret; }
-
-float check_float(lua_State* L, int idx)
-{ TO_NUMBER(double, 0); return ret; }
-
-uintptr_t check_uintptr(lua_State* L, int idx)
-{ TO_NUMBER(uintptr_t, 1); return ret; }
-
-complex_double check_complex_double(lua_State* L, int idx)
-{
- double real = 0, imag = 0;
- void* p;
- struct ctype ct;
-
- switch (lua_type(L, idx)) {
- case LUA_TNUMBER:
- real = (double) lua_tonumber(L, idx);
- break;
- case LUA_TTABLE:
- lua_rawgeti(L, idx, 1);
- real = check_double(L, -1);
- lua_pop(L, 1);
-
- lua_rawgeti(L, idx, 2);
- if (lua_isnil(L, -1)) {
- imag = real;
- } else {
- imag = check_double(L, -1);
- }
- lua_pop(L, 1);
- break;
- case LUA_TUSERDATA:
- p = to_cdata(L, idx, &ct);
- if (ct.type == COMPLEX_DOUBLE_TYPE) {
- real = creal(*(complex_double*) p);
- imag = cimag(*(complex_double*) p);
- } else if (ct.type == COMPLEX_FLOAT_TYPE) {
- real = crealf(*(complex_float*) p);
- imag = cimagf(*(complex_float*) p);
- } else if (ct.type == DOUBLE_TYPE) {
- real = *(double*) p;
- } else if (ct.type == FLOAT_TYPE) {
- real = *(float*) p;
- } else {
- real = check_intptr(L, idx, p, &ct);
- }
- lua_pop(L, 1);
- break;
-
- default:
- type_error(L, idx, "complex", 0, NULL);
- }
-
- return mk_complex_double(real, imag);
-}
-
-complex_float check_complex_float(lua_State* L, int idx)
-{
- complex_double d = check_complex_double(L, idx);
- return mk_complex_float(creal(d), cimag(d));
-}
-
-static size_t unpack_vararg(lua_State* L, int i, char* to)
-{
- void* p;
- struct ctype ct;
-
- switch (lua_type(L, i)) {
- case LUA_TBOOLEAN:
- *(int*) to = lua_toboolean(L, i);
- return sizeof(int);
-
- case LUA_TNUMBER:
- *(double*) to = lua_tonumber(L, i);
- return sizeof(double);
-
- case LUA_TSTRING:
- *(const char**) to = lua_tostring(L, i);
- return sizeof(const char*);
-
- case LUA_TLIGHTUSERDATA:
- *(void**) to = lua_touserdata(L, i);
- return sizeof(void*);
-
- case LUA_TUSERDATA:
- p = to_cdata(L, i, &ct);
- lua_pop(L, 1);
-
- if (ct.type == INVALID_TYPE) {
- *(void**) to = userdata_toptr(L, i);
- return sizeof(void*);
-
- } else if (ct.pointers || ct.type == INTPTR_TYPE) {
- *(void**) to = p;
- return sizeof(void*);
-
- } else if (ct.type == INT32_TYPE) {
- *(int32_t*) to = *(int32_t*) p;
- return sizeof(int32_t);
-
- } else if (ct.type == INT64_TYPE) {
- *(int64_t*) to = *(int64_t*) p;
- return sizeof(int64_t);
- }
- goto err;
-
- case LUA_TNIL:
- *(void**) to = NULL;
- return sizeof(void*);
-
- default:
- goto err;
- }
-
-err:
- return type_error(L, i, "vararg", 0, NULL);
-}
-
-void unpack_varargs_stack(lua_State* L, int first, int last, char* to)
-{
- int i;
-
- for (i = first; i <= last; i++) {
- to += unpack_vararg(L, i, to);
- }
-}
-
-void unpack_varargs_stack_skip(lua_State* L, int first, int last, int ints_to_skip, int floats_to_skip, char* to)
-{
- int i;
-
- for (i = first; i <= last; i++) {
- int type = lua_type(L, i);
-
- if (type == LUA_TNUMBER && --floats_to_skip >= 0) {
- continue;
- } else if (type != LUA_TNUMBER && --ints_to_skip >= 0) {
- continue;
- }
-
- to += unpack_vararg(L, i, to);
- }
-}
-
-void unpack_varargs_float(lua_State* L, int first, int last, int max, char* to)
-{
- int i;
-
- for (i = first; i <= last && max > 0; i++) {
- if (lua_type(L, i) == LUA_TNUMBER) {
- unpack_vararg(L, i, to);
- to += sizeof(double);
- max--;
- }
- }
-}
-
-void unpack_varargs_int(lua_State* L, int first, int last, int max, char* to)
-{
- int i;
-
- for (i = first; i <= last && max > 0; i++) {
- if (lua_type(L, i) != LUA_TNUMBER) {
- unpack_vararg(L, i, to);
- to += sizeof(void*);
- max--;
- }
- }
-}
-
-void unpack_varargs_reg(lua_State* L, int first, int last, char* to)
-{
- int i;
-
- for (i = first; i <= last; i++) {
- unpack_vararg(L, i, to);
- to += sizeof(double);
- }
-}
-
-/* to_enum tries to convert a value at idx to the enum type indicated by to_ct
- * and uv to_usr. For strings this means it will do a string lookup for the
- * enum type. It leaves the stack unchanged. Will throw an error if the type
- * at idx can't be conerted.
- */
-int32_t check_enum(lua_State* L, int idx, int to_usr, const struct ctype* to_ct)
-{
- int32_t ret;
-
- switch (lua_type(L, idx)) {
- case LUA_TSTRING:
- /* lookup string in to_usr to find value */
- to_usr = lua_absindex(L, to_usr);
- lua_pushvalue(L, idx);
- lua_rawget(L, to_usr);
-
- if (lua_isnil(L, -1)) {
- goto err;
- }
-
- ret = (int32_t) lua_tointeger(L, -1);
- lua_pop(L, 1);
- return ret;
-
- case LUA_TUSERDATA:
- return check_int32(L, idx);
-
- case LUA_TNIL:
- return (int32_t) 0;
-
- case LUA_TNUMBER:
- return (int32_t) lua_tointeger(L, idx);
-
- default:
- goto err;
- }
-
-err:
- return type_error(L, idx, NULL, to_usr, to_ct);
-}
-
-/* to_pointer tries converts a value at idx to a pointer. It fills out ct and
- * pushes the uv of the found type. It will throw a lua error if it can not
- * convert the value to a pointer. */
-static void* check_pointer(lua_State* L, int idx, struct ctype* ct)
-{
- void* p;
- memset(ct, 0, sizeof(*ct));
- idx = lua_absindex(L, idx);
-
- switch (lua_type(L, idx)) {
- case LUA_TNIL:
- ct->type = VOID_TYPE;
- ct->pointers = 1;
- ct->is_null = 1;
- lua_pushnil(L);
- return NULL;
-
- case LUA_TNUMBER:
- ct->type = INTPTR_TYPE;
- ct->is_unsigned = 1;
- ct->pointers = 0;
- lua_pushnil(L);
- return (void*) (uintptr_t) lua_tonumber(L, idx);
-
- case LUA_TLIGHTUSERDATA:
- ct->type = VOID_TYPE;
- ct->pointers = 1;
- lua_pushnil(L);
- return lua_touserdata(L, idx);
-
- case LUA_TSTRING:
- ct->type = INT8_TYPE;
- ct->pointers = 1;
- ct->is_unsigned = IS_CHAR_UNSIGNED;
- ct->is_array = 1;
- ct->base_size = 1;
- ct->const_mask = 2;
- lua_pushnil(L);
- return (void*) lua_tolstring(L, idx, &ct->array_size);
-
- case LUA_TUSERDATA:
- p = to_cdata(L, idx, ct);
-
- if (ct->type == INVALID_TYPE) {
- /* some other type of user data */
- ct->type = VOID_TYPE;
- ct->pointers = 1;
- return userdata_toptr(L, idx);
- } else if (ct->type == STRUCT_TYPE || ct->type == UNION_TYPE) {
- return p;
- } else {
- return (void*) (intptr_t) check_intptr(L, idx, p, ct);
- }
- break;
- }
-
- type_error(L, idx, "pointer", 0, NULL);
- return NULL;
-}
-
-static int is_void_ptr(const struct ctype* ct)
-{
- return ct->type == VOID_TYPE
- && ct->pointers == 1;
-}
-
-static int is_same_type(lua_State* L, int usr1, int usr2, const struct ctype* t1, const struct ctype* t2)
-{
- if (t1->type != t2->type) {
- return 0;
- }
-
-#if LUA_VERSION_NUM == 501
- if (lua_isnil(L, usr1) != lua_isnil(L, usr2)) {
- int ret;
- usr1 = lua_absindex(L, usr1);
- usr2 = lua_absindex(L, usr2);
- push_upval(L, &niluv_key);
-
- ret = lua_rawequal(L, usr1, -1)
- || lua_rawequal(L, usr2, -1);
-
- lua_pop(L, 1);
-
- if (ret) {
- return 1;
- }
- }
-#endif
-
- return lua_rawequal(L, usr1, usr2);
-}
-
-static void set_struct(lua_State* L, int idx, void* to, int to_usr, const struct ctype* tt, int check_pointers);
-
-/* to_typed_pointer converts a value at idx to a type tt with target uv to_usr
- * checking all types. May push a temporary value so that it can create
- * structs on the fly. */
-void* check_typed_pointer(lua_State* L, int idx, int to_usr, const struct ctype* tt)
-{
- struct ctype ft;
- void* p;
-
- to_usr = lua_absindex(L, to_usr);
- idx = lua_absindex(L, idx);
-
- if (tt->pointers == 1 && (tt->type == STRUCT_TYPE || tt->type == UNION_TYPE) && lua_type(L, idx) == LUA_TTABLE) {
- /* need to construct a struct of the target type */
- struct ctype ct = *tt;
- ct.pointers = ct.is_array = 0;
- p = push_cdata(L, to_usr, &ct);
- set_struct(L, idx, p, to_usr, &ct, 1);
- return p;
- }
-
- p = check_pointer(L, idx, &ft);
-
- if (tt->pointers == 1 && ft.pointers == 0 && (ft.type == STRUCT_TYPE || ft.type == UNION_TYPE)) {
- /* auto dereference structs */
- ft.pointers = 1;
- ft.const_mask <<= 1;
- }
-
- if (is_void_ptr(tt)) {
- /* any pointer can convert to void* */
- goto suc;
-
- } else if (is_void_ptr(&ft) && (ft.pointers || ft.is_reference)) {
- /* void* can convert to any pointer */
- goto suc;
-
- } else if (ft.is_null) {
- /* NULL can convert to any pointer */
- goto suc;
-
- } else if (!is_same_type(L, to_usr, -1, tt, &ft)) {
- /* the base type is different */
- goto err;
-
- } else if (tt->pointers != ft.pointers) {
- goto err;
-
- } else if (ft.const_mask & ~tt->const_mask) {
- /* for every const in from it must be in to, there are further rules
- * for const casting (see the c++ spec), but they are hard to test
- * quickly */
- goto err;
- }
-
-suc:
- return p;
-
-err:
- type_error(L, idx, NULL, to_usr, tt);
- return NULL;
-}
-
-/**
- * gets the address of the wrapped C function for the lua function value at idx
- * and returns 1 if it exists; otherwise returns 0 and nothing is pushed */
-static int get_cfunction_address(lua_State* L, int idx, cfunction* addr)
-{
- int top = 0;
- int n = 2;
- cfunction* f = NULL;
- if (!lua_isfunction(L, idx)) return 0;
-
- top = lua_gettop(L);
-
- // Get the last upvalue
- while (lua_getupvalue(L, idx, n)) {
- lua_pop(L, 1);
- n++;
- }
-
- if (!lua_getupvalue(L, idx, n - 1))
- return 0;
-
- if (!lua_isuserdata(L, -1) || !lua_getmetatable(L, -1)) {
- lua_pop(L, 1);
- return 0;
- }
-
- push_upval(L, &callback_mt_key);
- if (!lua_rawequal(L, -1, -2)) {
- lua_pop(L, 3);
- return 0;
- }
-
- /* stack is:
- * userdata upval
- * metatable
- * callback_mt
- */
-
- f = (cfunction*)lua_touserdata(L, -3);
- *addr = f[1];
- lua_pop(L, 3);
- return 1;
-}
-
-/* to_cfunction converts a value at idx with usr table at to_usr and type tt
- * into a function. Leaves the stack unchanged. */
-static cfunction check_cfunction(lua_State* L, int idx, int to_usr, const struct ctype* tt, int check_pointers)
-{
- void* p;
- struct ctype ft;
- cfunction f;
- int top = lua_gettop(L);
-
- idx = lua_absindex(L, idx);
- to_usr = lua_absindex(L, to_usr);
-
- switch (lua_type(L, idx)) {
- case LUA_TFUNCTION:
- if (get_cfunction_address(L, idx, &f)) {
- return f;
- }
-
- /* Function cdatas are pinned and must be manually cleaned up by
- * calling func:free(). */
- push_upval(L, &callbacks_key);
- f = compile_callback(L, idx, to_usr, tt);
- lua_pushboolean(L, 1);
- lua_rawset(L, -3);
- lua_pop(L, 1); /* callbacks tbl */
- return f;
-
- case LUA_TNIL:
- return NULL;
-
- case LUA_TLIGHTUSERDATA:
- if (check_pointers) {
- goto err;
- } else {
- return (cfunction) lua_touserdata(L, idx);
- }
-
- case LUA_TUSERDATA:
- p = to_cdata(L, idx, &ft);
- assert(lua_gettop(L) == top + 1);
-
- if (ft.type == INVALID_TYPE) {
- if (check_pointers) {
- goto err;
- } else {
- lua_pop(L, 1);
- return (cfunction) lua_touserdata(L, idx);
- }
-
- } else if (ft.is_null) {
- lua_pop(L, 1);
- return NULL;
-
- } else if (!check_pointers && (ft.pointers || ft.type == INTPTR_TYPE)) {
- lua_pop(L, 1);
- return (cfunction) *(void**) p;
-
- } else if (ft.type != FUNCTION_PTR_TYPE) {
- goto err;
-
- } else if (!check_pointers) {
- lua_pop(L, 1);
- return *(cfunction*) p;
-
- } else if (ft.calling_convention != tt->calling_convention) {
- goto err;
-
- } else if (!is_same_type(L, -1, to_usr, &ft, tt)) {
- goto err;
-
- } else {
- lua_pop(L, 1);
- return *(cfunction*) p;
- }
-
- default:
- goto err;
- }
-
-err:
- type_error(L, idx, NULL, to_usr, tt);
- return NULL;
-}
-
-/* to_type_cfunction converts a value at idx with uv at to_usr and type tt to
- * a cfunction. Leaves the stack unchanged. */
-cfunction check_typed_cfunction(lua_State* L, int idx, int to_usr, const struct ctype* tt)
-{ return check_cfunction(L, idx, to_usr, tt, 1); }
-
-static void set_value(lua_State* L, int idx, void* to, int to_usr, const struct ctype* tt, int check_pointers);
-
-static void set_array(lua_State* L, int idx, void* to, int to_usr, const struct ctype* tt, int check_pointers)
-{
- size_t i, sz, esz;
- struct ctype et;
-
- idx = lua_absindex(L, idx);
- to_usr = lua_absindex(L, to_usr);
-
- switch (lua_type(L, idx)) {
- case LUA_TSTRING:
- if (tt->pointers == 1 && tt->type == INT8_TYPE) {
- const char* str = lua_tolstring(L, idx, &sz);
-
- if (!tt->is_variable_array && sz >= tt->array_size) {
- memcpy(to, str, tt->array_size);
- } else {
- /* include nul terminator */
- memcpy(to, str, sz+1);
- }
- } else {
- goto err;
- }
- break;
-
- case LUA_TTABLE:
- et = *tt;
- et.pointers--;
- et.const_mask >>= 1;
- et.is_array = 0;
- esz = et.pointers ? sizeof(void*) : et.base_size;
-
- lua_rawgeti(L, idx, 2);
-
- if (tt->is_variable_array) {
- /* we have no idea how big the array is, so set values based off
- * how many items were given to us */
- lua_pop(L, 1);
- for (i = 0; i < lua_rawlen(L, idx); i++) {
- lua_rawgeti(L, idx, (int) i + 1);
- set_value(L, -1, (char*) to + esz * i, to_usr, &et, check_pointers);
- lua_pop(L, 1);
- }
-
- } else if (lua_isnil(L, -1)) {
- /* there is no second element, so we set the whole array to the
- * first element (or nil - ie 0) if there is no first element) */
- lua_pop(L, 1);
- lua_rawgeti(L, idx, 1);
-
- if (lua_isnil(L, -1)) {
- memset(to, 0, ctype_size(L, tt));
- } else {
- /* if its still variable we have no idea how many values to set */
- for (i = 0; i < tt->array_size; i++) {
- set_value(L, -1, (char*) to + esz * i, to_usr, &et, check_pointers);
- }
- }
-
- lua_pop(L, 1);
-
- } else {
- /* there is a second element, so we set each element using the
- * equiv index in the table initializer */
- lua_pop(L, 1);
- for (i = 0; i < tt->array_size; i++) {
- lua_rawgeti(L, idx, (int) (i+1));
-
- if (lua_isnil(L, -1)) {
- /* we've hit the end of the values provided in the
- * initializer, so memset the rest to zero */
- lua_pop(L, 1);
- memset((char*) to + esz * i, 0, (tt->array_size - i) * esz);
- break;
-
- } else {
- set_value(L, -1, (char*) to + esz * i, to_usr, &et, check_pointers);
- lua_pop(L, 1);
- }
- }
- }
- break;
-
- default:
- goto err;
- }
-
- return;
-
-err:
- type_error(L, idx, NULL, to_usr, tt);
-}
-
-/* pops the member key from the stack, leaves the member user value on the
- * stack. Returns the member offset. Returns -ve if the member can not be
- * found. */
-static ptrdiff_t get_member(lua_State* L, int usr, const struct ctype* ct, struct ctype* mt)
-{
- ptrdiff_t off;
- lua_rawget(L, usr);
-
- if (lua_isnil(L, -1)) {
- lua_pop(L, 1);
- return -1;
- }
-
- *mt = *(const struct ctype*) lua_touserdata(L, -1);
- lua_getuservalue(L, -1);
- lua_replace(L, -2);
-
- if (mt->is_variable_array && ct->variable_size_known) {
- /* eg char mbr[?] */
- size_t sz = (mt->pointers > 1) ? sizeof(void*) : mt->base_size;
- assert(ct->is_variable_struct && mt->is_array);
- mt->array_size = ct->variable_increment / sz;
- mt->is_variable_array = 0;
-
- } else if (mt->is_variable_struct && ct->variable_size_known) {
- /* eg struct {char a; char b[?]} mbr; */
- assert(ct->is_variable_struct);
- mt->variable_size_known = 1;
- mt->variable_increment = ct->variable_increment;
- }
-
- off = mt->offset;
- mt->offset = 0;
- return off;
-}
-
-static void set_struct(lua_State* L, int idx, void* to, int to_usr, const struct ctype* tt, int check_pointers)
-{
- int have_first = 0;
- int have_other = 0;
- struct ctype mt;
- void* p;
-
- to_usr = lua_absindex(L, to_usr);
- idx = lua_absindex(L, idx);
-
- switch (lua_type(L, idx)) {
- case LUA_TTABLE:
- /* match up to the members based off the table initializers key - this
- * will match both numbered and named members in the user table
- * we need a special case for when no entries in the initializer -
- * zero initialize the c struct, and only one entry in the initializer
- * - set all members to this value */
- memset(to, 0, ctype_size(L, tt));
- lua_pushnil(L);
- while (lua_next(L, idx)) {
- ptrdiff_t off;
-
- if (!have_first && lua_tonumber(L, -2) == 1 && lua_tonumber(L, -1) != 0) {
- have_first = 1;
- } else if (!have_other && (lua_type(L, -2) != LUA_TNUMBER || lua_tonumber(L, -2) != 1)) {
- have_other = 1;
- }
-
- lua_pushvalue(L, -2);
- off = get_member(L, to_usr, tt, &mt);
- assert(off >= 0);
- set_value(L, -2, (char*) to + off, -1, &mt, check_pointers);
-
- /* initializer value, mt usr */
- lua_pop(L, 2);
- }
-
- /* if we only had a single non zero value then initialize all members to that value */
- if (!have_other && have_first && tt->type != UNION_TYPE) {
- size_t i, sz;
- ptrdiff_t off;
- lua_rawgeti(L, idx, 1);
- sz = lua_rawlen(L, to_usr);
-
- for (i = 2; i < sz; i++) {
- lua_pushinteger(L, i);
- off = get_member(L, to_usr, tt, &mt);
- assert(off >= 0);
- set_value(L, -2, (char*) to + off, -1, &mt, check_pointers);
- lua_pop(L, 1); /* mt usr */
- }
-
- lua_pop(L, 1); /* initializer table */
- }
- break;
-
- case LUA_TUSERDATA:
- if (check_pointers) {
- p = check_typed_pointer(L, idx, to_usr, tt);
- } else {
- struct ctype ct;
- p = check_pointer(L, idx, &ct);
- }
- memcpy(to, p, tt->base_size);
- lua_pop(L, 1);
- break;
-
- default:
- goto err;
- }
-
- return;
-
-err:
- type_error(L, idx, NULL, to_usr, tt);
-}
-
-static void set_value(lua_State* L, int idx, void* to, int to_usr, const struct ctype* tt, int check_pointers)
-{
- int top = lua_gettop(L);
-
- if (tt->is_array) {
- set_array(L, idx, to, to_usr, tt, check_pointers);
-
- } else if (tt->pointers || tt->is_reference) {
- union {
- uint8_t c[sizeof(void*)];
- void* p;
- } u;
-
- if (lua_istable(L, idx)) {
- luaL_error(L, "Can't set a pointer member to a struct that's about to be freed");
- }
-
- if (check_pointers) {
- u.p = check_typed_pointer(L, idx, to_usr, tt);
- } else {
- struct ctype ct;
- u.p = check_pointer(L, idx, &ct);
- }
-
-#ifndef ALLOW_MISALIGNED_ACCESS
- if ((uintptr_t) to & PTR_ALIGN_MASK) {
- memcpy(to, u.c, sizeof(void*));
- } else
-#endif
- {
- *(void**) to = u.p;
- }
-
- lua_pop(L, 1);
-
- } else if (tt->is_bitfield) {
-
- uint64_t hi_mask = UINT64_C(0) - (UINT64_C(1) << (tt->bit_offset + tt->bit_size));
- uint64_t low_mask = (UINT64_C(1) << tt->bit_offset) - UINT64_C(1);
- uint64_t val = check_uint64(L, idx);
- val &= (UINT64_C(1) << tt->bit_size) - 1;
- val <<= tt->bit_offset;
- *(uint64_t*) to = val | (*(uint64_t*) to & (hi_mask | low_mask));
-
- } else if (tt->type == STRUCT_TYPE || tt->type == UNION_TYPE) {
- set_struct(L, idx, to, to_usr, tt, check_pointers);
-
- } else {
-
-#ifndef ALLOW_MISALIGNED_ACCESS
- union {
- uint8_t c[8];
- _Bool b;
- uint64_t u64;
- float f;
- double d;
- cfunction func;
- } misalign;
-
- void* origto = to;
-
- if ((uintptr_t) origto & (tt->base_size - 1)) {
- to = misalign.c;
- }
-#endif
-
- switch (tt->type) {
- case BOOL_TYPE:
- *(_Bool*) to = (cast_int64(L, idx, !check_pointers) != 0);
- break;
- case INT8_TYPE:
- if (tt->is_unsigned) {
- *(uint8_t*) to = (uint8_t) cast_uint64(L, idx, !check_pointers);
- } else {
- *(int8_t*) to = (int8_t) cast_int64(L, idx, !check_pointers);
- }
- break;
- case INT16_TYPE:
- if (tt->is_unsigned) {
- *(uint16_t*) to = (uint16_t) cast_uint64(L, idx, !check_pointers);
- } else {
- *(int16_t*) to = (int16_t) cast_int64(L, idx, !check_pointers);
- }
- break;
- case INT32_TYPE:
- if (tt->is_unsigned) {
- *(uint32_t*) to = (uint32_t) cast_uint64(L, idx, !check_pointers);
- } else {
- *(int32_t*) to = (int32_t) cast_int64(L, idx, !check_pointers);
- }
- break;
- case INT64_TYPE:
- if (tt->is_unsigned) {
- *(uint64_t*) to = cast_uint64(L, idx, !check_pointers);
- } else {
- *(int64_t*) to = cast_int64(L, idx, !check_pointers);
- }
- break;
- case FLOAT_TYPE:
- *(float*) to = (float) check_double(L, idx);
- break;
- case DOUBLE_TYPE:
- *(double*) to = check_double(L, idx);
- break;
- case COMPLEX_FLOAT_TYPE:
- *(complex_float*) to = check_complex_float(L, idx);
- break;
- case COMPLEX_DOUBLE_TYPE:
- *(complex_double*) to = check_complex_double(L, idx);
- break;
- case INTPTR_TYPE:
- *(uintptr_t*) to = check_uintptr(L, idx);
- break;
- case ENUM_TYPE:
- *(int32_t*) to = check_enum(L, idx, to_usr, tt);
- break;
- case FUNCTION_PTR_TYPE:
- *(cfunction*) to = check_cfunction(L, idx, to_usr, tt, check_pointers);
- break;
- default:
- goto err;
- }
-
-#ifndef ALLOW_MISALIGNED_ACCESS
- if ((uintptr_t) origto & (tt->base_size - 1)) {
- memcpy(origto, misalign.c, tt->base_size);
- }
-#endif
- }
-
- assert(lua_gettop(L) == top);
- return;
-err:
- type_error(L, idx, NULL, to_usr, tt);
-}
-
-static int ffi_typeof(lua_State* L)
-{
- struct ctype ct;
- check_ctype(L, 1, &ct);
- push_ctype(L, -1, &ct);
- return 1;
-}
-
-static void setmintop(lua_State* L, int idx)
-{
- if (lua_gettop(L) < idx) {
- lua_settop(L, idx);
- }
-}
-
-/* warning: in the case that it finds an array size, it removes that index */
-static void get_variable_array_size(lua_State* L, int idx, struct ctype* ct)
-{
- /* we only care about the variable buisness for the variable array
- * directly ie ffi.new('char[?]') or the struct that contains the variable
- * array ffi.new('struct {char v[?]}'). A pointer to the struct doesn't
- * care about the variable size (it treats it as a zero sized array). */
-
- if (ct->is_variable_array) {
- assert(ct->is_array);
- ct->array_size = (size_t) luaL_checknumber(L, idx);
- ct->is_variable_array = 0;
- lua_remove(L, idx);
-
- } else if (ct->is_variable_struct && !ct->variable_size_known) {
- assert(ct->type == STRUCT_TYPE && !ct->is_array);
- ct->variable_increment *= (size_t) luaL_checknumber(L, idx);
- ct->variable_size_known = 1;
- lua_remove(L, idx);
- }
-}
-
-static int is_scalar(struct ctype* ct)
-{
- int type = ct->type;
- if (ct->pointers || ct->is_reference) {
- return !ct->is_array;
- }
- return type != STRUCT_TYPE && type != UNION_TYPE && !IS_COMPLEX(type);
-}
-
-static int should_pack(lua_State *L, int ct_usr, struct ctype* ct, int idx)
-{
- struct ctype argt;
- int same = 0;
- ct_usr = lua_absindex(L, ct_usr);
-
- if (IS_COMPLEX(ct->type)) {
- return 0;
- }
-
- switch (lua_type(L, idx)) {
- case LUA_TTABLE:
- return 0;
- case LUA_TSTRING:
- return ct->type == STRUCT_TYPE;
- case LUA_TUSERDATA:
- // don't pack if the argument is a cdata with the same type
- to_cdata(L, idx, &argt);
- same = is_same_type(L, ct_usr, -1, ct, &argt);
- lua_pop(L, 1);
- return !same;
- default:
- return 1;
- }
-}
-
-static int do_new(lua_State* L, int is_cast)
-{
- int cargs, i;
- void* p;
- struct ctype ct;
- int check_ptrs = !is_cast;
- int scalar = 0;
-
- check_ctype(L, 1, &ct);
-
- /* don't push a callback when we have a c function, as cb:set needs a
- * compiled callback from a lua function to work */
- if (!ct.pointers && ct.type == FUNCTION_PTR_TYPE && (lua_isnil(L, 2) || lua_isfunction(L, 2))) {
- // Get the bound C function if this is a ffi lua function
- cfunction func;
- if (get_cfunction_address(L, 2, &func)) {
- p = push_cdata(L, -1, &ct);
- *(cfunction*) p = func;
- return 1;
- }
-
- /* Function cdatas are pinned and must be manually cleaned up by
- * calling func:free(). */
- compile_callback(L, 2, -1, &ct);
- push_upval(L, &callbacks_key);
- lua_pushvalue(L, -2);
- lua_pushboolean(L, 1);
- lua_rawset(L, -3);
- lua_pop(L, 1); /* callbacks tbl */
- return 1;
- }
-
- /* this removes the vararg argument if its needed, and errors if its invalid */
- if (!is_cast) {
- get_variable_array_size(L, 2, &ct);
- }
-
- p = push_cdata(L, -1, &ct);
-
- /* if the user mt has a __gc function then call ffi.gc on this value */
- if (push_user_mt(L, -2, &ct)) {
- push_upval(L, &gc_key);
- lua_pushvalue(L, -3);
-
- /* user_mt.__gc */
- lua_pushliteral(L, "__gc");
- lua_rawget(L, -4);
-
- lua_rawset(L, -3); /* gc_upval[cdata] = user_mt.__gc */
- lua_pop(L, 2); /* user_mt and gc_upval */
- }
-
- /* stack is:
- * ctype arg
- * ctor args ... 0+
- * ctype usr
- * cdata
- */
-
- cargs = lua_gettop(L) - 3;
-
- if (cargs == 0) {
- return 1;
- }
-
- scalar = is_scalar(&ct);
- if (scalar && cargs > 1) {
- return luaL_error(L, "too many initializers");
- }
-
- if (cargs > 1 || (!scalar && should_pack(L, -2, &ct, 2))) {
- lua_createtable(L, cargs, 0);
- lua_replace(L, 1);
- for (i = 1; i <= cargs; i++) {
- lua_pushvalue(L, i + 1);
- lua_rawseti(L, 1, i);
- }
- assert(lua_gettop(L) == cargs + 3);
- set_value(L, 1, p, -2, &ct, check_ptrs);
- return 1;
- }
-
- set_value(L, 2, p, -2, &ct, check_ptrs);
- return 1;
-}
-
-static int ffi_new(lua_State* L)
-{ return do_new(L, 0); }
-
-static int ffi_cast(lua_State* L)
-{ return do_new(L, 1); }
-
-static int ctype_new(lua_State* L)
-{ return do_new(L, 0); }
-
-static int ctype_call(lua_State* L)
-{
- struct ctype ct;
- int top = lua_gettop(L);
-
- check_ctype(L, 1, &ct);
-
- if (push_user_mt(L, -1, &ct)) {
- lua_pushstring(L, "__new");
- lua_rawget(L, -2);
- if (!lua_isnil(L, -1)) {
- lua_insert(L, 1); // function at bottom of stack under args
- lua_pop(L, 2);
- lua_call(L, top, 1);
- return 1;
- }
- lua_pop(L, 2);
- }
- lua_pop(L, 1);
-
- assert(lua_gettop(L) == top);
- return do_new(L, 0);
-}
-
-static int ffi_sizeof(lua_State* L)
-{
- struct ctype ct;
- check_ctype(L, 1, &ct);
- get_variable_array_size(L, 2, &ct);
- lua_pushinteger(L, ctype_size(L, &ct));
- return 1;
-}
-
-static int ffi_alignof(lua_State* L)
-{
- struct ctype ct, mt;
- lua_settop(L, 2);
- check_ctype(L, 1, &ct);
-
- /* if no member is specified then we return the alignment of the type */
- if (lua_isnil(L, 2)) {
- lua_pushinteger(L, ct.align_mask + 1);
- return 1;
- }
-
- /* get the alignment of the member */
- lua_pushvalue(L, 2);
- if (get_member(L, -2, &ct, &mt) < 0) {
- push_type_name(L, 3, &ct);
- return luaL_error(L, "type %s has no member %s", lua_tostring(L, -1), lua_tostring(L, 2));
- }
-
- lua_pushinteger(L, mt.align_mask + 1);
- return 1;
-}
-
-static int ffi_offsetof(lua_State* L)
-{
- ptrdiff_t off;
- struct ctype ct, mt;
- lua_settop(L, 2);
- check_ctype(L, 1, &ct);
-
- lua_pushvalue(L, 2);
- off = get_member(L, -2, &ct, &mt); /* this replaces the member key at -1 with the mbr usr value */
- if (off < 0) {
- push_type_name(L, 3, &ct);
- return luaL_error(L, "type %s has no member %s", lua_tostring(L, -1), lua_tostring(L, 2));
- }
-
- lua_pushinteger(L, off);
-
- if (!mt.is_bitfield) {
- return 1;
- }
-
- lua_pushinteger(L, mt.bit_offset);
- lua_pushinteger(L, mt.bit_size);
- return 3;
-}
-
-static int ffi_istype(lua_State* L)
-{
- struct ctype tt, ft;
- check_ctype(L, 1, &tt);
- to_cdata(L, 2, &ft);
-
- if (ft.type == INVALID_TYPE) {
- goto fail;
- }
-
- if (!is_same_type(L, 3, 4, &tt, &ft)) {
- goto fail;
- }
-
- if (tt.pointers != ft.pointers) {
- goto fail;
- }
-
- if (tt.is_array != ft.is_array) {
- goto fail;
- }
-
- if (tt.is_array && tt.array_size != ft.array_size) {
- goto fail;
- }
-
- if (tt.calling_convention != ft.calling_convention) {
- goto fail;
- }
-
- lua_pushboolean(L, 1);
- return 1;
-
-fail:
- lua_pushboolean(L, 0);
- return 1;
-}
-
-static int cdata_gc(lua_State* L)
-{
- struct ctype ct;
- check_cdata(L, 1, &ct);
- lua_settop(L, 1);
-
- /* call the gc func if there is any registered */
- lua_pushvalue(L, 1);
- lua_rawget(L, lua_upvalueindex(2));
- if (!lua_isnil(L, -1)) {
- lua_pushvalue(L, 1);
- lua_pcall(L, 1, 0, 0);
- }
-
- /* unset the closure */
- lua_pushvalue(L, 1);
- lua_pushnil(L);
- lua_rawset(L, lua_upvalueindex(1));
-
- return 0;
-}
-
-static int callback_free(lua_State* L)
-{
- cfunction* p = (cfunction*) lua_touserdata(L, 1);
- // FIXME: temporarily disabled to prevent SIGTRAP on exit
- // free_code(get_jit(L), L, *p);
- return 0;
-}
-
-static int cdata_free(lua_State* L)
-{
- struct ctype ct;
- cfunction* p = (cfunction*) check_cdata(L, 1, &ct);
- lua_settop(L, 1);
-
- /* unset the closure */
- lua_pushvalue(L, 1);
- lua_pushnil(L);
- lua_rawset(L, lua_upvalueindex(1));
-
- if (ct.is_jitted) {
- free_code(get_jit(L), L, *p);
- *p = NULL;
- }
-
- return 0;
-}
-
-static int cdata_set(lua_State* L)
-{
- struct ctype ct;
- cfunction* p = (cfunction*) check_cdata(L, 1, &ct);
- luaL_checktype(L, 2, LUA_TFUNCTION);
-
- if (!ct.is_jitted) {
- luaL_error(L, "can't set the function for a non-lua callback");
- }
-
- if (*p == NULL) {
- luaL_error(L, "can't set the function for a free'd callback");
- }
-
- push_func_ref(L, *p);
- lua_pushvalue(L, 2);
- lua_rawseti(L, -2, CALLBACK_FUNC_USR_IDX);
-
- /* remove the closure for this callback as it embeds the function pointer
- * value */
- lua_pushvalue(L, 1);
- lua_pushboolean(L, 1);
- lua_rawset(L, lua_upvalueindex(1));
-
- return 0;
-}
-
-static int cdata_call(lua_State* L)
-{
- struct ctype ct;
- int top = lua_gettop(L);
- cfunction* p = (cfunction*) check_cdata(L, 1, &ct);
-
- if (push_user_mt(L, -1, &ct)) {
- lua_pushliteral(L, "__call");
- lua_rawget(L, -2);
-
- if (!lua_isnil(L, -1)) {
- lua_insert(L, 1);
- lua_pop(L, 2); /* ct_usr, user_mt */
- lua_call(L, lua_gettop(L) - 1, LUA_MULTRET);
- return lua_gettop(L);
- }
- }
- if (ct.pointers || ct.type != FUNCTION_PTR_TYPE) {
- return luaL_error(L, "only function callbacks are callable");
- }
-
- lua_pushvalue(L, 1);
- lua_rawget(L, lua_upvalueindex(1));
-
- if (!lua_isfunction(L, -1)) {
- lua_pop(L, 1);
- compile_function(L, *p, -1, &ct);
-
- assert(lua_gettop(L) == top + 2); /* uv, closure */
-
- /* closures[func] = closure */
- lua_pushvalue(L, 1);
- lua_pushvalue(L, -2);
- lua_rawset(L, lua_upvalueindex(1));
-
- lua_replace(L, 1);
- } else {
- lua_replace(L, 1);
- }
-
- lua_pop(L, 1); /* uv */
- assert(lua_gettop(L) == top);
-
- lua_call(L, lua_gettop(L) - 1, LUA_MULTRET);
- return lua_gettop(L);
-}
-
-static int user_mt_key;
-
-static int ffi_metatype(lua_State* L)
-{
- struct ctype ct;
- lua_settop(L, 2);
-
- check_ctype(L, 1, &ct);
- if (lua_type(L, 2) != LUA_TTABLE && lua_type(L, 2) != LUA_TNIL) {
- return luaL_argerror(L, 2, "metatable must be a table or nil");
- }
-
- lua_pushlightuserdata(L, &user_mt_key);
- lua_pushvalue(L, 2);
- lua_rawset(L, 3); /* user[user_mt_key] = mt */
-
- /* return the passed in ctype */
- push_ctype(L, 3, &ct);
- return 1;
-}
-
-/* push_user_mt returns 1 if the type has a user metatable and pushes it onto
- * the stack, otherwise it returns 0 and pushes nothing */
-int push_user_mt(lua_State* L, int ct_usr, const struct ctype* ct)
-{
- if (ct->type != STRUCT_TYPE && ct->type != UNION_TYPE && !IS_COMPLEX(ct->type)) {
- return 0;
- }
- if (!lua_istable(L, ct_usr)) {
- return 0;
- }
-
- ct_usr = lua_absindex(L, ct_usr);
- lua_pushlightuserdata(L, &user_mt_key);
- lua_rawget(L, ct_usr);
-
- if (lua_isnil(L, -1)) {
- lua_pop(L, 1);
- return 0;
- }
- return 1;
-}
-
-static int ffi_gc(lua_State* L)
-{
- struct ctype ct;
- lua_settop(L, 2);
- check_cdata(L, 1, &ct);
-
- push_upval(L, &gc_key);
- lua_pushvalue(L, 1);
- lua_pushvalue(L, 2);
- lua_rawset(L, -3);
-
- /* return the cdata back */
- lua_settop(L, 1);
- return 1;
-}
-
-/* lookup_cdata_index returns the offset of the found type and user value on
- * the stack if valid. Otherwise returns -ve and doesn't touch the stack.
- */
-static ptrdiff_t lookup_cdata_index(lua_State* L, int idx, int ct_usr, struct ctype* ct)
-{
- struct ctype mt;
- ptrdiff_t off;
- int type = 0;
-
- ct_usr = lua_absindex(L, ct_usr);
- type = lua_type(L, idx);
-
- switch (type) {
- case LUA_TNUMBER:
- case LUA_TUSERDATA:
- /* possibilities are array, pointer */
-
- if (!ct->pointers || is_void_ptr(ct)) {
- return -1;
- }
-
- // unbox cdata
- if (type == LUA_TUSERDATA) {
- if (!cdata_tointeger(L, idx, &off)) {
- return -1;
- }
- } else {
- off = lua_tointeger(L, idx);
- }
-
- ct->is_array = 0;
- ct->pointers--;
- ct->const_mask >>= 1;
- ct->is_reference = 0;
-
- lua_pushvalue(L, ct_usr);
-
- return (ct->pointers ? sizeof(void*) : ct->base_size) * off;
-
- case LUA_TSTRING:
- /* possibilities are struct/union, pointer to struct/union */
-
- if ((ct->type != STRUCT_TYPE && ct->type != UNION_TYPE) || ct->is_array || ct->pointers > 1) {
- return -1;
- }
-
- lua_pushvalue(L, idx);
- off = get_member(L, ct_usr, ct, &mt);
- if (off < 0) {
- return -1;
- }
-
- *ct = mt;
- return off;
-
- default:
- return -1;
- }
-}
-
-static int cdata_newindex(lua_State* L)
-{
- struct ctype tt;
- char* to;
- ptrdiff_t off;
-
- lua_settop(L, 3);
-
- to = (char*) check_cdata(L, 1, &tt);
- off = lookup_cdata_index(L, 2, -1, &tt);
-
- if (off < 0) {
- if (!push_user_mt(L, -1, &tt)) {
- goto err;
- }
-
- lua_pushliteral(L, "__newindex");
- lua_rawget(L, -2);
-
- if (lua_isnil(L, -1)) {
- goto err;
- }
-
- lua_insert(L, 1);
- lua_settop(L, 4);
- lua_call(L, 3, LUA_MULTRET);
- return lua_gettop(L);
- }
-
- if (tt.const_mask & 1) {
- return luaL_error(L, "can't set const data");
- }
-
- set_value(L, 3, to + off, -1, &tt, 1);
- return 0;
-
-err:
- push_type_name(L, 4, &tt);
- return luaL_error(L, "type %s has no member %s", lua_tostring(L, -1), lua_tostring(L, 2));
-}
-
-static int cdata_index(lua_State* L)
-{
- void* to;
- struct ctype ct;
- char* data;
- ptrdiff_t off;
-
- lua_settop(L, 2);
- data = (char*) check_cdata(L, 1, &ct);
- assert(lua_gettop(L) == 3);
-
- if (!ct.pointers) {
- switch (ct.type) {
- case FUNCTION_PTR_TYPE:
- /* Callbacks use the same metatable as standard cdata values, but have set
- * and free members. So instead of mt.__index = mt, we do the equiv here. */
- lua_getmetatable(L, 1);
- lua_pushvalue(L, 2);
- lua_rawget(L, -2);
- return 1;
-
- /* This provides the .re and .im virtual members */
- case COMPLEX_DOUBLE_TYPE:
- case COMPLEX_FLOAT_TYPE:
- if (!lua_isstring(L, 2)) {
- luaL_error(L, "invalid member for complex number");
-
- } else if (strcmp(lua_tostring(L, 2), "re") == 0) {
- lua_pushnumber(L, ct.type == COMPLEX_DOUBLE_TYPE ? creal(*(complex_double*) data) : crealf(*(complex_float*) data));
-
- } else if (strcmp(lua_tostring(L, 2), "im") == 0) {
- lua_pushnumber(L, ct.type == COMPLEX_DOUBLE_TYPE ? cimag(*(complex_double*) data) : cimagf(*(complex_float*) data));
-
- } else {
- luaL_error(L, "invalid member for complex number");
- }
- return 1;
- }
- }
-
- off = lookup_cdata_index(L, 2, -1, &ct);
-
- if (off < 0) {
- assert(lua_gettop(L) == 3);
- if (!push_user_mt(L, -1, &ct)) {
- goto err;
- }
-
- lua_pushliteral(L, "__index");
- lua_rawget(L, -2);
-
- if (lua_isnil(L, -1)) {
- goto err;
- }
-
- if (lua_istable(L, -1)) {
- lua_pushvalue(L, 2);
- lua_gettable(L, -2);
- return 1;
- }
-
- lua_insert(L, 1);
- lua_settop(L, 3);
- lua_call(L, 2, LUA_MULTRET);
- return lua_gettop(L);
-
-err:
- push_type_name(L, 3, &ct);
- return luaL_error(L, "type %s has no member %s", lua_tostring(L, -1), lua_tostring(L, 2));
- }
-
- assert(lua_gettop(L) == 4); /* ct, key, ct_usr, mbr_usr */
- data += off;
-
- if (ct.is_array) {
- /* push a reference to the array */
- ct.is_reference = 1;
- to = push_cdata(L, -1, &ct);
- *(void**) to = data;
- return 1;
-
- } else if (ct.is_bitfield) {
-
- if (ct.type == INT64_TYPE) {
- struct ctype rt;
- uint64_t val = *(uint64_t*) data;
- val >>= ct.bit_offset;
- val &= (UINT64_C(1) << ct.bit_size) - 1;
-
- memset(&rt, 0, sizeof(rt));
- rt.base_size = 8;
- rt.type = INT64_TYPE;
- rt.is_unsigned = 1;
- rt.is_defined = 1;
-
- to = push_cdata(L, 0, &rt);
- *(uint64_t*) to = val;
-
- return 1;
-
- } else if (ct.type == BOOL_TYPE) {
- uint64_t val = *(uint64_t*) data;
- lua_pushboolean(L, (int) (val & (UINT64_C(1) << ct.bit_offset)));
- return 1;
-
- } else {
- uint64_t val = *(uint64_t*) data;
- val >>= ct.bit_offset;
- val &= (UINT64_C(1) << ct.bit_size) - 1;
- lua_pushinteger(L, val);
- return 1;
- }
-
- } else if (ct.pointers) {
-#ifndef ALLOW_MISALIGNED_ACCESS
- union {
- uint8_t c[8];
- void* p;
- } misalignbuf;
-
- if ((uintptr_t) data & PTR_ALIGN_MASK) {
- memcpy(misalignbuf.c, data, sizeof(void*));
- data = misalignbuf.c;
- }
-#endif
- to = push_cdata(L, -1, &ct);
- *(void**) to = *(void**) data;
- return 1;
-
- } else if (ct.type == STRUCT_TYPE || ct.type == UNION_TYPE) {
- /* push a reference to the member */
- ct.is_reference = 1;
- to = push_cdata(L, -1, &ct);
- *(void**) to = data;
- return 1;
-
- } else if (ct.type == FUNCTION_PTR_TYPE) {
- cfunction* pf = (cfunction*) push_cdata(L, -1, &ct);
- *pf = *(cfunction*) data;
- return 1;
-
- } else {
-#ifndef ALLOW_MISALIGNED_ACCESS
- union {
- uint8_t c[8];
- double d;
- float f;
- uint64_t u64;
- } misalignbuf;
-
- assert(ct.base_size <= 8);
-
- if ((uintptr_t) data & (ct.base_size - 1)) {
- memcpy(misalignbuf.c, data, ct.base_size);
- data = misalignbuf.c;
- }
-#endif
-
- switch (ct.type) {
- case BOOL_TYPE:
- lua_pushboolean(L, *(_Bool*) data);
- break;
- case INT8_TYPE:
- lua_pushinteger(L, ct.is_unsigned ? (lua_Integer) *(uint8_t*) data : (lua_Integer) *(int8_t*) data);
- break;
- case INT16_TYPE:
- lua_pushinteger(L, ct.is_unsigned ? (lua_Integer) *(uint16_t*) data : (lua_Integer) *(int16_t*) data);
- break;
- case ENUM_TYPE:
- case INT32_TYPE:
- lua_pushinteger(L, ct.is_unsigned ? (lua_Integer) *(uint32_t*) data : (lua_Integer) *(int32_t*) data);
- break;
- case INT64_TYPE:
- to = push_cdata(L, -1, &ct);
- *(int64_t*) to = *(int64_t*) data;
- break;
- case INTPTR_TYPE:
- to = push_cdata(L, -1, &ct);
- *(intptr_t*) to = *(intptr_t*) data;
- break;
- case FLOAT_TYPE:
- lua_pushnumber(L, *(float*) data);
- break;
- case DOUBLE_TYPE:
- lua_pushnumber(L, *(double*) data);
- break;
- case COMPLEX_DOUBLE_TYPE:
- to = push_cdata(L, -1, &ct);
- *(complex_double*) to = *(complex_double*) data;
- break;
- case COMPLEX_FLOAT_TYPE:
- to = push_cdata(L, -1, &ct);
- *(complex_float*) to = *(complex_float*) data;
- break;
- default:
- luaL_error(L, "internal error: invalid member type");
- }
-
- return 1;
- }
-}
-
-static complex_double check_complex(lua_State* L, int idx, void* p, struct ctype* ct)
-{
- if (ct->type == INVALID_TYPE) {
- double d = luaL_checknumber(L, idx);
-#ifdef HAVE_COMPLEX
- return d;
-#else
- complex_double c;
- c.real = d;
- c.imag = 0;
- return c;
-#endif
- } else if (ct->type == COMPLEX_DOUBLE_TYPE) {
- return *(complex_double*) p;
- } else if (ct->type == COMPLEX_FLOAT_TYPE) {
- complex_float* f = (complex_float*) p;
-#ifdef HAVE_COMPLEX
- return *f;
-#else
- complex_double d;
- d.real = f->real;
- d.imag = f->imag;
- return d;
-#endif
- } else {
- complex_double dummy;
- type_error(L, idx, "complex", 0, NULL);
- memset(&dummy, 0, sizeof(dummy));
- return dummy;
- }
-}
-
-static int rank(const struct ctype* ct)
-{
- if (ct->pointers) {
- return 5;
- }
-
- switch (ct->type) {
- case COMPLEX_DOUBLE_TYPE:
- return 7;
- case COMPLEX_FLOAT_TYPE:
- return 6;
- case INTPTR_TYPE:
- return sizeof(intptr_t) >= sizeof(int64_t) ? 4 : 1;
- case INT64_TYPE:
- return ct->is_unsigned ? 3 : 2;
- case INT32_TYPE:
- case INT16_TYPE:
- case INT8_TYPE:
- return 2;
- default:
- return 0;
- }
-}
-
-static void push_complex(lua_State* L, complex_double res, int ct_usr, const struct ctype* ct)
-{
- if (ct->type == COMPLEX_DOUBLE_TYPE) {
- complex_double* p = (complex_double*) push_cdata(L, ct_usr, ct);
- *p = res;
- } else {
- complex_float* p = (complex_float*) push_cdata(L, ct_usr, ct);
-#ifdef HAVE_COMPLEX
- *p = (complex float) res;
-#else
- p->real = (float) res.real;
- p->imag = (float) res.imag;
-#endif
- }
-}
-
-static void push_number(lua_State* L, int64_t val, int ct_usr, const struct ctype* ct)
-{
- if ((ct->pointers || ct->type == INTPTR_TYPE) && sizeof(intptr_t) != sizeof(int64_t)) {
- intptr_t* p = (intptr_t*) push_cdata(L, ct_usr, ct);
- *p = val;
- } else {
- int64_t* p = (int64_t*) push_cdata(L, ct_usr, ct);
- *p = val;
- }
-}
-
-static int call_user_op(lua_State* L, const char* opfield, int idx, int ct_usr, const struct ctype* ct)
-{
- idx = lua_absindex(L, idx);
-
- if (push_user_mt(L, ct_usr, ct)) {
- lua_pushstring(L, opfield);
- lua_rawget(L, -2);
- if (!lua_isnil(L, -1)) {
- int top = lua_gettop(L);
- lua_pushvalue(L, idx);
- lua_call(L, 1, LUA_MULTRET);
- return lua_gettop(L) - top + 1;
- }
- lua_pop(L, 2);
- }
- return -1;
-}
-
-static int cdata_unm(lua_State* L)
-{
- struct ctype ct;
- void* p;
- int64_t val;
- int ret;
-
- lua_settop(L, 1);
- p = to_cdata(L, 1, &ct);
-
- ret = call_user_op(L, "__unm", 1, 2, &ct);
- if (ret >= 0) {
- return ret;
- }
-
- val = check_intptr(L, 1, p, &ct);
-
- if (ct.pointers) {
- luaL_error(L, "can't negate a pointer value");
- } else {
- memset(&ct, 0, sizeof(ct));
- ct.type = INT64_TYPE;
- ct.base_size = 8;
- ct.is_defined = 1;
- push_number(L, -val, 0, &ct);
- }
-
- return 1;
-}
-
-/* returns -ve if no binop was called otherwise returns the number of return
- * arguments */
-static int call_user_binop(lua_State* L, const char* opfield, int lidx, int lusr, const struct ctype* lt, int ridx, int rusr, const struct ctype* rt)
-{
- lidx = lua_absindex(L, lidx);
- ridx = lua_absindex(L, ridx);
-
- if (push_user_mt(L, lusr, lt)) {
- lua_pushstring(L, opfield);
- lua_rawget(L, -2);
-
- if (!lua_isnil(L, -1)) {
- int top = lua_gettop(L);
- lua_pushvalue(L, lidx);
- lua_pushvalue(L, ridx);
- lua_call(L, 2, LUA_MULTRET);
- return lua_gettop(L) - top + 1;
- }
-
- lua_pop(L, 2); /* user_mt and user_mt.op */
- }
-
- if (push_user_mt(L, rusr, rt)) {
- lua_pushstring(L, opfield);
- lua_rawget(L, -2);
-
- if (!lua_isnil(L, -1)) {
- int top = lua_gettop(L);
- lua_pushvalue(L, lidx);
- lua_pushvalue(L, ridx);
- lua_call(L, 2, LUA_MULTRET);
- return lua_gettop(L) - top + 1;
- }
-
- lua_pop(L, 2); /* user_mt and user_mt.op */
- }
-
- return -1;
-}
-
-static int cdata_concat(lua_State* L)
-{
- struct ctype lt, rt;
- int ret;
-
- lua_settop(L, 2);
- to_cdata(L, 1, <);
- to_cdata(L, 2, &rt);
-
- ret = call_user_binop(L, "__concat", 1, 3, <, 2, 4, &rt);
- if (ret >= 0) {
- return ret;
- }
-
- return luaL_error(L, "NYI");
-}
-
-static int cdata_len(lua_State* L)
-{
- struct ctype ct;
- int ret;
-
- lua_settop(L, 1);
- to_cdata(L, 1, &ct);
-
- ret = call_user_op(L, "__len", 1, 2, &ct);
- if (ret >= 0) {
- return ret;
- }
-
- push_type_name(L, 2, &ct);
- return luaL_error(L, "type %s does not implement the __len metamethod", lua_tostring(L, -1));
-}
-
-static int cdata_pairs(lua_State* L)
-{
- struct ctype ct;
- int ret;
-
- lua_settop(L, 1);
- to_cdata(L, 1, &ct);
-
- ret = call_user_op(L, "__pairs", 1, 2, &ct);
- if (ret >= 0) {
- return ret;
- }
-
- push_type_name(L, 2, &ct);
- return luaL_error(L, "type %s does not implement the __pairs metamethod", lua_tostring(L, -1));
-}
-
-static int cdata_ipairs(lua_State* L)
-{
- struct ctype ct;
- int ret;
-
- lua_settop(L, 1);
- to_cdata(L, 1, &ct);
-
- ret = call_user_op(L, "__ipairs", 1, 2, &ct);
- if (ret >= 0) {
- return ret;
- }
-
- push_type_name(L, 2, &ct);
- return luaL_error(L, "type %s does not implement the __ipairs metamethod", lua_tostring(L, -1));
-}
-
-static int cdata_add(lua_State* L)
-{
- struct ctype lt, rt, ct;
- void *lp, *rp;
- int ct_usr;
- int ret;
-
- lua_settop(L, 2);
-
- lp = to_cdata(L, 1, <);
- rp = to_cdata(L, 2, &rt);
- assert(lua_gettop(L) == 4);
-
- ret = call_user_binop(L, "__add", 1, 3, <, 2, 4, &rt);
- if (ret >= 0) {
- return ret;
- }
- assert(lua_gettop(L) == 4);
-
- ct_usr = rank(<) > rank(&rt) ? 3 : 4;
- ct = rank(<) > rank(&rt) ? lt : rt;
-
- if (IS_COMPLEX(ct.type)) {
- complex_double left, right, res;
-
- left = check_complex(L, 1, lp, <);
- right = check_complex(L, 2, rp, &rt);
- assert(lua_gettop(L) == 4);
-
-#ifdef HAVE_COMPLEX
- res = left + right;
-#else
- res.real = left.real + right.real;
- res.imag = left.imag + right.imag;
-#endif
-
- push_complex(L, res, ct_usr, &ct);
- return 1;
-
- } else {
- int64_t left = check_intptr(L, 1, lp, <);
- int64_t right = check_intptr(L, 2, rp, &rt);
- assert(lua_gettop(L) == 4);
-
- /* note due to 2s complement it doesn't matter if we do the addition as int or uint,
- * but the result needs to be uint64_t if either of the sources are */
-
- if (lt.pointers && rt.pointers) {
- luaL_error(L, "can't add two pointers");
-
- } else if (lt.pointers) {
- int64_t res = left + (lt.pointers > 1 ? sizeof(void*) : lt.base_size) * right;
- lt.is_array = 0;
- push_number(L, res, 3, <);
-
- } else if (rt.pointers) {
- int64_t res = right + (rt.pointers > 1 ? sizeof(void*) : rt.base_size) * left;
- rt.is_array = 0;
- push_number(L, res, 4, &rt);
-
- } else {
- push_number(L, left + right, ct_usr, &ct);
- }
-
- return 1;
- }
-}
-
-static int cdata_sub(lua_State* L)
-{
- struct ctype lt, rt, ct;
- void *lp, *rp;
- int ct_usr;
- int ret;
-
- lua_settop(L, 2);
-
- lp = to_cdata(L, 1, <);
- rp = to_cdata(L, 2, &rt);
-
- ret = call_user_binop(L, "__sub", 1, 3, <, 2, 4, &rt);
- if (ret >= 0) {
- return ret;
- }
-
- ct_usr = rank(<) > rank(&rt) ? 3 : 4;
- ct = rank(<) > rank(&rt) ? lt : rt;
-
- if (IS_COMPLEX(ct.type)) {
- complex_double left, right, res;
-
- left = check_complex(L, 1, lp, <);
- right = check_complex(L, 2, rp, &rt);
-
-#ifdef HAVE_COMPLEX
- res = left - right;
-#else
- res.real = left.real - right.real;
- res.imag = left.imag - right.imag;
-#endif
-
- push_complex(L, res, ct_usr, &ct);
- return 1;
-
- } else {
- int64_t left = check_intptr(L, 1, lp, <);
- int64_t right = check_intptr(L, 2, rp, &rt);
-
- if (rt.pointers) {
- luaL_error(L, "NYI: can't subtract a pointer value");
-
- } else if (lt.pointers) {
- int64_t res = left - (lt.pointers > 1 ? sizeof(void*) : lt.base_size) * right;
- lt.is_array = 0;
- push_number(L, res, 3, <);
-
- } else {
- int64_t res = left - right;
- push_number(L, res, ct_usr, &ct);
- }
-
- return 1;
- }
-}
-
-/* TODO fix for unsigned */
-#define NUMBER_ONLY_BINOP(OPSTR, DO_NORMAL, DO_COMPLEX) \
- struct ctype lt, rt, ct; \
- void *lp, *rp; \
- int ct_usr; \
- int ret; \
- \
- lua_settop(L, 2); \
- \
- lp = to_cdata(L, 1, <); \
- rp = to_cdata(L, 2, &rt); \
- \
- ret = call_user_binop(L, OPSTR, 1, 3, <, 2, 4, &rt); \
- if (ret >= 0) { \
- return ret; \
- } \
- \
- ct_usr = rank(<) > rank(&rt) ? 3 : 4; \
- ct = rank(<) > rank(&rt) ? lt : rt; \
- \
- if (IS_COMPLEX(ct.type)) { \
- complex_double res; \
- complex_double left = check_complex(L, 1, lp, <); \
- complex_double right = check_complex(L, 2, rp, &rt); \
- \
- DO_COMPLEX(left, right, res); \
- push_complex(L, res, ct_usr, &ct); \
- \
- } else if (lt.pointers || rt.pointers) { \
- luaL_error(L, "can't operate on a pointer value"); \
- \
- } else { \
- int64_t res; \
- int64_t left = check_intptr(L, 1, lp, <); \
- int64_t right = check_intptr(L, 2, rp, &rt); \
- \
- DO_NORMAL(left, right, res); \
- push_number(L, res, ct_usr, &ct); \
- } \
- \
- return 1
-
-#define MUL(l,r,s) s = l * r
-#define DIV(l,r,s) s = l / r
-#define MOD(l,r,s) s = l % r
-#define POW(l,r,s) s = pow(l, r)
-
-#ifdef HAVE_COMPLEX
-#define MULC(l,r,s) s = l * r
-#define DIVC(l,r,s) s = l / r
-#define MODC(l,r,s) (void) l, (void) r, memset(&s, 0, sizeof(s)), luaL_error(L, "NYI: complex mod")
-#define POWC(l,r,s) s = cpow(l, r)
-#else
-#define MULC(l,r,s) s.real = l.real * r.real - l.imag * r.imag, s.imag = l.real * r.imag + l.imag * r.real
-#define DIVC(l,r,s) s.real = (l.real * r.real + l.imag * r.imag) / (r.real * r.real + r.imag * r.imag), \
- s.imag = (l.imag * r.real - l.real * r.imag) / (r.real * r.real + r.imag * r.imag)
-#define MODC(l,r,s) (void) l, (void) r, memset(&s, 0, sizeof(s)), luaL_error(L, "NYI: complex mod")
-#define POWC(l,r,s) (void) l, (void) r, memset(&s, 0, sizeof(s)), luaL_error(L, "NYI: complex pow")
-#endif
-
-static int cdata_mul(lua_State* L)
-{ NUMBER_ONLY_BINOP("__mul", MUL, MULC); }
-
-static int cdata_div(lua_State* L)
-{ NUMBER_ONLY_BINOP("__div", DIV, DIVC); }
-
-static int cdata_mod(lua_State* L)
-{ NUMBER_ONLY_BINOP("__mod", MOD, MODC); }
-
-static int cdata_pow(lua_State* L)
-{ NUMBER_ONLY_BINOP("__pow", POW, POWC); }
-
-#define COMPARE_BINOP(OPSTR, OP, OPC) \
- struct ctype lt, rt; \
- void *lp, *rp; \
- int ret, res; \
- \
- lua_settop(L, 2); \
- \
- lp = to_cdata(L, 1, <); \
- rp = to_cdata(L, 2, &rt); \
- \
- ret = call_user_binop(L, OPSTR, 1, 3, <, 2, 4, &rt); \
- if (ret >= 0) { \
- return ret; \
- } \
- \
- if (IS_COMPLEX(lt.type) || IS_COMPLEX(rt.type)) { \
- complex_double left = check_complex(L, 1, lp, <); \
- complex_double right = check_complex(L, 2, rp, &rt); \
- \
- res = OPC(left, right); \
- \
- lua_pushboolean(L, res); \
- \
- } else { \
- int64_t left = check_intptr(L, 1, lp, <); \
- int64_t right = check_intptr(L, 2, rp, &rt); \
- \
- if (lt.pointers && rt.pointers) { \
- if (is_void_ptr(<) || is_void_ptr(&rt) || is_same_type(L, 3, 4, <, &rt)) { \
- res = OP((uint64_t) left, (uint64_t) right); \
- } else { \
- goto err; \
- } \
- \
- } else if (lt.is_null && rt.type == FUNCTION_PTR_TYPE) { \
- res = OP((uint64_t) left, (uint64_t) right); \
- \
- } else if (rt.is_null && lt.type == FUNCTION_PTR_TYPE) { \
- res = OP((uint64_t) left, (uint64_t) right); \
- \
- } else if (lt.pointers && rt.type == INTPTR_TYPE && rt.is_unsigned) {\
- res = OP((uint64_t) left, (uint64_t) right); \
- \
- } else if (rt.pointers && lt.type == INTPTR_TYPE && lt.is_unsigned) {\
- res = OP((uint64_t) left, (uint64_t) right); \
- \
- } else if (rt.pointers || lt.pointers) { \
- goto err; \
- \
- } else if (lt.is_unsigned && rt.is_unsigned) { \
- res = OP((uint64_t) left, (uint64_t) right); \
- \
- } else if (lt.is_unsigned) { \
- res = OP((int64_t) (uint64_t) left, right); \
- \
- } else if (rt.is_unsigned) { \
- res = OP(left, (int64_t) (uint64_t) right); \
- \
- } else { \
- res = OP(left, right); \
- } \
- \
- lua_pushboolean(L, res); \
- } \
- return 1
-
-#define EQ(l, r) (l) == (r)
-#define LT(l, r) (l) < (r)
-#define LE(l, r) (l) <= (r)
-
-#ifdef HAVE_COMPLEX
-#define EQC(l, r) (l) == (r)
-#else
-#define EQC(l, r) (l).real == (r).real && (l).imag == (r).imag
-#endif
-
-#define LEC(l, r) EQC(l, r), luaL_error(L, "complex numbers are non-orderable")
-#define LTC(l, r) EQC(l, r), luaL_error(L, "complex numbers are non-orderable")
-
-static int cdata_eq(lua_State* L)
-{
- COMPARE_BINOP("__eq", EQ, EQC);
-err:
- lua_pushboolean(L, 0);
- return 1;
-}
-
-static int cdata_lt(lua_State* L)
-{
- COMPARE_BINOP("__lt", LT, LTC);
-err:
- lua_getuservalue(L, 1);
- lua_getuservalue(L, 2);
- push_type_name(L, -2, <);
- push_type_name(L, -2, <);
- return luaL_error(L, "trying to compare incompatible types %s and %s", lua_tostring(L, -2), lua_tostring(L, -1));
-}
-
-static int cdata_le(lua_State* L)
-{
- COMPARE_BINOP("__le", LE, LEC);
-err:
- lua_getuservalue(L, 1);
- lua_getuservalue(L, 2);
- push_type_name(L, -2, <);
- push_type_name(L, -2, <);
- return luaL_error(L, "trying to compare incompatible types %s and %s", lua_tostring(L, -2), lua_tostring(L, -1));
-}
-
-static const char* etype_tostring(int type)
-{
- switch (type) {
- case VOID_TYPE: return "void";
- case DOUBLE_TYPE: return "double";
- case FLOAT_TYPE: return "float";
- case COMPLEX_DOUBLE_TYPE: return "complex double";
- case COMPLEX_FLOAT_TYPE: return "complex float";
- case BOOL_TYPE: return "bool";
- case INT8_TYPE: return "int8";
- case INT16_TYPE: return "int16";
- case INT32_TYPE: return "int32";
- case INT64_TYPE: return "int64";
- case INTPTR_TYPE: return "intptr";
- case ENUM_TYPE: return "enum";
- case UNION_TYPE: return "union";
- case STRUCT_TYPE: return "struct";
- case FUNCTION_PTR_TYPE: return "function ptr";
- case FUNCTION_TYPE: return "function";
- default: return "invalid";
- }
-}
-
-static void print_type(lua_State* L, const struct ctype* ct)
-{
- lua_pushfstring(L, " sz %d %d %d align %d ptr %d %d %d type %s%s %d %d %d name %d call %d %d var %d %d %d bit %d %d %d %d jit %d",
- /* sz */
- ct->base_size,
- ct->array_size,
- ct->offset,
- /* align */
- ct->align_mask,
- /* ptr */
- ct->is_array,
- ct->pointers,
- ct->const_mask,
- /* type */
- ct->is_unsigned ? "u" : "",
- etype_tostring(ct->type),
- ct->is_reference,
- ct->is_defined,
- ct->is_null,
- /* name */
- ct->has_member_name,
- /* call */
- ct->calling_convention,
- ct->has_var_arg,
- /* var */
- ct->is_variable_array,
- ct->is_variable_struct,
- ct->variable_size_known,
- /* bit */
- ct->is_bitfield,
- ct->has_bitfield,
- ct->bit_offset,
- ct->bit_size,
- /* jit */
- ct->is_jitted);
-}
-
-static int ctype_tostring(lua_State* L)
-{
- struct ctype ct;
- assert(lua_type(L, 1) == LUA_TUSERDATA);
- lua_settop(L, 1);
- check_ctype(L, 1, &ct);
- assert(lua_gettop(L) == 2);
- push_type_name(L, -1, &ct);
- lua_pushfstring(L, "ctype<%s>", lua_tostring(L, -1));
-
- if (DEBUG_TOSTRING) {
- print_type(L, &ct);
- lua_concat(L, 2);
- }
-
- return 1;
-}
-
-static int cdata_tostring(lua_State* L)
-{
- struct ctype ct;
- char buf[64];
- void* p;
- int ret;
-
- lua_settop(L, 1);
- p = to_cdata(L, 1, &ct);
-
- ret = call_user_op(L, "__tostring", 1, 2, &ct);
- if (ret >= 0) {
- return ret;
- }
-
- if (ct.pointers > 0 || ct.is_reference || ct.type == STRUCT_TYPE || ct.type == UNION_TYPE) {
- push_type_name(L, -1, &ct);
- lua_pushfstring(L, "cdata<%s>: %p", lua_tostring(L, -1), p);
-
- if (DEBUG_TOSTRING) {
- print_type(L, &ct);
- lua_concat(L, 2);
- }
-
- return 1;
- }
-
- switch (ct.type) {
- case COMPLEX_DOUBLE_TYPE:
- {
- complex_double c = *(complex_double*) p;
- lua_pushfstring(L, "%f+%fi", creal(c), cimag(c));
- }
- return 1;
-
- case COMPLEX_FLOAT_TYPE:
- {
- complex_float c = *(complex_float*) p;
- lua_pushfstring(L, "%f+%fi", crealf(c), cimagf(c));
- }
- return 1;
-
- case FUNCTION_PTR_TYPE:
- p = *(void**) p;
- push_type_name(L, -1, &ct);
- lua_pushfstring(L, "cdata<%s>: %p", lua_tostring(L, -1), *(void**) p);
- return 1;
-
- case INTPTR_TYPE:
- lua_pushfstring(L, "%p", *(uintptr_t*) p);
- return 1;
-
- case INT64_TYPE:
- sprintf(buf, ct.is_unsigned ? "%"PRIu64 : "%"PRId64, *(uint64_t*) p);
- lua_pushstring(L, buf);
- return 1;
-
- default:
- sprintf(buf, ct.is_unsigned ? "%"PRId64 : "%"PRId64, (int64_t) check_intptr(L, 1, p, &ct));
- lua_pushstring(L, buf);
- return 1;
- }
-}
-
-static int ffi_errno(lua_State* L)
-{
- struct jit* jit = get_jit(L);
-
- if (!lua_isnoneornil(L, 1)) {
- lua_pushinteger(L, jit->last_errno);
- jit->last_errno = luaL_checknumber(L, 1);
- } else {
- lua_pushinteger(L, jit->last_errno);
- }
-
- return 1;
-}
-
-static int ffi_type(lua_State* L)
-{
- if (lua_isuserdata(L, 1) && lua_getmetatable(L, 1)) {
- if (equals_upval(L, -1, &cdata_mt_key) || equals_upval(L, -1, &ctype_mt_key)) {
- lua_pushstring(L, "cdata");
- return 1;
- }
- lua_pop(L, 1); /* mt */
- }
-
- /* call the old _G.type, we use an upvalue as _G.type is set
- * to this function */
- lua_pushvalue(L, lua_upvalueindex(1));
- lua_insert(L, 1);
- lua_call(L, lua_gettop(L)-1, LUA_MULTRET);
- return lua_gettop(L);
-}
-
-static int ffi_number(lua_State* L)
-{
- struct ctype ct;
- void* data = to_cdata(L, 1, &ct);
-
- if (ct.type != INVALID_TYPE) {
- lua_pushinteger(L, check_intptr(L, 1, data, &ct));
- return 1;
- } else {
- /* call the old _G.tonumber, we use an upvalue as _G.tonumber is set
- * to this function */
- lua_pushvalue(L, lua_upvalueindex(1));
- lua_insert(L, 1);
- lua_call(L, lua_gettop(L)-1, LUA_MULTRET);
- return lua_gettop(L);
- }
-}
-
-static int ffi_string(lua_State* L)
-{
- struct ctype ct;
- char* data;
- lua_settop(L, 2);
-
- data = (char*) check_cdata(L, 1, &ct);
-
- if (is_void_ptr(&ct)) {
- lua_pushlstring(L, data, (size_t) luaL_checknumber(L, 2));
- return 1;
-
- } else if (ct.type == INT8_TYPE && ct.pointers == 1) {
- size_t sz;
-
- if (lua_isuserdata(L, 2)) {
- ptrdiff_t val;
- if (!cdata_tointeger(L, 2, &val)) {
- type_error(L, 2, "int", 0, NULL);
- }
- sz = (size_t) val;
- } else if (!lua_isnil(L, 2)) {
- sz = (size_t) luaL_checknumber(L, 2);
-
- } else if (ct.is_array && !ct.is_variable_array) {
- char* nul = memchr(data, '\0', ct.array_size);
- sz = nul ? nul - data : ct.array_size;
-
- } else {
- sz = strlen(data);
- }
-
- lua_pushlstring(L, data, sz);
- return 1;
- }
-
- return luaL_error(L, "unable to convert cdata to string");
-}
-
-static int ffi_copy(lua_State* L)
-{
- struct ctype ft, tt;
- char *to, *from;
-
- setmintop(L, 3);
- to = (char*) check_pointer(L, 1, &tt);
- from = (char*) check_pointer(L, 2, &ft);
-
- if (!lua_isnoneornil(L, 3)) {
- memcpy(to, from, (size_t) luaL_checknumber(L, 3));
-
- } else if (ft.type == INT8_TYPE && ft.pointers == 1) {
- size_t sz = ft.is_array ? ft.array_size : strlen(from);
- memcpy(to, from, sz);
- to[sz] = '\0';
- }
-
- return 0;
-}
-
-static int ffi_fill(lua_State* L)
-{
- struct ctype ct;
- void* to;
- size_t sz;
- int val = 0;
-
- setmintop(L, 3);
- to = check_pointer(L, 1, &ct);
- sz = (size_t) luaL_checknumber(L, 2);
-
- if (!lua_isnoneornil(L, 3)) {
- val = (int) luaL_checkinteger(L, 3);
- }
-
- memset(to, val, sz);
- return 0;
-}
-
-static int ffi_abi(lua_State* L)
-{
- luaL_checkstring(L, 1);
- push_upval(L, &abi_key);
- lua_pushvalue(L, 1);
- lua_rawget(L, -2);
- lua_pushboolean(L, lua_toboolean(L, -1));
- return 1;
-}
-
-static int ffi_load(lua_State* L)
-{
- const char* libname = luaL_checkstring(L, 1);
- void** lib = (void**) lua_newuserdata(L, sizeof(void*));
-
- *lib = LoadLibraryA(libname);
-
-#ifdef LIB_FORMAT_1
- if (!*lib) {
- libname = lua_pushfstring(L, LIB_FORMAT_1, lua_tostring(L, 1));
- *lib = LoadLibraryA(libname);
- lua_pop(L, 1);
- }
-#endif
-
-#ifdef LIB_FORMAT_2
- if (!*lib) {
- libname = lua_pushfstring(L, LIB_FORMAT_2, lua_tostring(L, 1));
- *lib = LoadLibraryA(libname);
- lua_pop(L, 1);
- }
-#endif
-
- if (!*lib) {
- return luaL_error(L, "could not load library %s", lua_tostring(L, 1));
- }
-
- lua_newtable(L);
- lua_setuservalue(L, -2);
-
- push_upval(L, &cmodule_mt_key);
- lua_setmetatable(L, -2);
- return 1;
-}
-
-static void* find_symbol(lua_State* L, int modidx, const char* asmname)
-{
- size_t i;
- void** libs;
- size_t num;
- void* sym = NULL;
-
- libs = (void**) lua_touserdata(L, modidx);
- num = lua_rawlen(L, modidx) / sizeof(void*);
-
- for (i = 0; i < num && sym == NULL; i++) {
- if (libs[i]) {
- sym = GetProcAddressA(libs[i], asmname);
- }
- }
-
- return sym;
-}
-
-/* pushes the user table */
-static void* lookup_global(lua_State* L, int modidx, int nameidx, const char** pname, struct ctype* ct)
-{
- int top = lua_gettop(L);
- void* sym;
-
- modidx = lua_absindex(L, modidx);
- nameidx = lua_absindex(L, nameidx);
-
- *pname = luaL_checkstring(L, nameidx);
-
- /* get the ctype */
- push_upval(L, &functions_key);
- lua_pushvalue(L, nameidx);
- lua_rawget(L, -2);
- if (lua_isnil(L, -1)) {
- luaL_error(L, "missing declaration for function/global %s", *pname);
- return NULL;
- }
-
- /* leave just the ct_usr on the stack */
- *ct = *(const struct ctype*) lua_touserdata(L, -1);
- lua_getuservalue(L, -1);
- lua_replace(L, top + 1);
- lua_pop(L, 1);
-
- assert(lua_gettop(L) == top + 1);
-
- /* get the assembly name */
- push_upval(L, &asmname_key);
- lua_pushvalue(L, nameidx);
- lua_rawget(L, -2);
- if (lua_isstring(L, -1)) {
- *pname = lua_tostring(L, -1);
- }
- lua_pop(L, 2);
-
- sym = find_symbol(L, modidx, *pname);
-
- assert(lua_gettop(L) == top + 1);
- return sym;
-}
-
-static int cmodule_index(lua_State* L)
-{
- const char* asmname;
- struct ctype ct;
- void *sym;
-
- lua_settop(L, 2);
-
- /* see if we have already loaded the function */
- lua_getuservalue(L, 1);
- lua_pushvalue(L, 2);
- lua_rawget(L, -2);
- if (!lua_isnil(L, -1)) {
- return 1;
- }
- lua_pop(L, 2);
-
- /* check the constants table */
- push_upval(L, &constants_key);
- lua_pushvalue(L, 2);
- lua_rawget(L, -2);
- if (!lua_isnil(L, -1)) {
- return 1;
- }
- lua_pop(L, 2);
-
- /* lookup_global pushes the ct_usr */
- sym = lookup_global(L, 1, 2, &asmname, &ct);
-
-#if defined _WIN32 && !defined _WIN64 && (defined __i386__ || defined _M_IX86)
- if (!sym && ct.type == FUNCTION_TYPE) {
- ct.calling_convention = STD_CALL;
- lua_pushfstring(L, "_%s@%d", asmname, x86_return_size(L, -1, &ct));
- sym = find_symbol(L, 1, lua_tostring(L, -1));
- lua_pop(L, 1);
- }
-
- if (!sym && ct.type == FUNCTION_TYPE) {
- ct.calling_convention = FAST_CALL;
- lua_pushfstring(L, "@%s@%d", asmname, x86_return_size(L, -1, &ct));
- sym = find_symbol(L, 1, lua_tostring(L, -1));
- lua_pop(L, 1);
- }
-#endif
-
- if (!sym) {
- return luaL_error(L, "failed to find function/global %s", asmname);
- }
-
- assert(lua_gettop(L) == 3); /* module, name, ct_usr */
-
- if (ct.type == FUNCTION_TYPE) {
- compile_function(L, (cfunction) sym, -1, &ct);
- assert(lua_gettop(L) == 4); /* module, name, ct_usr, function */
-
- /* set module usr value[luaname] = function to cache for next time */
- lua_getuservalue(L, 1);
- lua_pushvalue(L, 2);
- lua_pushvalue(L, -3);
- lua_rawset(L, -3);
- lua_pop(L, 1); /* module uv */
- return 1;
- }
-
- /* extern const char* foo; and extern const char foo[]; */
- if (ct.pointers == 1 && ct.type == INT8_TYPE) {
- char* str = (char*) sym;
- if (!ct.is_array) {
- str = *(char**) sym;
- }
- lua_pushstring(L, str);
- return 1;
- }
-
- /* extern struct foo foo[], extern void* foo[]; and extern struct foo foo; */
- if (ct.is_array || (!ct.pointers && (ct.type == UNION_TYPE || ct.type == STRUCT_TYPE))) {
- void* p;
- ct.is_reference = 1;
- p = push_cdata(L, -1, &ct);
- *(void**) p = sym;
- return 1;
- }
-
- /* extern void* foo; and extern void (*foo)(); */
- if (ct.pointers || ct.type == FUNCTION_PTR_TYPE) {
- void* p = push_cdata(L, -1, &ct);
- *(void**) p = *(void**) sym;
- return 1;
- }
-
- switch (ct.type) {
- case COMPLEX_DOUBLE_TYPE:
- case COMPLEX_FLOAT_TYPE:
- case INTPTR_TYPE:
- case INT64_TYPE:
- {
- /* TODO: complex float/double need to be references if .re and
- * .imag are setable */
- void* p = push_cdata(L, -1, &ct);
- memcpy(p, sym, ct.base_size);
- return 1;
- }
-
- case DOUBLE_TYPE:
- lua_pushnumber(L, *(double*) sym);
- return 1;
-
- case FLOAT_TYPE:
- lua_pushnumber(L, *(float*) sym);
- return 1;
-
- case BOOL_TYPE:
- lua_pushboolean(L, *(bool*) sym);
- return 1;
-
- case INT8_TYPE:
- lua_pushinteger(L, ct.is_unsigned ? (lua_Integer) *(uint8_t*) sym : (lua_Integer) *(int8_t*) sym);
- return 1;
-
- case INT16_TYPE:
- lua_pushinteger(L, ct.is_unsigned ? (lua_Integer) *(uint16_t*) sym : (lua_Integer) *(int16_t*) sym);
- return 1;
-
- case INT32_TYPE:
- case ENUM_TYPE:
- lua_pushinteger(L, ct.is_unsigned ? (lua_Integer) *(uint32_t*) sym : (lua_Integer) *(int32_t*) sym);
- return 1;
- }
-
- return luaL_error(L, "NYI - global value type");
-}
-
-static int cmodule_newindex(lua_State* L)
-{
- const char* name;
- void* sym;
- struct ctype ct;
-
- lua_settop(L, 3);
-
- /* pushes the ct_usr */
- sym = lookup_global(L, 1, 2, &name, &ct);
- assert(lua_gettop(L) == 4); /* module, name, value, ct_usr */
-
- if (sym == NULL) {
- return luaL_error(L, "failed to find global %s", name);
- }
-
- if (ct.type == FUNCTION_TYPE || ct.is_array || (ct.const_mask & 1)) {
- return luaL_error(L, "can not set global %s", name);
- }
-
- set_value(L, 3, sym, -1, &ct, 1);
- return 0;
-}
-
-static int jit_gc(lua_State* L)
-{
- size_t i;
- struct jit* jit = get_jit(L);
- dasm_free(jit);
- for (i = 0; i < jit->pagenum; i++) {
- FreePage(jit->pages[i], jit->pages[i]->size);
- }
- free(jit->globals);
- return 0;
-}
-
-static int ffi_debug(lua_State* L)
-{
- lua_newtable(L);
- push_upval(L, &ctype_mt_key);
- lua_setfield(L, -2, "ctype_mt");
- push_upval(L, &cdata_mt_key);
- lua_setfield(L, -2, "cdata_mt");
- push_upval(L, &cmodule_mt_key);
- lua_setfield(L, -2, "cmodule_mt");
- push_upval(L, &constants_key);
- lua_setfield(L, -2, "constants");
- push_upval(L, &types_key);
- lua_setfield(L, -2, "types");
- push_upval(L, &jit_key);
- lua_setfield(L, -2, "jit");
- push_upval(L, &gc_key);
- lua_setfield(L, -2, "gc");
- push_upval(L, &callbacks_key);
- lua_setfield(L, -2, "callbacks");
- push_upval(L, &functions_key);
- lua_setfield(L, -2, "functions");
- push_upval(L, &abi_key);
- lua_setfield(L, -2, "abi");
- push_upval(L, &next_unnamed_key);
- lua_setfield(L, -2, "next_unnamed");
- return 1;
-}
-
-static int do64(lua_State* L, int is_unsigned)
-{
- lua_Number low, high;
- struct ctype ct;
- int64_t val;
-
- lua_settop(L, 2);
-
- if (!lua_isnil(L, 2)) {
- high = luaL_checknumber(L, 1);
- low = luaL_checknumber(L, 2);
- } else {
- high = 0;
- low = luaL_checknumber(L, 1);
- }
-
- val = ((int64_t) (uint32_t) high << 32) | (int64_t) (uint32_t) low;
-
- if (!is_unsigned && (high < 0 || low < 0)) {
- val = -val;
- }
-
- memset(&ct, 0, sizeof(ct));
- ct.type = INT64_TYPE;
- ct.is_unsigned = is_unsigned;
- ct.is_defined = 1;
- ct.base_size = sizeof(int64_t);
- push_number(L, (int64_t) val, 0, &ct);
-
- return 1;
-}
-
-static int ffi_i64(lua_State* L)
-{ return do64(L, 0); }
-
-static int ffi_u64(lua_State* L)
-{ return do64(L, 1); }
-
-static const luaL_Reg cdata_mt[] = {
- {"__gc", &cdata_gc},
- {"__call", &cdata_call},
- {"free", &cdata_free},
- {"set", &cdata_set},
- {"__index", &cdata_index},
- {"__newindex", &cdata_newindex},
- {"__add", &cdata_add},
- {"__sub", &cdata_sub},
- {"__mul", &cdata_mul},
- {"__div", &cdata_div},
- {"__mod", &cdata_mod},
- {"__pow", &cdata_pow},
- {"__unm", &cdata_unm},
- {"__eq", &cdata_eq},
- {"__lt", &cdata_lt},
- {"__le", &cdata_le},
- {"__tostring", &cdata_tostring},
- {"__concat", &cdata_concat},
- {"__len", &cdata_len},
- {"__pairs", &cdata_pairs},
- {"__ipairs", &cdata_ipairs},
- {NULL, NULL}
-};
-
-static const luaL_Reg callback_mt[] = {
- {"__gc", &callback_free},
- {NULL, NULL}
-};
-
-static const luaL_Reg ctype_mt[] = {
- {"__call", &ctype_call},
- {"__new", &ctype_new},
- {"__tostring", &ctype_tostring},
- {NULL, NULL}
-};
-
-static const luaL_Reg cmodule_mt[] = {
- {"__index", &cmodule_index},
- {"__newindex", &cmodule_newindex},
- {NULL, NULL}
-};
-
-static const luaL_Reg jit_mt[] = {
- {"__gc", &jit_gc},
- {NULL, NULL}
-};
-
-static const luaL_Reg ffi_reg[] = {
- {"cdef", &ffi_cdef},
- {"load", &ffi_load},
- {"new", &ffi_new},
- {"typeof", &ffi_typeof},
- {"cast", &ffi_cast},
- {"metatype", &ffi_metatype},
- {"gc", &ffi_gc},
- {"sizeof", &ffi_sizeof},
- {"alignof", &ffi_alignof},
- {"offsetof", &ffi_offsetof},
- {"istype", &ffi_istype},
- {"errno", &ffi_errno},
- {"string", &ffi_string},
- {"copy", &ffi_copy},
- {"fill", &ffi_fill},
- {"abi", &ffi_abi},
- {"debug", &ffi_debug},
- {"i64", &ffi_i64},
- {"u64", &ffi_u64},
- {NULL, NULL}
-};
-
-/* leaves the usr table on the stack */
-static void push_builtin(lua_State* L, struct ctype* ct, const char* name, int type, int size, int align, int is_unsigned)
-{
- memset(ct, 0, sizeof(*ct));
- ct->type = type;
- ct->base_size = size;
- ct->align_mask = align;
- ct->is_defined = 1;
- ct->is_unsigned = is_unsigned;
-
- if (IS_COMPLEX(type)) {
- lua_newtable(L);
- } else {
- lua_pushnil(L);
- }
-
- push_upval(L, &types_key);
- push_ctype(L, -2, ct);
- lua_setfield(L, -2, name);
- lua_pop(L, 2); /* types, usr table */
-}
-
-static void push_builtin_undef(lua_State* L, struct ctype* ct, const char* name, int type)
-{
- memset(ct, 0, sizeof(*ct));
- ct->type = type;
-
- push_upval(L, &types_key);
- push_ctype(L, 0, ct);
- lua_setfield(L, -2, name);
- lua_pop(L, 1); /* types */
-}
-
-static void add_typedef(lua_State* L, const char* from, const char* to)
-{
- struct ctype ct;
- struct parser P;
- P.line = 1;
- P.align_mask = DEFAULT_ALIGN_MASK;
- P.next = P.prev = from;
-
- push_upval(L, &types_key);
- parse_type(L, &P, &ct);
- parse_argument(L, &P, -1, &ct, NULL, NULL);
- push_ctype(L, -1, &ct);
-
- /* stack is at +4: types, type usr, arg usr, ctype */
-
- lua_setfield(L, -4, to);
- lua_pop(L, 3); /* types, type usr, arg usr */
-}
-
-static int setup_upvals(lua_State* L)
-{
- struct jit* jit = get_jit(L);
-
- /* jit setup */
- {
- dasm_init(jit, 64);
-#ifdef _WIN32
- {
- SYSTEM_INFO si;
- GetSystemInfo(&si);
- jit->align_page_size = si.dwAllocationGranularity - 1;
- }
-#else
- jit->align_page_size = sysconf(_SC_PAGE_SIZE) - 1;
-#endif
- jit->globals = (void**) malloc(64 * sizeof(void*));
- dasm_setupglobal(jit, jit->globals, 64);
- compile_globals(jit, L);
- }
-
- /* ffi.C */
- {
-#ifdef _WIN32
- size_t sz = sizeof(HMODULE) * 6;
- HMODULE* libs = lua_newuserdata(L, sz);
- memset(libs, 0, sz);
-
- /* exe */
- GetModuleHandle(NULL);
- /* lua dll */
-#ifdef LUA_DLL_NAME
-#define STR2(tok) #tok
-#define STR(tok) STR2(tok)
- libs[1] = LoadLibraryA(STR(LUA_DLL_NAME));
-#undef STR
-#undef STR2
-#endif
-
- /* crt */
-#ifdef UNDER_CE
- libs[2] = LoadLibraryA("coredll.dll");
-#else
- GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (char*) &_fmode, &libs[2]);
- libs[3] = LoadLibraryA("kernel32.dll");
- libs[4] = LoadLibraryA("user32.dll");
- libs[5] = LoadLibraryA("gdi32.dll");
-#endif
-
- jit->lua_dll = libs[1];
- jit->kernel32_dll = libs[3];
-
-#else /* !_WIN32 */
- size_t sz = sizeof(void*) * 5;
- void** libs = lua_newuserdata(L, sz);
- memset(libs, 0, sz);
-
- libs[0] = LoadLibraryA(NULL); /* exe */
- libs[1] = LoadLibraryA("libc.so");
-#ifdef __GNUC__
- libs[2] = LoadLibraryA("libgcc.so");
-#endif
- libs[3] = LoadLibraryA("libm.so");
- libs[4] = LoadLibraryA("libdl.so");
-#endif
-
- lua_newtable(L);
- lua_setuservalue(L, -2);
-
- push_upval(L, &cmodule_mt_key);
- lua_setmetatable(L, -2);
-
- lua_setfield(L, 1, "C");
- }
-
- /* setup builtin types */
- {
- complex_double* pc;
- struct {char ch; uint16_t v;} a16;
- struct {char ch; uint32_t v;} a32;
- struct {char ch; uint64_t v;} a64;
- struct {char ch; float v;} af;
- struct {char ch; double v;} ad;
-#ifdef HAVE_LONG_DOUBLE
- struct {char ch; long double v;} ald;
-#endif
- struct {char ch; uintptr_t v;} aptr;
- struct ctype ct;
- struct {char ch; complex_float v;} cf;
- struct {char ch; complex_double v;} cd;
-#if defined HAVE_LONG_DOUBLE && defined HAVE_COMPLEX
- struct {char ch; complex long double v;} cld;
-#endif
-
- push_builtin(L, &ct, "void", VOID_TYPE, 0, 0, 0);
- push_builtin(L, &ct, "bool", BOOL_TYPE, sizeof(_Bool), sizeof(_Bool) -1, 1);
- push_builtin(L, &ct, "uint8_t", INT8_TYPE, sizeof(uint8_t), 0, 1);
- push_builtin(L, &ct, "int8_t", INT8_TYPE, sizeof(int8_t), 0, 0);
- push_builtin(L, &ct, "uint16_t", INT16_TYPE, sizeof(uint16_t), ALIGNOF(a16), 1);
- push_builtin(L, &ct, "int16_t", INT16_TYPE, sizeof(int16_t), ALIGNOF(a16), 0);
- push_builtin(L, &ct, "uint32_t", INT32_TYPE, sizeof(uint32_t), ALIGNOF(a32), 1);
- push_builtin(L, &ct, "int32_t", INT32_TYPE, sizeof(int32_t), ALIGNOF(a32), 0);
- push_builtin(L, &ct, "uint64_t", INT64_TYPE, sizeof(uint64_t), ALIGNOF(a64), 1);
- push_builtin(L, &ct, "int64_t", INT64_TYPE, sizeof(int64_t), ALIGNOF(a64), 0);
- push_builtin(L, &ct, "float", FLOAT_TYPE, sizeof(float), ALIGNOF(af), 0);
- push_builtin(L, &ct, "double", DOUBLE_TYPE, sizeof(double), ALIGNOF(ad), 0);
-#ifdef HAVE_LONG_DOUBLE
- push_builtin(L, &ct, "long double", LONG_DOUBLE_TYPE, sizeof(long double), ALIGNOF(ald), 0);
-#else
- push_builtin_undef(L, &ct, "long double", LONG_DOUBLE_TYPE);
-#endif
- push_builtin(L, &ct, "uintptr_t", INTPTR_TYPE, sizeof(uintptr_t), ALIGNOF(aptr), 1);
- push_builtin(L, &ct, "intptr_t", INTPTR_TYPE, sizeof(uintptr_t), ALIGNOF(aptr), 0);
- push_builtin(L, &ct, "complex float", COMPLEX_FLOAT_TYPE, sizeof(complex_float), ALIGNOF(cf), 0);
- push_builtin(L, &ct, "complex double", COMPLEX_DOUBLE_TYPE, sizeof(complex_double), ALIGNOF(cd), 0);
-#if defined HAVE_LONG_DOUBLE && defined HAVE_COMPLEX
- push_builtin(L, &ct, "complex long double", COMPLEX_LONG_DOUBLE_TYPE, sizeof(complex long double), ALIGNOF(cld), 0);
-#else
- push_builtin_undef(L, &ct, "complex long double", COMPLEX_LONG_DOUBLE_TYPE);
-#endif
-
- /* add NULL and i constants */
- push_upval(L, &constants_key);
-
- memset(&ct, 0, sizeof(ct));
- ct.type = VOID_TYPE;
- ct.is_defined = 1;
- ct.pointers = 1;
- ct.is_null = 1;
-
- /* add ffi.C.NULL */
- push_cdata(L, 0, &ct);
- lua_setfield(L, -2, "NULL");
-
- /* add ffi.NULL */
- push_cdata(L, 0, &ct);
- lua_setfield(L, 1, "NULL");
-
- memset(&ct, 0, sizeof(ct));
- ct.type = COMPLEX_DOUBLE_TYPE;
- ct.is_defined = 1;
- ct.base_size = sizeof(complex_double);
- pc = (complex_double*) push_cdata(L, 0, &ct);
-#ifdef HAVE_COMPLEX
- *pc = 1i;
-#else
- pc->real = 0;
- pc->imag = 1;
-#endif
- lua_setfield(L, -2, "i");
-
- lua_pop(L, 1); /* constants */
- }
-
- assert(lua_gettop(L) == 1);
-
- /* setup builtin typedefs */
- {
- add_typedef(L, "bool", "_Bool");
-
- if (sizeof(uint32_t) == sizeof(size_t)) {
- add_typedef(L, "uint32_t", "size_t");
- add_typedef(L, "int32_t", "ssize_t");
- } else if (sizeof(uint64_t) == sizeof(size_t)) {
- add_typedef(L, "uint64_t", "size_t");
- add_typedef(L, "int64_t", "ssize_t");
- }
-
- if (sizeof(int32_t) == sizeof(intptr_t)) {
- add_typedef(L, "int32_t", "intptr_t");
- add_typedef(L, "int32_t", "ptrdiff_t");
- } else if (sizeof(int64_t) == sizeof(intptr_t)) {
- add_typedef(L, "int64_t", "intptr_t");
- add_typedef(L, "int64_t", "ptrdiff_t");
- }
-
- if (sizeof(uint8_t) == sizeof(wchar_t)) {
- add_typedef(L, "uint8_t", "wchar_t");
- } else if (sizeof(uint16_t) == sizeof(wchar_t)) {
- add_typedef(L, "uint16_t", "wchar_t");
- } else if (sizeof(uint32_t) == sizeof(wchar_t)) {
- add_typedef(L, "uint32_t", "wchar_t");
- }
-
- if (sizeof(va_list) == sizeof(char*)) {
- add_typedef(L, "char*", "va_list");
- } else {
- struct {char ch; va_list v;} av;
- lua_pushfstring(L, "struct {char data[%d] __attribute__((align(%d)));}", (int) sizeof(va_list), (int) ALIGNOF(av) + 1);
- add_typedef(L, lua_tostring(L, -1), "va_list");
- lua_pop(L, 1);
- }
-
- add_typedef(L, "va_list", "__builtin_va_list");
- add_typedef(L, "va_list", "__gnuc_va_list");
- }
-
- assert(lua_gettop(L) == 1);
-
- /* setup ABI params table */
- push_upval(L, &abi_key);
-
-#if defined ARCH_X86 || defined ARCH_ARM
- lua_pushboolean(L, 1);
- lua_setfield(L, -2, "32bit");
-#elif defined ARCH_X64
- lua_pushboolean(L, 1);
- lua_setfield(L, -2, "64bit");
-#else
-#error
-#endif
-
-#if defined ARCH_X86 || defined ARCH_X64 || defined ARCH_ARM
- lua_pushboolean(L, 1);
- lua_setfield(L, -2, "le");
-#else
-#error
-#endif
-
-#if defined ARCH_X86 || defined ARCH_X64
- lua_pushboolean(L, 1);
- lua_setfield(L, -2, "fpu");
-#elif defined ARCH_ARM
- lua_pushboolean(L, 1);
- lua_setfield(L, -2, "softfp");
-#else
-#error
-#endif
- lua_pop(L, 1); /* abi tbl */
-
-
- /* GC table - shouldn't pin cdata values */
- push_upval(L, &gc_key);
- lua_newtable(L);
- lua_pushliteral(L, "k");
- lua_setfield(L, -2, "__mode");
- lua_setmetatable(L, -2);
- lua_pop(L, 1); /* gc table */
-
-
- /* ffi.os */
-#if defined OS_CE
- lua_pushliteral(L, "WindowsCE");
-#elif defined OS_WIN
- lua_pushliteral(L, "Windows");
-#elif defined OS_OSX
- lua_pushliteral(L, "OSX");
-#elif defined OS_LINUX
- lua_pushliteral(L, "Linux");
-#elif defined OS_BSD
- lua_pushliteral(L, "BSD");
-#elif defined OS_POSIX
- lua_pushliteral(L, "POSIX");
-#else
- lua_pushliteral(L, "Other");
-#endif
- lua_setfield(L, 1, "os");
-
-
- /* ffi.arch */
-#if defined ARCH_X86
- lua_pushliteral(L, "x86");
-#elif defined ARCH_X64
- lua_pushliteral(L, "x64");
-#elif defined ARCH_ARM
- lua_pushliteral(L, "arm");
-#else
-# error
-#endif
- lua_setfield(L, 1, "arch");
-
- assert(lua_gettop(L) == 1);
-
- return 0;
-}
-
-static void setup_mt(lua_State* L, const luaL_Reg* mt, int upvals)
-{
- lua_pushboolean(L, 1);
- lua_setfield(L, -upvals-2, "__metatable");
- luaL_setfuncs(L, mt, upvals);
-}
-
-int luaopen_ffi(lua_State* L)
-{
- lua_settop(L, 0);
-
- lua_newtable(L);
- set_upval(L, &niluv_key);
-
- lua_newtable(L);
- setup_mt(L, ctype_mt, 0);
- set_upval(L, &ctype_mt_key);
-
- lua_newtable(L);
- set_upval(L, &callbacks_key);
-
- lua_newtable(L);
- set_upval(L, &gc_key);
-
- lua_newtable(L);
- push_upval(L, &callbacks_key);
- push_upval(L, &gc_key);
- setup_mt(L, cdata_mt, 2);
- set_upval(L, &cdata_mt_key);
-
- lua_newtable(L);
- setup_mt(L, callback_mt, 0);
- set_upval(L, &callback_mt_key);
-
- lua_newtable(L);
- setup_mt(L, cmodule_mt, 0);
- set_upval(L, &cmodule_mt_key);
-
- memset(lua_newuserdata(L, sizeof(struct jit)), 0, sizeof(struct jit));
- lua_newtable(L);
- setup_mt(L, jit_mt, 0);
- lua_setmetatable(L, -2);
- set_upval(L, &jit_key);
-
- lua_newtable(L);
- set_upval(L, &constants_key);
-
- lua_newtable(L);
- set_upval(L, &types_key);
-
- lua_newtable(L);
- set_upval(L, &functions_key);
-
- lua_newtable(L);
- set_upval(L, &asmname_key);
-
- lua_newtable(L);
- set_upval(L, &abi_key);
-
- lua_pushinteger(L, 1);
- set_upval(L, &next_unnamed_key);
-
- assert(lua_gettop(L) == 0);
-
- /* ffi table */
- lua_newtable(L);
- luaL_setfuncs(L, ffi_reg, 0);
-
- /* setup_upvals(ffi tbl) */
- lua_pushcfunction(L, &setup_upvals);
- lua_pushvalue(L, 1);
- lua_call(L, 1, 0);
-
- assert(lua_gettop(L) == 1);
-
- lua_getglobal(L, "tonumber");
- lua_pushcclosure(L, &ffi_number, 1);
- lua_pushvalue(L, -1);
- lua_setglobal(L, "tonumber");
- lua_setfield(L, -2, "number"); /* ffi.number */
-
- lua_getglobal(L, "type");
- lua_pushcclosure(L, &ffi_type, 1);
- lua_pushvalue(L, -1);
- lua_setglobal(L, "type");
- lua_setfield(L, -2, "type"); /* ffi.type */
- return 1;
-}
diff --git a/plugins/MirLua/Modules/ffi/src/ffi.h b/plugins/MirLua/Modules/ffi/src/ffi.h deleted file mode 100644 index 48e5d2c761..0000000000 --- a/plugins/MirLua/Modules/ffi/src/ffi.h +++ /dev/null @@ -1,460 +0,0 @@ -/* vim: ts=4 sw=4 sts=4 et tw=78
- * Portions copyright (c) 2015-present, Facebook, Inc. All rights reserved.
- * Portions copyright (c) 2011 James R. McKaskill.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-#define LUA_FFI_BUILD_AS_DLL
-
-#include <stdint.h>
-
-#if _MSC_VER < 1800
-# include "msvc/stdbool.h"
-# include <msapi/inttypes.h>
-#else
-# include <stdbool.h>
-# include <inttypes.h>
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-
-#ifdef __cplusplus
-# define EXTERN_C extern "C"
-extern "C"
-{
-#else
-# define EXTERN_C extern
-#endif
-# include "..\..\..\..\..\libs\liblua\src\lua.h"
-# include "..\..\..\..\..\libs\liblua\src\lauxlib.h"
-# include "..\..\..\..\..\libs\liblua\src\lualib.h"
-
-#ifdef __cplusplus
-}
-#endif
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <errno.h>
-#include <unistd.h>
-#include <dlfcn.h>
-#include <sys/mman.h>
-#endif
-
-//#include <complex.h>
-//#define HAVE_COMPLEX
-#define HAVE_LONG_DOUBLE
-
-#ifndef NDEBUG
-#define DASM_CHECKS
-#endif
-
-struct jit;
-#define Dst_DECL struct jit* Dst
-#define Dst_REF (Dst->ctx)
-#define DASM_EXTERN(a,b,c,d) get_extern(a,b,c,d)
-
-#include "dynasm/dasm_proto.h"
-
-#if defined LUA_FFI_BUILD_AS_DLL
-# define EXPORT __declspec(dllexport)
-#elif defined __GNUC__
-# define EXPORT __attribute__((visibility("default")))
-#else
-# define EXPORT
-#endif
-
-EXTERN_C EXPORT int luaopen_ffi(lua_State* L);
-
-static int lua_absindex2(lua_State* L, int idx) {
- return (LUA_REGISTRYINDEX <= idx && idx < 0)
- ? lua_gettop(L) + idx + 1
- : idx;
-}
-/* use our own version of lua_absindex such that lua_absindex(L, 0) == 0 */
-#define lua_absindex(L, idx) lua_absindex2(L, idx)
-
-#if LUA_VERSION_NUM == 501
-static void lua_callk(lua_State *L, int nargs, int nresults, int ctx, lua_CFunction k)
-{
- lua_call(L, nargs, nresults);
-}
-/*
-** set functions from list 'l' into table at top - 'nup'; each
-** function gets the 'nup' elements at the top as upvalues.
-** Returns with only the table at the stack.
-*/
-static void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
- luaL_checkstack(L, nup, "too many upvalues");
- for (; l && l->name; l++) { /* fill the table with given functions */
- int i;
- for (i = 0; i < nup; i++) /* copy upvalues to the top */
- lua_pushvalue(L, -nup);
- lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */
- lua_setfield(L, -(nup + 2), l->name);
- }
- lua_pop(L, nup); /* remove upvalues */
-}
-#define lua_setuservalue lua_setfenv
-#define lua_getuservalue lua_getfenv
-#define lua_rawlen lua_objlen
-static char* luaL_prepbuffsize(luaL_Buffer* B, size_t sz) {
- if (sz > LUAL_BUFFERSIZE) {
- luaL_error(B->L, "string too long");
- }
- return luaL_prepbuffer(B);
-}
-#elif LUA_VERSION_NUM == 503
-static void (lua_remove)(lua_State *L, int idx) {
- lua_remove(L, idx);
-}
-#endif
-
-/* architectures */
-#if defined _WIN32 && defined UNDER_CE
-# define OS_CE
-#elif defined _WIN32
-# define OS_WIN
-#elif defined __APPLE__ && defined __MACH__
-# define OS_OSX
-#elif defined __linux__
-# define OS_LINUX
-#elif defined __FreeBSD__ || defined __OpenBSD__ || defined __NetBSD__
-# define OS_BSD
-#elif defined unix || defined __unix__ || defined __unix || defined _POSIX_VERSION || defined _XOPEN_VERSION
-# define OS_POSIX
-#endif
-
-/* architecture */
-#if defined __i386__ || defined _M_IX86
-# define ARCH_X86
-#elif defined __amd64__ || defined _M_X64
-# define ARCH_X64
-#elif defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm
-# define ARCH_ARM
-#else
-# error
-#endif
-
-
-#ifdef _WIN32
-
-# ifdef UNDER_CE
- static void* DoLoadLibraryA(const char* name) {
- wchar_t buf[MAX_PATH];
- int sz = MultiByteToWideChar(CP_UTF8, 0, name, -1, buf, 512);
- if (sz > 0) {
- buf[sz] = 0;
- return LoadLibraryW(buf);
- } else {
- return NULL;
- }
- }
-# define LoadLibraryA DoLoadLibraryA
-# else
-# define GetProcAddressA GetProcAddress
-# endif
-
-# define LIB_FORMAT_1 "%s.dll"
-# define AllocPage(size) VirtualAlloc(NULL, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE)
-# define FreePage(data, size) VirtualFree(data, 0, MEM_RELEASE)
-# define EnableExecute(data, size) do {DWORD old; VirtualProtect(data, size, PAGE_EXECUTE, &old); FlushInstructionCache(GetCurrentProcess(), data, size);} while (0)
-# define EnableWrite(data, size) do {DWORD old; VirtualProtect(data, size, PAGE_READWRITE, &old);} while (0)
-
-#else
-#ifdef OS_OSX
-# define LIB_FORMAT_1 "%s.dylib"
-# define LIB_FORMAT_2 "lib%s.dylib"
-#else
-# define LIB_FORMAT_1 "%s.so"
-# define LIB_FORMAT_2 "lib%s.so"
-#endif
-# define LoadLibraryA(name) dlopen(name, RTLD_LAZY | RTLD_GLOBAL)
-# define GetProcAddressA(lib, name) dlsym(lib, name)
-# define AllocPage(size) mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0)
-# define FreePage(data, size) munmap(data, size)
-# define EnableExecute(data, size) mprotect(data, size, PROT_READ|PROT_EXEC)
-# define EnableWrite(data, size) mprotect(data, size, PROT_READ|PROT_WRITE)
-#endif
-
-#if defined ARCH_X86 || defined ARCH_X64
-#define ALLOW_MISALIGNED_ACCESS
-#endif
-
-struct token;
-
-struct parser {
- int line;
- const char* next;
- const char* prev;
- unsigned align_mask;
-};
-
-struct page {
- size_t size;
- size_t off;
- size_t freed;
-};
-
-struct jit {
- lua_State* L;
- int32_t last_errno;
- dasm_State* ctx;
- size_t pagenum;
- struct page** pages;
- size_t align_page_size;
- void** globals;
- int function_extern;
- void* lua_dll;
- void* kernel32_dll;
-};
-
-#define ALIGN_DOWN(PTR, MASK) \
- (((uintptr_t) (PTR)) & (~ ((uintptr_t) (MASK)) ))
-#define ALIGN_UP(PTR, MASK) \
- (( ((uintptr_t) (PTR)) + ((uintptr_t) (MASK)) ) & (~ ((uintptr_t) (MASK)) ))
-
-/* struct cdata/struct ctype */
-
-#define PTR_ALIGN_MASK (sizeof(void*) - 1)
-#define FUNCTION_ALIGN_MASK (sizeof(void (*)()) - 1)
-#define DEFAULT_ALIGN_MASK 7
-
-#ifdef OS_OSX
-/* TODO: figure out why the alignof trick doesn't work on OS X */
-#define ALIGNED_DEFAULT 7
-#elif defined __GNUC__
-#define ALIGNED_DEFAULT (__alignof__(void* __attribute__((aligned))) - 1)
-#else
-#define ALIGNED_DEFAULT PTR_ALIGN_MASK
-#endif
-
-extern int jit_key;
-extern int ctype_mt_key;
-extern int cdata_mt_key;
-extern int cmodule_mt_key;
-extern int callback_mt_key;
-extern int constants_key;
-extern int types_key;
-extern int gc_key;
-extern int callbacks_key;
-extern int functions_key;
-extern int abi_key;
-extern int next_unnamed_key;
-extern int niluv_key;
-extern int asmname_key;
-
-int equals_upval(lua_State* L, int idx, int* key);
-void push_upval(lua_State* L, int* key);
-void set_upval(lua_State* L, int* key);
-struct jit* get_jit(lua_State* L);
-
-/* both ctype and cdata are stored as userdatas
- *
- * usr value is a table shared between the related subtypes which has:
- * name -> member ctype (for structs and unions)
- * +ves -> member ctype - in memory order (for structs)
- * +ves -> argument ctype (for function prototypes)
- * 0 -> return ctype (for function prototypes)
- * light userdata -> misc
- */
-
-enum {
- C_CALL,
- STD_CALL,
- FAST_CALL,
-};
-
-enum {
- INVALID_TYPE,
- VOID_TYPE,
- FLOAT_TYPE,
- DOUBLE_TYPE,
- LONG_DOUBLE_TYPE,
- COMPLEX_FLOAT_TYPE,
- COMPLEX_DOUBLE_TYPE,
- COMPLEX_LONG_DOUBLE_TYPE,
- BOOL_TYPE,
- INT8_TYPE,
- INT16_TYPE,
- INT32_TYPE,
- INT64_TYPE,
- INTPTR_TYPE,
- ENUM_TYPE,
- UNION_TYPE,
- STRUCT_TYPE,
- FUNCTION_TYPE,
- FUNCTION_PTR_TYPE,
-};
-
-#define IS_CHAR_UNSIGNED (((char) -1) > 0)
-#define IS_COMPLEX(type) ((type) == COMPLEX_FLOAT_TYPE || (type) == COMPLEX_DOUBLE_TYPE)
-
-#define POINTER_BITS 2
-#define POINTER_MAX ((1 << POINTER_BITS) - 1)
-
-#define ALIGNOF(S) ((int) ((char*) &S.v - (char*) &S - 1))
-
-/* Note: if adding a new member that is associated with a struct/union
- * definition then it needs to be copied over in ctype.c:set_defined for when
- * we create types based off of the declaration alone.
- *
- * Since this is used as a header for every ctype and cdata, and we create a
- * ton of them on the stack, we try and minimise its size.
- */
-struct ctype {
- size_t base_size; /* size of the base type in bytes */
-
- union {
- /* valid if is_bitfield */
- struct {
- /* size of bitfield in bits */
- unsigned bit_size : 7;
- /* offset within the current byte between 0-63 */
- unsigned bit_offset : 6;
- };
- /* Valid if is_array */
- size_t array_size;
- /* Valid for is_variable_struct or is_variable_array. If
- * variable_size_known (only used for is_variable_struct) then this is
- * the total increment otherwise this is the per element increment.
- */
- size_t variable_increment;
- };
- size_t offset;
- unsigned align_mask : 4; /* as (align bytes - 1) eg 7 gives 8 byte alignment */
- unsigned pointers : POINTER_BITS; /* number of dereferences to get to the base type including +1 for arrays */
- unsigned const_mask : POINTER_MAX + 1; /* const pointer mask, LSB is current pointer, +1 for the whether the base type is const */
- unsigned type : 5; /* value given by type enum above */
- unsigned is_reference : 1;
- unsigned is_array : 1;
- unsigned is_defined : 1;
- unsigned is_null : 1;
- unsigned has_member_name : 1;
- unsigned calling_convention : 2;
- unsigned has_var_arg : 1;
- unsigned is_variable_array : 1; /* set for variable array types where we don't know the variable size yet */
- unsigned is_variable_struct : 1;
- unsigned variable_size_known : 1; /* used for variable structs after we know the variable size */
- unsigned is_bitfield : 1;
- unsigned has_bitfield : 1;
- unsigned is_jitted : 1;
- unsigned is_packed : 1;
- unsigned is_unsigned : 1;
-};
-
-#ifdef _MSC_VER
-__declspec(align(16))
-#endif
-struct cdata {
- const struct ctype type
-#ifdef __GNUC__
- __attribute__ ((aligned(16)))
-#endif
- ;
-};
-
-typedef void (*cfunction)(void);
-
-#ifdef HAVE_COMPLEX
-typedef double complex complex_double;
-typedef float complex complex_float;
-static complex_double mk_complex_double(double real, double imag) {
- return real + imag * 1i;
-}
-static complex_double mk_complex_float(double real, double imag) {
- return real + imag * 1i;
-}
-#else
-typedef struct {
- double real, imag;
-} complex_double;
-
-typedef struct {
- float real, imag;
-} complex_float;
-
-static complex_double mk_complex_double(double real, double imag) {
- complex_double ret = { real, imag };
- return ret;
-}
-static complex_float mk_complex_float(double real, double imag) {
- complex_float ret = { real, imag };
- return ret;
-}
-static double creal(complex_double c) {
- return c.real;
-}
-static float crealf(complex_float c) {
- return c.real;
-}
-
-static double cimag(complex_double c) {
- return c.imag;
-}
-static float cimagf(complex_float c) {
- return c.imag;
-}
-#endif
-
-#define CALLBACK_FUNC_USR_IDX 1
-
-void set_defined(lua_State* L, int ct_usr, struct ctype* ct);
-struct ctype* push_ctype(lua_State* L, int ct_usr, const struct ctype* ct);
-void* push_cdata(lua_State* L, int ct_usr, const struct ctype* ct); /* called from asm */
-void push_callback(lua_State* L, cfunction luafunc, cfunction cfunc);
-void check_ctype(lua_State* L, int idx, struct ctype* ct);
-void* to_cdata(lua_State* L, int idx, struct ctype* ct);
-void* check_cdata(lua_State* L, int idx, struct ctype* ct);
-size_t ctype_size(lua_State* L, const struct ctype* ct);
-
-int parse_type(lua_State* L, struct parser* P, struct ctype* type);
-void parse_argument(lua_State* L, struct parser* P, int ct_usr, struct ctype* type, struct token* name, struct parser* asmname);
-void push_type_name(lua_State* L, int usr, const struct ctype* ct);
-
-int push_user_mt(lua_State* L, int ct_usr, const struct ctype* ct);
-
-int ffi_cdef(lua_State* L);
-
-void push_func_ref(lua_State* L, cfunction func);
-void free_code(struct jit* jit, lua_State* L, cfunction func);
-int x86_return_size(lua_State* L, int usr, const struct ctype* ct);
-void compile_function(lua_State* L, cfunction f, int ct_usr, const struct ctype* ct);
-cfunction compile_callback(lua_State* L, int fidx, int ct_usr, const struct ctype* ct);
-void compile_globals(struct jit* jit, lua_State* L);
-int get_extern(struct jit* jit, uint8_t* addr, int idx, int type);
-
-/* WARNING: assembly needs to be updated for prototype changes of these functions */
-int check_bool(lua_State* L, int idx);
-double check_double(lua_State* L, int idx);
-double check_complex_imag(lua_State* L, int idx);
-float check_float(lua_State* L, int idx);
-uint64_t check_uint64(lua_State* L, int idx);
-int64_t check_int64(lua_State* L, int idx);
-int32_t check_int32(lua_State* L, int idx);
-uint32_t check_uint32(lua_State* L, int idx);
-uintptr_t check_uintptr(lua_State* L, int idx);
-int32_t check_enum(lua_State* L, int idx, int to_usr, const struct ctype* tt);
-/* these two will always push a value so that we can create structs/functions on the fly */
-void* check_typed_pointer(lua_State* L, int idx, int to_usr, const struct ctype* tt);
-cfunction check_typed_cfunction(lua_State* L, int idx, int to_usr, const struct ctype* tt);
-complex_double check_complex_double(lua_State* L, int idx);
-complex_float check_complex_float(lua_State* L, int idx);
-
-void unpack_varargs_stack(lua_State* L, int first, int last, char* to);
-void unpack_varargs_reg(lua_State* L, int first, int last, char* to);
-
-void unpack_varargs_stack_skip(lua_State* L, int first, int last, int ints_to_skip, int floats_to_skip, char* to);
-void unpack_varargs_float(lua_State* L, int first, int last, int max, char* to);
-void unpack_varargs_int(lua_State* L, int first, int last, int max, char* to);
-
-
-
diff --git a/plugins/MirLua/Modules/ffi/src/generate_call_h.bat b/plugins/MirLua/Modules/ffi/src/generate_call_h.bat deleted file mode 100644 index 294204271f..0000000000 --- a/plugins/MirLua/Modules/ffi/src/generate_call_h.bat +++ /dev/null @@ -1,4 +0,0 @@ -lua.exe dynasm\dynasm.lua -LNE -D X32WIN -o call_x86.h call_x86.dasc
-lua.exe dynasm\dynasm.lua -LNE -D X64 -o call_x64.h call_x86.dasc
-lua.exe dynasm\dynasm.lua -LNE -D X64 -D X64WIN -o call_x64win.h call_x86.dasc
-lua.exe dynasm\dynasm.lua -LNE -o call_arm.h call_arm.dasc
diff --git a/plugins/MirLua/Modules/ffi/src/luaffi-scm-1.rockspec b/plugins/MirLua/Modules/ffi/src/luaffi-scm-1.rockspec deleted file mode 100644 index bb7d2d5809..0000000000 --- a/plugins/MirLua/Modules/ffi/src/luaffi-scm-1.rockspec +++ /dev/null @@ -1,34 +0,0 @@ -package = "luaffi"
-version = "scm-1"
-
-source = {
- url = "git://github.com/facebook/luaffifb.git",
-}
-
-description = {
- summary = "FFI library for calling C functions from lua",
- detailed = [[
- ]],
- homepage = "https://github.com/facebook/luaffifb",
- license = "BSD"
-}
-
-dependencies = {
- "lua >= 5.1",
-}
-
-build = {
- type = "builtin",
- modules = {
- ['ffi'] = {
- incdirs = {
- "dynasm"
- },
- sources = {
- "call.c", "ctype.c", "ffi.c", "parser.c",
- }
- },
- ['ffi.libtest'] = 'test.c',
- ['ffi.test'] = 'test.lua',
- }
-}
diff --git a/plugins/MirLua/Modules/ffi/src/msvc/stdbool.h b/plugins/MirLua/Modules/ffi/src/msvc/stdbool.h deleted file mode 100644 index b6fa0603d2..0000000000 --- a/plugins/MirLua/Modules/ffi/src/msvc/stdbool.h +++ /dev/null @@ -1,42 +0,0 @@ -/* vim: ts=4 sw=4 sts=4 et
- *
- * Copyright (c) 2009 James R. McKaskill
- *
- * This software is licensed under the stock MIT license:
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * ----------------------------------------------------------------------------
- */
-
-#pragma once
-
-
-#if defined __cplusplus
-typedef bool _Bool;
-
-#else
-#pragma warning(disable:4244) /* conversion from int to _Bool */
-typedef unsigned char _Bool;
-#define bool _Bool
-#define true 1
-#define false 0
-#define __bool_true_false_are_defined 1
-
-#endif
diff --git a/plugins/MirLua/Modules/ffi/src/msvc/stdint.h b/plugins/MirLua/Modules/ffi/src/msvc/stdint.h deleted file mode 100644 index 01ca453687..0000000000 --- a/plugins/MirLua/Modules/ffi/src/msvc/stdint.h +++ /dev/null @@ -1,174 +0,0 @@ -// boost cstdint.hpp header file ------------------------------------------//
-
-// (C) Copyright Beman Dawes 1999.
-// (C) Copyright Jens Mauer 2001
-// (C) Copyright John Maddock 2001
-// Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/libs/integer for documentation.
-
-// Revision History
-// 31 Oct 01 use BOOST_HAS_LONG_LONG to check for "long long" (Jens M.)
-// 16 Apr 01 check LONGLONG_MAX when looking for "long long" (Jens Maurer)
-// 23 Jan 01 prefer "long" over "int" for int32_t and intmax_t (Jens Maurer)
-// 12 Nov 00 Merged <boost/stdint.h> (Jens Maurer)
-// 23 Sep 00 Added INTXX_C macro support (John Maddock).
-// 22 Sep 00 Better 64-bit support (John Maddock)
-// 29 Jun 00 Reimplement to avoid including stdint.h within namespace boost
-// 8 Aug 99 Initial version (Beman Dawes)
-
-
-#ifndef STDINT_H
-#define STDINT_H
-
-#ifndef UNDER_CE
-#include <crtdefs.h>
-#endif
-
-#include <limits.h>
-
-// These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit
-// platforms. For other systems, they will have to be hand tailored.
-//
-// Because the fast types are assumed to be the same as the undecorated types,
-// it may be possible to hand tailor a more efficient implementation. Such
-// an optimization may be illusionary; on the Intel x86-family 386 on, for
-// example, byte arithmetic and load/stores are as fast as "int" sized ones.
-
-// 8-bit types ------------------------------------------------------------//
-
-# if UCHAR_MAX == 0xff
- typedef signed char int8_t;
- typedef signed char int_least8_t;
- typedef signed char int_fast8_t;
- typedef unsigned char uint8_t;
- typedef unsigned char uint_least8_t;
- typedef unsigned char uint_fast8_t;
-# else
-# error defaults not correct; you must hand modify boost/cstdint.hpp
-# endif
-
-// 16-bit types -----------------------------------------------------------//
-
-# if USHRT_MAX == 0xffff
-# if defined(__crayx1)
- // The Cray X1 has a 16-bit short, however it is not recommend
- // for use in performance critical code.
- typedef short int16_t;
- typedef short int_least16_t;
- typedef int int_fast16_t;
- typedef unsigned short uint16_t;
- typedef unsigned short uint_least16_t;
- typedef unsigned int uint_fast16_t;
-# else
- typedef short int16_t;
- typedef short int_least16_t;
- typedef short int_fast16_t;
- typedef unsigned short uint16_t;
- typedef unsigned short uint_least16_t;
- typedef unsigned short uint_fast16_t;
-# endif
-# elif (USHRT_MAX == 0xffffffff) && defined(CRAY)
- // no 16-bit types on Cray:
- typedef short int_least16_t;
- typedef short int_fast16_t;
- typedef unsigned short uint_least16_t;
- typedef unsigned short uint_fast16_t;
-# else
-# error defaults not correct; you must hand modify boost/cstdint.hpp
-# endif
-
-// 32-bit types -----------------------------------------------------------//
-
-# if ULONG_MAX == 0xffffffff
- typedef long int32_t;
- typedef long int_least32_t;
- typedef long int_fast32_t;
- typedef unsigned long uint32_t;
- typedef unsigned long uint_least32_t;
- typedef unsigned long uint_fast32_t;
-# elif UINT_MAX == 0xffffffff
- typedef int int32_t;
- typedef int int_least32_t;
- typedef int int_fast32_t;
- typedef unsigned int uint32_t;
- typedef unsigned int uint_least32_t;
- typedef unsigned int uint_fast32_t;
-# else
-# error defaults not correct; you must hand modify boost/cstdint.hpp
-# endif
-
-// 64-bit types + intmax_t and uintmax_t ----------------------------------//
-
- //
- // we have Borland/Intel/Microsoft __int64:
- //
- typedef __int64 intmax_t;
- typedef unsigned __int64 uintmax_t;
- typedef __int64 int64_t;
- typedef __int64 int_least64_t;
- typedef __int64 int_fast64_t;
- typedef unsigned __int64 uint64_t;
- typedef unsigned __int64 uint_least64_t;
- typedef unsigned __int64 uint_fast64_t;
-
-
-
-/****************************************************
-
-Macro definition section:
-
-Define various INTXX_C macros only if
-__STDC_CONSTANT_MACROS is defined.
-
-Undefine the macros if __STDC_CONSTANT_MACROS is
-not defined and the macros are (cf <cassert>).
-
-Added 23rd September 2000 (John Maddock).
-Modified 11th September 2001 to be excluded when
-BOOST_HAS_STDINT_H is defined (John Maddock).
-
-******************************************************/
-
-#if defined(__STDC_CONSTANT_MACROS) || !defined(__cplusplus)
-//
-// Borland/Intel/Microsoft compilers have width specific suffixes:
-//
-# define INT8_C(value) value##i8
-# define INT16_C(value) value##i16
-# define INT32_C(value) value##i32
-# define INT64_C(value) value##i64
-# define UINT8_C(value) value##ui8
-# define UINT16_C(value) value##ui16
-# define UINT32_C(value) value##ui32
-# define UINT64_C(value) value##ui64
-# define INTMAX_C(value) value##i64
-# define UINTMAX_C(value) value##ui64
-
-#endif // __STDC_CONSTANT_MACROS_DEFINED etc.
-
-#if defined(__STDC_LIMIT_MACROS) || !defined(__cplusplus)
-# define INT8_MIN INT8_C(-127)-1
-# define INT8_MAX INT8_C(127)
-# define INT16_MIN INT16_C(-32767)-1
-# define INT16_MAX INT16_C(32767)
-# define INT32_MIN INT32_C(-2147483647)-1
-# define INT32_MAX INT32_C(2147483647)
-# define INT64_MAX INT64_C(9223372036854775807)
-# define UINT8_MAX UINT8_C(255)
-# define UINT16_MAX UINT16_C(65535)
-# define UINT32_MAX UINT32_C(4294967295)
-# define UINT64_MAX UINT64_C(18446744073709551615)
-#endif
-
-#ifdef UNDER_CE
-typedef unsigned long uintptr_t;
-typedef long intptr_t;
-#endif
-
-
-
-#endif // BOOST_CSTDINT_HPP
-
diff --git a/plugins/MirLua/Modules/ffi/src/msvcbuild.bat b/plugins/MirLua/Modules/ffi/src/msvcbuild.bat deleted file mode 100644 index 0279641c4c..0000000000 --- a/plugins/MirLua/Modules/ffi/src/msvcbuild.bat +++ /dev/null @@ -1,76 +0,0 @@ -@if not defined INCLUDE goto :FAIL
-
-@setlocal
-
-@if "%1"=="debug-5.1" goto :DEBUG_5_1
-
-rem These should not have quotes
-@set LUA_INCLUDE=Z:\c\lua-5.2.0\src
-@set LUA_LIB=Z:\c\lua-5.2.0\lua5.2.lib
-@set LUA_EXE=Z:\c\lua-5.2.0\lua.exe
-rem This the name of the dll that can be handed to LoadLibrary. This should not have a path.
-@set LUA_DLL=lua5.2.dll
-@goto :DEBUG
-
-:DEBUG_5_1
-@set LUA_INCLUDE=Z:\c\lua-5.1.4\src
-@set LUA_LIB=Z:\c\lua-5.1.4\lua5.1.lib
-@set LUA_EXE=Z:\c\lua-5.1.4\lua.exe
-@set LUA_DLL=lua5.1.dll
-
-:DEBUG
-@set DO_CL=cl.exe /nologo /c /MDd /FC /Zi /Od /W3 /WX /D_CRT_SECURE_NO_DEPRECATE /DLUA_FFI_BUILD_AS_DLL /I"msvc"
-@set DO_LINK=link /nologo /debug
-@set DO_MT=mt /nologo
-
-@if "%1"=="debug" goto :COMPILE
-@if "%1"=="debug-5.1" goto :COMPILE
-@if "%1"=="test" goto :COMPILE
-@if "%1"=="clean" goto :CLEAN
-@if "%1"=="release" goto :RELEASE
-@if "%1"=="test-release" goto :RELEASE
-
-:RELEASE
-@set DO_CL=cl.exe /nologo /c /MD /Ox /W3 /Zi /WX /D_CRT_SECURE_NO_DEPRECATE /DLUA_FFI_BUILD_AS_DLL /I"msvc"
-@set DO_LINK=link.exe /nologo /debug
-@set DO_MT=mt.exe /nologo
-@goto :COMPILE
-
-:COMPILE
-"%LUA_EXE%" dynasm\dynasm.lua -LNE -D X32WIN -o call_x86.h call_x86.dasc
-"%LUA_EXE%" dynasm\dynasm.lua -LNE -D X64 -o call_x64.h call_x86.dasc
-"%LUA_EXE%" dynasm\dynasm.lua -LNE -D X64 -D X64WIN -o call_x64win.h call_x86.dasc
-"%LUA_EXE%" dynasm\dynasm.lua -LNE -o call_arm.h call_arm.dasc
-%DO_CL% /I"." /I"%LUA_INCLUDE%" /DLUA_DLL_NAME="%LUA_DLL%" call.c ctype.c ffi.c parser.c
-%DO_LINK% /DLL /OUT:ffi.dll "%LUA_LIB%" *.obj
-if exist ffi.dll.manifest^
- %DO_MT% -manifest ffi.dll.manifest -outputresource:"ffi.dll;2"
-
-%DO_CL% /Gd test.c /Fo"test_cdecl.obj"
-%DO_CL% /Gz test.c /Fo"test_stdcall.obj"
-%DO_CL% /Gr test.c /Fo"test_fastcall.obj"
-%DO_LINK% /DLL /OUT:test_cdecl.dll test_cdecl.obj
-%DO_LINK% /DLL /OUT:test_stdcall.dll test_stdcall.obj
-%DO_LINK% /DLL /OUT:test_fastcall.dll test_fastcall.obj
-if exist test_cdecl.dll.manifest^
- %DO_MT% -manifest test_cdecl.dll.manifest -outputresource:"test_cdecl.dll;2"
-if exist test_stdcall.dll.manifest^
- %DO_MT% -manifest test_stdcall.dll.manifest -outputresource:"test_stdcall.dll;2"
-if exist test_fastcall.dll.manifest^
- %DO_MT% -manifest test_fastcall.dll.manifest -outputresource:"test_fastcall.dll;2"
-
-@if "%1"=="test" "%LUA_EXE%" test.lua
-@if "%1"=="test-5.2" "%LUA_EXE%" test.lua
-@if "%1"=="test-release" "%LUA_EXE%" test.lua
-@goto :CLEAN_OBJ
-
-:CLEAN
-del *.dll
-:CLEAN_OBJ
-del *.obj *.manifest
-@goto :END
-
-:FAIL
-@echo You must open a "Visual Studio .NET Command Prompt" to run this script
-:END
-
diff --git a/plugins/MirLua/Modules/ffi/src/parser.c b/plugins/MirLua/Modules/ffi/src/parser.c deleted file mode 100644 index 6dd099a9a4..0000000000 --- a/plugins/MirLua/Modules/ffi/src/parser.c +++ /dev/null @@ -1,2618 +0,0 @@ -/* vim: ts=4 sw=4 sts=4 et tw=78
- * Portions copyright (c) 2015-present, Facebook, Inc. All rights reserved.
- * Portions copyright (c) 2011 James R. McKaskill.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-#include "ffi.h"
-
-#define IS_CONST(tok) (IS_LITERAL(tok, "const") || IS_LITERAL(tok, "__const") || IS_LITERAL(tok, "__const__"))
-#define IS_VOLATILE(tok) (IS_LITERAL(tok, "volatile") || IS_LITERAL(tok, "__volatile") || IS_LITERAL(tok, "__volatile__"))
-#define IS_RESTRICT(tok) (IS_LITERAL(tok, "restrict") || IS_LITERAL(tok, "__restrict") || IS_LITERAL(tok, "__restrict__"))
-#define IS_INLINE(tok) (IS_LITERAL(tok, "inline") || IS_LITERAL(tok, "__inline") || IS_LITERAL(tok, "__inline__"))
-
-enum etoken {
- TOK_NIL,
- TOK_NUMBER,
- TOK_STRING,
- TOK_TOKEN,
-
- /* the order of these values must match the token strings in lex.c */
-
- TOK_3_BEGIN,
- TOK_VA_ARG,
-
- TOK_2_BEGIN,
- TOK_LEFT_SHIFT, TOK_RIGHT_SHIFT, TOK_LOGICAL_AND, TOK_LOGICAL_OR, TOK_LESS_EQUAL,
- TOK_GREATER_EQUAL, TOK_EQUAL, TOK_NOT_EQUAL,
-
- TOK_1_BEGIN,
- TOK_OPEN_CURLY, TOK_CLOSE_CURLY, TOK_SEMICOLON, TOK_COMMA, TOK_COLON,
- TOK_ASSIGN, TOK_OPEN_PAREN, TOK_CLOSE_PAREN, TOK_OPEN_SQUARE, TOK_CLOSE_SQUARE,
- TOK_DOT, TOK_AMPERSAND, TOK_LOGICAL_NOT, TOK_BITWISE_NOT, TOK_MINUS,
- TOK_PLUS, TOK_STAR, TOK_DIVIDE, TOK_MODULUS, TOK_LESS,
- TOK_GREATER, TOK_BITWISE_XOR, TOK_BITWISE_OR, TOK_QUESTION, TOK_POUND,
-
- TOK_REFERENCE = TOK_AMPERSAND,
- TOK_MULTIPLY = TOK_STAR,
- TOK_BITWISE_AND = TOK_AMPERSAND,
-};
-
-struct token {
- enum etoken type;
- int64_t integer;
- const char* str;
- size_t size;
-};
-
-#define IS_LITERAL(TOK, STR) \
- (((TOK).size == sizeof(STR) - 1) && 0 == memcmp((TOK).str, STR, sizeof(STR) - 1))
-
-/* the order of tokens _must_ match the order of the enum etoken enum */
-
-static char tok3[][4] = {
- "...", /* unused ">>=", "<<=", */
-};
-
-static char tok2[][3] = {
- "<<", ">>", "&&", "||", "<=",
- ">=", "==", "!=",
- /* unused "+=", "-=", "*=", "/=", "%=", "&=", "^=", "|=", "++", "--", "->", "::", */
-};
-
-static char tok1[] = {
- '{', '}', ';', ',', ':',
- '=', '(', ')', '[', ']',
- '.', '&', '!', '~', '-',
- '+', '*', '/', '%', '<',
- '>', '^', '|', '?', '#'
-};
-
-static int next_token(lua_State* L, struct parser* P, struct token* tok)
-{
- size_t i;
- const char* s = P->next;
-
- /* UTF8 BOM */
- if (s[0] == '\xEF' && s[1] == '\xBB' && s[2] == '\xBF') {
- s += 3;
- }
-
- /* consume whitespace and comments */
- for (;;) {
- /* consume whitespace */
- while(*s == '\t' || *s == '\n' || *s == ' ' || *s == '\v' || *s == '\r') {
- if (*s == '\n') {
- P->line++;
- }
- s++;
- }
-
- /* consume comments */
- if (*s == '/' && *(s+1) == '/') {
-
- s = strchr(s, '\n');
- if (!s) {
- luaL_error(L, "non-terminated comment");
- }
-
- } else if (*s == '/' && *(s+1) == '*') {
- s += 2;
-
- for (;;) {
- if (s[0] == '\0') {
- luaL_error(L, "non-terminated comment");
- } else if (s[0] == '*' && s[1] == '/') {
- s += 2;
- break;
- } else if (s[0] == '\n') {
- P->line++;
- }
- s++;
- }
-
- } else if (*s == '\0') {
- tok->type = TOK_NIL;
- return 0;
-
- } else {
- break;
- }
- }
-
- P->prev = s;
-
- for (i = 0; i < sizeof(tok3) / sizeof(tok3[0]); i++) {
- if (s[0] == tok3[i][0] && s[1] == tok3[i][1] && s[2] == tok3[i][2]) {
- tok->type = (enum etoken) (TOK_3_BEGIN + 1 + i);
- P->next = s + 3;
- goto end;
- }
- }
-
- for (i = 0; i < sizeof(tok2) / sizeof(tok2[0]); i++) {
- if (s[0] == tok2[i][0] && s[1] == tok2[i][1]) {
- tok->type = (enum etoken) (TOK_2_BEGIN + 1 + i);
- P->next = s + 2;
- goto end;
- }
- }
-
- for (i = 0; i < sizeof(tok1) / sizeof(tok1[0]); i++) {
- if (s[0] == tok1[i]) {
- tok->type = (enum etoken) (TOK_1_BEGIN + 1 + i);
- P->next = s + 1;
- goto end;
- }
- }
-
- if (*s == '.' || *s == '-' || ('0' <= *s && *s <= '9')) {
- /* number */
- tok->type = TOK_NUMBER;
-
- /* split out the negative case so we get the full range of bits for
- * unsigned (eg to support 0xFFFFFFFF where sizeof(long) == 4)
- */
- if (*s == '-') {
- tok->integer = strtol(s, (char**) &s, 0);
- } else {
- tok->integer = strtoul(s, (char**) &s, 0);
- }
-
- while (*s == 'u' || *s == 'U' || *s == 'l' || *s == 'L') {
- s++;
- }
-
- P->next = s;
- goto end;
-
- } else if (*s == '\'' || *s == '\"') {
- /* "..." or '...' */
- char quote = *s;
- s++; /* jump over " */
-
- tok->type = TOK_STRING;
- tok->str = s;
-
- while (*s != quote) {
-
- if (*s == '\0' || (*s == '\\' && *(s+1) == '\0')) {
- return luaL_error(L, "string not finished");
- }
-
- if (*s == '\\') {
- s++;
- }
-
- s++;
- }
-
- tok->size = s - tok->str;
- s++; /* jump over " */
- P->next = s;
- goto end;
-
- } else if (('a' <= *s && *s <= 'z') || ('A' <= *s && *s <= 'Z') || *s == '_') {
- /* tokens */
- tok->type = TOK_TOKEN;
- tok->str = s;
-
- while (('a' <= *s && *s <= 'z') || ('A' <= *s && *s <= 'Z') || *s == '_' || ('0' <= *s && *s <= '9')) {
- s++;
- }
-
- tok->size = s - tok->str;
- P->next = s;
- goto end;
-
- } else {
- return luaL_error(L, "invalid character %d", P->line);
- }
-
-end:
- /*fprintf(stderr, "token %d %d %.*s %.10s\n", tok->type, (int) tok->size, (tok->type == TOK_TOKEN || tok->type == TOK_STRING) ? (int) tok->size : 0, tok->str, P->next);*/
- return 1;
-}
-
-#define require_token(L, P, tok) require_token_line(L, P, tok, __FILE__, __LINE__)
-
-static void require_token_line(lua_State* L, struct parser* P, struct token* tok, const char* file, int line)
-{
- if (!next_token(L, P, tok)) {
- luaL_error(L, "unexpected end on line %s:%d", file, line);
- }
-}
-
-static void check_token(lua_State* L, struct parser* P, int type, const char* str, const char* err, ...)
-{
- struct token tok;
- if (!next_token(L, P, &tok) || tok.type != type || (tok.type == TOK_TOKEN && (tok.size != strlen(str) || memcmp(tok.str, str, tok.size) != 0))) {
- va_list ap;
- va_start(ap, err);
- lua_pushvfstring(L, err, ap);
- lua_error(L);
- }
-}
-
-static void put_back(struct parser* P)
-{ P->next = P->prev; }
-
-
-int64_t calculate_constant(lua_State* L, struct parser* P);
-
-static int g_name_key;
-static int g_front_name_key;
-static int g_back_name_key;
-
-#ifndef max
-#define max(a,b) ((a) < (b) ? (b) : (a))
-#endif
-
-#ifndef min
-#define min(a,b) ((a) < (b) ? (a) : (b))
-#endif
-
-enum test {TEST};
-
-/* Parses an enum definition from after the open curly through to the close
- * curly. Expects the user table to be on the top of the stack
- */
-static int parse_enum(lua_State* L, struct parser* P, struct ctype* type)
-{
- struct token tok;
- int value = -1;
- int ct_usr = lua_gettop(L);
-
- for (;;) {
- require_token(L, P, &tok);
-
- assert(lua_gettop(L) == ct_usr);
-
- if (tok.type == TOK_CLOSE_CURLY) {
- break;
- } else if (tok.type != TOK_TOKEN) {
- return luaL_error(L, "unexpected token in enum at line %d", P->line);
- }
-
- lua_pushlstring(L, tok.str, tok.size);
-
- require_token(L, P, &tok);
-
- if (tok.type == TOK_COMMA || tok.type == TOK_CLOSE_CURLY) {
- /* we have an auto calculated enum value */
- value++;
- } else if (tok.type == TOK_ASSIGN) {
- /* we have an explicit enum value */
- value = (int) calculate_constant(L, P);
- require_token(L, P, &tok);
- } else {
- return luaL_error(L, "unexpected token in enum at line %d", P->line);
- }
-
- assert(lua_gettop(L) == ct_usr + 1);
-
- /* add the enum value to the constants table */
- push_upval(L, &constants_key);
- lua_pushvalue(L, -2);
- lua_pushinteger(L, value);
- lua_rawset(L, -3);
- lua_pop(L, 1);
-
- assert(lua_gettop(L) == ct_usr + 1);
-
- /* add the enum value to the enum usr value table */
- lua_pushinteger(L, value);
- lua_rawset(L, ct_usr);
-
- if (tok.type == TOK_CLOSE_CURLY) {
- break;
- } else if (tok.type != TOK_COMMA) {
- return luaL_error(L, "unexpected token in enum at line %d", P->line);
- }
- }
-
- type->base_size = sizeof(enum test);
- type->align_mask = sizeof(enum test) - 1;
-
- assert(lua_gettop(L) == ct_usr);
- return 0;
-}
-
-static void calculate_member_position(lua_State* L, struct parser* P, struct ctype* ct, struct ctype* mt, int* pbit_offset, int* pbitfield_type)
-{
- int bit_offset = *pbit_offset;
-
- if (ct->type == UNION_TYPE) {
- size_t msize;
-
- if (mt->is_variable_struct || mt->is_variable_array) {
- luaL_error(L, "NYI: variable sized members in unions");
- return;
-
- } else if (mt->is_bitfield) {
- msize = (mt->align_mask + 1);
-#ifdef _WIN32
- /* MSVC has a bug where it doesn't update the alignment of
- * a union for bitfield members. */
- mt->align_mask = 0;
-#endif
-
- } else if (mt->is_array) {
- msize = mt->array_size * (mt->pointers > 1 ? sizeof(void*) : mt->base_size);
-
- } else {
- msize = mt->pointers ? sizeof(void*) : mt->base_size;
- }
-
- ct->base_size = max(ct->base_size, msize);
-
- } else if (mt->is_bitfield) {
- if (mt->has_member_name && mt->bit_size == 0) {
- luaL_error(L, "zero length bitfields must be unnamed on line %d", P->line);
- }
-
-#if defined _WIN32
- /* MSVC uses a seperate storage unit for each size. This is aligned
- * before the first bitfield. :0 finishes up the storage unit using
- * the greater alignment of the storage unit or the type used with the
- * :0. This is equivalent to the :0 always creating a new storage
- * unit, but not necesserily using it yet.
- */
-
- if (*pbitfield_type == -1 && mt->bit_size == 0) {
- /* :0 not after a bitfield are ignored */
- return;
- }
-
- {
- int different_storage = mt->align_mask != *pbitfield_type;
- int no_room_left = bit_offset + mt->bit_size > (mt->align_mask + 1) * CHAR_BIT;
-
- if (different_storage || no_room_left || !mt->bit_size) {
- ct->base_size += (bit_offset + CHAR_BIT - 1) / CHAR_BIT;
- bit_offset = 0;
- if (*pbitfield_type >= 0) {
- ct->base_size = ALIGN_UP(ct->base_size, *pbitfield_type);
- }
- ct->base_size = ALIGN_UP(ct->base_size, mt->align_mask);
- }
- }
-
- mt->bit_offset = bit_offset;
- mt->offset = ct->base_size;
-
- *pbitfield_type = mt->align_mask;
- bit_offset += mt->bit_size;
-
-// #elif defined OS_OSX
-// /* OSX doesn't use containers and bitfields are not aligned. So
-// * bitfields never add any padding, except for :0 which still forces
-// * an alignment based off the type used with the :0 */
-// if (mt->bit_size) {
-// mt->offset = ct->base_size;
-// mt->bit_offset = bit_offset;
-// bit_offset += mt->bit_size;
-// ct->base_size += bit_offset / CHAR_BIT;
-// bit_offset = bit_offset % CHAR_BIT;
-// } else {
-// ct->base_size += (bit_offset + CHAR_BIT - 1) / CHAR_BIT;
-// ct->base_size = ALIGN_UP(ct->base_size, mt->align_mask);
-// bit_offset = 0;
-// }
-
-// if (!mt->has_member_name) {
-// /* unnamed bitfields don't update the struct alignment */
-// mt->align_mask = 0;
-// }
-
-#elif defined __GNUC__
- /* GCC tries to pack bitfields in as close as much as possible, but
- * still making sure that they don't cross alignment boundaries.
- * :0 forces an alignment based off the type used with the :0
- */
-
- int bits_used = (ct->base_size - ALIGN_DOWN(ct->base_size, mt->align_mask)) * CHAR_BIT + bit_offset;
- int need_to_realign = bits_used + mt->bit_size > mt->base_size * CHAR_BIT;
-
- if (!mt->is_packed && (!mt->bit_size || need_to_realign)) {
- ct->base_size += (bit_offset + CHAR_BIT - 1) / CHAR_BIT;
- ct->base_size = ALIGN_UP(ct->base_size, mt->align_mask);
- bit_offset = 0;
- }
-
- mt->bit_offset = bit_offset;
- mt->offset = ct->base_size;
-
- bit_offset += mt->bit_size;
- ct->base_size += bit_offset / CHAR_BIT;
- bit_offset = bit_offset % CHAR_BIT;
-
- /* unnamed bitfields don't update the struct alignment */
- if (!mt->has_member_name) {
- mt->align_mask = 0;
- }
-#else
-#error
-#endif
-
- } else {
- /* finish up the current bitfield storage unit */
- ct->base_size += (bit_offset + CHAR_BIT - 1) / CHAR_BIT;
- bit_offset = 0;
-
- if (*pbitfield_type >= 0) {
- ct->base_size = ALIGN_UP(ct->base_size, *pbitfield_type);
- }
-
- *pbitfield_type = -1;
-
- ct->base_size = ALIGN_UP(ct->base_size, mt->align_mask);
- mt->offset = ct->base_size;
-
- if (mt->is_variable_array) {
- ct->is_variable_struct = 1;
- ct->variable_increment = mt->pointers > 1 ? sizeof(void*) : mt->base_size;
-
- } else if (mt->is_variable_struct) {
- assert(!mt->variable_size_known && !mt->is_array && !mt->pointers);
- ct->base_size += mt->base_size;
- ct->is_variable_struct = 1;
- ct->variable_increment = mt->variable_increment;
-
- } else if (mt->is_array) {
- ct->base_size += mt->array_size * (mt->pointers > 1 ? sizeof(void*) : mt->base_size);
-
- } else {
- ct->base_size += mt->pointers ? sizeof(void*) : mt->base_size;
- }
- }
-
- /* increase the outer struct/union alignment if needed */
- if (mt->align_mask > (int) ct->align_mask) {
- ct->align_mask = mt->align_mask;
- }
-
- if (mt->has_bitfield || mt->is_bitfield) {
- ct->has_bitfield = 1;
- }
-
- *pbit_offset = bit_offset;
-}
-
-static int copy_submembers(lua_State* L, int to_usr, int from_usr, const struct ctype* ft, int* midx)
-{
- struct ctype ct;
- int i, sublen;
-
- from_usr = lua_absindex(L, from_usr);
- to_usr = lua_absindex(L, to_usr);
-
- /* integer keys */
- sublen = (int) lua_rawlen(L, from_usr);
- for (i = 1; i <= sublen; i++) {
- lua_rawgeti(L, from_usr, i);
-
- ct = *(const struct ctype*) lua_touserdata(L, -1);
- ct.offset += ft->offset;
- lua_getuservalue(L, -1);
-
- push_ctype(L, -1, &ct);
- lua_rawseti(L, to_usr, (*midx)++);
-
- lua_pop(L, 2); /* ctype, user value */
- }
-
- /* string keys */
- lua_pushnil(L);
- while (lua_next(L, from_usr)) {
- if (lua_type(L, -2) == LUA_TSTRING) {
- struct ctype ct = *(const struct ctype*) lua_touserdata(L, -1);
- ct.offset += ft->offset;
- lua_getuservalue(L, -1);
-
- /* uservalue[sub_mname] = new_sub_mtype */
- lua_pushvalue(L, -3);
- push_ctype(L, -2, &ct);
- lua_rawset(L, to_usr);
-
- lua_pop(L, 1); /* remove submember user value */
- }
- lua_pop(L, 1);
- }
-
- return 0;
-}
-
-static int add_member(lua_State* L, int ct_usr, int mname, int mbr_usr, const struct ctype* mt, int* midx)
-{
- ct_usr = lua_absindex(L, ct_usr);
- mname = lua_absindex(L, mname);
-
- push_ctype(L, mbr_usr, mt);
-
- /* usrvalue[mbr index] = pushed mtype */
- lua_pushvalue(L, -1);
- lua_rawseti(L, ct_usr, (*midx)++);
-
- /* set usrvalue[mname] = pushed mtype */
- lua_pushvalue(L, mname);
- lua_pushvalue(L, -2);
- lua_rawset(L, ct_usr);
-
- /* set usrvalue[mtype] = mname */
- lua_pushvalue(L, -1);
- lua_pushvalue(L, mname);
- lua_rawset(L, ct_usr);
-
- lua_pop(L, 1);
-
- return 0;
-}
-
-/* Parses a struct from after the open curly through to the close curly.
- */
-static int parse_struct(lua_State* L, struct parser* P, int tmp_usr, const struct ctype* ct)
-{
- struct token tok;
- int midx = 1;
- int top = lua_gettop(L);
-
- tmp_usr = lua_absindex(L, tmp_usr);
-
- /* parse members */
- for (;;) {
- struct ctype mbase;
-
- assert(lua_gettop(L) == top);
-
- /* see if we're at the end of the struct */
- require_token(L, P, &tok);
- if (tok.type == TOK_CLOSE_CURLY) {
- break;
- } else if (ct->is_variable_struct) {
- return luaL_error(L, "can't have members after a variable sized member on line %d", P->line);
- } else {
- put_back(P);
- }
-
- /* members are of the form
- * <base type> <arg>, <arg>, <arg>;
- * eg struct foo bar, *bar2[2];
- * mbase is 'struct foo'
- * mtype is '' then '*[2]'
- * mname is 'bar' then 'bar2'
- */
-
- parse_type(L, P, &mbase);
-
- for (;;) {
- struct token mname;
- struct ctype mt = mbase;
-
- memset(&mname, 0, sizeof(mname));
-
- if (ct->is_variable_struct) {
- return luaL_error(L, "can't have members after a variable sized member on line %d", P->line);
- }
-
- assert(lua_gettop(L) == top + 1);
- parse_argument(L, P, -1, &mt, &mname, NULL);
- assert(lua_gettop(L) == top + 2);
-
- if (!mt.is_defined && (mt.pointers - mt.is_array) == 0) {
- return luaL_error(L, "member type is undefined on line %d", P->line);
- }
-
- if (mt.type == VOID_TYPE && (mt.pointers - mt.is_array) == 0) {
- return luaL_error(L, "member type can not be void on line %d", P->line);
- }
-
- mt.has_member_name = (mname.size > 0);
- lua_pushlstring(L, mname.str, mname.size);
-
- add_member(L, tmp_usr, -1, -2, &mt, &midx);
-
- /* pop the usr value from push_argument and the member name */
- lua_pop(L, 2);
- assert(lua_gettop(L) == top + 1);
-
- require_token(L, P, &tok);
- if (tok.type == TOK_SEMICOLON) {
- break;
- } else if (tok.type != TOK_COMMA) {
- luaL_error(L, "unexpected token in struct definition on line %d", P->line);
- }
- }
-
- /* pop the usr value from push_type */
- lua_pop(L, 1);
- }
-
- assert(lua_gettop(L) == top);
- return 0;
-}
-
-static int calculate_struct_offsets(lua_State* L, struct parser* P, int ct_usr, struct ctype* ct, int tmp_usr)
-{
- int i;
- int midx = 1;
- int sz = (int) lua_rawlen(L, tmp_usr);
- int bit_offset = 0;
- int bitfield_type = -1;
-
- ct_usr = lua_absindex(L, ct_usr);
- tmp_usr = lua_absindex(L, tmp_usr);
-
- for (i = 1; i <= sz; i++) {
- struct ctype mt;
-
- /* get the member type */
- lua_rawgeti(L, tmp_usr, i);
- mt = *(const struct ctype*) lua_touserdata(L, -1);
-
- /* get the member user table */
- lua_getuservalue(L, -1);
-
- /* get the member name */
- lua_pushvalue(L, -2);
- lua_rawget(L, tmp_usr);
-
- calculate_member_position(L, P, ct, &mt, &bit_offset, &bitfield_type);
-
- if (mt.has_member_name) {
- assert(!lua_isnil(L, -1));
- add_member(L, ct_usr, -1, -2, &mt, &midx);
-
- } else if (mt.type == STRUCT_TYPE || mt.type == UNION_TYPE) {
- /* With an unnamed member we copy all of the submembers into our
- * usr value adjusting the offset as necessary. Note ctypes are
- * immutable so need to push a new ctype to update the offset.
- */
- copy_submembers(L, ct_usr, -2, &mt, &midx);
-
- } else {
- /* We ignore unnamed members that aren't structs or unions. These
- * are there just to change the padding */
- }
-
- lua_pop(L, 3);
- }
-
- /* finish up the current bitfield storage unit */
- ct->base_size += (bit_offset + CHAR_BIT - 1) / CHAR_BIT;
-
- /* only void is allowed 0 size */
- if (ct->base_size == 0) {
- ct->base_size = 1;
- }
-
- ct->base_size = ALIGN_UP(ct->base_size, ct->align_mask);
- return 0;
-}
-
-/* copy over attributes that could be specified before the typedef eg
- * __attribute__(packed) const type_t */
-static void instantiate_typedef(struct parser* P, struct ctype* tt, const struct ctype* ft)
-{
- struct ctype pt = *tt;
- *tt = *ft;
-
- tt->const_mask |= pt.const_mask;
- tt->is_packed = pt.is_packed;
-
- if (tt->is_packed) {
- tt->align_mask = 0;
- } else {
- /* Instantiate the typedef in the current packing. This may be
- * further updated if a pointer is added or another alignment
- * attribute is applied. If pt.align_mask is already non-zero than an
- * increased alignment via __declspec(aligned(#)) has been set. */
- tt->align_mask = max(min(P->align_mask, tt->align_mask), pt.align_mask);
- }
-}
-
-/* this parses a struct or union starting with the optional
- * name before the opening brace
- * leaves the type usr value on the stack
- */
-static int parse_record(lua_State* L, struct parser* P, struct ctype* ct)
-{
- struct token tok;
- int top = lua_gettop(L);
-
- require_token(L, P, &tok);
-
- /* name is optional */
- if (tok.type == TOK_TOKEN) {
- /* declaration */
- lua_pushlstring(L, tok.str, tok.size);
-
- assert(lua_gettop(L) == top+1);
-
- /* lookup the name to see if we've seen this type before */
- push_upval(L, &types_key);
- lua_pushvalue(L, -2);
- lua_rawget(L, top+2);
-
- assert(lua_gettop(L) == top+3);
-
- if (lua_isnil(L, -1)) {
- lua_pop(L, 1); /* pop the nil usr value */
- lua_newtable(L); /* the new usr table */
-
- /* stack layout is:
- * top+1: record name
- * top+2: types table
- * top+3: new usr table
- */
-
- lua_pushlightuserdata(L, &g_name_key);
- lua_pushvalue(L, top+1);
- lua_rawset(L, top+3); /* usr[name_key] = name */
-
- lua_pushvalue(L, top+1);
- push_ctype(L, top+3, ct);
- lua_rawset(L, top+2); /* types[name] = new_ctype */
-
- } else {
- /* get the exsting declared type */
- const struct ctype* prevt = (const struct ctype*) lua_touserdata(L, top+3);
-
- if (prevt->type != ct->type) {
- lua_getuservalue(L, top+3);
- push_type_name(L, -1, ct);
- push_type_name(L, top+3, prevt);
- luaL_error(L, "type '%s' previously declared as '%s'", lua_tostring(L, -2), lua_tostring(L, -1));
- }
-
- instantiate_typedef(P, ct, prevt);
-
- /* replace the ctype with its usr value */
- lua_getuservalue(L, -1);
- lua_replace(L, -2);
- }
-
- /* remove the extra name and types table */
- lua_replace(L, -3);
- lua_pop(L, 1);
-
- assert(lua_gettop(L) == top + 1 && lua_istable(L, -1));
-
- /* if a name is given then we may be at the end of the string
- * eg for ffi.new('struct foo')
- */
- if (!next_token(L, P, &tok)) {
- return 0;
- }
-
- } else {
- /* create a new unnamed record */
- int num;
-
- /* get the next unnamed number */
- push_upval(L, &next_unnamed_key);
- num = lua_tointeger(L, -1);
- lua_pop(L, 1);
-
- /* increment the unnamed upval */
- lua_pushinteger(L, num + 1);
- set_upval(L, &next_unnamed_key);
-
- lua_newtable(L); /* the new usr table - leave on stack */
-
- /* usr[name_key] = num */
- lua_pushlightuserdata(L, &g_name_key);
- lua_pushfstring(L, "%d", num);
- lua_rawset(L, -3);
- }
-
- if (tok.type != TOK_OPEN_CURLY) {
- /* this may just be a declaration or use of the type as an argument or
- * member */
- put_back(P);
- return 0;
- }
-
- if (ct->is_defined) {
- return luaL_error(L, "redefinition in line %d", P->line);
- }
-
- assert(lua_gettop(L) == top + 1 && lua_istable(L, -1));
-
- if (ct->type == ENUM_TYPE) {
- parse_enum(L, P, ct);
- } else {
- /* we do a two stage parse, where we parse the content first and build up
- * the temp user table. We then iterate over that to calculate the offsets
- * and fill out ct_usr. This is so we can handle out of order members
- * (eg vtable) and attributes specified at the end of the struct.
- */
- lua_newtable(L);
- parse_struct(L, P, -1, ct);
- calculate_struct_offsets(L, P, -2, ct, -1);
- assert(lua_gettop(L) == top + 2 && lua_istable(L, -1));
- lua_pop(L, 1);
- }
-
- assert(lua_gettop(L) == top + 1 && lua_istable(L, -1));
- set_defined(L, -1, ct);
- assert(lua_gettop(L) == top + 1);
- return 0;
-}
-
-/* parses single or multi work built in types, and pushes it onto the stack */
-static int parse_type_name(lua_State* L, struct parser* P)
-{
- struct token tok;
- int flags = 0;
-
- enum {
- UNSIGNED = 0x01,
- SIGNED = 0x02,
- LONG = 0x04,
- SHORT = 0x08,
- INT = 0x10,
- CHAR = 0x20,
- LONG_LONG = 0x40,
- INT8 = 0x80,
- INT16 = 0x100,
- INT32 = 0x200,
- INT64 = 0x400,
- DOUBLE = 0x800,
- FLOAT = 0x1000,
- COMPLEX = 0x2000,
- };
-
- require_token(L, P, &tok);
-
- /* we have to manually decode the builtin types since they can take up
- * more then one token
- */
- for (;;) {
- if (tok.type != TOK_TOKEN) {
- break;
- } else if (IS_LITERAL(tok, "unsigned")) {
- flags |= UNSIGNED;
- } else if (IS_LITERAL(tok, "signed")) {
- flags |= SIGNED;
- } else if (IS_LITERAL(tok, "short")) {
- flags |= SHORT;
- } else if (IS_LITERAL(tok, "char")) {
- flags |= CHAR;
- } else if (IS_LITERAL(tok, "long")) {
- flags |= (flags & LONG) ? LONG_LONG : LONG;
- } else if (IS_LITERAL(tok, "int")) {
- flags |= INT;
- } else if (IS_LITERAL(tok, "__int8")) {
- flags |= INT8;
- } else if (IS_LITERAL(tok, "__int16")) {
- flags |= INT16;
- } else if (IS_LITERAL(tok, "__int32")) {
- flags |= INT32;
- } else if (IS_LITERAL(tok, "__int64")) {
- flags |= INT64;
- } else if (IS_LITERAL(tok, "double")) {
- flags |= DOUBLE;
- } else if (IS_LITERAL(tok, "float")) {
- flags |= FLOAT;
- } else if (IS_LITERAL(tok, "complex") || IS_LITERAL(tok, "_Complex")) {
- flags |= COMPLEX;
- } else if (IS_LITERAL(tok, "register")) {
- /* ignore */
- } else {
- break;
- }
-
- if (!next_token(L, P, &tok)) {
- break;
- }
- }
-
- if (flags) {
- put_back(P);
- }
-
- if (flags & CHAR) {
- if (flags & SIGNED) {
- lua_pushliteral(L, "int8_t");
- } else if (flags & UNSIGNED) {
- lua_pushliteral(L, "uint8_t");
- } else {
- lua_pushstring(L, (((char) -1) > 0) ? "uint8_t" : "int8_t");
- }
-
- } else if (flags & INT8) {
- lua_pushstring(L, (flags & UNSIGNED) ? "uint8_t" : "int8_t");
- } else if (flags & INT16) {
- lua_pushstring(L, (flags & UNSIGNED) ? "uint16_t" : "int16_t");
- } else if (flags & INT32) {
- lua_pushstring(L, (flags & UNSIGNED) ? "uint32_t" : "int32_t");
- } else if (flags & (INT64 | LONG_LONG)) {
- lua_pushstring(L, (flags & UNSIGNED) ? "uint64_t" : "int64_t");
-
- } else if (flags & COMPLEX) {
- if (flags & LONG) {
- lua_pushliteral(L, "complex long double");
- } else if (flags & FLOAT) {
- lua_pushliteral(L, "complex float");
- } else {
- lua_pushliteral(L, "complex double");
- }
-
- } else if (flags & DOUBLE) {
- if (flags & LONG) {
- lua_pushliteral(L, "long double");
- } else {
- lua_pushliteral(L, "double");
- }
-
- } else if (flags & FLOAT) {
- lua_pushliteral(L, "float");
-
- } else if (flags & SHORT) {
-#define SHORT_TYPE(u) (sizeof(short) == sizeof(int64_t) ? u "int64_t" : sizeof(short) == sizeof(int32_t) ? u "int32_t" : u "int16_t")
- if (flags & UNSIGNED) {
- lua_pushstring(L, SHORT_TYPE("u"));
- } else {
- lua_pushstring(L, SHORT_TYPE(""));
- }
-#undef SHORT_TYPE
-
- } else if (flags & LONG) {
-#define LONG_TYPE(u) (sizeof(long) == sizeof(int64_t) ? u "int64_t" : u "int32_t")
- if (flags & UNSIGNED) {
- lua_pushstring(L, LONG_TYPE("u"));
- } else {
- lua_pushstring(L, LONG_TYPE(""));
- }
-#undef LONG_TYPE
-
- } else if (flags) {
-#define INT_TYPE(u) (sizeof(int) == sizeof(int64_t) ? u "int64_t" : sizeof(int) == sizeof(int32_t) ? u "int32_t" : u "int16_t")
- if (flags & UNSIGNED) {
- lua_pushstring(L, INT_TYPE("u"));
- } else {
- lua_pushstring(L, INT_TYPE(""));
- }
-#undef INT_TYPE
-
- } else {
- lua_pushlstring(L, tok.str, tok.size);
- }
-
- return 0;
-}
-
-/* parse_attribute parses a token to see if it is an attribute. It may then
- * parse some following tokens to decode the attribute setting the appropriate
- * fields in ct. It will return 1 if the token was used (and possibly some
- * more following it) or 0 if not. If the token was used, the next token must
- * be retrieved using next_token/require_token.
- */
-static int parse_attribute(lua_State* L, struct parser* P, struct token* tok, struct ctype* ct, struct parser* asmname)
-{
- if (tok->type != TOK_TOKEN) {
- return 0;
-
- } else if (asmname && (IS_LITERAL(*tok, "__asm__") || IS_LITERAL(*tok, "__asm"))) {
- check_token(L, P, TOK_OPEN_PAREN, NULL, "unexpected token after __asm__ on line %d", P->line);
- *asmname = *P;
-
- require_token(L, P, tok);
- while (tok->type == TOK_STRING) {
- require_token(L, P, tok);
- }
-
- if (tok->type != TOK_CLOSE_PAREN) {
- luaL_error(L, "unexpected token after __asm__ on line %d", P->line);
- }
- return 1;
-
- } else if (IS_LITERAL(*tok, "__attribute__") || IS_LITERAL(*tok, "__declspec")) {
- int parens = 1;
- check_token(L, P, TOK_OPEN_PAREN, NULL, "expected parenthesis after __attribute__ or __declspec on line %d", P->line);
-
- for (;;) {
- require_token(L, P, tok);
- if (tok->type == TOK_OPEN_PAREN) {
- parens++;
- } else if (tok->type == TOK_CLOSE_PAREN) {
- if (--parens == 0) {
- break;
- }
-
- } else if (tok->type != TOK_TOKEN) {
- /* ignore unknown symbols within parentheses */
-
- } else if (IS_LITERAL(*tok, "align") || IS_LITERAL(*tok, "aligned") || IS_LITERAL(*tok, "__aligned__")) {
- unsigned align = 0;
- require_token(L, P, tok);
-
- switch (tok->type) {
- case TOK_CLOSE_PAREN:
- align = ALIGNED_DEFAULT;
- put_back(P);
- break;
-
- case TOK_OPEN_PAREN:
- require_token(L, P, tok);
-
- if (tok->type != TOK_NUMBER) {
- luaL_error(L, "expected align(#) on line %d", P->line);
- }
-
- switch (tok->integer) {
- case 1: align = 0; break;
- case 2: align = 1; break;
- case 4: align = 3; break;
- case 8: align = 7; break;
- case 16: align = 15; break;
- default:
- luaL_error(L, "unsupported align size on line %d", P->line);
- }
-
- check_token(L, P, TOK_CLOSE_PAREN, NULL, "expected align(#) on line %d", P->line);
- break;
-
- default:
- luaL_error(L, "expected align(#) on line %d", P->line);
- }
-
- /* __attribute__(aligned(#)) is only supposed to increase alignment */
- ct->align_mask = max(align, ct->align_mask);
-
- } else if (IS_LITERAL(*tok, "packed") || IS_LITERAL(*tok, "__packed__")) {
- ct->align_mask = 0;
- ct->is_packed = 1;
-
- } else if (IS_LITERAL(*tok, "mode") || IS_LITERAL(*tok, "__mode__")) {
-
- check_token(L, P, TOK_OPEN_PAREN, NULL, "expected mode(MODE) on line %d", P->line);
-
- require_token(L, P, tok);
- if (tok->type != TOK_TOKEN) {
- luaL_error(L, "expected mode(MODE) on line %d", P->line);
- }
-
- if (ct->type == FLOAT_TYPE || ct->type == DOUBLE_TYPE) {
- struct {char ch; float v;} af;
- struct {char ch; double v;} ad;
-
- if (IS_LITERAL(*tok, "SF") || IS_LITERAL(*tok, "__SF__")) {
- ct->type = FLOAT_TYPE;
- ct->base_size = sizeof(float);
- ct->align_mask = ALIGNOF(af);
-
- } else if (IS_LITERAL(*tok, "DF") || IS_LITERAL(*tok, "__DF__")) {
- ct->type = DOUBLE_TYPE;
- ct->base_size = sizeof(double);
- ct->align_mask = ALIGNOF(ad);
-
- } else {
- luaL_error(L, "unexpected mode on line %d", P->line);
- }
-
- } else {
- struct {char ch; uint16_t v;} a16;
- struct {char ch; uint32_t v;} a32;
- struct {char ch; uint64_t v;} a64;
-
- if (IS_LITERAL(*tok, "QI") || IS_LITERAL(*tok, "__QI__")
- || IS_LITERAL(*tok, "byte") || IS_LITERAL(*tok, "__byte__")
- ) {
- ct->type = INT8_TYPE;
- ct->base_size = sizeof(uint8_t);
- ct->align_mask = 0;
-
- } else if (IS_LITERAL(*tok, "HI") || IS_LITERAL(*tok, "__HI__")) {
- ct->type = INT16_TYPE;
- ct->base_size = sizeof(uint16_t);
- ct->align_mask = ALIGNOF(a16);
-
- } else if (IS_LITERAL(*tok, "SI") || IS_LITERAL(*tok, "__SI__")
-#if defined ARCH_X86 || defined ARCH_ARM
- || IS_LITERAL(*tok, "word") || IS_LITERAL(*tok, "__word__")
- || IS_LITERAL(*tok, "pointer") || IS_LITERAL(*tok, "__pointer__")
-#endif
- ) {
- ct->type = INT32_TYPE;
- ct->base_size = sizeof(uint32_t);
- ct->align_mask = ALIGNOF(a32);
-
- } else if (IS_LITERAL(*tok, "DI") || IS_LITERAL(*tok, "__DI__")
-#if defined ARCH_X64
- || IS_LITERAL(*tok, "word") || IS_LITERAL(*tok, "__word__")
- || IS_LITERAL(*tok, "pointer") || IS_LITERAL(*tok, "__pointer__")
-#endif
- ) {
- ct->type = INT64_TYPE;
- ct->base_size = sizeof(uint64_t);
- ct->align_mask = ALIGNOF(a64);
-
- } else {
- luaL_error(L, "unexpected mode on line %d", P->line);
- }
- }
-
- check_token(L, P, TOK_CLOSE_PAREN, NULL, "expected mode(MODE) on line %d", P->line);
-
- } else if (IS_LITERAL(*tok, "cdecl") || IS_LITERAL(*tok, "__cdecl__")) {
- ct->calling_convention = C_CALL;
-
- } else if (IS_LITERAL(*tok, "fastcall") || IS_LITERAL(*tok, "__fastcall__")) {
- ct->calling_convention = FAST_CALL;
-
- } else if (IS_LITERAL(*tok, "stdcall") || IS_LITERAL(*tok, "__stdcall__")) {
- ct->calling_convention = STD_CALL;
- }
- /* ignore unknown tokens within parentheses */
- }
- return 1;
-
- } else if (IS_LITERAL(*tok, "__cdecl")) {
- ct->calling_convention = C_CALL;
- return 1;
-
- } else if (IS_LITERAL(*tok, "__fastcall")) {
- ct->calling_convention = FAST_CALL;
- return 1;
-
- } else if (IS_LITERAL(*tok, "__stdcall")) {
- ct->calling_convention = STD_CALL;
- return 1;
-
- } else if (IS_LITERAL(*tok, "__extension__") || IS_LITERAL(*tok, "extern")) {
- /* ignore */
- return 1;
-
- } else {
- return 0;
- }
-}
-
-/* parses out the base type of a type expression in a function declaration,
- * struct definition, typedef etc
- *
- * leaves the usr value of the type on the stack
- */
-int parse_type(lua_State* L, struct parser* P, struct ctype* ct)
-{
- struct token tok;
- int top = lua_gettop(L);
-
- memset(ct, 0, sizeof(*ct));
-
- require_token(L, P, &tok);
-
- /* get const/volatile before the base type */
- for (;;) {
- if (tok.type != TOK_TOKEN) {
- return luaL_error(L, "unexpected value before type name on line %d", P->line);
-
- } else if (IS_CONST(tok)) {
- ct->const_mask = 1;
- require_token(L, P, &tok);
-
- } else if (IS_VOLATILE(tok) ||
- IS_RESTRICT(tok) ||
- IS_LITERAL(tok, "static") ||
- IS_INLINE(tok)) {
- /* ignored for now */
- require_token(L, P, &tok);
- } else if (parse_attribute(L, P, &tok, ct, NULL)) {
- /* get function attributes before the return type */
- require_token(L, P, &tok);
-
- } else {
- break;
- }
- }
-
- /* get base type */
- if (tok.type != TOK_TOKEN) {
- return luaL_error(L, "unexpected value before type name on line %d", P->line);
-
- } else if (IS_LITERAL(tok, "struct")) {
- ct->type = STRUCT_TYPE;
- parse_record(L, P, ct);
-
- } else if (IS_LITERAL(tok, "union")) {
- ct->type = UNION_TYPE;
- parse_record(L, P, ct);
-
- } else if (IS_LITERAL(tok, "enum")) {
- ct->type = ENUM_TYPE;
- parse_record(L, P, ct);
-
- } else {
- put_back(P);
-
- /* lookup type */
- push_upval(L, &types_key);
- parse_type_name(L, P);
- lua_rawget(L, -2);
- lua_remove(L, -2);
-
- if (lua_isnil(L, -1)) {
- lua_pushlstring(L, tok.str, tok.size);
- return luaL_error(L, "unknown type %s on line %d", lua_tostring(L, -1), P->line);
- }
-
- instantiate_typedef(P, ct, (const struct ctype*) lua_touserdata(L, -1));
-
- /* we only want the usr tbl from the ctype in the types tbl */
- lua_getuservalue(L, -1);
- lua_replace(L, -2);
- }
-
- while (next_token(L, P, &tok)) {
- if (tok.type != TOK_TOKEN) {
- put_back(P);
- break;
-
- } else if (IS_CONST(tok) || IS_VOLATILE(tok)) {
- /* ignore for now */
-
- } else {
- put_back(P);
- break;
- }
- }
-
- assert(lua_gettop(L) == top + 1 && (lua_istable(L, -1) || lua_isnil(L, -1)));
- return 0;
-}
-
-enum name_type {
- BOTH,
- FRONT,
- BACK,
-};
-
-static void append_type_name(luaL_Buffer* B, int usr, const struct ctype* ct, enum name_type type)
-{
- size_t i;
- lua_State* L = B->L;
-
- usr = lua_absindex(L, usr);
-
- if (type == FRONT || type == BOTH) {
- if (ct->type != FUNCTION_PTR_TYPE && (ct->const_mask & (1 << ct->pointers))) {
- luaL_addstring(B, "const ");
- }
-
- if (ct->is_unsigned) {
- luaL_addstring(B, "unsigned ");
- }
-
- switch (ct->type) {
- case ENUM_TYPE:
- luaL_addstring(B, "enum ");
- goto get_name;
-
- case STRUCT_TYPE:
- luaL_addstring(B, "struct ");
- goto get_name;
-
- case UNION_TYPE:
- luaL_addstring(B, "union ");
- goto get_name;
-
- get_name:
- lua_pushlightuserdata(L, &g_name_key);
- lua_rawget(L, usr);
- luaL_addvalue(B);
- break;
-
- case FUNCTION_TYPE:
- case FUNCTION_PTR_TYPE:
- lua_pushlightuserdata(L, &g_front_name_key);
- lua_rawget(L, usr);
- luaL_addvalue(B);
- break;
-
- case VOID_TYPE:
- luaL_addstring(B, "void");
- break;
- case BOOL_TYPE:
- luaL_addstring(B, "bool");
- break;
- case DOUBLE_TYPE:
- luaL_addstring(B, "double");
- break;
- case LONG_DOUBLE_TYPE:
- luaL_addstring(B, "long double");
- break;
- case FLOAT_TYPE:
- luaL_addstring(B, "float");
- break;
- case COMPLEX_LONG_DOUBLE_TYPE:
- luaL_addstring(B, "long complex double");
- break;
- case COMPLEX_DOUBLE_TYPE:
- luaL_addstring(B, "complex double");
- break;
- case COMPLEX_FLOAT_TYPE:
- luaL_addstring(B, "complex float");
- break;
- case INT8_TYPE:
- luaL_addstring(B, "char");
- break;
- case INT16_TYPE:
- luaL_addstring(B, "short");
- break;
- case INT32_TYPE:
- luaL_addstring(B, "int");
- break;
- case INT64_TYPE:
- luaL_addstring(B, "long long");
- break;
-
- case INTPTR_TYPE:
- if (sizeof(intptr_t) == sizeof(int32_t)) {
- luaL_addstring(B, "long");
- } else if (sizeof(intptr_t) == sizeof(int64_t)) {
- luaL_addstring(B, "long long");
- } else {
- luaL_error(L, "internal error - bad type");
- }
- break;
-
- default:
- luaL_error(L, "internal error - bad type %d", ct->type);
- }
-
- for (i = 0; i < ct->pointers - ct->is_array; i++) {
- luaL_addchar(B, '*');
- if (ct->const_mask & (1 << (ct->pointers - i - 1))) {
- luaL_addstring(B, " const");
- }
- }
- }
-
- if (type == BOTH || type == BACK) {
- if (ct->is_reference) {
- luaL_addstring(B, " &");
- }
-
- if (ct->is_variable_array && !ct->variable_size_known) {
- luaL_addstring(B, "[?]");
- } else if (ct->is_array) {
- lua_pushfstring(L, "[%d]", (int) ct->array_size);
- luaL_addvalue(B);
- }
-
- if (ct->type == FUNCTION_PTR_TYPE || ct->type == FUNCTION_TYPE) {
- lua_pushlightuserdata(L, &g_back_name_key);
- lua_rawget(L, usr);
- luaL_addvalue(B);
- }
-
- if (ct->is_bitfield) {
- lua_pushfstring(L, " : %d", (int) ct->bit_size);
- luaL_addvalue(B);
- }
- }
-}
-
-void push_type_name(lua_State* L, int usr, const struct ctype* ct)
-{
- luaL_Buffer B;
- usr = lua_absindex(L, usr);
- luaL_buffinit(L, &B);
- append_type_name(&B, usr, ct, BOTH);
- luaL_pushresult(&B);
-}
-
-static void push_function_type_strings(lua_State* L, int usr, const struct ctype* ct)
-{
- size_t i, args;
- luaL_Buffer B;
- int top = lua_gettop(L);
- const struct ctype* ret_ct;
-
- int arg_ct = top+3;
- int arg_usr = top+4;
- int ret_usr = top+6;
-
- usr = lua_absindex(L, usr);
-
- /* return type */
- lua_settop(L, top+4); /* room for two returns and two temp positions */
- lua_rawgeti(L, usr, 0);
- lua_getuservalue(L, -1);
- ret_ct = (const struct ctype*) lua_touserdata(L, -2);
-
- luaL_buffinit(L, &B);
- append_type_name(&B, ret_usr, ret_ct, FRONT);
-
- if (ret_ct->type != FUNCTION_TYPE && ret_ct->type != FUNCTION_PTR_TYPE) {
- luaL_addchar(&B, ' ');
- }
-
- switch (ct->calling_convention) {
- case STD_CALL:
- luaL_addstring(&B, "(__stdcall *");
- break;
- case FAST_CALL:
- luaL_addstring(&B, "(__fastcall *");
- break;
- case C_CALL:
- luaL_addstring(&B, "(*");
- break;
- default:
- luaL_error(L, "internal error - unknown calling convention");
- }
-
- luaL_pushresult(&B);
- lua_replace(L, top+1);
-
- luaL_buffinit(L, &B);
- luaL_addstring(&B, ")(");
-
- /* arguments */
- args = lua_rawlen(L, usr);
- for (i = 1; i <= args; i++) {
- if (i > 1) {
- luaL_addstring(&B, ", ");
- }
-
- /* note push the arg and user value below the indexes used by the buffer
- * and use indexes relative to top to avoid problems due to the buffer
- * system pushing a variable number of arguments onto the stack */
- lua_rawgeti(L, usr, (int) i);
- lua_replace(L, arg_ct);
- lua_getuservalue(L, arg_ct);
- lua_replace(L, arg_usr);
- append_type_name(&B, arg_usr, (const struct ctype*) lua_touserdata(L, arg_ct), BOTH);
- }
-
- luaL_addstring(&B, ")");
- append_type_name(&B, ret_usr, ret_ct, BACK);
- luaL_pushresult(&B);
- lua_replace(L, top+2);
-
- lua_settop(L, top+2);
- assert(lua_isstring(L, top+1) && lua_isstring(L, top+2));
-}
-
-/* parses from after the opening paranthesis to after the closing parenthesis */
-static void parse_function_arguments(lua_State* L, struct parser* P, int ct_usr, struct ctype* ct)
-{
- struct token tok;
- int args = 0;
- int top = lua_gettop(L);
-
- ct_usr = lua_absindex(L, ct_usr);
-
- for (;;) {
- require_token(L, P, &tok);
-
- if (tok.type == TOK_CLOSE_PAREN) {
- break;
- }
-
- if (args) {
- if (tok.type != TOK_COMMA) {
- luaL_error(L, "unexpected token in function argument %d on line %d", args, P->line);
- }
-
- require_token(L, P, &tok);
- }
-
- if (tok.type == TOK_VA_ARG) {
- ct->has_var_arg = true;
- check_token(L, P, TOK_CLOSE_PAREN, "", "unexpected token after ... in function on line %d", P->line);
- break;
-
- } else if (tok.type == TOK_TOKEN) {
- struct ctype at;
-
- put_back(P);
- parse_type(L, P, &at);
- parse_argument(L, P, -1, &at, NULL, NULL);
-
- assert(lua_gettop(L) == top + 2);
-
- /* array arguments are just treated as their base pointer type */
- at.is_array = 0;
-
- /* check for the c style int func(void) and error on other uses of arguments of type void */
- if (at.type == VOID_TYPE && at.pointers == 0) {
- if (args) {
- luaL_error(L, "can't have argument of type void on line %d", P->line);
- }
-
- check_token(L, P, TOK_CLOSE_PAREN, "", "unexpected void in function on line %d", P->line);
- lua_pop(L, 2);
- break;
- }
-
- push_ctype(L, -1, &at);
- lua_rawseti(L, ct_usr, ++args);
-
- lua_pop(L, 2); /* parse_type and parse_argument at_usr */
-
- } else {
- luaL_error(L, "unexpected token in function argument %d on line %d", args+1, P->line);
- }
- }
-
- assert(lua_gettop(L) == top);
-}
-
-static int max_bitfield_size(int type)
-{
- switch (type) {
- case BOOL_TYPE:
- return 1;
- case INT8_TYPE:
- return 8;
- case INT16_TYPE:
- return 16;
- case INT32_TYPE:
- case ENUM_TYPE:
- return 32;
- case INT64_TYPE:
- return 64;
- default:
- return -1;
- }
-}
-
-static struct ctype* parse_argument2(lua_State* L, struct parser* P, int ct_usr, struct ctype* ct, struct token* name, struct parser* asmname);
-
-/* parses from after the first ( in a function declaration or function pointer
- * can be one of:
- * void foo(...) before ...
- * void (foo)(...) before foo
- * void (* <>)(...) before <> which is the inner type
- */
-static struct ctype* parse_function(lua_State* L, struct parser* P, int ct_usr, struct ctype* ct, struct token* name, struct parser* asmname)
-{
- /* We have a function pointer or a function. The usr table will
- * get replaced by the canonical one (if there is one) in
- * find_canonical_usr after all the arguments and returns have
- * been parsed. */
- struct token tok;
- int top = lua_gettop(L);
- struct ctype* ret;
-
- lua_newtable(L);
- ret = push_ctype(L, ct_usr, ct);
- lua_rawseti(L, -2, 0);
- ct_usr = lua_gettop(L);
-
- memset(ct, 0, sizeof(*ct));
- ct->base_size = sizeof(void (*)());
- ct->align_mask = min(FUNCTION_ALIGN_MASK, P->align_mask);
- ct->type = FUNCTION_TYPE;
- ct->is_defined = 1;
-
- if (name->type == TOK_NIL) {
- for (;;) {
- require_token(L, P, &tok);
-
- if (tok.type == TOK_STAR) {
-
- if (ct->type == FUNCTION_TYPE) {
- ct->type = FUNCTION_PTR_TYPE;
- } else if (ct->pointers == POINTER_MAX) {
- luaL_error(L, "maximum number of pointer derefs reached - use a struct to break up the pointers on line %d", P->line);
- } else {
- ct->pointers++;
- ct->const_mask <<= 1;
- }
-
- } else if (parse_attribute(L, P, &tok, ct, asmname)) {
- /* parse_attribute sets the appropriate fields */
-
- } else {
- /* call parse_argument to handle the inner contents
- * e.g. the <> in "void (* <>) (...)". Note that the
- * inner contents can itself be a function, a function
- * ptr, array, etc (e.g. "void (*signal(int sig, void
- * (*func)(int)))(int)" ).
- */
- put_back(P);
- ct = parse_argument2(L, P, ct_usr, ct, name, asmname);
- break;
- }
- }
-
- check_token(L, P, TOK_CLOSE_PAREN, NULL, "unexpected token in function on line %d", P->line);
- check_token(L, P, TOK_OPEN_PAREN, NULL, "unexpected token in function on line %d", P->line);
- }
-
- parse_function_arguments(L, P, ct_usr, ct);
-
- /* if we have an inner function then set the outer function ptr as its
- * return type and return the inner function
- * e.g. for void (* <signal(int, void (*)(int))> )(int) inner is
- * surrounded by <>, return type is void (*)(int)
- */
- if (lua_gettop(L) == ct_usr+1) {
- lua_replace(L, ct_usr);
- }
-
- assert(lua_gettop(L) == top + 1 && lua_istable(L, -1));
- return ret;
-}
-
-static struct ctype* parse_argument2(lua_State* L, struct parser* P, int ct_usr, struct ctype* ct, struct token* name, struct parser* asmname)
-{
- struct token tok;
- int top = lua_gettop(L);
- int ft_usr = 0;
-
- luaL_checkstack(L, 10, "function too complex");
- ct_usr = lua_absindex(L, ct_usr);
-
- for (;;) {
- if (!next_token(L, P, &tok)) {
- /* we've reached the end of the string */
- break;
-
- } else if (tok.type == TOK_STAR) {
- if (ct->pointers == POINTER_MAX) {
- luaL_error(L, "maximum number of pointer derefs reached - use a struct to break up the pointers on line %d", P->line);
- }
-
- ct->pointers++;
- ct->const_mask <<= 1;
-
- /* __declspec(align(#)) may come before the type in a member */
- if (!ct->is_packed) {
- ct->align_mask = max(min(PTR_ALIGN_MASK, P->align_mask), ct->align_mask);
- }
-
- } else if (tok.type == TOK_REFERENCE) {
- ct->is_reference = 1;
-
- } else if (parse_attribute(L, P, &tok, ct, asmname)) {
- /* parse attribute has filled out appropriate fields in type */
-
- } else if (tok.type == TOK_OPEN_PAREN) {
- ct = parse_function(L, P, ct_usr, ct, name, asmname);
- ft_usr = lua_gettop(L);
-
- } else if (tok.type == TOK_OPEN_SQUARE) {
- /* array */
- if (ct->pointers == POINTER_MAX) {
- luaL_error(L, "maximum number of pointer derefs reached - use a struct to break up the pointers");
- }
- ct->is_array = 1;
- ct->pointers++;
- ct->const_mask <<= 1;
- require_token(L, P, &tok);
-
- if (ct->pointers == 1 && !ct->is_defined) {
- luaL_error(L, "array of undefined type on line %d", P->line);
- }
-
- if (ct->is_variable_struct || ct->is_variable_array) {
- luaL_error(L, "can't have an array of a variably sized type on line %d", P->line);
- }
-
- if (tok.type == TOK_QUESTION) {
- ct->is_variable_array = 1;
- ct->variable_increment = (ct->pointers > 1) ? sizeof(void*) : ct->base_size;
- check_token(L, P, TOK_CLOSE_SQUARE, "", "invalid character in array on line %d", P->line);
-
- } else if (tok.type == TOK_CLOSE_SQUARE) {
- ct->array_size = 0;
-
- } else if (tok.type == TOK_TOKEN && IS_RESTRICT(tok)) {
- /* odd gcc extension foo[__restrict] for arguments */
- ct->array_size = 0;
- check_token(L, P, TOK_CLOSE_SQUARE, "", "invalid character in array on line %d", P->line);
-
- } else {
- int64_t asize;
- put_back(P);
- asize = calculate_constant(L, P);
- if (asize < 0) {
- luaL_error(L, "array size can not be negative on line %d", P->line);
- }
- ct->array_size = (size_t) asize;
- check_token(L, P, TOK_CLOSE_SQUARE, "", "invalid character in array on line %d", P->line);
- }
-
- } else if (tok.type == TOK_COLON) {
- int64_t bsize = calculate_constant(L, P);
-
- if (ct->pointers || bsize < 0 || bsize > max_bitfield_size(ct->type)) {
- luaL_error(L, "invalid bitfield on line %d", P->line);
- }
-
- ct->is_bitfield = 1;
- ct->bit_size = (unsigned) bsize;
-
- } else if (tok.type != TOK_TOKEN) {
- /* we've reached the end of the declaration */
- put_back(P);
- break;
-
- } else if (IS_CONST(tok)) {
- ct->const_mask |= 1;
-
- } else if (IS_VOLATILE(tok) || IS_RESTRICT(tok)) {
- /* ignored for now */
-
- } else {
- *name = tok;
- }
- }
-
- assert((ft_usr == 0 && lua_gettop(L) == top) || (lua_gettop(L) == top + 1 && ft_usr == top + 1 && (lua_istable(L, -1) || lua_isnil(L, -1))));
- return ct;
-}
-
-static void find_canonical_usr(lua_State* L, int ct_usr, const struct ctype *ct)
-{
- struct ctype rt;
- int top = lua_gettop(L);
- int types;
-
- if (ct->type != FUNCTION_PTR_TYPE && ct->type != FUNCTION_TYPE) {
- return;
- }
-
- luaL_checkstack(L, 10, "function too complex");
- ct_usr = lua_absindex(L, ct_usr);
-
- /* check to see if we already have the canonical usr table */
- lua_pushlightuserdata(L, &g_name_key);
- lua_rawget(L, ct_usr);
- if (!lua_isnil(L, -1)) {
- lua_pop(L, 1);
- assert(top == lua_gettop(L));
- return;
- }
- lua_pop(L, 1);
-
- assert(top == lua_gettop(L));
-
- /* first canonize the return type */
- lua_rawgeti(L, ct_usr, 0);
- rt = *(struct ctype*) lua_touserdata(L, -1);
- lua_getuservalue(L, -1);
- find_canonical_usr(L, -1, &rt);
- push_ctype(L, -1, &rt);
- lua_rawseti(L, ct_usr, 0);
- lua_pop(L, 2); /* return ctype and usr */
-
- assert(top == lua_gettop(L));
-
- /* look up the type string in the types table */
- push_upval(L, &types_key);
- types = lua_gettop(L);
-
- push_function_type_strings(L, ct_usr, ct);
- lua_pushvalue(L, -2);
- lua_pushvalue(L, -2);
- lua_concat(L, 2);
-
- lua_pushvalue(L, -1);
- lua_rawget(L, types);
-
- assert(lua_gettop(L) == types + 4 && types == top + 1);
- /* stack: types, front, back, both, looked up value */
-
- if (lua_isnil(L, -1)) {
- lua_pop(L, 1);
-
- lua_pushlightuserdata(L, &g_front_name_key);
- lua_pushvalue(L, -4);
- lua_rawset(L, ct_usr);
-
- lua_pushlightuserdata(L, &g_back_name_key);
- lua_pushvalue(L, -3);
- lua_rawset(L, ct_usr);
-
- lua_pushlightuserdata(L, &g_name_key);
- lua_pushvalue(L, -2);
- lua_rawset(L, ct_usr);
-
- lua_pushvalue(L, -1);
- push_ctype(L, ct_usr, ct);
- lua_rawset(L, types);
- } else {
- lua_getuservalue(L, -1);
- lua_replace(L, ct_usr);
- lua_pop(L, 1);
- }
-
- lua_pop(L, 4);
- assert(top == lua_gettop(L) && types == top + 1);
-}
-
-
-/* parses after the main base type of a typedef, function argument or
- * struct/union member
- * eg for const void* bar[3] the base type is void with the subtype so far of
- * const, this parses the "* bar[3]" and updates the type argument
- *
- * ct_usr and type must be as filled out by parse_type
- *
- * pushes the updated user value on the top of the stack
- */
-void parse_argument(lua_State* L, struct parser* P, int ct_usr, struct ctype* ct, struct token* pname, struct parser* asmname)
-{
- struct token tok, name;
- int top = lua_gettop(L);
-
- memset(&name, 0, sizeof(name));
- parse_argument2(L, P, ct_usr, ct, &name, asmname);
-
- for (;;) {
- if (!next_token(L, P, &tok)) {
- break;
- } else if (parse_attribute(L, P, &tok, ct, asmname)) {
- /* parse_attribute sets the appropriate fields */
- } else {
- put_back(P);
- break;
- }
- }
-
- if (lua_gettop(L) == top) {
- lua_pushvalue(L, ct_usr);
- }
-
- find_canonical_usr(L, -1, ct);
-
- if (pname) {
- *pname = name;
- }
-}
-
-static void parse_typedef(lua_State* L, struct parser* P)
-{
- struct token tok;
- struct ctype base_type;
- int top = lua_gettop(L);
-
- parse_type(L, P, &base_type);
-
- for (;;) {
- struct ctype arg_type = base_type;
- struct token name;
-
- memset(&name, 0, sizeof(name));
-
- assert(lua_gettop(L) == top + 1);
- parse_argument(L, P, -1, &arg_type, &name, NULL);
- assert(lua_gettop(L) == top + 2);
-
- if (!name.size) {
- luaL_error(L, "Can't have a typedef without a name on line %d", P->line);
- } else if (arg_type.is_variable_array) {
- luaL_error(L, "Can't typedef a variable length array on line %d", P->line);
- }
-
- push_upval(L, &types_key);
- lua_pushlstring(L, name.str, name.size);
- push_ctype(L, -3, &arg_type);
- lua_rawset(L, -3);
- lua_pop(L, 2); /* types and parse_argument usr tbl */
-
- require_token(L, P, &tok);
-
- if (tok.type == TOK_SEMICOLON) {
- break;
- } else if (tok.type != TOK_COMMA) {
- luaL_error(L, "Unexpected character in typedef on line %d", P->line);
- }
- }
-
- lua_pop(L, 1); /* parse_type usr tbl */
- assert(lua_gettop(L) == top);
-}
-
-static bool is_hex(char ch)
-{ return ('0' <= ch && ch <= '9') || ('a' <= ch && ch <= 'f') || ('A' <= ch && ch <= 'F'); }
-
-static bool is_digit(char ch)
-{ return '0' <= ch && ch <= '9'; }
-
-static int from_hex(char ch)
-{
- if (ch >= 'a') {
- return ch - 'a' + 10;
- } else if (ch >= 'A') {
- return ch - 'A' + 10;
- } else {
- return ch - '0';
- }
-}
-
-static void push_strings(lua_State* L, struct parser* P)
-{
- luaL_Buffer B;
- luaL_buffinit(L, &B);
-
- for (;;) {
- const char *p, *e;
- char *t, *s;
- struct token tok;
-
- require_token(L, P, &tok);
- if (tok.type != TOK_STRING) {
- break;
- }
-
- p = tok.str;
- e = p + tok.size;
-
- t = luaL_prepbuffsize(&B, tok.size);
- s = t;
-
- while (p < e) {
- if (*p == '\\') {
- if (++p == e) {
- luaL_error(L, "parse error in string");
- }
- switch (*p) {
- case '\\': *(t++) = '\\'; p++; break;
- case '\"': *(t++) = '\"'; p++; break;
- case '\'': *(t++) = '\''; p++; break;
- case 'n': *(t++) = '\n'; p++; break;
- case 'r': *(t++) = '\r'; p++; break;
- case 'b': *(t++) = '\b'; p++; break;
- case 't': *(t++) = '\t'; p++; break;
- case 'f': *(t++) = '\f'; p++; break;
- case 'a': *(t++) = '\a'; p++; break;
- case 'v': *(t++) = '\v'; p++; break;
- case 'e': *(t++) = 0x1B; p++; break;
- case 'x':
- {
- uint8_t u;
- p++;
- if (p + 2 > e || !is_hex(p[0]) || !is_hex(p[1])) {
- luaL_error(L, "parse error in string");
- }
- u = (from_hex(p[0]) << 4) | from_hex(p[1]);
- *(t++) = *(char*) &u;
- p += 2;
- break;
- }
- default:
- {
- uint8_t u;
- const char* e2 = min(p + 3, e);
- if (!is_digit(*p)) {
- luaL_error(L, "parse error in string");
- }
- u = *p - '0';
- p++;
- while (is_digit(*p) && p < e2) {
- u = 10*u + *p-'0';
- p++;
- }
- *(t++) = *(char*) &u;
- break;
- }
- }
- } else {
- *(t++) = *(p++);
- }
- }
-
- luaL_addsize(&B, t-s);
- }
-
- luaL_pushresult(&B);
-}
-
-static void parse_constant_assignemnt(lua_State* L,
- struct parser* P,
- const struct ctype* type,
- const struct token* name)
-{
- int64_t val = calculate_constant(L, P);
-
- check_token(L, P, TOK_SEMICOLON, "", "expected ; after constant definition on line %d", P->line);
-
- push_upval(L, &constants_key);
- lua_pushlstring(L, name->str, name->size);
-
- switch (type->type) {
- case INT8_TYPE:
- case INT16_TYPE:
- case INT32_TYPE:
- if (type->is_unsigned)
- lua_pushinteger(L, (unsigned int) val);
- else
- lua_pushinteger(L, (int) val);
- break;
-
- default:
- luaL_error(L, "expected a valid 8-, 16-, or 32-bit signed or unsigned integer type after 'static const' on line %d", P->line);
- }
-
- lua_rawset(L, -3);
- lua_pop(L, 2); /*constants and type*/
-}
-
-#define END 0
-#define PRAGMA_POP 1
-
-static int parse_root(lua_State* L, struct parser* P)
-{
- int top = lua_gettop(L);
- struct token tok;
-
- while (next_token(L, P, &tok)) {
- /* we can have:
- * struct definition
- * enum definition
- * union definition
- * struct/enum/union declaration
- * typedef
- * function declaration
- * pragma pack
- */
-
- assert(lua_gettop(L) == top);
-
- if (tok.type == TOK_SEMICOLON) {
- /* empty semicolon in root continue on */
-
- } else if (tok.type == TOK_POUND) {
-
- check_token(L, P, TOK_TOKEN, "pragma", "unexpected pre processor directive on line %d", P->line);
- check_token(L, P, TOK_TOKEN, "pack", "unexpected pre processor directive on line %d", P->line);
- check_token(L, P, TOK_OPEN_PAREN, "", "invalid pack directive on line %d", P->line);
-
- require_token(L, P, &tok);
-
- if (tok.type == TOK_NUMBER) {
- if (tok.integer != 1 && tok.integer != 2 && tok.integer != 4 && tok.integer != 8 && tok.integer != 16) {
- luaL_error(L, "pack directive with invalid pack size on line %d", P->line);
- }
-
- P->align_mask = (unsigned) (tok.integer - 1);
- check_token(L, P, TOK_CLOSE_PAREN, "", "invalid pack directive on line %d", P->line);
-
- } else if (tok.type == TOK_TOKEN && IS_LITERAL(tok, "push")) {
- int line = P->line;
- unsigned previous_alignment = P->align_mask;
-
- check_token(L, P, TOK_CLOSE_PAREN, "", "invalid pack directive on line %d", P->line);
-
- if (parse_root(L, P) != PRAGMA_POP) {
- luaL_error(L, "reached end of string without a pragma pop to match the push on line %d", line);
- }
-
- P->align_mask = previous_alignment;
-
- } else if (tok.type == TOK_TOKEN && IS_LITERAL(tok, "pop")) {
- check_token(L, P, TOK_CLOSE_PAREN, "", "invalid pack directive on line %d", P->line);
- return PRAGMA_POP;
-
- } else {
- luaL_error(L, "invalid pack directive on line %d", P->line);
- }
-
-
- } else if (tok.type != TOK_TOKEN) {
- return luaL_error(L, "unexpected character on line %d", P->line);
-
- } else if (IS_LITERAL(tok, "__extension__")) {
- /* ignore */
- continue;
-
- } else if (IS_LITERAL(tok, "extern")) {
- /* ignore extern as data and functions can only be extern */
- continue;
-
- } else if (IS_LITERAL(tok, "typedef")) {
- parse_typedef(L, P);
-
- } else {
- /* type declaration, type definition, or function declaration */
- struct ctype type;
- struct token name;
- struct parser asmname;
-
- memset(&name, 0, sizeof(name));
- memset(&asmname, 0, sizeof(asmname));
-
- put_back(P);
- parse_type(L, P, &type);
-
- for (;;) {
- parse_argument(L, P, -1, &type, &name, &asmname);
-
- if (name.size) {
- /* global/function declaration */
-
- /* set asmname_tbl[name] = asmname */
- if (asmname.next) {
- push_upval(L, &asmname_key);
- lua_pushlstring(L, name.str, name.size);
- push_strings(L, &asmname);
- lua_rawset(L, -3);
- lua_pop(L, 1); /* asmname upval */
- }
-
- push_upval(L, &functions_key);
- lua_pushlstring(L, name.str, name.size);
- push_ctype(L, -3, &type);
- lua_rawset(L, -3);
- lua_pop(L, 1); /* functions upval */
- } else {
- /* type declaration/definition - already been processed */
- }
-
- lua_pop(L, 1);
-
- if (!next_token(L, P, &tok)) {
- break;
- }
-
- if (tok.type == TOK_COMMA) {
- continue;
- }
-
- if (tok.type == TOK_OPEN_CURLY) {
- int line = P->line;
- int remaining = 1;
- while (remaining > 0 && next_token(L, P, &tok)) {
- if (tok.type == TOK_CLOSE_CURLY) {
- remaining--;
- } else if (tok.type == TOK_OPEN_CURLY) {
- remaining++;
- }
- }
- if (remaining > 0) {
- luaL_error(L, "missing closing bracket for line %d", line);
- }
- } else if (tok.type == TOK_ASSIGN) {
- parse_constant_assignemnt(L, P, &type, &name);
- } else if (tok.type != TOK_SEMICOLON) {
- luaL_error(L, "missing semicolon on line %d", P->line);
- }
- break;
- }
-
- lua_pop(L, 1);
- }
- }
-
- return END;
-}
-
-int ffi_cdef(lua_State* L)
-{
- struct parser P;
-
- P.line = 1;
- P.prev = P.next = luaL_checkstring(L, 1);
- P.align_mask = DEFAULT_ALIGN_MASK;
-
- if (parse_root(L, &P) == PRAGMA_POP) {
- luaL_error(L, "pragma pop without an associated push on line %d", P.line);
- }
-
- return 0;
-}
-
-/* calculate_constant handles operator precedence by having a number of
- * recursive commands each of which computes the result at that level of
- * precedence and above. calculate_constant1 is the highest precedence
- */
-
-static int64_t string_to_int(const char* str, size_t size)
-{
- const char* end = str + size;
- char c = *str++;
- if (str < end)
- {
- if (c == '\\') {
- c = *str++;
- switch (c) {
- case '\'': c = '\''; break;
- case '\"': c = '\"'; break;
- case '\?': c = '\?'; break;
- case '\\': c = '\\'; break;
- case 'a': c = '\a'; break;
- case 'b': c = '\b'; break;
- case 'f': c = '\f'; break;
- case 'n': c = '\n'; break;
- case 'r': c = '\r'; break;
- case 't': c = '\t'; break;
- case 'v': c = '\v'; break;
- case 'e': c = 27; break;
- case 'x':
- c = 0;
- while (str < end) {
- char d = *str++;
- c *= 16;
- if (d >= '0' && d <= '9') c += (d - '0');
- else c += (d - 'a' + 10);
- }
- break;
- default:
- c = c - '0';
- while (str < end) {
- char d = *str++;
- c = c*8 + (d - '0');
- }
- break;
- }
- }
- }
- return c;
-}
-
-static int try_cast(lua_State* L)
-{
- struct parser* P = (struct parser*) lua_touserdata(L, 1);
- struct ctype ct;
- struct token name, tok;
- memset(&name, 0, sizeof(name));
-
- parse_type(L, P, &ct);
- parse_argument(L, P, -1, &ct, &name, NULL);
-
- require_token(L, P, &tok);
- if (tok.type != TOK_CLOSE_PAREN || name.size) {
- return luaL_error(L, "invalid cast");
- }
-
- if (ct.pointers/* || ct.type != INT32_TYPE*/) {
- return luaL_error(L, "unsupported cast on line %d", P->line);
- }
-
- return 0;
-}
-
-static int64_t calculate_constant2(lua_State* L, struct parser* P, struct token* tok);
-
-/* () */
-static int64_t calculate_constant1(lua_State* L, struct parser* P, struct token* tok)
-{
- int64_t ret;
-
- if (tok->type == TOK_NUMBER) {
- ret = tok->integer;
- next_token(L, P, tok);
- return ret;
-
- } else if (tok->type == TOK_TOKEN) {
- /* look up name in constants table */
- push_upval(L, &constants_key);
- lua_pushlstring(L, tok->str, tok->size);
- lua_rawget(L, -2);
- lua_remove(L, -2); /* constants table */
-
- if (!lua_isnumber(L, -1)) {
- lua_pushlstring(L, tok->str, tok->size);
- luaL_error(L, "use of undefined constant %s on line %d", lua_tostring(L, -1), P->line);
- }
-
- ret = (int64_t) lua_tonumber(L, -1);
- lua_pop(L, 1);
- next_token(L, P, tok);
- return ret;
-
- } else if (tok->type == TOK_OPEN_PAREN) {
- struct parser before_cast = *P;
- int top = lua_gettop(L);
-
- /* see if this is a numeric cast, which we ignore */
- lua_pushcfunction(L, &try_cast);
- lua_pushlightuserdata(L, P);
- if (!lua_pcall(L, 1, 0, 0)) {
- next_token(L, P, tok);
- return calculate_constant2(L, P, tok);
- }
- lua_settop(L, top);
-
- *P = before_cast;
- ret = calculate_constant(L, P);
-
- require_token(L, P, tok);
- if (tok->type != TOK_CLOSE_PAREN) {
- luaL_error(L, "error whilst parsing constant at line %d", P->line);
- }
-
- next_token(L, P, tok);
- return ret;
-
- } else if (tok->type == TOK_STRING) {
- ret = string_to_int(tok->str, tok->size);
-
- next_token(L, P, tok);
- return ret;
-
- } else {
- return luaL_error(L, "unexpected token whilst parsing constant at line %d", P->line);
- }
-}
-
-/* ! and ~, unary + and -, and sizeof */
-static int64_t calculate_constant2(lua_State* L, struct parser* P, struct token* tok)
-{
- if (tok->type == TOK_LOGICAL_NOT) {
- require_token(L, P, tok);
- return !calculate_constant2(L, P, tok);
-
- } else if (tok->type == TOK_BITWISE_NOT) {
- require_token(L, P, tok);
- return ~calculate_constant2(L, P, tok);
-
- } else if (tok->type == TOK_PLUS) {
- require_token(L, P, tok);
- return calculate_constant2(L, P, tok);
-
- } else if (tok->type == TOK_MINUS) {
- require_token(L, P, tok);
- return -calculate_constant2(L, P, tok);
-
- } else if (tok->type == TOK_TOKEN &&
- (IS_LITERAL(*tok, "sizeof")
- || IS_LITERAL(*tok, "alignof")
- || IS_LITERAL(*tok, "__alignof__")
- || IS_LITERAL(*tok, "__alignof"))) {
-
- bool issize = IS_LITERAL(*tok, "sizeof");
- struct ctype type;
-
- require_token(L, P, tok);
- if (tok->type != TOK_OPEN_PAREN) {
- luaL_error(L, "invalid sizeof at line %d", P->line);
- }
-
- parse_type(L, P, &type);
- parse_argument(L, P, -1, &type, NULL, NULL);
- lua_pop(L, 2);
-
- require_token(L, P, tok);
- if (tok->type != TOK_CLOSE_PAREN) {
- luaL_error(L, "invalid sizeof at line %d", P->line);
- }
-
- next_token(L, P, tok);
-
- return issize ? ctype_size(L, &type) : type.align_mask + 1;
-
- } else {
- return calculate_constant1(L, P, tok);
- }
-}
-
-/* binary * / and % (left associative) */
-static int64_t calculate_constant3(lua_State* L, struct parser* P, struct token* tok)
-{
- int64_t left = calculate_constant2(L, P, tok);
-
- for (;;) {
- if (tok->type == TOK_MULTIPLY) {
- require_token(L, P, tok);
- left *= calculate_constant2(L, P, tok);
-
- } else if (tok->type == TOK_DIVIDE) {
- require_token(L, P, tok);
- left /= calculate_constant2(L, P, tok);
-
- } else if (tok->type == TOK_MODULUS) {
- require_token(L, P, tok);
- left %= calculate_constant2(L, P, tok);
-
- } else {
- return left;
- }
- }
-}
-
-/* binary + and - (left associative) */
-static int64_t calculate_constant4(lua_State* L, struct parser* P, struct token* tok)
-{
- int64_t left = calculate_constant3(L, P, tok);
-
- for (;;) {
- if (tok->type == TOK_PLUS) {
- require_token(L, P, tok);
- left += calculate_constant3(L, P, tok);
-
- } else if (tok->type == TOK_MINUS) {
- require_token(L, P, tok);
- left -= calculate_constant3(L, P, tok);
-
- } else {
- return left;
- }
- }
-}
-
-/* binary << and >> (left associative) */
-static int64_t calculate_constant5(lua_State* L, struct parser* P, struct token* tok)
-{
- int64_t left = calculate_constant4(L, P, tok);
-
- for (;;) {
- if (tok->type == TOK_LEFT_SHIFT) {
- require_token(L, P, tok);
- left <<= calculate_constant4(L, P, tok);
-
- } else if (tok->type == TOK_RIGHT_SHIFT) {
- require_token(L, P, tok);
- left >>= calculate_constant4(L, P, tok);
-
- } else {
- return left;
- }
- }
-}
-
-/* binary <, <=, >, and >= (left associative) */
-static int64_t calculate_constant6(lua_State* L, struct parser* P, struct token* tok)
-{
- int64_t left = calculate_constant5(L, P, tok);
-
- for (;;) {
- if (tok->type == TOK_LESS) {
- require_token(L, P, tok);
- left = (left < calculate_constant5(L, P, tok));
-
- } else if (tok->type == TOK_LESS_EQUAL) {
- require_token(L, P, tok);
- left = (left <= calculate_constant5(L, P, tok));
-
- } else if (tok->type == TOK_GREATER) {
- require_token(L, P, tok);
- left = (left > calculate_constant5(L, P, tok));
-
- } else if (tok->type == TOK_GREATER_EQUAL) {
- require_token(L, P, tok);
- left = (left >= calculate_constant5(L, P, tok));
-
- } else {
- return left;
- }
- }
-}
-
-/* binary ==, != (left associative) */
-static int64_t calculate_constant7(lua_State* L, struct parser* P, struct token* tok)
-{
- int64_t left = calculate_constant6(L, P, tok);
-
- for (;;) {
- if (tok->type == TOK_EQUAL) {
- require_token(L, P, tok);
- left = (left == calculate_constant6(L, P, tok));
-
- } else if (tok->type == TOK_NOT_EQUAL) {
- require_token(L, P, tok);
- left = (left != calculate_constant6(L, P, tok));
-
- } else {
- return left;
- }
- }
-}
-
-/* binary & (left associative) */
-static int64_t calculate_constant8(lua_State* L, struct parser* P, struct token* tok)
-{
- int64_t left = calculate_constant7(L, P, tok);
-
- for (;;) {
- if (tok->type == TOK_BITWISE_AND) {
- require_token(L, P, tok);
- left = (left & calculate_constant7(L, P, tok));
-
- } else {
- return left;
- }
- }
-}
-
-/* binary ^ (left associative) */
-static int64_t calculate_constant9(lua_State* L, struct parser* P, struct token* tok)
-{
- int64_t left = calculate_constant8(L, P, tok);
-
- for (;;) {
- if (tok->type == TOK_BITWISE_XOR) {
- require_token(L, P, tok);
- left = (left ^ calculate_constant8(L, P, tok));
-
- } else {
- return left;
- }
- }
-}
-
-/* binary | (left associative) */
-static int64_t calculate_constant10(lua_State* L, struct parser* P, struct token* tok)
-{
- int64_t left = calculate_constant9(L, P, tok);
-
- for (;;) {
- if (tok->type == TOK_BITWISE_OR) {
- require_token(L, P, tok);
- left = (left | calculate_constant9(L, P, tok));
-
- } else {
- return left;
- }
- }
-}
-
-/* binary && (left associative) */
-static int64_t calculate_constant11(lua_State* L, struct parser* P, struct token* tok)
-{
- int64_t left = calculate_constant10(L, P, tok);
-
- for (;;) {
- if (tok->type == TOK_LOGICAL_AND) {
- require_token(L, P, tok);
- left = (left && calculate_constant10(L, P, tok));
-
- } else {
- return left;
- }
- }
-}
-
-/* binary || (left associative) */
-static int64_t calculate_constant12(lua_State* L, struct parser* P, struct token* tok)
-{
- int64_t left = calculate_constant11(L, P, tok);
-
- for (;;) {
- if (tok->type == TOK_LOGICAL_OR) {
- require_token(L, P, tok);
- left = (left || calculate_constant11(L, P, tok));
-
- } else {
- return left;
- }
- }
-}
-
-/* ternary ?: (right associative) */
-static int64_t calculate_constant13(lua_State* L, struct parser* P, struct token* tok)
-{
- int64_t left = calculate_constant12(L, P, tok);
-
- if (tok->type == TOK_QUESTION) {
- int64_t middle, right;
- require_token(L, P, tok);
- middle = calculate_constant13(L, P, tok);
- if (tok->type != TOK_COLON) {
- luaL_error(L, "invalid ternery (? :) in constant on line %d", P->line);
- }
- require_token(L, P, tok);
- right = calculate_constant13(L, P, tok);
- return left ? middle : right;
-
- } else {
- return left;
- }
-}
-
-int64_t calculate_constant(lua_State* L, struct parser* P)
-{
- struct token tok;
- int64_t ret;
- require_token(L, P, &tok);
- ret = calculate_constant13(L, P, &tok);
-
- if (tok.type != TOK_NIL) {
- put_back(P);
- }
-
- return ret;
-}
-
-
-
-
diff --git a/plugins/MirLua/Modules/ffi/src/pretty.lua b/plugins/MirLua/Modules/ffi/src/pretty.lua deleted file mode 100644 index b3746d5930..0000000000 --- a/plugins/MirLua/Modules/ffi/src/pretty.lua +++ /dev/null @@ -1,150 +0,0 @@ ---[[
-Author: Julio Manuel Fernandez-Diaz
-Date: January 12, 2007
-(For Lua 5.1)
-
-Modified slightly by RiciLake to avoid the unnecessary table traversal in tablecount()
-
-Formats tables with cycles recursively to any depth.
-The output is returned as a string.
-References to other tables are shown as values.
-Self references are indicated.
-
-The string returned is "Lua code", which can be procesed
-(in the case in which indent is composed by spaces or "--").
-Userdata and function keys and values are shown as strings,
-which logically are exactly not equivalent to the original code.
-
-This routine can serve for pretty formating tables with
-proper indentations, apart from printing them:
-
-print(table.show(t, "t")) -- a typical use
-
-Heavily based on "Saving tables with cycles", PIL2, p. 113.
-
-Arguments:
-t is the table.
-name is the name of the table (optional)
-indent is a first indentation (optional).
---]]
-local debug = require('debug')
-local dbg_getfenv = debug.getfenv or debug.getuservalue
-
-function table.show(t, name, indent)
- local cart -- a container
- local autoref -- for self references
-
- --[[ counts the number of elements in a table
- local function tablecount(t)
- local n = 0
- for _, _ in pairs(t) do n = n+1 end
- return n
- end
- ]]
- -- (RiciLake) returns true if the table is empty
- local function isemptytable(t) return type(t) == "table" and next(t) == nil end
-
- local function basicSerialize (o)
- local so = tostring(o)
- if type(o) == "function" then
- local info = debug.getinfo(o, "S")
- -- info.name is nil because o is not a calling level
- if info.what == "C" then
- return string.format("%q", so .. ", C function")
- else
- -- the information is defined through lines
- return string.format("%q", so .. ", defined in (" ..
- info.linedefined .. "-" .. info.lastlinedefined ..
- ")" .. info.source)
- end
- elseif type(o) == "number" or type(o) == "boolean" then
- return so
- else
- return string.format("%q", so)
- end
- end
-
- local function addtocart (value, name, indent, saved, field)
- indent = indent or ""
- saved = saved or {}
- field = field or name
-
- cart = cart .. indent .. field
-
- if type(value) == "table" then
- if saved[value] then
- cart = cart .. " = {}; -- " .. saved[value] .. " (self reference)\n"
- autoref = autoref .. name .. " = " .. saved[value] .. ";\n"
- else
- saved[value] = name
- --if tablecount(value) == 0 then
- if isemptytable(value) then
- cart = cart .. " = {};\n"
- else
- cart = cart .. " = {\n"
- for k, v in pairs(value) do
- k = basicSerialize(k)
- local fname = string.format("%s[%s]", name, k)
- field = string.format("[%s]", k)
- -- three spaces between levels
- addtocart(v, fname, indent .. " ", saved, field)
- end
- for k, v in pairs{env = dbg_getfenv(value), mt = debug.getmetatable(value)} do
- k = basicSerialize(k)
- local fname = string.format("%s[%s]", name, k)
- field = string.format("[%s]", k)
- -- three spaces between levels
- addtocart(v, fname, indent .. " ", saved, field)
- end
- cart = cart .. indent .. "};\n"
- end
- end
- elseif type(value) == "userdata" then
- if saved[value] then
- cart = cart .. " = " .. basicSerialize(value) .. "; -- " .. saved[value] .. " (self reference)\n"
- autoref = autoref .. name .. " = " .. saved[value] .. ";\n"
- else
- saved[value] = name
- cart = cart .. " = " .. basicSerialize(value) .. " {\n"
- for k, v in pairs{env = dbg_getfenv(value), mt = debug.getmetatable(value)} do
- k = basicSerialize(k)
- local fname = string.format("%s[%s]", name, k)
- field = string.format("[%s]", k)
- -- three spaces between levels
- addtocart(v, fname, indent .. " ", saved, field)
- end
- cart = cart .. indent .. "};\n"
- end
- elseif type(value) == "function" then
- cart = cart .. " = " .. basicSerialize(value)
- if debug.getupvalue(value, 1) == nil then
- cart = cart .. ";\n"
- else
- cart = cart .. " {\n"
- local i = 1
- while true do
- local k, v = debug.getupvalue(value, i)
- if k == nil and v == nil then break end
- k = basicSerialize(i)
- local fname = string.format("%s[%s]", name, k)
- field = string.format("[%s]", k)
- -- three spaces between levels
- addtocart(v, fname, indent .. " ", saved, field)
- i = i + 1
- end
- cart = cart .. indent .. "};\n"
- end
- else
- cart = cart .. " = " .. basicSerialize(value) .. ";\n"
- end
- end
-
- name = name or "__unnamed__"
- if type(t) ~= "table" and type(t) ~= 'userdata' then
- return name .. " = " .. basicSerialize(t)
- end
- cart, autoref = "", ""
- addtocart(t, name, indent)
- return cart .. autoref
-end
-
diff --git a/plugins/MirLua/Modules/ffi/src/stdafx.cxx b/plugins/MirLua/Modules/ffi/src/stdafx.cxx deleted file mode 100644 index 7b43c3cb6c..0000000000 --- a/plugins/MirLua/Modules/ffi/src/stdafx.cxx +++ /dev/null @@ -1 +0,0 @@ -#include "ffi.h" diff --git a/plugins/MirLua/Modules/ffi/src/test.c0 b/plugins/MirLua/Modules/ffi/src/test.c0 deleted file mode 100644 index 29660e5073..0000000000 --- a/plugins/MirLua/Modules/ffi/src/test.c0 +++ /dev/null @@ -1,720 +0,0 @@ -/* vim: ts=4 sw=4 sts=4 et tw=78
- * Portions copyright (c) 2015-present, Facebook, Inc. All rights reserved.
- * Portions copyright (c) 2011 James R. McKaskill.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-#include <stdio.h>
-#include <stdint.h>
-#include <inttypes.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include <stdarg.h>
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <errno.h>
-#endif
-
-#include <complex.h>
-#define HAVE_COMPLEX
-
-#ifdef __cplusplus
-# define EXTERN_C extern "C"
-#else
-# define EXTERN_C extern
-#endif
-
-#ifdef _WIN32
-#define EXPORT EXTERN_C __declspec(dllexport)
-#elif defined __GNUC__
-#define EXPORT EXTERN_C __attribute__((visibility("default")))
-#else
-#define EXPORT EXTERN_C
-#endif
-
-enum e8 {
- FOO8,
- BAR8,
-};
-enum e16 {
- FOO16 = 1 << 8,
- BAR16,
- BIG16 = 1 << 14,
-};
-enum e32 {
- FOO32 = 1 << 16,
- BAR32,
- BIG32 = 1 << 30,
-};
-
-EXPORT bool have_complex();
-
-bool have_complex()
-{
-#ifdef HAVE_COMPLEX
- return 1;
-#else
- return 0;
-#endif
-}
-
-EXPORT bool is_msvc;
-
-bool is_msvc =
-#ifdef _MSC_VER
- 1;
-#else
- 0;
-#endif
-
-EXPORT int test_pow(int v);
-int test_pow(int v)
-{ return v * v; }
-
-#define ADD(TYPE, NAME) \
- EXPORT TYPE NAME(TYPE a, TYPE b); \
- TYPE NAME(TYPE a, TYPE b) { return a + b; }
-
-ADD(int8_t, add_i8)
-ADD(uint8_t, add_u8)
-ADD(int16_t, add_i16)
-ADD(uint16_t, add_u16)
-ADD(int32_t, add_i32)
-ADD(uint32_t, add_u32)
-ADD(int64_t, add_i64)
-ADD(uint64_t, add_u64)
-ADD(double, add_d)
-ADD(float, add_f)
-#ifdef HAVE_COMPLEX
-ADD(double complex, add_dc)
-ADD(float complex, add_fc)
-#endif
-
-EXPORT enum e8 inc_e8(enum e8 v);
-EXPORT enum e16 inc_e16(enum e16 v);
-EXPORT enum e32 inc_e32(enum e32 v);
-enum e8 inc_e8(enum e8 v) {return v+1;}
-enum e16 inc_e16(enum e16 v) {return v+1;}
-enum e32 inc_e32(enum e32 v) {return v+1;}
-
-EXPORT _Bool not_b(_Bool v);
-EXPORT _Bool not_b2(_Bool v);
-
-_Bool not_b(_Bool v) {return !v;}
-_Bool not_b2(_Bool v) {return !v;}
-
-#define PRINT(TYPE, NAME, FORMAT) \
- EXPORT int NAME(char* buf, TYPE val); \
- int NAME(char* buf, TYPE val) {return sprintf(buf, "%" FORMAT, val);}
-
-PRINT(int8_t, print_i8, PRId8)
-PRINT(uint8_t, print_u8, PRIu8)
-PRINT(int16_t, print_i16, PRId16)
-PRINT(uint16_t, print_u16, PRIu16)
-PRINT(int32_t, print_i32, PRId32)
-PRINT(uint32_t, print_u32, PRIu32)
-PRINT(int64_t, print_i64, PRId64)
-PRINT(uint64_t, print_u64, PRIu64)
-PRINT(double, print_d, "g")
-PRINT(float, print_f, "g")
-PRINT(const char*, print_s, "s")
-PRINT(void*, print_p, "p")
-PRINT(enum e8, print_e8, "d")
-PRINT(enum e16, print_e16, "d")
-PRINT(enum e32, print_e32, "d")
-
-#ifdef HAVE_COMPLEX
-/*EXPORT int print_dc(char* buf, double complex val);
-EXPORT int print_fc(char* buf, float complex val);
-int print_dc(char* buf, double complex val) {return sprintf(buf, "%g+%gi", creal(val), cimag(val));}
-int print_fc(char* buf, float complex val) {return sprintf(buf, "%g+%gi", creal(val), cimag(val));}*/
-#endif
-
-EXPORT int print_b(char* buf, _Bool val);
-EXPORT int print_b2(char* buf, _Bool val);
-int print_b(char* buf, _Bool val) {return sprintf(buf, "%s", val ? "true" : "false");}
-int print_b2(char* buf, _Bool val) {return sprintf(buf, "%s", val ? "true" : "false");}
-
-EXPORT bool (*ret_fp(bool (*val)(bool)))(bool);
-bool (*ret_fp(bool (*val)(bool)))(bool)
-{return val;}
-
-#define OFFSETOF(STRUCT, MEMBER) ((int) ((char*) &STRUCT.MEMBER - (char*) &S - 1))
-
-#define ALIGN_UP(VALUE, ALIGNMENT, SUFFIX) \
- struct align_##ALIGNMENT##_##SUFFIX { \
- char pad; \
- VALUE; \
- }; \
- EXPORT int print_align_##ALIGNMENT##_##SUFFIX(char* buf, struct align_##ALIGNMENT##_##SUFFIX* p); \
- int print_align_##ALIGNMENT##_##SUFFIX(char* buf, struct align_##ALIGNMENT##_##SUFFIX* p) { \
- struct {char ch; struct align_##ALIGNMENT##_##SUFFIX v;} s; \
- int off = sprintf(buf, "size %d offset %d align %d value ", \
- (int) sizeof(s.v), \
- (int) (((char*) &p->v) - (char*) p), \
- (int) (((char*) &s.v) - (char*) &s)); \
- return print_##SUFFIX(buf+off, p->v); \
- }
-
-#ifdef HAVE_COMPLEX
-#define COMPLEX_ALIGN(ALIGNMENT, ATTR) \
- ALIGN_UP(ATTR(double complex), ALIGNMENT, dc) \
- ALIGN_UP(ATTR(float complex), ALIGNMENT, fc)
-#else
-#define COMPLEX_ALIGN(ALIGNMENT, ATTR)
-#endif
-
-/* MSVC doesn't support __declspec(aligned(#)) on enums see C4329 */
-#define ENUM_ALIGN2(ALIGNMENT, ATTR) \
- ALIGN_UP(ATTR(enum e8), ALIGNMENT, e8) \
- ALIGN_UP(ATTR(enum e16), ALIGNMENT, e16) \
- ALIGN_UP(ATTR(enum e32), ALIGNMENT, e32) \
-
-#ifdef _MSC_VER
-#define ENUM_ALIGN(ALIGNMENT, ATTR)
-#else
-#define ENUM_ALIGN(ALIGNMENT, ATTR) ENUM_ALIGN2(ALIGNMENT, ATTR)
-#endif
-
-#define ALIGN2(ALIGNMENT, ATTR) \
- ALIGN_UP(ATTR(uint16_t), ALIGNMENT, u16) \
- ALIGN_UP(ATTR(uint32_t), ALIGNMENT, u32) \
- ALIGN_UP(ATTR(uint64_t), ALIGNMENT, u64) \
- ALIGN_UP(ATTR(float), ALIGNMENT, f) \
- ALIGN_UP(ATTR(double), ALIGNMENT, d) \
- ALIGN_UP(ATTR(const char*), ALIGNMENT, s) \
- ALIGN_UP(ATTR(void*), ALIGNMENT, p) \
- ALIGN_UP(ATTR(_Bool), ALIGNMENT, b) \
- ALIGN_UP(ATTR(_Bool), ALIGNMENT, b2) \
- ENUM_ALIGN(ALIGNMENT, ATTR) \
- COMPLEX_ALIGN(ALIGNMENT, ATTR)
-
-#define NO_ATTR(TYPE) TYPE v
-
-#ifdef _MSC_VER
-#define ALIGN_NO_ATTR(ALIGNMENT) \
- ALIGN2(ALIGNMENT, NO_ATTR) \
- ENUM_ALIGN2(ALIGNMENT, NO_ATTR)
-#else
-#define ALIGN_NO_ATTR(ALIGNMENT) \
- ALIGN2(ALIGNMENT, NO_ATTR)
-#endif
-
-ALIGN_NO_ATTR(0)
-
-#pragma pack(push)
-#pragma pack(1)
-ALIGN_NO_ATTR(1)
-#pragma pack(2)
-ALIGN_NO_ATTR(2)
-#pragma pack(4)
-ALIGN_NO_ATTR(4)
-#pragma pack(8)
-ALIGN_NO_ATTR(8)
-#pragma pack(16)
-ALIGN_NO_ATTR(16)
-#pragma pack(pop)
-
-#ifdef _MSC_VER
-#define ATTR_(TYPE, ALIGN) __declspec(align(ALIGN)) TYPE v
-#else
-#define ATTR_(TYPE, ALIGN) TYPE v __attribute__((aligned(ALIGN)))
-#endif
-
-#define ATTR1(TYPE) ATTR_(TYPE, 1)
-#define ATTR2(TYPE) ATTR_(TYPE, 2)
-#define ATTR4(TYPE) ATTR_(TYPE, 4)
-#define ATTR8(TYPE) ATTR_(TYPE, 8)
-#define ATTR16(TYPE) ATTR_(TYPE, 16)
-
-#define ATTR_DEF(TYPE) TYPE v __attribute__((aligned))
-
-ALIGN2(attr_1, ATTR1)
-ALIGN2(attr_2, ATTR2)
-ALIGN2(attr_4, ATTR4)
-ALIGN2(attr_8, ATTR8)
-ALIGN2(attr_16, ATTR16)
-
-#ifndef _MSC_VER
-ALIGN2(attr_def, ATTR_DEF)
-#endif
-
-#ifdef _MSC_VER
-#define alignof(type) __alignof(type)
-#else
-#define alignof(type) __alignof__(type)
-#endif
-
-EXPORT int max_alignment();
-
-int max_alignment()
-{ return alignof(struct align_attr_16_p); }
-
-/* bit_fields1.cpp */
-/* compile with: /LD */
-struct Date {
- unsigned short nWeekDay : 3; /* 0..7 (3 bits) */
- unsigned short nMonthDay : 6; /* 0..31 (6 bits) */
- unsigned short nMonth : 5; /* 0..12 (5 bits) */
- unsigned short nYear : 8; /* 0..100 (8 bits) */
-};
-
-EXPORT int print_date(size_t* sz, size_t* align, char* buf, struct Date* d);
-
-int print_date(size_t* sz, size_t* align, char* buf, struct Date* d) {
- *sz = sizeof(struct Date);
- *align = alignof(struct Date);
- return sprintf(buf, "%d %d %d %d", d->nWeekDay, d->nMonthDay, d->nMonth, d->nYear);
-}
-
-/* bit_fields2.cpp */
-/* compile with: /LD */
-struct Date2 {
- unsigned nWeekDay : 3; /* 0..7 (3 bits) */
- unsigned nMonthDay : 6; /* 0..31 (6 bits) */
- unsigned : 0; /* Force alignment to next boundary. */
- unsigned nMonth : 5; /* 0..12 (5 bits) */
- unsigned nYear : 8; /* 0..100 (8 bits) */
-};
-
-EXPORT int print_date2(size_t* sz, size_t* align, char* buf, struct Date2* d);
-
-int print_date2(size_t* sz, size_t* align, char* buf, struct Date2* d) {
- *sz = sizeof(struct Date2);
- *align = alignof(struct Date2);
- return sprintf(buf, "%d %d %d %d", d->nWeekDay, d->nMonthDay, d->nMonth, d->nYear);
-}
-
-// Examples from SysV X86 ABI
-struct sysv1 {
- int j:5;
- int k:6;
- int m:7;
-};
-
-EXPORT int print_sysv1(size_t* sz, size_t* align, char* buf, struct sysv1* s);
-
-int print_sysv1(size_t* sz, size_t* align, char* buf, struct sysv1* s) {
- *sz = sizeof(struct sysv1);
- *align = alignof(struct sysv1);
- return sprintf(buf, "%d %d %d", s->j, s->k, s->m);
-}
-
-struct sysv2 {
- short s:9;
- int j:9;
- char c;
- short t:9;
- short u:9;
- char d;
-};
-
-EXPORT int print_sysv2(size_t* sz, size_t* align, char* buf, struct sysv2* s);
-
-int print_sysv2(size_t* sz, size_t* align, char* buf, struct sysv2* s) {
- *sz = sizeof(struct sysv2);
- *align = alignof(struct sysv2);
- return sprintf(buf, "%d %d %d %d %d %d", s->s, s->j, s->c, s->t, s->u, s->d);
-}
-
-struct sysv3 {
- char c;
- short s:8;
-};
-
-EXPORT int print_sysv3(size_t* sz, size_t* align, char* buf, struct sysv3* s);
-
-int print_sysv3(size_t* sz, size_t* align, char* buf, struct sysv3* s) {
- *sz = sizeof(struct sysv3);
- *align = alignof(struct sysv3);
- return sprintf(buf, "%d %d", s->c, s->s);
-}
-
-union sysv4 {
- char c;
- short s:8;
-};
-
-EXPORT int print_sysv4(size_t* sz, size_t* align, char* buf, union sysv4* s);
-
-int print_sysv4(size_t* sz, size_t* align, char* buf, union sysv4* s) {
- *sz = sizeof(union sysv4);
- *align = alignof(union sysv4);
- return sprintf(buf, "%d", s->s);
-}
-
-struct sysv5 {
- char c;
- int :0;
- char d;
- short :9;
- char e;
- char :0;
-};
-
-EXPORT int print_sysv5(size_t* sz, size_t* align, char* buf, struct sysv5* s);
-
-int print_sysv5(size_t* sz, size_t* align, char* buf, struct sysv5* s) {
- *sz = sizeof(struct sysv5);
- *align = alignof(struct sysv5);
- return sprintf(buf, "%d %d %d", s->c, s->d, s->e);
-}
-
-struct sysv6 {
- char c;
- int :0;
- char d;
- int :9;
- char e;
-};
-
-EXPORT int print_sysv6(size_t* sz, size_t* align, char* buf, struct sysv6* s);
-
-int print_sysv6(size_t* sz, size_t* align, char* buf, struct sysv6* s) {
- *sz = sizeof(struct sysv6);
- *align = alignof(struct sysv6);
- return sprintf(buf, "%d %d %d", s->c, s->d, s->e);
-}
-
-struct sysv7 {
- int j:9;
- short s:9;
- char c;
- short t:9;
- short u:9;
-};
-
-EXPORT int print_sysv7(size_t* sz, size_t* align, char* buf, struct sysv7* s);
-
-int print_sysv7(size_t* sz, size_t* align, char* buf, struct sysv7* s) {
- *sz = sizeof(struct sysv7);
- *align = alignof(struct sysv7);
- return sprintf(buf, "%d %d %d %d %d", s->j, s->s, s->c, s->t, s->u);
-}
-
-/* Now some targeting bitfield tests */
-
-/* Bitfield alignment */
-#define BITALIGN(TNUM,BNUM) \
- struct ba_##TNUM##_##BNUM { \
- char a; \
- uint##TNUM##_t b : BNUM; \
- }; \
- EXPORT int print_ba_##TNUM##_##BNUM(size_t* sz, size_t* align, char* buf, struct ba_##TNUM##_##BNUM* s); \
- int print_ba_##TNUM##_##BNUM(size_t* sz, size_t* align, char* buf, struct ba_##TNUM##_##BNUM* s) { \
- *sz = sizeof(struct ba_##TNUM##_##BNUM); \
- *align = alignof(struct ba_##TNUM##_##BNUM); \
- return sprintf(buf, "%d %d", (int) s->a, (int) s->b); \
- }
-
-BITALIGN(8,7)
-BITALIGN(16,7)
-BITALIGN(16,15)
-BITALIGN(32,7)
-BITALIGN(32,15)
-BITALIGN(32,31)
-BITALIGN(64,7)
-BITALIGN(64,15)
-BITALIGN(64,31)
-BITALIGN(64,63)
-
-/* Do unsigned and signed coallesce */
-#define BITCOALESCE(NUM) \
- struct bc##NUM { \
- uint##NUM##_t a : 3; \
- int##NUM##_t b : 3; \
- }; \
- EXPORT int print_bc##NUM(size_t* sz, size_t* align, char* buf, struct bc##NUM* s); \
- int print_bc##NUM(size_t* sz, size_t* align, char* buf, struct bc##NUM* s) { \
- *sz = sizeof(struct bc##NUM); \
- *align = alignof(struct bc##NUM); \
- return sprintf(buf, "%d %d", (int) s->a, (int) s->b); \
- }
-
-BITCOALESCE(8)
-BITCOALESCE(16)
-BITCOALESCE(32)
-BITCOALESCE(64)
-
-// Do different sizes coallesce
-struct bdsz {
- uint8_t a : 3;
- uint16_t b : 3;
- uint32_t c : 3;
- uint64_t d : 3;
-};
-
-EXPORT int print_bdsz(size_t* sz, size_t* align, char* buf, struct bdsz* s);
-int print_bdsz(size_t* sz, size_t* align, char* buf, struct bdsz* s) {
- *sz = sizeof(struct bdsz);
- *align = alignof(struct bdsz);
- return sprintf(buf, "%d %d %d %d", (int) s->a, (int) s->b, (int) s->c, (int) s->d);
-}
-
-// Does coallesence upgrade the storage unit
-struct bcup {
- uint8_t a : 7;
- uint16_t b : 9;
- uint32_t c : 17;
- uint64_t d : 33;
-};
-
-EXPORT int print_bcup(size_t* sz, size_t* align, char* buf, struct bcup* s);
-int print_bcup(size_t* sz, size_t* align, char* buf, struct bcup* s) {
- *sz = sizeof(struct bcup);
- *align = alignof(struct bcup);
- return sprintf(buf, "%d %d %d %"PRIu64, (int) s->a, (int) s->b, (int) s->c, (uint64_t) s->d);
-}
-
-// Is unaligned access allowed
-struct buna {
- uint32_t a : 31;
- uint32_t b : 31;
-};
-
-EXPORT int print_buna(size_t* sz, size_t* align, char* buf, struct buna* s);
-int print_buna(size_t* sz, size_t* align, char* buf, struct buna* s) {
- *sz = sizeof(struct buna);
- *align = alignof(struct buna);
- return sprintf(buf, "%d %d", (int) s->a, (int) s->b);
-}
-
-/* What does a lone :0 do */
-#define BITLONEZERO(NUM) \
- struct blz##NUM { \
- uint##NUM##_t a; \
- uint##NUM##_t :0; \
- uint##NUM##_t b; \
- }; \
- EXPORT int print_##blz##NUM(size_t* sz, size_t* align, char* buf, struct blz##NUM* s); \
- int print_blz##NUM(size_t* sz, size_t* align, char* buf, struct blz##NUM* s) { \
- *sz = sizeof(struct blz##NUM); \
- *align = alignof(struct blz##NUM); \
- return sprintf(buf, "%d %d", (int) s->a, (int) s->b); \
- }
-
-BITLONEZERO(8)
-BITLONEZERO(16)
-BITLONEZERO(32)
-BITLONEZERO(64)
-
-/* What does a :0 or unnamed :# of the same or different type do */
-#define BITZERO(NUM, ZNUM, BNUM) \
- struct bz_##NUM##_##ZNUM##_##BNUM { \
- uint8_t a; \
- uint##NUM##_t b : 3; \
- uint##ZNUM##_t :BNUM; \
- uint##NUM##_t c : 3; \
- }; \
- EXPORT int print_bz_##NUM##_##ZNUM##_##BNUM(size_t* sz, size_t* align, char* buf, struct bz_##NUM##_##ZNUM##_##BNUM* s); \
- int print_bz_##NUM##_##ZNUM##_##BNUM(size_t* sz, size_t* align, char* buf, struct bz_##NUM##_##ZNUM##_##BNUM* s) { \
- *sz = sizeof(struct bz_##NUM##_##ZNUM##_##BNUM); \
- *align = alignof(struct bz_##NUM##_##ZNUM##_##BNUM); \
- return sprintf(buf, "%d %d %d", (int) s->a, (int) s->b, (int) s->c); \
- }
-
-BITZERO(8,8,0)
-BITZERO(8,8,7)
-BITZERO(8,16,0)
-BITZERO(8,16,7)
-BITZERO(8,16,15)
-BITZERO(8,32,0)
-BITZERO(8,32,7)
-BITZERO(8,32,15)
-BITZERO(8,32,31)
-BITZERO(8,64,0)
-BITZERO(8,64,7)
-BITZERO(8,64,15)
-BITZERO(8,64,31)
-BITZERO(8,64,63)
-BITZERO(16,8,0)
-BITZERO(16,8,7)
-BITZERO(16,16,0)
-BITZERO(16,16,7)
-BITZERO(16,16,15)
-BITZERO(16,32,0)
-BITZERO(16,32,7)
-BITZERO(16,32,15)
-BITZERO(16,32,31)
-BITZERO(16,64,0)
-BITZERO(16,64,7)
-BITZERO(16,64,15)
-BITZERO(16,64,31)
-BITZERO(16,64,63)
-BITZERO(32,8,0)
-BITZERO(32,8,7)
-BITZERO(32,16,0)
-BITZERO(32,16,7)
-BITZERO(32,16,15)
-BITZERO(32,32,0)
-BITZERO(32,32,7)
-BITZERO(32,32,15)
-BITZERO(32,32,31)
-BITZERO(32,64,0)
-BITZERO(32,64,7)
-BITZERO(32,64,15)
-BITZERO(32,64,31)
-BITZERO(32,64,63)
-BITZERO(64,8,0)
-BITZERO(64,8,7)
-BITZERO(64,16,0)
-BITZERO(64,16,7)
-BITZERO(64,16,15)
-BITZERO(64,32,0)
-BITZERO(64,32,7)
-BITZERO(64,32,15)
-BITZERO(64,32,31)
-BITZERO(64,64,0)
-BITZERO(64,64,7)
-BITZERO(64,64,15)
-BITZERO(64,64,31)
-BITZERO(64,64,63)
-
-#define CALL(TYPE, SUFFIX) \
- EXPORT TYPE call_##SUFFIX(TYPE (*func)(TYPE), TYPE arg); \
- TYPE call_##SUFFIX(TYPE (*func)(TYPE), TYPE arg) { \
- return func(arg); \
- }
-
-CALL(int, i)
-CALL(float, f)
-CALL(double, d)
-CALL(const char*, s)
-CALL(_Bool, b)
-CALL(enum e8, e8)
-CALL(enum e16, e16)
-CALL(enum e32, e32)
-#ifdef HAVE_COMPLEX
-CALL(double complex, dc)
-CALL(float complex, fc)
-#endif
-
-struct fptr {
-#ifdef _MSC_VER
- int (__cdecl *p)(int);
-#else
- int (*p)(int);
-#endif
-};
-
-EXPORT int call_fptr(struct fptr* s, int val);
-
-int call_fptr(struct fptr* s, int val) {
- return (s->p)(val);
-}
-
-EXPORT bool g_b;
-EXPORT int8_t g_i8;
-EXPORT int16_t g_i16;
-EXPORT int32_t g_i32;
-EXPORT int64_t g_i64;
-EXPORT uint8_t g_u8;
-EXPORT uint16_t g_u16;
-EXPORT uint32_t g_u32;
-EXPORT uint64_t g_u64;
-EXPORT float g_f;
-EXPORT double g_d;
-#ifdef HAVE_COMPLEX
-EXPORT double complex g_dc;
-EXPORT float complex g_fc;
-#endif
-EXPORT bool (*g_fp)(bool);
-EXPORT const char g_s[];
-EXPORT const char* g_sp;
-EXPORT void* g_p;
-EXPORT enum e8 g_e8;
-EXPORT enum e16 g_e16;
-EXPORT enum e32 g_e32;
-EXPORT struct Date g_date;
-
-bool g_b = true;
-int8_t g_i8 = -8;
-int16_t g_i16 = -16;
-int32_t g_i32 = -32;
-int64_t g_i64 = -64;
-uint8_t g_u8 = 8;
-uint16_t g_u16 = 16;
-uint32_t g_u32 = 32;
-uint64_t g_u64 = 64;
-float g_f = 3;
-double g_d = 5;
-#ifdef HAVE_COMPLEX
-double complex g_dc = 7+8i;
-float complex g_fc = 6+9i;
-#endif
-bool (*g_fp)(bool) = ¬_b;
-void* g_p = (void*) ¬_b;
-const char g_s[] = "g_s";
-const char* g_sp = "g_sp";
-enum e8 g_e8 = FOO8;
-enum e16 g_e16 = FOO16;
-enum e32 g_e32 = FOO32;
-struct Date g_date = {1,2,3,4};
-
-EXPORT void set_errno(int val);
-EXPORT int get_errno(void);
-
-void set_errno(int val) {
-#ifdef _WIN32
- SetLastError(val);
-#else
- errno = val;
-#endif
-}
-
-int get_errno(void) {
-#ifdef _WIN32
- return GetLastError();
-#else
- return errno;
-#endif
-}
-
-EXPORT int va_list_size, va_list_align;
-int va_list_size = sizeof(va_list);
-int va_list_align = alignof(va_list);
-
-
-EXPORT char buf[512];
-char buf[512];
-
-EXPORT void test_call_echo(char* c);
-void test_call_echo(char* c)
-{
- sprintf(buf, "%s", c);
-}
-
-EXPORT void test_call_pppppii(void* a, void* b, void* c, void* d, void* e, int f, int g);
-void test_call_pppppii(void* a, void* b, void* c, void* d, void* e, int f, int g)
-{
- sprintf(buf, "%p %p %p %p %p %d %d", a, b, c, d, e, f, g);
-}
-
-EXPORT void test_call_pppppiiiiii(void* p1, void* p2, void* p3, void* p4, void* p5, int i1, int i2, int i3, int i4, int i5, int i6);
-void test_call_pppppiiiiii(void* p1, void* p2, void* p3, void* p4, void* p5, int i1, int i2, int i3, int i4, int i5, int i6)
-{
- sprintf(buf, "%p %p %p %p %p %d %d %d %d %d %d", p1, p2, p3, p4, p5, i1, i2, i3, i4, i5, i6);
-}
-
-EXPORT void test_call_pppppffffff(void* p1, void* p2, void* p3, void* p4, void* p5, float f1, float f2, float f3, float f4, float f5, float f6);
-void test_call_pppppffffff(void* p1, void* p2, void* p3, void* p4, void* p5, float f1, float f2, float f3, float f4, float f5, float f6)
-{
- sprintf(buf, "%p %p %p %p %p %0.1f %0.1f %0.1f %0.1f %0.1f %0.1f", p1, p2, p3, p4, p5, f1, f2, f3, f4, f5, f6);
-}
-
-EXPORT void test_call_pppppiifiii(void* p1, void* p2, void* p3, void* p4, void* p5, int i1, int i2, float f3, int i4, int i5, int i6);
-void test_call_pppppiifiii(void* p1, void* p2, void* p3, void* p4, void* p5, int i1, int i2, float f3, int i4, int i5, int i6)
-{
- sprintf(buf, "%p %p %p %p %p %d %d %0.1f %d %d %d", p1, p2, p3, p4, p5, i1, i2, f3, i4, i5, i6);
-}
-
-EXPORT void test_call_pppppiiifii(void* p1, void* p2, void* p3, void* p4, void* p5, int i1, int i2, int i3, float f4, int i5, int i6);
-void test_call_pppppiiifii(void* p1, void* p2, void* p3, void* p4, void* p5, int i1, int i2, int i3, float f4, int i5, int i6)
-{
- sprintf(buf, "%p %p %p %p %p %d %d %d %0.1f %d %d", p1, p2, p3, p4, p5, i1, i2, i3, f4, i5, i6);
-}
-
diff --git a/plugins/MirLua/Modules/ffi/src/test.lua b/plugins/MirLua/Modules/ffi/src/test.lua deleted file mode 100644 index 866fec686c..0000000000 --- a/plugins/MirLua/Modules/ffi/src/test.lua +++ /dev/null @@ -1,978 +0,0 @@ --- vim: ts=4 sw=4 sts=4 et tw=78
--- Portions copyright (c) 2015-present, Facebook, Inc. All rights reserved.
--- Portions copyright (c) 2011 James R. McKaskill.
---
--- This source code is licensed under the BSD-style license found in the
--- LICENSE file in the root directory of this source tree. An additional grant
--- of patent rights can be found in the PATENTS file in the same directory.
---
-io.stdout:setvbuf('no')
-local ffi = require 'ffi'
-local dlls = {}
-
-local function loadlib(lib)
- for pattern in package.cpath:gmatch('[^;]+') do
- local path = pattern:gsub('?', lib)
- local ok, lib = pcall(ffi.load, path)
- if ok then
- return lib
- end
- end
- error("Unable to load", lib)
-end
-
-if _VERSION == 'Lua 5.1' then
- dlls.__cdecl = loadlib('ffi/libtest')
-else
- dlls.__cdecl = ffi.load(package.searchpath('ffi.libtest', package.cpath))
-end
-
-if ffi.arch == 'x86' and ffi.os == 'Windows' then
- dlls.__stdcall = ffi.load('test_stdcall')
- dlls.__fastcall = ffi.load('test_fastcall')
-end
-
-local function check(a, b, msg)
- if a ~= b then
- print('check', a, b)
- end
- return _G.assert(a == b, msg)
-end
-
-print('Running test')
-
-ffi.cdef [[
-enum e8 {
- FOO8,
- BAR8,
-};
-enum e16 {
- FOO16 = 1 << 8,
- BAR16,
- BIG16 = 1 << 14,
-};
-enum e32 {
- FOO32 = 1 << 16,
- BAR32,
- BIG32 = 1 << 30,
-};
-int max_alignment();
-bool is_msvc, is_msvc2 __asm__("is_msvc");
-bool have_complex(void);
-bool have_complex2() __asm__("have" /*foo*/ "\x5F" "complex"); // 5F is _
-
-int8_t add_i8(int8_t a, int8_t b);
-uint8_t add_u8(uint8_t a, uint8_t b);
-int16_t add_i16(int16_t a, int16_t b);
-uint16_t add_i16(uint16_t a, uint16_t b);
-int32_t add_i32(int32_t a, int32_t b);
-uint32_t add_u32(uint32_t a, uint32_t b);
-int64_t add_i64(int64_t a, int64_t b);
-uint64_t add_u64(uint64_t a, uint64_t b);
-double add_d(double a, double b);
-float add_f(float a, float b);
-double complex add_dc(double complex a, double complex b);
-float complex add_fc(float complex a, float complex b);
-enum e8 inc_e8(enum e8);
-enum e16 inc_e16(enum e16);
-enum e32 inc_e32(enum e32);
-bool not_b(bool v);
-_Bool not_b2(_Bool v);
-typedef bool (*fp)(bool);
-fp ret_fp(fp v);
-bool (*ret_fp2(bool (*)(bool)))(bool) __asm("ret_fp");
-
-int print_i8(char* buf, int8_t val);
-int print_u8(char* buf, uint8_t val);
-int print_i16(char* buf, int16_t val);
-int print_u16(char* buf, uint16_t val);
-int print_i32(char* buf, int32_t val);
-int print_u32(char* buf, uint32_t val);
-int print_i64(char* buf, int64_t val);
-int print_u64(char* buf, uint64_t val);
-int print_s(char* buf, const char* val);
-int print_b(char* buf, bool val);
-int print_b2(char* buf, _Bool val);
-int print_d(char* buf, double val);
-int print_f(char* buf, float val);
-int print_p(char* buf, void* val);
-int print_dc(char* buf, double complex val);
-int print_fc(char* buf, float complex val);
-int print_e8(char* buf, enum e8 val);
-int print_e16(char* buf, enum e16 val);
-int print_e32(char* buf, enum e32 val);
-int sprintf(char* buf, const char* format, ...);
-
-// Examples from MSDN
-
-// bit_fields1.cpp
-// compile with: /LD
-struct Date {
- unsigned short nWeekDay : 3; // 0..7 (3 bits)
- unsigned short nMonthDay : 6; // 0..31 (6 bits)
- unsigned short nMonth : 5; // 0..12 (5 bits)
- unsigned short nYear : 8; // 0..100 (8 bits)
-};
-
-// bit_fields2.cpp
-// compile with: /LD
-struct Date2 {
- unsigned nWeekDay : 3; // 0..7 (3 bits)
- unsigned nMonthDay : 6; // 0..31 (6 bits)
- unsigned : 0; // Force alignment to next boundary.
- unsigned nMonth : 5; // 0..12 (5 bits)
- unsigned nYear : 8; // 0..100 (8 bits)
-};
-
-// For checking the alignment of short bitfields
-struct Date3 {
- char pad;
- unsigned short nWeekDay : 3; // 0..7 (3 bits)
- unsigned short nMonthDay : 6; // 0..31 (6 bits)
- unsigned short nMonth : 5; // 0..12 (5 bits)
- unsigned short nYear : 8; // 0..100 (8 bits)
-};
-
-// For checking the alignment and container of int64 bitfields
-struct bit64 {
- char pad;
- uint64_t a : 15;
- uint64_t b : 14;
- uint64_t c : 13;
- uint64_t d : 12;
-};
-
-// Examples from SysV X86 ABI
-struct sysv1 {
- int j:5;
- int k:6;
- int m:7;
-};
-
-struct sysv2 {
- short s:9;
- int j:9;
- char c;
- short t:9;
- short u:9;
- char d;
-};
-
-struct sysv3 {
- char c;
- short s:8;
-};
-
-union sysv4 {
- char c;
- short s:8;
-};
-
-struct sysv5 {
- char c;
- int :0;
- char d;
- short :9;
- char e;
- char :0;
-};
-
-struct sysv6 {
- char c;
- int :0;
- char d;
- int :9;
- char e;
-};
-
-struct sysv7 {
- int j:9;
- short s:9;
- char c;
- short t:9;
- short u:9;
-};
-
-int print_date(size_t* sz, size_t* align, char* buf, struct Date* s);
-int print_date2(size_t* sz, size_t* align, char* buf, struct Date2* s);
-int print_date3(size_t* sz, size_t* align, char* buf, struct Date3* d);
-int print_bit64(size_t* sz, size_t* align, char* buf, struct bit64* d);
-int print_sysv1(size_t* sz, size_t* align, char* buf, struct sysv1* s);
-int print_sysv2(size_t* sz, size_t* align, char* buf, struct sysv2* s);
-int print_sysv3(size_t* sz, size_t* align, char* buf, struct sysv3* s);
-int print_sysv4(size_t* sz, size_t* align, char* buf, union sysv4* s);
-int print_sysv5(size_t* sz, size_t* align, char* buf, struct sysv5* s);
-int print_sysv6(size_t* sz, size_t* align, char* buf, struct sysv6* s);
-int print_sysv7(size_t* sz, size_t* align, char* buf, struct sysv7* s);
-
-struct fptr {
- int (__cdecl *p)(int);
-};
-int call_fptr(struct fptr* s, int val);
-
-bool g_b;
-int8_t g_i8;
-int16_t g_i16;
-int32_t g_i32;
-int64_t g_i64;
-uint8_t g_u8;
-uint16_t g_u16;
-uint32_t g_u32;
-uint64_t g_u64;
-float g_f;
-double g_d;
-double complex g_dc;
-float complex g_fc;
-bool (*g_fp)(bool);
-const char g_s[];
-const char* g_sp;
-void* g_p;
-enum e8 g_e8;
-enum e16 g_e16;
-enum e32 g_e32;
-struct Date g_date;
-
-void set_errno(int val);
-int get_errno(void);
-]]
-
-local align = [[
-struct align_ALIGN_SUFFIX {
- char pad;
- TYPE v;
-};
-
-int print_align_ALIGN_SUFFIX(char* buf, struct align_ALIGN_SUFFIX* p);
-]]
-
-local palign = [[
-#pragma pack(push)
-#pragma pack(ALIGN)
-]] .. align .. [[
-#pragma pack(pop)
-]]
-
-local bitfields = [[
-struct bcTNUM {
- uintTNUM_t a : 3;
- intTNUM_t b : 3;
-};
-struct blzTNUM {
- uintTNUM_t a;
- uintTNUM_t :0;
- uintTNUM_t b;
-};
-int print_bcTNUM(size_t* sz, size_t* align, char* buf, struct bcTNUM* s);
-int print_blzTNUM(size_t* sz, size_t* align, char* buf, struct blzTNUM* s);
-]]
-
-local bitalign = [[
-struct ba_TNUM_BNUM {
- char a;
- uintTNUM_t b : BNUM;
-};
-struct bu_TNUM_BNUM {
- char a;
- uintTNUM_t :BNUM;
- char b;
-};
-int print_ba_TNUM_BNUM(size_t* sz, size_t* align, char* buf, struct ba_TNUM_BNUM* s);
-]]
-
-local bitzero = [[
-struct bz_TNUM_ZNUM_BNUM {
- uint8_t a;
- uintTNUM_t b : 3;
- uintZNUM_t :BNUM;
- uintTNUM_t c : 3;
-};
-int print_bz_TNUM_ZNUM_BNUM(size_t* sz, size_t* align, char* buf, struct bz_TNUM_ZNUM_BNUM* s);
-]]
-
-local i = ffi.C.i
-local test_values = {
- ['void*'] = ffi.new('char[3]'),
- ['const char*'] = 'foo',
- float = 3.4,
- double = 5.6,
- uint16_t = 65000,
- uint32_t = ffi.new('uint32_t', 700000056),
- uint64_t = 12345678901234,
- bool = true,
- _Bool = false,
- ['float complex'] = 3.1+4.2*i,
- ['double complex'] = 5.1+6.2*i,
- ['enum e8'] = ffi.C.FOO8,
- ['enum e16'] = ffi.C.FOO16,
- ['enum e32'] = ffi.C.FOO32,
-}
-
-local types = {
- b = 'bool',
- b2 = '_Bool',
- d = 'double',
- f = 'float',
- u64 = 'uint64_t',
- u32 = 'uint32_t',
- u16 = 'uint16_t',
- s = 'const char*',
- p = 'void*',
- e8 = 'enum e8',
- e16 = 'enum e16',
- e32 = 'enum e32',
-}
-
-local buf = ffi.new('char[256]')
-
-local function checkbuf(type, ret, msg)
- local str = tostring(test_values[type]):gsub('^cdata%b<>: ', '')
- check(ffi.string(buf), str, msg)
- check(ret, #str, msg)
-end
-
-local function checkalign(type, v, ret)
- --print(v)
- local str = tostring(test_values[type]):gsub('^cdata%b<>: ', '')
- check(ffi.string(buf), ('size %d offset %d align %d value %s'):format(ffi.sizeof(v), ffi.offsetof(v, 'v'), ffi.alignof(v, 'v'), str))
- check(ret, #str)
-end
-
-local u64 = ffi.typeof('uint64_t')
-local i64 = ffi.typeof('int64_t')
-
-local first = true
-
-for convention,c in pairs(dlls) do
- check(c.add_i8(1,1), 2)
- check(c.add_i8(256,1), 1)
- check(c.add_i8(127,1), -128)
- check(c.add_i8(-120,120), 0)
- check(c.add_u8(255,1), 0)
- check(c.add_u8(120,120), 240)
- check(c.add_i16(2000,4000), 6000)
- check(c.add_d(20, 12), 32)
- check(c.add_f(40, 32), 72)
- check(c.not_b(true), false)
- check(c.not_b2(false), true)
- check(c.inc_e8(c.FOO8), c.BAR8)
- check(c.inc_e8('FOO8'), c.BAR8)
- check(c.inc_e16(c.FOO16), c.BAR16)
- check(c.inc_e32(c.FOO32), c.BAR32)
- check(c.ret_fp(c.g_fp), c.g_fp)
- check(c.ret_fp2(c.g_fp), c.g_fp)
-
- if c.have_complex() then
- check(c.add_dc(3+4*i, 4+5*i), 7+9*i)
- check(c.add_fc(2+4*i, 6+8*i), 8+12*i)
- types.dc = 'double complex'
- types.fc = 'float complex'
- else
- types.dc = nil
- types.fc = nil
- end
- check((3+4*i).re, 3)
- check((3+4*i).im, 4)
- check(ffi.new('complex float', 2+8*i).re, 2)
- check(ffi.new('complex float', 5+6*i).im, 6)
-
- check(c.have_complex(), c.have_complex2())
- check(c.is_msvc, c.is_msvc2)
-
- check(c.g_b, true)
- check(c.g_i8, -8)
- check(c.g_i16, -16)
- check(c.g_i32, -32)
- check(c.g_i64, i64(-64))
- check(c.g_u8, 8)
- check(c.g_u16, 16)
- check(c.g_u32, 32)
- check(c.g_u64, u64(64))
- check(c.g_f, 3)
- check(c.g_d, 5)
- if c.have_complex() then
- check(c.g_dc, 7 + 8*i)
- check(c.g_fc, 6 + 9*i)
- end
- check(ffi.cast('void*', c.g_fp), c.g_p)
- check(c.g_s, 'g_s')
- check(c.g_sp, 'g_sp')
- check(c.g_e8, c.FOO8)
- check(c.g_e16, c.FOO16)
- check(c.g_e32, c.FOO32)
- check(c.g_date.nWeekDay, 1)
- check(c.g_date.nMonthDay, 2)
- check(c.g_date.nMonth, 3)
- check(c.g_date.nYear, 4)
-
- c.g_b = false; check(c.g_b, false)
- c.g_i8 = -108; check(c.g_i8, -108)
- c.g_i16 = -1016; check(c.g_i16, -1016)
- c.g_i32 = -1032; check(c.g_i32, -1032)
- c.g_i64 = -1064; check(c.g_i64, i64(-1064))
- c.g_u8 = 208; check(c.g_u8, 208)
- c.g_u16 = 2016; check(c.g_u16, 2016)
- c.g_u32 = 2032; check(c.g_u32, 2032)
- c.g_u64 = 2064; check(c.g_u64, u64(2064))
- c.g_f = 13; check(c.g_f, 13)
- c.g_d = 15; check(c.g_d, 15)
- if c.have_complex() then
- c.g_dc = 17+18*i; check(c.g_dc, 17+18*i)
- c.g_fc = 16+19*i; check(c.g_fc, 16+19*i)
- end
- c.g_sp = 'foo'; check(c.g_sp, 'foo')
- c.g_e8 = c.BAR8; check(c.g_e8, c.BAR8)
- c.g_e16 = c.BAR16; check(c.g_e16, c.BAR16)
- c.g_e32 = c.BAR32; check(c.g_e32, c.BAR32)
- c.g_date.nWeekDay = 3; check(c.g_date.nWeekDay, 3)
-
- local align_attr = c.is_msvc and [[
- struct align_attr_ALIGN_SUFFIX {
- char pad;
- __declspec(align(ALIGN)) TYPE v;
- };
-
- int print_align_attr_ALIGN_SUFFIX(char* buf, struct align_attr_ALIGN_SUFFIX* p);
- ]] or [[
- struct align_attr_ALIGN_SUFFIX {
- char pad;
- TYPE v __attribute__(aligned(ALIGN));
- };
-
- int print_align_attr_ALIGN_SUFFIX(char* buf, struct align_attr_ALIGN_SUFFIX* p);
- ]]
-
- for suffix, type in pairs(types) do
- local test = test_values[type]
- --print('checkbuf', suffix, type, buf, test)
- checkbuf(type, c['print_' .. suffix](buf, test), suffix)
-
- if first then
- ffi.cdef(align:gsub('SUFFIX', suffix):gsub('TYPE', type):gsub('ALIGN', 0))
- end
-
- local v = ffi.new('struct align_0_' .. suffix, {0, test})
- checkalign(type, v, c['print_align_0_' .. suffix](buf, v))
-
- for _,align in ipairs{1,2,4,8,16} do
- if align > c.max_alignment() then
- break
- end
-
- if first then
- ffi.cdef(palign:gsub('SUFFIX', suffix):gsub('TYPE', type):gsub('ALIGN', align))
- ffi.cdef(align_attr:gsub('SUFFIX', suffix):gsub('TYPE', type):gsub('ALIGN', align))
- end
-
- local v = ffi.new('struct align_' .. align .. '_' .. suffix, {0, test})
- checkalign(type, v, c['print_align_' .. align .. '_' .. suffix](buf, v))
-
- -- MSVC doesn't support aligned attributes on enums
- if not type:match('^enum e[0-9]*$') or not c.is_msvc then
- local v2 = ffi.new('struct align_attr_' .. align .. '_' .. suffix, {0, test})
- checkalign(type, v2, c['print_align_attr_' .. align .. '_' .. suffix](buf, v2))
- end
- end
-
- if not c.is_msvc then
- if first then
- local h = [[
- struct align_attr_def_SUFFIX {
- char pad;
- TYPE v __attribute__(aligned);
- };
- int print_align_attr_def_SUFFIX(char* buf, struct align_attr_def_SUFFIX* p);
- ]]
- ffi.cdef(h:gsub('SUFFIX', suffix):gsub('TYPE', type))
- end
-
- local v = ffi.new('struct align_attr_def_' .. suffix, {0, test})
- -- print(type)
- -- print("Align " .. c['print_align_attr_def_' .. suffix](buf, v))
- -- print(ffi.string(buf))
- -- checkalign(type, v, c['print_align_attr_def_' .. suffix](buf, v))
- end
- end
-
- local psz = ffi.new('size_t[1]')
- local palign = ffi.new('size_t[1]')
- local function check_align(type, test, ret)
- --print('check_align', type, test, ret, ffi.string(buf), psz[0], palign[0])
- check(tonumber(palign[0]), ffi.alignof(type))
- check(tonumber(psz[0]), ffi.sizeof(type))
- check(ret, #test)
- check(test, ffi.string(buf))
- end
-
- for _, tnum in ipairs{8, 16, 32, 64} do
- if first then
- ffi.cdef(bitfields:gsub('TNUM',tnum))
- end
-
- check_align('struct bc'..tnum, '1 2', c['print_bc'..tnum](psz, palign, buf, {1,2}))
- check_align('struct blz'..tnum, '1 2', c['print_blz'..tnum](psz, palign, buf, {1,2}))
-
- for _, znum in ipairs{8, 16, 32, 64} do
- for _, bnum in ipairs{7, 15, 31, 63} do
- if bnum > znum then
- break
- end
- if first then
- ffi.cdef(bitzero:gsub('TNUM',tnum):gsub('ZNUM',znum):gsub('BNUM', bnum))
- end
- check_align('struct bz_'..tnum..'_'..znum..'_'..bnum, '1 2 3', c['print_bz_'..tnum..'_'..znum..'_'..bnum](psz, palign, buf, {1,2,3}))
- end
- end
-
- for _, bnum in ipairs{7, 15, 31, 63} do
- if bnum > tnum then
- break
- end
- if first then
- ffi.cdef(bitalign:gsub('TNUM',tnum):gsub('BNUM',bnum))
- end
- check_align('struct ba_'..tnum..'_'..bnum, '1 2', c['print_ba_'..tnum..'_'..bnum](psz, palign, buf, {1,2}))
- end
- end
-
- check_align('struct Date', '1 2 3 4', c.print_date(psz, palign, buf, {1,2,3,4}))
- check_align('struct Date2', '1 2 3 4', c.print_date2(psz, palign, buf, {1,2,3,4}))
- check_align('struct sysv1', '1 2 3', c.print_sysv1(psz, palign, buf, {1,2,3}))
- check_align('struct sysv2', '1 2 3 4 5 6', c.print_sysv2(psz, palign, buf, {1,2,3,4,5,6}))
- check_align('struct sysv3', '1 2', c.print_sysv3(psz, palign, buf, {1,2}))
- check_align('union sysv4', '1', c.print_sysv4(psz, palign, buf, {1}))
- check_align('struct sysv5', '1 2 3', c.print_sysv5(psz, palign, buf, {1,2,3}))
- check_align('struct sysv6', '1 2 3', c.print_sysv6(psz, palign, buf, {1,2,3}))
- check_align('struct sysv7', '1 2 3 4 5', c.print_sysv7(psz, palign, buf, {1,2,3,4,5}))
-
- local cbs = [[
- typedef const char* (*__cdecl sfunc)(const char*);
- int call_i(int (*__cdecl func)(int), int arg);
- float call_f(float (*__cdecl func)(float), float arg);
- double call_d(double (*__cdecl func)(double), double arg);
- const char* call_s(sfunc func, const char* arg);
- _Bool call_b(_Bool (*__cdecl func)(_Bool), _Bool arg);
- double complex call_dc(double complex (*__cdecl func)(double complex), double complex arg);
- float complex call_fc(float complex (*__cdecl func)(float complex), float complex arg);
- enum e8 call_e8(enum e8 (*__cdecl func)(enum e8), enum e8 arg);
- enum e16 call_e16(enum e16 (*__cdecl func)(enum e16), enum e16 arg);
- enum e32 call_e32(enum e32 (*__cdecl func)(enum e32), enum e32 arg);
- ]]
-
- ffi.cdef(cbs:gsub('__cdecl', convention))
-
- local u3 = ffi.new('uint64_t', 3)
- check(c.call_i(function(a) return 2*a end, 3), 6)
- assert(math.abs(c.call_d(function(a) return 2*a end, 3.2) - 6.4) < 0.0000000001)
- assert(math.abs(c.call_f(function(a) return 2*a end, 3.2) - 6.4) < 0.000001)
- check(ffi.string(c.call_s(function(s) return s + u3 end, 'foobar')), 'bar')
- check(c.call_b(function(v) return not v end, true), false)
- check(c.call_e8(function(v) return v + 1 end, c.FOO8), c.BAR8)
- check(c.call_e16(function(v) return v + 1 end, c.FOO16), c.BAR16)
- check(c.call_e32(function(v) return v + 1 end, c.FOO32), c.BAR32)
-
- if c.have_complex() then
- check(c.call_dc(function(v) return v + 2+3*i end, 4+6*i), 6+9*i)
- check(c.call_fc(function(v) return v + 1+2*i end, 7+4*i), 8+6*i)
- end
-
- local u2 = ffi.new('uint64_t', 2)
- local cb = ffi.new('sfunc', function(s) return s + u3 end)
- check(ffi.string(cb('foobar')), 'bar')
- check(ffi.string(c.call_s(cb, 'foobar')), 'bar')
- cb:set(function(s) return s + u2 end)
- check(ffi.string(c.call_s(cb, 'foobar')), 'obar')
-
- local fp = ffi.new('struct fptr')
- assert(fp.p == ffi.C.NULL)
- fp.p = function(a) return 2*a end
- assert(fp.p ~= ffi.C.NULL)
- check(c.call_fptr(fp, 4), 8)
- local suc, err = pcall(function() fp.p:set(function() end) end)
- assert(not suc)
- check(err:gsub('^.*: ',''), "can't set the function for a non-lua callback")
-
- check(c.call_fptr({function(a) return 3*a end}, 5), 15)
-
- local suc, err = pcall(c.call_s, function(s) error(ffi.string(s), 0) end, 'my error')
- check(suc, false)
- check(err, 'my error')
-
- check(ffi.errno(), c.get_errno())
- c.set_errno(3)
- check(ffi.errno(), 3)
- check(c.get_errno(), 3)
- check(ffi.errno(4), 3)
- check(ffi.errno(), 4)
- check(c.get_errno(), 4)
-
- local gccattr = {
- __cdecl = 'int test_pow(int v) __attribute__((cdecl));',
- __stdcall = 'int test_pow(int v) __attribute__(stdcall);',
- __fastcall = '__attribute__(fastcall) int test_pow(int v);',
- }
-
- ffi.cdef(gccattr[convention])
- check(c.test_pow(5), 25)
-
- ffi.cdef [[
- int va_list_size, va_list_align;
- int vsnprintf(char* buf, size_t sz, const char* fmt, va_list ap);
- ]]
- ffi.new('va_list')
- assert(ffi.debug().functions.vsnprintf ~= nil)
- assert(ffi.istype('va_list', ffi.new('__builtin_va_list')))
- assert(ffi.istype('va_list', ffi.new('__gnuc_va_list')))
- check(ffi.sizeof('va_list'), c.va_list_size)
- check(ffi.alignof('va_list'), c.va_list_align)
-
- first = false
-end
-
-local c = ffi.C
-
-assert(c.sprintf(buf, "%g", 5.3) == 3 and ffi.string(buf) == '5.3')
-assert(c.sprintf(buf, "%d", false) == 1 and ffi.string(buf) == '0')
-assert(c.sprintf(buf, "%d%g", false, 6.7) == 4 and ffi.string(buf) == '06.7')
-
-assert(ffi.sizeof('uint32_t[?]', 32) == 32 * 4)
-assert(ffi.sizeof(ffi.new('uint32_t[?]', 32)) == 32 * 4)
-
-ffi.cdef [[
-struct vls {
- struct {
- char a;
- struct {
- char b;
- char v[?];
- } c;
- } d;
-};
-struct vls2 {
- char pad;
- union {
- uint8_t a;
- uint16_t b;
- };
-};
-]]
-
-assert(ffi.sizeof('struct vls', 3) == 5)
-assert(ffi.sizeof(ffi.new('struct vls', 4).d.c) == 5)
-assert(ffi.offsetof('struct vls2', 'a') == 2)
-assert(ffi.sizeof('struct vls2') == 4)
-
-ffi.cdef [[ static const int DUMMY = 8 << 2; ]]
-assert(ffi.C.DUMMY == 32)
-
-ffi.new('struct {const char* foo;}', {'foo'})
-
-assert(not pcall(function()
- ffi.new('struct {char* foo;}', {'ff'})
-end))
-
-local mt = {}
-local vls = ffi.new(ffi.metatype('struct vls', mt), 1)
-
-assert(not pcall(function() return vls.key end))
-
-mt.__index = function(vls, key)
- return function(vls, a, b)
- return 'in index ' .. key .. ' ' .. vls.d.a .. ' ' .. a .. ' ' .. b
- end
-end
-
-vls.d.a = 3
-check(vls:key('a', 'b'), 'in index key 3 a b')
-
-assert(not pcall(function() vls.k = 3 end))
-
-mt.__newindex = function(vls, key, val)
- error('in newindex ' .. key .. ' ' .. vls.d.a .. ' ' .. val, 0)
-end
-
-vls.d.a = 4
-local suc, err = pcall(function() vls.key = 'val' end)
-assert(not suc)
-check(err, 'in newindex key 4 val')
-
-mt.__add = function(vls, a) return vls.d.a + a end
-mt.__sub = function(vls, a) return vls.d.a - a end
-mt.__mul = function(vls, a) return vls.d.a * a end
-mt.__div = function(vls, a) return vls.d.a / a end
-mt.__mod = function(vls, a) return vls.d.a % a end
-mt.__pow = function(vls, a) return vls.d.a ^ a end
-mt.__eq = function(vls, a) return u64(vls.d.a) == a end
-mt.__lt = function(vls, a) return u64(vls.d.a) < a end
-mt.__le = function(vls, a) return u64(vls.d.a) <= a end
-mt.__call = function(vls, a, b) return '__call', vls.d.a .. a .. (b or 'nil') end
-mt.__unm = function(vls) return -vls.d.a end
-mt.__concat = function(vls, a) return vls.d.a .. a end
-mt.__len = function(vls) return vls.d.a end
-mt.__tostring = function(vls) return 'string ' .. vls.d.a end
-
-vls.d.a = 5
-check(vls + 5, 10)
-check(vls - 5, 0)
-check(vls * 5, 25)
-check(vls / 5, 1)
-check(vls % 3, 2)
-check(vls ^ 3, 125)
-check(vls == u64(4), false)
-check(vls == u64(5), true)
-check(vls == u64(6), false)
-check(vls < u64(4), false)
-check(vls < u64(5), false)
-check(vls < u64(6), true)
-check(vls <= u64(4), false)
-check(vls <= u64(5), true)
-check(vls <= u64(6), true)
-check(-vls, -5)
-local a,b = vls('6')
-check(a, '__call')
-check(b, '56nil')
-check(tostring(vls), 'string 5')
-
-if _VERSION ~= 'Lua 5.1' then
- check(vls .. 'str', '5str')
- check(#vls, 5)
-end
-
-check(tostring(1.1+3.2*i), '1.1+3.2i')
-check((1+3*i)*(2+4*i), -10+10*i)
-check((3+2*i)*(3-2*i), 13+0*i)
-
--- Should ignore unknown attributes
-ffi.cdef [[
-typedef int ALenum;
-__attribute__((dllimport)) void __attribute__((__cdecl__)) alEnable( ALenum capability );
-]]
-
-check(ffi.sizeof('struct {char foo[alignof(uint64_t)];}'), ffi.alignof('uint64_t'))
-
--- Long double is not supported yet but it should be parsed
-ffi.cdef('long double foo(long double val);')
-check(tostring(ffi.debug().functions.foo):match('ctype(%b<>)'), '<long double (*)(long double)>')
-
-ffi.cdef [[
-typedef int byte1 __attribute__(mode(QI));
-typedef int byte2 __attribute__(mode(HI));
-typedef int byte4 __attribute__(mode(SI));
-typedef int byte8 __attribute__(mode(DI));
-typedef unsigned ubyte8 __attribute__(mode(DI));
-typedef int word __attribute__(mode(word));
-typedef int pointer __attribute__(mode(pointer));
-typedef int byte __attribute__(mode(byte));
-typedef float float4 __attribute__(mode(SF));
-typedef float float8 __attribute__(mode(DF));
-]]
-assert(ffi.istype('int8_t', ffi.new('byte1')))
-assert(ffi.istype('int16_t', ffi.new('byte2')))
-assert(ffi.istype('int32_t', ffi.new('byte4')))
-assert(ffi.istype('int64_t', ffi.new('byte8')))
-assert(ffi.istype('uint64_t', ffi.new('ubyte8')))
-check(ffi.sizeof('void*'), ffi.sizeof('pointer'))
-check(ffi.alignof('void*'), ffi.alignof('pointer'))
-check(ffi.sizeof('void*'), ffi.sizeof('word'))
-check(ffi.alignof('void*'), ffi.alignof('word'))
-assert(ffi.istype('int8_t', ffi.new('byte')))
-assert(ffi.istype('float', ffi.new('float4')))
-assert(ffi.istype('double', ffi.new('float8')))
-
-ffi.cdef('void register_foo(register int val);')
-check(tostring(ffi.debug().functions.register_foo):match('%b<>'), '<void (*)(int)>')
-
-ffi.cdef [[
- typedef struct __sFILE FILE;
-]]
-
-assert(not ffi.istype('int', ffi.new('int*')))
-assert(not ffi.istype('int[]', ffi.new('int*')))
-assert(not ffi.istype('int[3]', ffi.new('int*')))
-assert(not ffi.istype('int[3]', ffi.new('int[2]')))
-assert(ffi.istype('const int[3]', ffi.new('const int[3]')))
-assert(ffi.istype('int[3]', ffi.new('const int[3]')))
-
--- Crazy function pointer that takes an int and a function pointer and returns
--- a function pointer. Type of &signal.
-check(tostring(ffi.typeof('void (*foo(int, void(*)(int)))(int)')):match('%b<>'), '<void (*(*)(int, void (*)(int)))(int)>')
-
--- Make sure we pass all arguments to tonumber
-check(tonumber('FE', 16), 0xFE)
-
--- Allow casts from pointer to numeric types
-ffi.cast('long', ffi.C.NULL)
-ffi.cast('int8_t', ffi.C.NULL)
-assert(not pcall(function() ffi.new('long', ffi.C.NULL) end))
-
--- ffi.new and ffi.cast allow unpacked struct/arrays
-assert(ffi.new('int[3]', 1)[0] == 1)
-assert(ffi.new('int[3]', {1})[0] == 1)
-assert(ffi.new('int[3]', 1, 2)[1] == 2)
-assert(ffi.new('int[3]', {1, 2})[1] == 2)
-
-ffi.cdef[[
-struct var {
- char ch[?];
-};
-]]
-local d = ffi.new('char[4]')
-local v = ffi.cast('struct var*', d)
-v.ch = {1,2,3,4}
-assert(v.ch[3] == 4)
-v.ch = "bar"
-assert(v.ch[3] == 0)
-assert(v.ch[2] == string.byte('r'))
-assert(d[1] == string.byte('a'))
-
-ffi.cast('char*', 1)
-
--- 2 arg form of ffi.copy
-ffi.copy(d, 'bar')
-
--- unsigned should be ignored for pointer rules
-ffi.cdef[[
-int strncmp(const signed char *s1, const unsigned char *s2, size_t n);
-]]
-assert(ffi.C.strncmp("two", "three", 3) ~= 0)
-
-ffi.fill(d, 3, 1)
-assert(d[2] == 1)
-ffi.fill(d, 3)
-assert(d[2] == 0)
-
--- tests for __new
-ffi.cdef[[
-struct newtest {
- int a;
- int b;
- int c;
-};
-]]
-
-local tp = ffi.metatype("struct newtest", {__new =
- function(tp, x, y, z)
- tp = ffi.new(tp)
- tp.a, tp.b, tp.c = x, y, z
- return tp
- end})
-local v = tp(1, 2, 3)
-assert(v.a == 1 and v.b == 2 and v.c == 3)
-
-local tp = ffi.metatype("struct newtest", {__new =
- function(tp, x, y, z)
- tp = ffi.new(tp, {a = x, b = y, c = z})
- return tp
- end})
-local v = tp(1, 2, 3)
-assert(v.a == 1 and v.b == 2 and v.c == 3)
-
--- tests for __pairs and __ipairs; not iterating just testing what is returned
-local tp = ffi.metatype("struct newtest",
- {__pairs = function(tp) return tp.a, tp.b end, __ipairs = function(tp) return tp.b, tp.c end}
-)
-if _VERSION ~= 'Lua 5.1' then
- local v = tp(1, 2, 3)
- x, y = pairs(v)
- assert(x == 1 and y == 2)
- x, y = ipairs(v)
- assert(x == 2 and y == 3)
-end
-
--- test for pointer to struct having same metamethods
-local st = ffi.cdef "struct ptest {int a, b;};"
-local tp = ffi.metatype("struct ptest", {__index = function(s, k) return k end, __len = function(s) return 3 end})
-
-local a = tp(1, 2)
-assert(a.banana == "banana")
-assert(#a == 3)
-local b = ffi.new("int[2]")
-local c = ffi.cast("struct ptest *", b)
-assert(c.banana == "banana") -- should have same methods
-assert(#c == 3)
-
-
-ffi.cdef [[
-char buf[512];
-void test_call_echo(const char* c);
-void test_call_pppppii(void* a, void* b, void* c, void* d, void* e, int f, int g);
-void test_call_pppppiiiiii(void* p1, void* p2, void* p3, void* p4, void* p5, int i1, int i2, int i3, int i4, int i5, int i6);
-void test_call_pppppffffff(void* p1, void* p2, void* p3, void* p4, void* p5, float f1, float f2, float f3, float f4, float f5, float f6);
-void test_call_pppppiifiii(void* p1, void* p2, void* p3, void* p4, void* p5, int i1, int i2, float f3, int i4, int i5, int i6);
-void test_call_pppppiiifii(void* p1, void* p2, void* p3, void* p4, void* p5, int i1, int i2, int i3, float i4, int i5, int i6);
-]]
-
-ffi.C.test_call_echo("input")
-assert(ffi.C.buf == "input")
-
-local function ptr(x) return ffi.new('void*', x) end
-
-ffi.C.test_call_pppppii(ptr(1), ptr(2), ptr(3), ptr(4), ptr(5), 6, 7)
-assert(ffi.C.buf == "0x1 0x2 0x3 0x4 0x5 6 7")
-
-ffi.C.test_call_pppppiiiiii(ptr(1), ptr(2), ptr(3), ptr(4), ptr(5), 6, 7, 8, 9, 10, 11)
-assert(ffi.C.buf == "0x1 0x2 0x3 0x4 0x5 6 7 8 9 10 11")
-
-ffi.C.test_call_pppppffffff(ptr(1), ptr(2), ptr(3), ptr(4), ptr(5), 6.5, 7.5, 8.5, 9.5, 10.5, 11.5)
-assert(ffi.C.buf == "0x1 0x2 0x3 0x4 0x5 6.5 7.5 8.5 9.5 10.5 11.5")
-
-ffi.C.test_call_pppppiifiii(ptr(1), ptr(2), ptr(3), ptr(4), ptr(5), 6, 7, 8.5, 9, 10, 11)
-assert(ffi.C.buf == "0x1 0x2 0x3 0x4 0x5 6 7 8.5 9 10 11")
-
-ffi.C.test_call_pppppiiifii(ptr(1), ptr(2), ptr(3), ptr(4), ptr(5), 6, 7, 8, 9.5, 10, 11)
-assert(ffi.C.buf == "0x1 0x2 0x3 0x4 0x5 6 7 8 9.5 10 11")
-
-local sum = ffi.C.add_dc(ffi.new('complex', 1, 2), ffi.new('complex', 3, 5))
-assert(ffi.istype('complex', sum))
-
-sum = ffi.C.add_fc(ffi.new('complex float', 1, 2), ffi.new('complex float', 3, 5))
-assert(ffi.istype('complex float', sum))
-
-ffi.cdef [[
-struct Arrays {
- int ints[3];
- unsigned int uints[3];
-};
-struct ArrayOfArrays {
- struct Arrays arrays[3];
-};
-]]
-
-local struct = ffi.new('struct Arrays')
-local structOfStructs = ffi.new('struct ArrayOfArrays')
-for i=0,2 do
- struct.ints[i] = i
- struct.uints[i] = i
- structOfStructs.arrays[0].ints[i] = i
-end
-for i=0,2 do
- assert(struct.ints[i] == i)
- assert(struct.uints[i] == i)
- assert(structOfStructs.arrays[0].ints[i] == i)
-end
-
--- Test ffi.string
-local buf = ffi.new('char[5]')
-ffi.fill(buf, 4, 97)
-buf[4] = 0
-
-assert(ffi.string(buf) == 'aaaa')
-assert(ffi.string(buf, 4) == 'aaaa')
-assert(ffi.string(buf, 2) == 'aa')
-assert(ffi.string(buf, 0) == '')
-assert(ffi.string(buf, ffi.new('long long', 2)) == 'aa')
-assert(ffi.string(buf, ffi.new('int', 2)) == 'aa')
-
--- Test io.tmpfile()
-ffi.cdef [[
- int fprintf ( FILE * stream, const char * format, ... );
-]]
-local f = io.tmpfile()
-ffi.C.fprintf(f, "test: %s\n", "foo")
-
-f:seek("set", 0)
-local str = f:read('*l')
-assert(str == 'test: foo', str)
-f:close()
-
-print('Test PASSED')
-
diff --git a/plugins/MirLua/Modules/ffi/src/test_includes.sh b/plugins/MirLua/Modules/ffi/src/test_includes.sh deleted file mode 100644 index c0b9cfa1f9..0000000000 --- a/plugins/MirLua/Modules/ffi/src/test_includes.sh +++ /dev/null @@ -1,25 +0,0 @@ -#!/bin/sh
-make test || exit
-rm -rf test_includes
-mkdir -p test_includes
-for f in /usr/include/*.h
-do
- gcc -E -c "${f}" > tmp 2>/dev/null
- if [ $? == 0 ]
- then
- echo "${f}";
- lua -e '
- local str = io.read("*a")
- -- remove preprocessor commands eg line directives
- str = str:gsub("#[^\n]*", "")
- -- remove inline function definitions and declarations
- str = str:gsub("extern%s+__inline__", "static")
- str = str:gsub("extern%s+__inline", "static")
- str = str:gsub("static[^;(]+__attribute__%s*%b()", "static ")
- str = str:gsub("static[^;(]+__attribute__%s*%b()", "static ")
- str = str:gsub("static[^;(]+%b()%s*%b{}", "")
- str = str:gsub("static[^;(]+%b()%s*;", "")
- io.write(str)' > "test_includes/`basename $f`" < tmp
- lua -e 'ffi = require("ffi"); ffi.cdef(io.read("*a"))' < "test_includes/`basename $f`"
- fi
-done
|