snailed
/
void-packages
2
0
Fork 0
Code Issues 1 Pull Requests 2 Actions Activity

LuaJIT: update to 2.1.1720049189, cleanup, adopt.

This commit is contained in:
Daniel Martinez 2024-01-31 02:54:09 -05:00 committed by classabbyamp
parent 3a90874fe7
commit 9af1377014
12 changed files with 33 additions and 4625 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
srcpkgs/LuaJIT/files/patches/ppc/musl-ppc-secureplt.patch
View File

@ -1,93 +0,0 @@
Imported from https://github.com/LuaJIT/LuaJIT/pull/486.
This fixes crashes on ppc-musl, as musl only supports secureplt.
--- a/src/lj_dispatch.c
+++ b/src/lj_dispatch.c
@@ -56,6 +56,18 @@ static const ASMFunction dispatch_got[] = {
#undef GOTFUNC
#endif
+#if LJ_TARGET_PPC && (LJ_ARCH_BITS == 32)
+#include <math.h>
+LJ_FUNCA_NORET void LJ_FASTCALL lj_ffh_coroutine_wrap_err(lua_State *L,
+ lua_State *co);
+
+#define GOTFUNC(name) (ASMFunction)name,
+static const ASMFunction dispatch_got[] = {
+ GOTDEF(GOTFUNC)
+};
+#undef GOTFUNC
+#endif
+
/* Initialize instruction dispatch table and hot counters. */
void lj_dispatch_init(GG_State *GG)
{
@@ -77,6 +89,9 @@ void lj_dispatch_init(GG_State *GG)
#if LJ_TARGET_MIPS
memcpy(GG->got, dispatch_got, LJ_GOT__MAX*sizeof(ASMFunction *));
#endif
+#if LJ_TARGET_PPC && (LJ_ARCH_BITS == 32)
+ memcpy(GG->got, dispatch_got, LJ_GOT__MAX*4);
+#endif
}
#if LJ_HASJIT
--- a/src/lj_dispatch.h
+++ b/src/lj_dispatch.h
@@ -66,6 +66,21 @@ GOTDEF(GOTENUM)
};
#endif
+#if LJ_TARGET_PPC && (LJ_ARCH_BITS == 32)
+/* Need our own global offset table for the dreaded MIPS calling conventions. */
+#define GOTDEF(_) \
+ _(floor) _(ceil) _(trunc) _(log) _(log10) _(exp) _(sin) _(cos) _(tan) \
+ _(asin) _(acos) _(atan) _(sinh) _(cosh) _(tanh) _(frexp) _(modf) _(atan2) \
+ _(pow) _(fmod) _(ldexp) _(sqrt)
+
+enum {
+#define GOTENUM(name) LJ_GOT_##name,
+GOTDEF(GOTENUM)
+#undef GOTENUM
+ LJ_GOT__MAX
+};
+#endif
+
/* Type of hot counter. Must match the code in the assembler VM. */
/* 16 bits are sufficient. Only 0.0015% overhead with maximum slot penalty. */
typedef uint16_t HotCount;
@@ -89,7 +104,7 @@ typedef uint16_t HotCount;
typedef struct GG_State {
lua_State L; /* Main thread. */
global_State g; /* Global state. */
-#if LJ_TARGET_MIPS
+#if LJ_TARGET_MIPS || (LJ_TARGET_PPC && (LJ_ARCH_BITS == 32))
ASMFunction got[LJ_GOT__MAX]; /* Global offset table. */
#endif
#if LJ_HASJIT
--- a/src/vm_ppc.dasc
+++ b/src/vm_ppc.dasc
@@ -59,7 +59,12 @@
|.define ENV_OFS, 8
|.endif
|.else // No TOC.
-|.macro blex, target; bl extern target@plt; .endmacro
+|.macro blex, target
+| lwz TMP0, DISPATCH_GOT(target)(DISPATCH)
+| mtctr TMP0
+| bctrl
+| //bl extern target@plt
+|.endmacro
|.macro .toc, a, b; .endmacro
|.endif
|.macro .tocenv, a, b; .if TOCENV; a, b; .endif; .endmacro
@@ -448,6 +453,8 @@
|// Assumes DISPATCH is relative to GL.
#define DISPATCH_GL(field) (GG_DISP2G + (int)offsetof(global_State, field))
#define DISPATCH_J(field) (GG_DISP2J + (int)offsetof(jit_State, field))
+#define GG_DISP2GOT (GG_OFS(got) - GG_OFS(dispatch))
+#define DISPATCH_GOT(name) (GG_DISP2GOT + 4*LJ_GOT_##name)
|
#define PC2PROTO(field) ((int)offsetof(GCproto, field)-(int)sizeof(GCproto))
|

3521
srcpkgs/LuaJIT/files/patches/ppc64/add-ppc64-support.patch
View File

File diff suppressed because it is too large Load Diff

11
srcpkgs/LuaJIT/files/patches/ppc64/fix-vm-jit-ppc64.patch
View File

@ -1,11 +0,0 @@
--- a/src/vm_ppc.dasc 2019-06-03 19:41:50.214671731 +0200
+++ b/src/vm_ppc.dasc 2019-06-03 19:44:40.229686143 +0200
@@ -2774,7 +2774,7 @@
|
|->vm_exit_handler:
|.if JIT
- | addi sp, TMP0, sp, -(EXIT_OFFSET+32*8+32*PSIZE)
+ | addi sp, sp, -(EXIT_OFFSET+32*8+32*PSIZE)
| saver 3 // CARG1
| saver 4 // CARG2
| saver 5 // CARG3

231
srcpkgs/LuaJIT/patches/aarch64-Fix-exit-stub-patching.patch
View File

@ -1,231 +0,0 @@
commit 9da06535092d6d9dec442641a26c64bce5574322
Author: Mike Pall <mike>
Date: Sun Jun 24 14:08:59 2018 +0200
ARM64: Fix exit stub patching.
Contributed by Javier Guerra Giraldez.
diff --git a/src/lj_asm_arm64.h b/src/lj_asm_arm64.h
index cbb186d3..baafa21a 100644
--- a/src/lj_asm_arm64.h
+++ b/src/lj_asm_arm64.h
@@ -56,11 +56,11 @@ static void asm_exitstub_setup(ASMState *as, ExitNo nexits)
asm_mclimit(as);
/* 1: str lr,[sp]; bl ->vm_exit_handler; movz w0,traceno; bl <1; bl <1; ... */
for (i = nexits-1; (int32_t)i >= 0; i--)
- *--mxp = A64I_LE(A64I_BL|((-3-i)&0x03ffffffu));
- *--mxp = A64I_LE(A64I_MOVZw|A64F_U16(as->T->traceno));
+ *--mxp = A64I_LE(A64I_BL | A64F_S26(-3-i));
+ *--mxp = A64I_LE(A64I_MOVZw | A64F_U16(as->T->traceno));
mxp--;
- *mxp = A64I_LE(A64I_BL|(((MCode *)(void *)lj_vm_exit_handler-mxp)&0x03ffffffu));
- *--mxp = A64I_LE(A64I_STRx|A64F_D(RID_LR)|A64F_N(RID_SP));
+ *mxp = A64I_LE(A64I_BL | A64F_S26(((MCode *)(void *)lj_vm_exit_handler-mxp)));
+ *--mxp = A64I_LE(A64I_STRx | A64F_D(RID_LR) | A64F_N(RID_SP));
as->mctop = mxp;
}
@@ -77,7 +77,7 @@ static void asm_guardcc(ASMState *as, A64CC cc)
MCode *p = as->mcp;
if (LJ_UNLIKELY(p == as->invmcp)) {
as->loopinv = 1;
- *p = A64I_B | ((target-p) & 0x03ffffffu);
+ *p = A64I_B | A64F_S26(target-p);
emit_cond_branch(as, cc^1, p-1);
return;
}
@@ -91,7 +91,7 @@ static void asm_guardtnb(ASMState *as, A64Ins ai, Reg r, uint32_t bit)
MCode *p = as->mcp;
if (LJ_UNLIKELY(p == as->invmcp)) {
as->loopinv = 1;
- *p = A64I_B | ((target-p) & 0x03ffffffu);
+ *p = A64I_B | A64F_S26(target-p);
emit_tnb(as, ai^0x01000000u, r, bit, p-1);
return;
}
@@ -105,7 +105,7 @@ static void asm_guardcnb(ASMState *as, A64Ins ai, Reg r)
MCode *p = as->mcp;
if (LJ_UNLIKELY(p == as->invmcp)) {
as->loopinv = 1;
- *p = A64I_B | ((target-p) & 0x03ffffffu);
+ *p = A64I_B | A64F_S26(target-p);
emit_cnb(as, ai^0x01000000u, r, p-1);
return;
}
@@ -1850,7 +1850,7 @@ static void asm_loop_fixup(ASMState *as)
p[-2] |= ((uint32_t)delta & mask) << 5;
} else {
ptrdiff_t delta = target - (p - 1);
- p[-1] = A64I_B | ((uint32_t)(delta) & 0x03ffffffu);
+ p[-1] = A64I_B | A64F_S26(delta);
}
}
@@ -1919,7 +1919,7 @@ static void asm_tail_fixup(ASMState *as, TraceNo lnk)
}
/* Patch exit branch. */
target = lnk ? traceref(as->J, lnk)->mcode : (MCode *)lj_vm_exit_interp;
- p[-1] = A64I_B | (((target-p)+1)&0x03ffffffu);
+ p[-1] = A64I_B | A64F_S26((target-p)+1);
}
/* Prepare tail of code. */
@@ -1982,40 +1982,50 @@ void lj_asm_patchexit(jit_State *J, GCtrace *T, ExitNo exitno, MCode *target)
{
MCode *p = T->mcode;
MCode *pe = (MCode *)((char *)p + T->szmcode);
- MCode *cstart = NULL, *cend = p;
+ MCode *cstart = NULL;
MCode *mcarea = lj_mcode_patch(J, p, 0);
MCode *px = exitstub_trace_addr(T, exitno);
+ /* Note: this assumes a trace exit is only ever patched once. */
for (; p < pe; p++) {
/* Look for exitstub branch, replace with branch to target. */
+ ptrdiff_t delta = target - p;
MCode ins = A64I_LE(*p);
if ((ins & 0xff000000u) == 0x54000000u &&
((ins ^ ((px-p)<<5)) & 0x00ffffe0u) == 0) {
- /* Patch bcc exitstub. */
- *p = A64I_LE((ins & 0xff00001fu) | (((target-p)<<5) & 0x00ffffe0u));
- cend = p+1;
- if (!cstart) cstart = p;
+ /* Patch bcc, if within range. */
+ if (A64F_S_OK(delta, 19)) {
+ *p = A64I_LE((ins & 0xff00001fu) | A64F_S19(delta));
+ if (!cstart) cstart = p;
+ }
} else if ((ins & 0xfc000000u) == 0x14000000u &&
((ins ^ (px-p)) & 0x03ffffffu) == 0) {
- /* Patch b exitstub. */
- *p = A64I_LE((ins & 0xfc000000u) | ((target-p) & 0x03ffffffu));
- cend = p+1;
+ /* Patch b. */
+ lua_assert(A64F_S_OK(delta, 26));
+ *p = A64I_LE((ins & 0xfc000000u) | A64F_S26(delta));
if (!cstart) cstart = p;
} else if ((ins & 0x7e000000u) == 0x34000000u &&
((ins ^ ((px-p)<<5)) & 0x00ffffe0u) == 0) {
- /* Patch cbz/cbnz exitstub. */
- *p = A64I_LE((ins & 0xff00001f) | (((target-p)<<5) & 0x00ffffe0u));
- cend = p+1;
- if (!cstart) cstart = p;
+ /* Patch cbz/cbnz, if within range. */
+ if (A64F_S_OK(delta, 19)) {
+ *p = A64I_LE((ins & 0xff00001fu) | A64F_S19(delta));
+ if (!cstart) cstart = p;
+ }
} else if ((ins & 0x7e000000u) == 0x36000000u &&
((ins ^ ((px-p)<<5)) & 0x0007ffe0u) == 0) {
- /* Patch tbz/tbnz exitstub. */
- *p = A64I_LE((ins & 0xfff8001fu) | (((target-p)<<5) & 0x0007ffe0u));
- cend = p+1;
- if (!cstart) cstart = p;
+ /* Patch tbz/tbnz, if within range. */
+ if (A64F_S_OK(delta, 14)) {
+ *p = A64I_LE((ins & 0xfff8001fu) | A64F_S14(delta));
+ if (!cstart) cstart = p;
+ }
}
}
- lua_assert(cstart != NULL);
- lj_mcode_sync(cstart, cend);
+ { /* Always patch long-range branch in exit stub itself. */
+ ptrdiff_t delta = target - px;
+ lua_assert(A64F_S_OK(delta, 26));
+ *px = A64I_B | A64F_S26(delta);
+ if (!cstart) cstart = px;
+ }
+ lj_mcode_sync(cstart, px+1);
lj_mcode_patch(J, mcarea, 1);
}
diff --git a/src/lj_emit_arm64.h b/src/lj_emit_arm64.h
index 6da4c7d4..1001b1d8 100644
--- a/src/lj_emit_arm64.h
+++ b/src/lj_emit_arm64.h
@@ -241,7 +241,7 @@ static void emit_loadk(ASMState *as, Reg rd, uint64_t u64, int is64)
#define mcpofs(as, k) \
((intptr_t)((uintptr_t)(k) - (uintptr_t)(as->mcp - 1)))
#define checkmcpofs(as, k) \
- ((((mcpofs(as, k)>>2) + 0x00040000) >> 19) == 0)
+ (A64F_S_OK(mcpofs(as, k)>>2, 19))
static Reg ra_allock(ASMState *as, intptr_t k, RegSet allow);
@@ -312,7 +312,7 @@ static void emit_cond_branch(ASMState *as, A64CC cond, MCode *target)
{
MCode *p = --as->mcp;
ptrdiff_t delta = target - p;
- lua_assert(((delta + 0x40000) >> 19) == 0);
+ lua_assert(A64F_S_OK(delta, 19));
*p = A64I_BCC | A64F_S19(delta) | cond;
}
@@ -320,24 +320,24 @@ static void emit_branch(ASMState *as, A64Ins ai, MCode *target)
{
MCode *p = --as->mcp;
ptrdiff_t delta = target - p;
- lua_assert(((delta + 0x02000000) >> 26) == 0);
- *p = ai | ((uint32_t)delta & 0x03ffffffu);
+ lua_assert(A64F_S_OK(delta, 26));
+ *p = ai | A64F_S26(delta);
}
static void emit_tnb(ASMState *as, A64Ins ai, Reg r, uint32_t bit, MCode *target)
{
MCode *p = --as->mcp;
ptrdiff_t delta = target - p;
- lua_assert(bit < 63 && ((delta + 0x2000) >> 14) == 0);
+ lua_assert(bit < 63 && A64F_S_OK(delta, 14));
if (bit > 31) ai |= A64I_X;
- *p = ai | A64F_BIT(bit & 31) | A64F_S14((uint32_t)delta & 0x3fffu) | r;
+ *p = ai | A64F_BIT(bit & 31) | A64F_S14(delta) | r;
}
static void emit_cnb(ASMState *as, A64Ins ai, Reg r, MCode *target)
{
MCode *p = --as->mcp;
ptrdiff_t delta = target - p;
- lua_assert(((delta + 0x40000) >> 19) == 0);
+ lua_assert(A64F_S_OK(delta, 19));
*p = ai | A64F_S19(delta) | r;
}
@@ -347,8 +347,8 @@ static void emit_call(ASMState *as, void *target)
{
MCode *p = --as->mcp;
ptrdiff_t delta = (char *)target - (char *)p;
- if ((((delta>>2) + 0x02000000) >> 26) == 0) {
- *p = A64I_BL | ((uint32_t)(delta>>2) & 0x03ffffffu);
+ if (A64F_S_OK(delta>>2, 26)) {
+ *p = A64I_BL | A64F_S26(delta>>2);
} else { /* Target out of range: need indirect call. But don't use R0-R7. */
Reg r = ra_allock(as, i64ptr(target),
RSET_RANGE(RID_X8, RID_MAX_GPR)-RSET_FIXED);
diff --git a/src/lj_target_arm64.h b/src/lj_target_arm64.h
index 520023ae..a207a2ba 100644
--- a/src/lj_target_arm64.h
+++ b/src/lj_target_arm64.h
@@ -132,9 +132,9 @@ static LJ_AINLINE uint32_t *exitstub_trace_addr_(uint32_t *p, uint32_t exitno)
#define A64F_IMMR(x) ((x) << 16)
#define A64F_U16(x) ((x) << 5)
#define A64F_U12(x) ((x) << 10)
-#define A64F_S26(x) (x)
+#define A64F_S26(x) (((uint32_t)(x) & 0x03ffffffu))
#define A64F_S19(x) (((uint32_t)(x) & 0x7ffffu) << 5)
-#define A64F_S14(x) ((x) << 5)
+#define A64F_S14(x) (((uint32_t)(x) & 0x3fffu) << 5)
#define A64F_S9(x) ((x) << 12)
#define A64F_BIT(x) ((x) << 19)
#define A64F_SH(sh, x) (((sh) << 22) | ((x) << 10))
@@ -145,6 +145,9 @@ static LJ_AINLINE uint32_t *exitstub_trace_addr_(uint32_t *p, uint32_t exitno)
#define A64F_LSL16(x) (((x) / 16) << 21)
#define A64F_BSH(sh) ((sh) << 10)
+/* Check for valid field range. */
+#define A64F_S_OK(x, b) ((((x) + (1 << (b-1))) >> (b)) == 0)
+
typedef enum A64Ins {
A64I_S = 0x20000000,
A64I_X = 0x80000000,

29
srcpkgs/LuaJIT/patches/aarch64-register-allocation-bug-fix.patch
View File

@ -1,29 +0,0 @@
From: Jason Teplitz <jason@tensyr.com>
Date: Mon, 9 Oct 2017 23:03:09 +0000
Subject: Fix register allocation bug in arm64
---
src/lj_asm_arm64.h | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git src/lj_asm_arm64.h src/lj_asm_arm64.h
index 8fd92e7..549f8a6 100644
--- a/src/lj_asm_arm64.h
+++ b/src/lj_asm_arm64.h
@@ -871,7 +871,7 @@ static void asm_hrefk(ASMState *as, IRIns *ir)
int bigofs = !emit_checkofs(A64I_LDRx, ofs);
RegSet allow = RSET_GPR;
Reg dest = (ra_used(ir) || bigofs) ? ra_dest(as, ir, RSET_GPR) : RID_NONE;
- Reg node = ra_alloc1(as, ir->op1, allow);
+ Reg node = ra_alloc1(as, ir->op1, ra_hasreg(dest) ? rset_clear(allow, dest) : allow);
Reg key = ra_scratch(as, rset_clear(allow, node));
Reg idx = node;
uint64_t k;
@@ -879,7 +879,6 @@ static void asm_hrefk(ASMState *as, IRIns *ir)
rset_clear(allow, key);
if (bigofs) {
idx = dest;
- rset_clear(allow, dest);
kofs = (int32_t)offsetof(Node, key);
} else if (ra_hasreg(dest)) {
emit_opk(as, A64I_ADDx, dest, node, ofs, allow);

562
srcpkgs/LuaJIT/patches/e9af1abec542e6f9851ff2368e7f196b6382a44c.patch
View File

@ -1,562 +0,0 @@
From e9af1abec542e6f9851ff2368e7f196b6382a44c Mon Sep 17 00:00:00 2001
From: Mike Pall <mike>
Date: Wed, 30 Sep 2020 01:31:27 +0200
Subject: [PATCH] Add support for full-range 64 bit lightuserdata.
---
doc/status.html | 11 ---------
src/jit/dump.lua | 4 +++-
src/lib_debug.c | 12 +++++-----
src/lib_jit.c | 14 ++++++------
src/lib_package.c | 8 +++----
src/lib_string.c | 2 +-
src/lj_api.c | 40 +++++++++++++++++++++++++++++----
src/lj_ccall.c | 2 +-
src/lj_cconv.c | 2 +-
src/lj_crecord.c | 6 ++---
src/lj_dispatch.c | 2 +-
src/lj_ir.c | 6 +++--
src/lj_obj.c | 5 +++--
src/lj_obj.h | 57 ++++++++++++++++++++++++++++++-----------------
src/lj_snap.c | 9 +++++++-
src/lj_state.c | 6 +++++
src/lj_strfmt.c | 2 +-
17 files changed, 121 insertions(+), 67 deletions(-)
#diff --git a/doc/status.html b/doc/status.html
#index 0aafe13a2..fd0ae8bae 100644
#--- a/doc/status.html
#+++ b/doc/status.html
#@@ -91,17 +91,6 @@ <h2>Current Status</h2>
# <tt>lua_atpanic</tt> on x64. This issue will be fixed with the new
# garbage collector.
# </li>
#-<li>
#-LuaJIT on 64 bit systems provides a <b>limited range</b> of 47 bits for the
#-<b>legacy <tt>lightuserdata</tt></b> data type.
#-This is only relevant on x64 systems which use the negative part of the
#-virtual address space in user mode, e.g. Solaris/x64, and on ARM64 systems
#-configured with a 48 bit or 52 bit VA.
#-Avoid using <tt>lightuserdata</tt> to hold pointers that may point outside
#-of that range, e.g. variables on the stack. In general, avoid this data
#-type for new code and replace it with (much more performant) FFI bindings.
#-FFI cdata pointers can address the full 64 bit range.
#-</li>
# </ul>
# <br class="flush">
# </div>
Index: luajit/src/jit/dump.lua
===================================================================
--- luajit.orig/src/jit/dump.lua
+++ luajit/src/jit/dump.lua
@@ -315,7 +315,9 @@
local tn = type(k)
local s
if tn == "number" then
- if band(sn or 0, 0x30000) ~= 0 then
+ if t < 12 then
+ s = k == 0 and "NULL" or format("[0x%08x]", k)
+ elseif band(sn or 0, 0x30000) ~= 0 then
s = band(sn, 0x20000) ~= 0 and "contpc" or "ftsz"
elseif k == 2^52+2^51 then
s = "bias"
Index: luajit/src/lib_debug.c
===================================================================
--- luajit.orig/src/lib_debug.c
+++ luajit/src/lib_debug.c
@@ -231,8 +231,8 @@
int32_t n = lj_lib_checkint(L, 2) - 1;
if ((uint32_t)n >= fn->l.nupvalues)
lj_err_arg(L, 2, LJ_ERR_IDXRNG);
- setlightudV(L->top-1, isluafunc(fn) ? (void *)gcref(fn->l.uvptr[n]) :
- (void *)&fn->c.upvalue[n]);
+ lua_pushlightuserdata(L, isluafunc(fn) ? (void *)gcref(fn->l.uvptr[n]) :
+ (void *)&fn->c.upvalue[n]);
return 1;
}
@@ -283,13 +283,13 @@
/* ------------------------------------------------------------------------ */
-#define KEY_HOOK ((void *)0x3004)
+#define KEY_HOOK (U64x(80000000,00000000)|'h')
static void hookf(lua_State *L, lua_Debug *ar)
{
static const char *const hooknames[] =
{"call", "return", "line", "count", "tail return"};
- lua_pushlightuserdata(L, KEY_HOOK);
+ (L->top++)->u64 = KEY_HOOK;
lua_rawget(L, LUA_REGISTRYINDEX);
if (lua_isfunction(L, -1)) {
lua_pushstring(L, hooknames[(int)ar->event]);
@@ -334,7 +334,7 @@
count = luaL_optint(L, arg+3, 0);
func = hookf; mask = makemask(smask, count);
}
- lua_pushlightuserdata(L, KEY_HOOK);
+ (L->top++)->u64 = KEY_HOOK;
lua_pushvalue(L, arg+1);
lua_rawset(L, LUA_REGISTRYINDEX);
lua_sethook(L, func, mask, count);
@@ -349,7 +349,7 @@
if (hook != NULL && hook != hookf) { /* external hook? */
lua_pushliteral(L, "external hook");
} else {
- lua_pushlightuserdata(L, KEY_HOOK);
+ (L->top++)->u64 = KEY_HOOK;
lua_rawget(L, LUA_REGISTRYINDEX); /* get hook */
}
lua_pushstring(L, unmakemask(mask, buff));
Index: luajit/src/lib_jit.c
===================================================================
--- luajit.orig/src/lib_jit.c
+++ luajit/src/lib_jit.c
@@ -540,15 +540,15 @@
/* Not loaded by default, use: local profile = require("jit.profile") */
-static const char KEY_PROFILE_THREAD = 't';
-static const char KEY_PROFILE_FUNC = 'f';
+#define KEY_PROFILE_THREAD (U64x(80000000,00000000)|'t')
+#define KEY_PROFILE_FUNC (U64x(80000000,00000000)|'f')
static void jit_profile_callback(lua_State *L2, lua_State *L, int samples,
int vmstate)
{
TValue key;
cTValue *tv;
- setlightudV(&key, (void *)&KEY_PROFILE_FUNC);
+ key.u64 = KEY_PROFILE_FUNC;
tv = lj_tab_get(L, tabV(registry(L)), &key);
if (tvisfunc(tv)) {
char vmst = (char)vmstate;
@@ -575,9 +575,9 @@
lua_State *L2 = lua_newthread(L); /* Thread that runs profiler callback. */
TValue key;
/* Anchor thread and function in registry. */
- setlightudV(&key, (void *)&KEY_PROFILE_THREAD);
+ key.u64 = KEY_PROFILE_THREAD;
setthreadV(L, lj_tab_set(L, registry, &key), L2);
- setlightudV(&key, (void *)&KEY_PROFILE_FUNC);
+ key.u64 = KEY_PROFILE_FUNC;
setfuncV(L, lj_tab_set(L, registry, &key), func);
lj_gc_anybarriert(L, registry);
luaJIT_profile_start(L, mode ? strdata(mode) : "",
@@ -592,9 +592,9 @@
TValue key;
luaJIT_profile_stop(L);
registry = tabV(registry(L));
- setlightudV(&key, (void *)&KEY_PROFILE_THREAD);
+ key.u64 = KEY_PROFILE_THREAD;
setnilV(lj_tab_set(L, registry, &key));
- setlightudV(&key, (void *)&KEY_PROFILE_FUNC);
+ key.u64 = KEY_PROFILE_FUNC;
setnilV(lj_tab_set(L, registry, &key));
lj_gc_anybarriert(L, registry);
return 0;
Index: luajit/src/lib_package.c
===================================================================
--- luajit.orig/src/lib_package.c
+++ luajit/src/lib_package.c
@@ -398,7 +398,7 @@
/* ------------------------------------------------------------------------ */
-#define sentinel ((void *)0x4004)
+#define KEY_SENTINEL (U64x(80000000,00000000)|'s')
static int lj_cf_package_require(lua_State *L)
{
@@ -408,7 +408,7 @@
lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
lua_getfield(L, 2, name);
if (lua_toboolean(L, -1)) { /* is it there? */
- if (lua_touserdata(L, -1) == sentinel) /* check loops */
+ if ((L->top-1)->u64 == KEY_SENTINEL) /* check loops */
luaL_error(L, "loop or previous error loading module " LUA_QS, name);
return 1; /* package is already loaded */
}
@@ -431,14 +431,14 @@
else
lua_pop(L, 1);
}
- lua_pushlightuserdata(L, sentinel);
+ (L->top++)->u64 = KEY_SENTINEL;
lua_setfield(L, 2, name); /* _LOADED[name] = sentinel */
lua_pushstring(L, name); /* pass name as argument to module */
lua_call(L, 1, 1); /* run loaded module */
if (!lua_isnil(L, -1)) /* non-nil return? */
lua_setfield(L, 2, name); /* _LOADED[name] = returned value */
lua_getfield(L, 2, name);
- if (lua_touserdata(L, -1) == sentinel) { /* module did not set a value? */
+ if ((L->top-1)->u64 == KEY_SENTINEL) { /* module did not set a value? */
lua_pushboolean(L, 1); /* use true as result */
lua_pushvalue(L, -1); /* extra copy to be returned */
lua_setfield(L, 2, name); /* _LOADED[name] = true */
Index: luajit/src/lib_string.c
===================================================================
--- luajit.orig/src/lib_string.c
+++ luajit/src/lib_string.c
@@ -714,7 +714,7 @@
lj_strfmt_putfchar(sb, sf, lj_lib_checkint(L, arg));
break;
case STRFMT_PTR: /* No formatting. */
- lj_strfmt_putptr(sb, lj_obj_ptr(L->base+arg-1));
+ lj_strfmt_putptr(sb, lj_obj_ptr(G(L), L->base+arg-1));
break;
default:
lua_assert(0);
Index: luajit/src/lj_api.c
===================================================================
--- luajit.orig/src/lj_api.c
+++ luajit/src/lj_api.c
@@ -595,7 +595,7 @@
if (tvisudata(o))
return uddata(udataV(o));
else if (tvislightud(o))
- return lightudV(o);
+ return lightudV(G(L), o);
else
return NULL;
}
@@ -608,7 +608,7 @@
LUA_API const void *lua_topointer(lua_State *L, int idx)
{
- return lj_obj_ptr(index2adr(L, idx));
+ return lj_obj_ptr(G(L), index2adr(L, idx));
}
/* -- Stack setters (object creation) ------------------------------------- */
@@ -694,9 +694,38 @@
incr_top(L);
}
+#if LJ_64
+static void *lightud_intern(lua_State *L, void *p)
+{
+ global_State *g = G(L);
+ uint64_t u = (uint64_t)p;
+ uint32_t up = lightudup(u);
+ uint32_t *segmap = mref(g->gc.lightudseg, uint32_t);
+ MSize segnum = g->gc.lightudnum;
+ if (segmap) {
+ MSize seg;
+ for (seg = 0; seg <= segnum; seg++)
+ if (segmap[seg] == up) /* Fast path. */
+ return (void *)(((uint64_t)seg << LJ_LIGHTUD_BITS_LO) | lightudlo(u));
+ segnum++;
+ }
+ if (!((segnum-1) & segnum) && segnum != 1) {
+ if (segnum >= (1 << LJ_LIGHTUD_BITS_SEG)) lj_err_msg(L, LJ_ERR_BADLU);
+ lj_mem_reallocvec(L, segmap, segnum, segnum ? 2*segnum : 2u, uint32_t);
+ setmref(g->gc.lightudseg, segmap);
+ }
+ g->gc.lightudnum = segnum;
+ segmap[segnum] = up;
+ return (void *)(((uint64_t)segnum << LJ_LIGHTUD_BITS_LO) | lightudlo(u));
+}
+#endif
+
LUA_API void lua_pushlightuserdata(lua_State *L, void *p)
{
- setlightudV(L->top, checklightudptr(L, p));
+#if LJ_64
+ p = lightud_intern(L, p);
+#endif
+ setrawlightudV(L->top, p);
incr_top(L);
}
@@ -1138,7 +1167,10 @@
fn->c.f = func;
setfuncV(L, top++, fn);
if (LJ_FR2) setnilV(top++);
- setlightudV(top++, checklightudptr(L, ud));
+#if LJ_64
+ ud = lightud_intern(L, ud);
+#endif
+ setrawlightudV(top++, ud);
cframe_nres(L->cframe) = 1+0; /* Zero results. */
L->top = top;
return top-1; /* Now call the newly allocated C function. */
Index: luajit/src/lj_ccall.c
===================================================================
--- luajit.orig/src/lj_ccall.c
+++ luajit/src/lj_ccall.c
@@ -1314,7 +1314,7 @@
lj_vm_ffi_call(&cc);
if (cts->cb.slot != ~0u) { /* Blacklist function that called a callback. */
TValue tv;
- setlightudV(&tv, (void *)cc.func);
+ tv.u64 = ((uintptr_t)(void *)cc.func >> 2) | U64x(800000000, 00000000);
setboolV(lj_tab_set(L, cts->miscmap, &tv), 1);
}
ct = (CType *)((intptr_t)ct+(intptr_t)cts->tab); /* May be reallocated. */
Index: luajit/src/lj_cconv.c
===================================================================
--- luajit.orig/src/lj_cconv.c
+++ luajit/src/lj_cconv.c
@@ -611,7 +611,7 @@
if (ud->udtype == UDTYPE_IO_FILE)
tmpptr = *(void **)tmpptr;
} else if (tvislightud(o)) {
- tmpptr = lightudV(o);
+ tmpptr = lightudV(cts->g, o);
} else if (tvisfunc(o)) {
void *p = lj_ccallback_new(cts, d, funcV(o));
if (p) {
Index: luajit/src/lj_crecord.c
===================================================================
--- luajit.orig/src/lj_crecord.c
+++ luajit/src/lj_crecord.c
@@ -643,8 +643,7 @@
}
} else if (tref_islightud(sp)) {
#if LJ_64
- sp = emitir(IRT(IR_BAND, IRT_P64), sp,
- lj_ir_kint64(J, U64x(00007fff,ffffffff)));
+ lj_trace_err(J, LJ_TRERR_NYICONV);
#endif
} else { /* NYI: tref_istab(sp). */
IRType t;
@@ -1209,8 +1208,7 @@
TRef tr;
TValue tv;
/* Check for blacklisted C functions that might call a callback. */
- setlightudV(&tv,
- cdata_getptr(cdataptr(cd), (LJ_64 && tp == IRT_P64) ? 8 : 4));
+ tv.u64 = ((uintptr_t)cdata_getptr(cdataptr(cd), (LJ_64 && tp == IRT_P64) ? 8 : 4) >> 2) | U64x(800000000, 00000000);
if (tvistrue(lj_tab_get(J->L, cts->miscmap, &tv)))
lj_trace_err(J, LJ_TRERR_BLACKL);
if (ctype_isvoid(ctr->info)) {
Index: luajit/src/lj_dispatch.c
===================================================================
--- luajit.orig/src/lj_dispatch.c
+++ luajit/src/lj_dispatch.c
@@ -302,7 +302,7 @@
if (idx != 0) {
cTValue *tv = idx > 0 ? L->base + (idx-1) : L->top + idx;
if (tvislightud(tv))
- g->wrapf = (lua_CFunction)lightudV(tv);
+ g->wrapf = (lua_CFunction)lightudV(g, tv);
else
return 0; /* Failed. */
} else {
Index: luajit/src/lj_ir.c
===================================================================
--- luajit.orig/src/lj_ir.c
+++ luajit/src/lj_ir.c
@@ -386,8 +386,10 @@
case IR_KPRI: setpriV(tv, irt_toitype(ir->t)); break;
case IR_KINT: setintV(tv, ir->i); break;
case IR_KGC: setgcV(L, tv, ir_kgc(ir), irt_toitype(ir->t)); break;
- case IR_KPTR: case IR_KKPTR: setlightudV(tv, ir_kptr(ir)); break;
- case IR_KNULL: setlightudV(tv, NULL); break;
+ case IR_KPTR: case IR_KKPTR:
+ setnumV(tv, (lua_Number)(uintptr_t)ir_kptr(ir));
+ break;
+ case IR_KNULL: setintV(tv, 0); break;
case IR_KNUM: setnumV(tv, ir_knum(ir)->n); break;
#if LJ_HASFFI
case IR_KINT64: {
Index: luajit/src/lj_obj.c
===================================================================
--- luajit.orig/src/lj_obj.c
+++ luajit/src/lj_obj.c
@@ -34,12 +34,13 @@
}
/* Return pointer to object or its object data. */
-const void * LJ_FASTCALL lj_obj_ptr(cTValue *o)
+const void * LJ_FASTCALL lj_obj_ptr(global_State *g, cTValue *o)
{
+ UNUSED(g);
if (tvisudata(o))
return uddata(udataV(o));
else if (tvislightud(o))
- return lightudV(o);
+ return lightudV(g, o);
else if (LJ_HASFFI && tviscdata(o))
return cdataptr(cdataV(o));
else if (tvisgcv(o))
Index: luajit/src/lj_obj.h
===================================================================
--- luajit.orig/src/lj_obj.h
+++ luajit/src/lj_obj.h
@@ -232,7 +232,7 @@
** ---MSW---.---LSW---
** primitive types | itype | |
** lightuserdata | itype | void * | (32 bit platforms)
-** lightuserdata |ffff| void * | (64 bit platforms, 47 bit pointers)
+** lightuserdata |ffff|seg| ofs | (64 bit platforms)
** GC objects | itype | GCRef |
** int (LJ_DUALNUM)| itype | int |
** number -------double------
@@ -245,7 +245,8 @@
**
** ------MSW------.------LSW------
** primitive types |1..1|itype|1..................1|
-** GC objects/lightud |1..1|itype|-------GCRef--------|
+** GC objects |1..1|itype|-------GCRef--------|
+** lightuserdata |1..1|itype|seg|------ofs-------|
** int (LJ_DUALNUM) |1..1|itype|0..0|-----int-------|
** number ------------double-------------
**
@@ -285,6 +286,12 @@
#define LJ_GCVMASK (((uint64_t)1 << 47) - 1)
#endif
+#if LJ_64
+/* To stay within 47 bits, lightuserdata is segmented. */
+#define LJ_LIGHTUD_BITS_SEG 8
+#define LJ_LIGHTUD_BITS_LO (47 - LJ_LIGHTUD_BITS_SEG)
+#endif
+
/* -- String object ------------------------------------------------------- */
/* String object header. String payload follows. */
@@ -576,7 +583,11 @@
uint8_t currentwhite; /* Current white color. */
uint8_t state; /* GC state. */
uint8_t nocdatafin; /* No cdata finalizer called. */
- uint8_t unused2;
+#if LJ_64
+ uint8_t lightudnum; /* Number of lightuserdata segments - 1. */
+#else
+ uint8_t unused1;
+#endif
MSize sweepstr; /* Sweep position in string table. */
GCRef root; /* List of all collectable objects. */
MRef sweep; /* Sweep position in root list. */
@@ -588,6 +599,9 @@
GCSize estimate; /* Estimate of memory actually in use. */
MSize stepmul; /* Incremental GC step granularity. */
MSize pause; /* Pause between successive GC cycles. */
+#if LJ_64
+ MRef lightudseg; /* Upper bits of lightuserdata segments. */
+#endif
} GCState;
/* Global state, shared by all threads of a Lua universe. */
@@ -795,10 +809,23 @@
#endif
#define boolV(o) check_exp(tvisbool(o), (LJ_TFALSE - itype(o)))
#if LJ_64
-#define lightudV(o) \
- check_exp(tvislightud(o), (void *)((o)->u64 & U64x(00007fff,ffffffff)))
+#define lightudseg(u) \
+ (((u) >> LJ_LIGHTUD_BITS_LO) & ((1 << LJ_LIGHTUD_BITS_SEG)-1))
+#define lightudlo(u) \
+ ((u) & (((uint64_t)1 << LJ_LIGHTUD_BITS_LO) - 1))
+#define lightudup(p) \
+ ((uint32_t)(((p) >> LJ_LIGHTUD_BITS_LO) << (LJ_LIGHTUD_BITS_LO-32)))
+static LJ_AINLINE void *lightudV(global_State *g, cTValue *o)
+{
+ uint64_t u = o->u64;
+ uint64_t seg = lightudseg(u);
+ uint32_t *segmap = mref(g->gc.lightudseg, uint32_t);
+ lua_assert(tvislightud(o));
+ lua_assert(seg <= g->gc.lightudnum);
+ return (void *)(((uint64_t)segmap[seg] << 32) | lightudlo(u));
+}
#else
-#define lightudV(o) check_exp(tvislightud(o), gcrefp((o)->gcr, void))
+#define lightudV(g, o) check_exp(tvislightud(o), gcrefp((o)->gcr, void))
#endif
#define gcV(o) check_exp(tvisgcv(o), gcval(o))
#define strV(o) check_exp(tvisstr(o), &gcval(o)->str)
@@ -824,7 +851,7 @@
#define setpriV(o, i) (setitype((o), (i)))
#endif
-static LJ_AINLINE void setlightudV(TValue *o, void *p)
+static LJ_AINLINE void setrawlightudV(TValue *o, void *p)
{
#if LJ_GC64
o->u64 = (uint64_t)p | (((uint64_t)LJ_TLIGHTUD) << 47);
@@ -835,24 +862,14 @@
#endif
}
-#if LJ_64
-#define checklightudptr(L, p) \
- (((uint64_t)(p) >> 47) ? (lj_err_msg(L, LJ_ERR_BADLU), NULL) : (p))
-#else
-#define checklightudptr(L, p) (p)
-#endif
-
-#if LJ_FR2
+#if LJ_FR2 || LJ_32
#define contptr(f) ((void *)(f))
#define setcont(o, f) ((o)->u64 = (uint64_t)(uintptr_t)contptr(f))
-#elif LJ_64
+#else
#define contptr(f) \
((void *)(uintptr_t)(uint32_t)((intptr_t)(f) - (intptr_t)lj_vm_asm_begin))
#define setcont(o, f) \
((o)->u64 = (uint64_t)(void *)(f) - (uint64_t)lj_vm_asm_begin)
-#else
-#define contptr(f) ((void *)(f))
-#define setcont(o, f) setlightudV((o), contptr(f))
#endif
#define tvchecklive(L, o) \
@@ -978,6 +995,6 @@
/* Compare two objects without calling metamethods. */
LJ_FUNC int LJ_FASTCALL lj_obj_equal(cTValue *o1, cTValue *o2);
-LJ_FUNC const void * LJ_FASTCALL lj_obj_ptr(cTValue *o);
+LJ_FUNC const void * LJ_FASTCALL lj_obj_ptr(global_State *g, cTValue *o);
#endif
Index: luajit/src/lj_snap.c
===================================================================
--- luajit.orig/src/lj_snap.c
+++ luajit/src/lj_snap.c
@@ -626,7 +626,12 @@
IRType1 t = ir->t;
RegSP rs = ir->prev;
if (irref_isk(ref)) { /* Restore constant slot. */
- lj_ir_kvalue(J->L, o, ir);
+ if (ir->o == IR_KPTR) {
+ o->u64 = (uint64_t)(uintptr_t)ir_kptr(ir);
+ } else {
+ lua_assert(!(ir->o == IR_KKPTR || ir->o == IR_KNULL));
+ lj_ir_kvalue(J->L, o, ir);
+ }
return;
}
if (LJ_UNLIKELY(bloomtest(rfilt, ref)))
Index: luajit/src/lj_state.c
===================================================================
--- luajit.orig/src/lj_state.c
+++ luajit/src/lj_state.c
@@ -171,6 +171,12 @@
lj_mem_freevec(g, g->strhash, g->strmask+1, GCRef);
lj_buf_free(g, &g->tmpbuf);
lj_mem_freevec(g, tvref(L->stack), L->stacksize, TValue);
+#if LJ_64
+ if (mref(g->gc.lightudseg, uint32_t)) {
+ MSize segnum = g->gc.lightudnum ? (2 << lj_fls(g->gc.lightudnum)) : 2;
+ lj_mem_freevec(g, mref(g->gc.lightudseg, uint32_t), segnum, uint32_t);
+ }
+#endif
lua_assert(g->gc.total == sizeof(GG_State));
#ifndef LUAJIT_USE_SYSMALLOC
if (g->allocf == lj_alloc_f)
Index: luajit/src/lj_strfmt.c
===================================================================
--- luajit.orig/src/lj_strfmt.c
+++ luajit/src/lj_strfmt.c
@@ -393,7 +393,7 @@
p = lj_buf_wmem(p, "builtin#", 8);
p = lj_strfmt_wint(p, funcV(o)->c.ffid);
} else {
- p = lj_strfmt_wptr(p, lj_obj_ptr(o));
+ p = lj_strfmt_wptr(p, lj_obj_ptr(G(L), o));
}
return lj_str_new(L, buf, (size_t)(p - buf));
}

24
srcpkgs/LuaJIT/patches/enable-debug-symbols.patch
View File

@ -1,24 +0,0 @@
From: =?utf-8?q?Ond=C5=99ej_Sur=C3=BD?= <ondrej@sury.org>
Date: Tue, 17 Nov 2015 16:27:11 +0100
Subject: Enable debugging symbols in the build
---
src/Makefile | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git src/Makefile src/Makefile
index 8a38efd..6b73a89 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -54,9 +54,9 @@ CCOPT_arm64=
CCOPT_ppc=
CCOPT_mips=
#
-CCDEBUG=
+#CCDEBUG=
# Uncomment the next line to generate debug information:
-#CCDEBUG= -g
+CCDEBUG= -g
#
CCWARN= -Wall
# Uncomment the next line to enable more warnings:

33
srcpkgs/LuaJIT/patches/fix-bcsave-ppc64.patch
View File

@ -1,33 +0,0 @@
--- a/src/jit/bcsave.lua 2018-12-17 19:06:27.215042417 +0100
+++ b/src/jit/bcsave.lua 2018-12-17 19:17:12.982477945 +0100
@@ -64,7 +64,7 @@
local map_arch = {
x86 = true, x64 = true, arm = true, arm64 = true, arm64be = true,
- ppc = true, mips = true, mipsel = true,
+ ppc = true, ppc64 = true, ppc64le = true, mips = true, mipsel = true,
}
local map_os = {
@@ -200,9 +200,10 @@
]]
local symname = LJBC_PREFIX..ctx.modname
local is64, isbe = false, false
- if ctx.arch == "x64" or ctx.arch == "arm64" or ctx.arch == "arm64be" then
+ if ctx.arch == "x64" or ctx.arch == "arm64" or ctx.arch == "arm64be" or ctx.arch == "ppc64" or ctx.arch == "ppc64le" then
is64 = true
- elseif ctx.arch == "ppc" or ctx.arch == "mips" then
+ end
+ if ctx.arch == "ppc" or ctx.arch == "ppc64" or ctx.arch == "mips" then
isbe = true
end
@@ -237,7 +238,7 @@
hdr.eendian = isbe and 2 or 1
hdr.eversion = 1
hdr.type = f16(1)
- hdr.machine = f16(({ x86=3, x64=62, arm=40, arm64=183, arm64be=183, ppc=20, mips=8, mipsel=8 })[ctx.arch])
+ hdr.machine = f16(({ x86=3, x64=62, arm=40, arm64=183, arm64be=183, ppc=20, ppc64=21, ppc64le=21, mips=8, mipsel=8 })[ctx.arch])
if ctx.arch == "mips" or ctx.arch == "mipsel" then
hdr.flags = f32(0x50001006)
end

51
srcpkgs/LuaJIT/patches/get-rid-of-luajit-version-sym.patch
View File

@ -1,51 +0,0 @@
From: =?utf-8?q?Ond=C5=99ej_Sur=C3=BD?= <ondrej@sury.org>
Date: Thu, 19 Nov 2015 16:29:02 +0200
Subject: Get rid of LUAJIT_VERSION_SYM that changes ABI on every patch release
---
src/lj_dispatch.c | 5 -----
src/luajit.c | 2 --
src/luajit.h | 3 ---
3 files changed, 10 deletions(-)
diff --git src/lj_dispatch.c src/lj_dispatch.c
index 5d6795f..e865a78 100644
--- a/src/lj_dispatch.c
+++ b/src/lj_dispatch.c
@@ -319,11 +319,6 @@ int luaJIT_setmode(lua_State *L, int idx, int mode)
return 1; /* OK. */
}
-/* Enforce (dynamic) linker error for version mismatches. See luajit.c. */
-LUA_API void LUAJIT_VERSION_SYM(void)
-{
-}
-
/* -- Hooks --------------------------------------------------------------- */
/* This function can be called asynchronously (e.g. during a signal). */
diff --git src/luajit.c src/luajit.c
index 1ca2430..ccf425e 100644
--- a/src/luajit.c
+++ b/src/luajit.c
@@ -516,8 +516,6 @@ static int pmain(lua_State *L)
globalL = L;
if (argv[0] && argv[0][0]) progname = argv[0];
- LUAJIT_VERSION_SYM(); /* Linker-enforced version check. */
-
argn = collectargs(argv, &flags);
if (argn < 0) { /* Invalid args? */
print_usage();
diff --git src/luajit.h src/luajit.h
index 708a5a1..35ae02c 100644
--- a/src/luajit.h
+++ b/src/luajit.h
@@ -73,7 +73,4 @@ LUA_API void luaJIT_profile_stop(lua_State *L);
LUA_API const char *luaJIT_profile_dumpstack(lua_State *L, const char *fmt,
int depth, size_t *len);
-/* Enforce (dynamic) linker error for version mismatches. Call from main. */
-LUA_API void LUAJIT_VERSION_SYM(void);
-
#endif

21
srcpkgs/LuaJIT/patches/unpollute-global-namespace.patch
View File

@ -1,21 +0,0 @@
From: =?utf-8?q?Ond=C5=99ej_Sur=C3=BD?= <ondrej@sury.org>
Date: Wed, 11 Oct 2017 08:42:41 +0000
Subject: Make ccall_copy_struct static to unpollute global library namespace
---
src/lj_ccall.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git src/lj_ccall.c src/lj_ccall.c
index b891591..a7dcc1b 100644
--- a/src/lj_ccall.c
+++ b/src/lj_ccall.c
@@ -960,7 +960,7 @@ noth: /* Not a homogeneous float/double aggregate. */
return 0; /* Struct is in GPRs. */
}
-void ccall_copy_struct(CCallState *cc, CType *ctr, void *dp, void *sp, int ft)
+static void ccall_copy_struct(CCallState *cc, CType *ctr, void *dp, void *sp, int ft)
{
if (LJ_ABI_SOFTFP ? ft :
((ft & 3) == FTYPE_FLOAT || (ft >> 2) == FTYPE_FLOAT)) {

80
srcpkgs/LuaJIT/template
View File

@ -1,71 +1,55 @@
# Template file for 'LuaJIT'
pkgname=LuaJIT
version=2.1.0beta3
revision=2
_so_version=2.1.0
_dist_version=${_so_version}-beta3
# the minor version is the contents of the .relver file in the source tarball
version=2.1.1720049189
revision=1
_commit_hash=04dca7911ea255f37be799c18d74c305b921c1a6
build_style=gnu-makefile
hostmakedepends="lua52-BitOp"
short_desc="Just-In-Time Compiler for Lua"
maintainer="Orphaned <orphan@voidlinux.org>"
maintainer="Daniel Martinez <danielmartinez@cock.li>"
license="MIT"
homepage="http://www.luajit.org"
distfiles="http://luajit.org/download/${pkgname}-${_dist_version}.tar.gz"
checksum=1ad2e34b111c802f9d0cdf019e986909123237a28c746b21295b63c9e785d9c3
distfiles="https://repo.or.cz/luajit-2.0.git/snapshot/${_commit_hash}.tar.gz"
checksum=5374d56b57929a3bb020518fd5468470465a6e08a3eb86d7b38fe7106a56ab26
build_options="lua52compat"
desc_option_lua52compat="higher compatibility with lua 5.2"
_cross_cc="cc"
if [ "$XBPS_WORDSIZE" != "$XBPS_TARGET_WORDSIZE" ]; then
if [ "${XBPS_MACHINE/-musl/}" = "x86_64" ]; then
hostmakedepends+=" cross-i686-linux-musl"
_cross_cc="i686-linux-musl-gcc -static"
else
broken="Host and target wordsize must match"
_host_cc="cc"
if [ -n "$CROSS_BUILD" ]; then
if [ "$XBPS_WORDSIZE" != "$XBPS_TARGET_WORDSIZE" ]; then
if [ "${XBPS_MACHINE%%-*}" = "x86_64" ]; then
hostmakedepends+=" cross-i686-linux-musl"
_host_cc="i686-linux-musl-gcc -static"
else
broken="Host and target wordsize must match when not on x86_64"
fi
fi
make_build_args+=" CROSS=${XBPS_CROSS_TRIPLET}-"
fi
# the ppc64 patchset subtly breaks ppc, needs investigation; for
# now apply patches conditionally, separately for ppc64 and ppc
post_patch() {
local patchdir
case "$XBPS_TARGET_MACHINE" in
ppc64*) patchdir="ppc64";;
ppc*) patchdir="ppc";;
*) return;;
esac
for i in ${FILESDIR}/patches/${patchdir}/*.patch; do
msg_normal "patching: $i\n"
patch -sNp1 -i ${i}
done
pre_build() {
if [ "$build_option_lua52compat" ]; then
make_build_args+=" XCFLAGS=-DLUAJIT_ENABLE_LUA52COMPAT"
fi
}
do_build() {
local _cflags=$CFLAGS
local _ldflags=$LDFLAGS
if [ "$CROSS_BUILD" ]; then
local cross="CROSS=${XBPS_CROSS_TRIPLET}-"
fi
if [ "$build_option_lua52compat" ]; then
local _xcflags="XCFLAGS=-DLUAJIT_ENABLE_LUA52COMPAT"
fi
# if we don't unset, the build fails to cross-compile
# due to confliction with the makefile macros
local _cflags="$CFLAGS"
local _ldflags="$LDFLAGS"
unset CFLAGS LDFLAGS
make ${makejobs} PREFIX=/usr HOST_LUA=lua5.2 HOST_CC="${_cross_cc}" \
make amalg ${makejobs} PREFIX=/usr HOST_LUA=lua5.2 \
HOST_CFLAGS="$XBPS_CFLAGS" HOST_LDFLAGS="$XBPS_LDFLAGS" \
TARGET_CFLAGS="${_cflags}" TARGET_LDFLAGS="${_ldflags}" \
${_xcflags} ${cross}
HOST_CC="${_host_cc}" ${make_build_args}
}
do_install() {
make DPREFIX=${DESTDIR}/usr DESTDIR=${DESTDIR} \
INSTALL_SHARE=${DESTDIR}/usr/share PREFIX=/usr install
mv ${DESTDIR}/usr/bin/luajit-* ${DESTDIR}/usr/bin/luajit
ln -fs libluajit-5.1.so.${_so_version} ${DESTDIR}/usr/lib/libluajit-5.1.so.2
post_install() {
vlicense COPYRIGHT
}

2
srcpkgs/LuaJIT/update
View File

@ -1 +1 @@
site="http://luajit.org/download.html"
disabled="impossible to determine given release style and versioning scheme"