4 years ago · d1c1d96165
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -201,12 +201,12 @@ endif()
 
															 set(MEGA_ZLIB_VER "1.2.11")

														
 
															 set(MEGA_LUA51_VER "5.1.5")

														
 
															-set(MEGA_LUAJIT_VER "2.1.0-ec6edc5")

														
 
															+set(MEGA_LUAJIT_VER "2.1.0-f3c8569")

														
 
															 set(MEGA_LIBOGG_VER "1.3.2")

														
 
															 set(MEGA_LIBVORBIS_VER "1.3.5")

														
 
															 set(MEGA_LIBTHEORA_VER "1.1.1")

														
 
															 set(MEGA_FREETYPE_VER "2.8.1")

														
 
															-set(MEGA_SDL2_VER "2.0.14")

														
 
															+set(MEGA_SDL2_VER "2.0.18")

														
 
															 set(MEGA_OPENAL_VER "1.21.1")

														
 
															 set(MEGA_MODPLUG_VER "0.8.8.4")

														
--- a/libs/LuaJIT/doc/contact.html
+++ b/libs/LuaJIT/doc/contact.html
@@ -1,8 +1,8 @@
 
															-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
														
 
															+<!DOCTYPE html>
														
 
															 <html>
														
 
															 <head>
														
 
															 <title>Contact</title>
														
 
															-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
														
 
															+<meta charset="utf-8">
														
 
															 <meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															 <meta name="Language" content="en">
														
 
															 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
@@ -37,6 +37,8 @@
 
															 <a href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															 </li></ul>
														
 
															 </li><li>
														
 
															+<a href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															 <a href="ext_jit.html">jit.* Library</a>
														
 
															 </li><li>
														
 
															 <a href="ext_c_api.html">Lua/C API</a>
														
--- a/libs/LuaJIT/doc/ext_buffer.html
+++ b/libs/LuaJIT/doc/ext_buffer.html
@@ -0,0 +1,693 @@
 
															+<!DOCTYPE html>
														
 
															+<html>
														
 
															+<head>
														
 
															+<title>String Buffer Library</title>
														
 
															+<meta charset="utf-8">
														
 
															+<meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															+<meta name="Language" content="en">
														
 
															+<link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
 
															+<link rel="stylesheet" type="text/css" href="bluequad-print.css" media="print">
														
 
															+<style type="text/css">
														
 
															+.lib {
														
 
															+  vertical-align: middle;
														
 
															+  margin-left: 5px;
														
 
															+  padding: 0 5px;
														
 
															+  font-size: 60%;
														
 
															+  border-radius: 5px;
														
 
															+  background: #c5d5ff;
														
 
															+  color: #000;
														
 
															+}
														
 
															+</style>
														
 
															+</head>
														
 
															+<body>
														
 
															+<div id="site">
														
 
															+<a href="https://luajit.org"><span>Lua<span id="logo">JIT</span></span></a>
														
 
															+</div>
														
 
															+<div id="head">
														
 
															+<h1>String Buffer Library</h1>
														
 
															+</div>
														
 
															+<div id="nav">
														
 
															+<ul><li>
														
 
															+<a href="luajit.html">LuaJIT</a>
														
 
															+<ul><li>
														
 
															+<a href="https://luajit.org/download.html">Download <span class="ext">&raquo;</span></a>
														
 
															+</li><li>
														
 
															+<a href="install.html">Installation</a>
														
 
															+</li><li>
														
 
															+<a href="running.html">Running</a>
														
 
															+</li></ul>
														
 
															+</li><li>
														
 
															+<a href="extensions.html">Extensions</a>
														
 
															+<ul><li>
														
 
															+<a href="ext_ffi.html">FFI Library</a>
														
 
															+<ul><li>
														
 
															+<a href="ext_ffi_tutorial.html">FFI Tutorial</a>
														
 
															+</li><li>
														
 
															+<a href="ext_ffi_api.html">ffi.* API</a>
														
 
															+</li><li>
														
 
															+<a href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															+</li></ul>
														
 
															+</li><li>
														
 
															+<a class="current" href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															+<a href="ext_jit.html">jit.* Library</a>
														
 
															+</li><li>
														
 
															+<a href="ext_c_api.html">Lua/C API</a>
														
 
															+</li><li>
														
 
															+<a href="ext_profiler.html">Profiler</a>
														
 
															+</li></ul>
														
 
															+</li><li>
														
 
															+<a href="status.html">Status</a>
														
 
															+</li><li>
														
 
															+<a href="faq.html">FAQ</a>
														
 
															+</li><li>
														
 
															+<a href="http://wiki.luajit.org/">Wiki <span class="ext">&raquo;</span></a>
														
 
															+</li><li>
														
 
															+<a href="https://luajit.org/list.html">Mailing List <span class="ext">&raquo;</span></a>
														
 
															+</li></ul>
														
 
															+</div>
														
 
															+<div id="main">
														
 
															+<p>
														
 
															+The string buffer library allows <b>high-performance manipulation of
														
 
															+string-like data</b>.
														
 
															+</p>
														
 
															+<p>
														
 
															+Unlike Lua strings, which are constants, string buffers are
														
 
															+<b>mutable</b> sequences of 8-bit (binary-transparent) characters. Data
														
 
															+can be stored, formatted and encoded into a string buffer and later
														
 
															+converted, extracted or decoded.
														
 
															+</p>
														
 
															+<p>
														
 
															+The convenient string buffer API simplifies common string manipulation
														
 
															+tasks, that would otherwise require creating many intermediate strings.
														
 
															+String buffers improve performance by eliminating redundant memory
														
 
															+copies, object creation, string interning and garbage collection
														
 
															+overhead. In conjunction with the FFI library, they allow zero-copy
														
 
															+operations.
														
 
															+</p>
														
 
															+<p>
														
 
															+The string buffer libary also includes a high-performance
														
 
															+<a href="serialize">serializer</a> for Lua objects.
														
 
															+</p>
														
 
															+
														
 
															+<h2 id="wip" style="color:#ff0000">Work in Progress</h2>
														
 
															+<p>
														
 
															+<b style="color:#ff0000">This library is a work in progress. More
														
 
															+functionality will be added soon.</b>
														
 
															+</p>
														
 
															+
														
 
															+<h2 id="use">Using the String Buffer Library</h2>
														
 
															+<p>
														
 
															+The string buffer library is built into LuaJIT by default, but it's not
														
 
															+loaded by default. Add this to the start of every Lua file that needs
														
 
															+one of its functions:
														
 
															+</p>
														
 
															+<pre class="code">
														
 
															+local buffer = require("string.buffer")
														
 
															+</pre>
														
 
															+<p>
														
 
															+The convention for the syntax shown on this page is that <tt>buffer</tt>
														
 
															+refers to the buffer library and <tt>buf</tt> refers to an individual
														
 
															+buffer object.
														
 
															+</p>
														
 
															+<p>
														
 
															+Please note the difference between a Lua function call, e.g.
														
 
															+<tt>buffer.new()</tt> (with a dot) and a Lua method call, e.g.
														
 
															+<tt>buf:reset()</tt> (with a colon).
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="buffer_object">Buffer Objects</h3>
														
 
															+<p>
														
 
															+A buffer object is a garbage-collected Lua object. After creation with
														
 
															+<tt>buffer.new()</tt>, it can (and should) be reused for many operations.
														
 
															+When the last reference to a buffer object is gone, it will eventually
														
 
															+be freed by the garbage collector, along with the allocated buffer
														
 
															+space.
														
 
															+</p>
														
 
															+<p>
														
 
															+Buffers operate like a FIFO (first-in first-out) data structure. Data
														
 
															+can be appended (written) to the end of the buffer and consumed (read)
														
 
															+from the front of the buffer. These operations may be freely mixed.
														
 
															+</p>
														
 
															+<p>
														
 
															+The buffer space that holds the characters is managed automatically
														
 
															+&mdash; it grows as needed and already consumed space is recycled. Use
														
 
															+<tt>buffer.new(size)</tt> and <tt>buf:free()</tt>, if you need more
														
 
															+control.
														
 
															+</p>
														
 
															+<p>
														
 
															+The maximum size of a single buffer is the same as the maximum size of a
														
 
															+Lua string, which is slightly below two gigabytes. For huge data sizes,
														
 
															+neither strings nor buffers are the right data structure &mdash; use the
														
 
															+FFI library to directly map memory or files up to the virtual memory
														
 
															+limit of your OS.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="buffer_overview">Buffer Method Overview</h3>
														
 
															+<ul>
														
 
															+<li>
														
 
															+The <tt>buf:put*()</tt>-like methods append (write) characters to the
														
 
															+end of the buffer.
														
 
															+</li>
														
 
															+<li>
														
 
															+The <tt>buf:get*()</tt>-like methods consume (read) characters from the
														
 
															+front of the buffer.
														
 
															+</li>
														
 
															+<li>
														
 
															+Other methods, like <tt>buf:tostring()</tt> only read the buffer
														
 
															+contents, but don't change the buffer.
														
 
															+</li>
														
 
															+<li>
														
 
															+The <tt>buf:set()</tt> method allows zero-copy consumption of a string
														
 
															+or an FFI cdata object as a buffer.
														
 
															+</li>
														
 
															+<li>
														
 
															+The FFI-specific methods allow zero-copy read/write-style operations or
														
 
															+modifying the buffer contents in-place. Please check the
														
 
															+<a href="#ffi_caveats">FFI caveats</a> below, too.
														
 
															+</li>
														
 
															+<li>
														
 
															+Methods that don't need to return anything specific, return the buffer
														
 
															+object itself as a convenience. This allows method chaining, e.g.:
														
 
															+<tt>buf:reset():encode(obj)</tt> or <tt>buf:skip(len):get()</tt>
														
 
															+</li>
														
 
															+</ul>
														
 
															+
														
 
															+<h2 id="create">Buffer Creation and Management</h2>
														
 
															+
														
 
															+<h3 id="buffer_new"><tt>local buf = buffer.new([size [,options]])<br>
														
 
															+local buf = buffer.new([options])</tt></h3>
														
 
															+<p>
														
 
															+Creates a new buffer object.
														
 
															+</p>
														
 
															+<p>
														
 
															+The optional <tt>size</tt> argument ensures a minimum initial buffer
														
 
															+size. This is strictly an optimization when the required buffer size is
														
 
															+known beforehand. The buffer space will grow as needed, in any case.
														
 
															+</p>
														
 
															+<p>
														
 
															+The optional table <tt>options</tt> sets various
														
 
															+<a href="#serialize_options">serialization options</a>.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="buffer_reset"><tt>buf = buf:reset()</tt></h3>
														
 
															+<p>
														
 
															+Reset (empty) the buffer. The allocated buffer space is not freed and
														
 
															+may be reused.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="buffer_free"><tt>buf = buf:free()</tt></h3>
														
 
															+<p>
														
 
															+The buffer space of the buffer object is freed. The object itself
														
 
															+remains intact, empty and may be reused.
														
 
															+</p>
														
 
															+<p>
														
 
															+Note: you normally don't need to use this method. The garbage collector
														
 
															+automatically frees the buffer space, when the buffer object is
														
 
															+collected. Use this method, if you need to free the associated memory
														
 
															+immediately.
														
 
															+</p>
														
 
															+
														
 
															+<h2 id="write">Buffer Writers</h2>
														
 
															+
														
 
															+<h3 id="buffer_put"><tt>buf = buf:put([str|num|obj] [,…])</tt></h3>
														
 
															+<p>
														
 
															+Appends a string <tt>str</tt>, a number <tt>num</tt> or any object
														
 
															+<tt>obj</tt> with a <tt>__tostring</tt> metamethod to the buffer.
														
 
															+Multiple arguments are appended in the given order.
														
 
															+</p>
														
 
															+<p>
														
 
															+Appending a buffer to a buffer is possible and short-circuited
														
 
															+internally. But it still involves a copy. Better combine the buffer
														
 
															+writes to use a single buffer.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="buffer_putf"><tt>buf = buf:putf(format, …)</tt></h3>
														
 
															+<p>
														
 
															+Appends the formatted arguments to the buffer. The <tt>format</tt>
														
 
															+string supports the same options as <tt>string.format()</tt>.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="buffer_putcdata"><tt>buf = buf:putcdata(cdata, len)</tt><span class="lib">FFI</span></h3>
														
 
															+<p>
														
 
															+Appends the given <tt>len</tt> number of bytes from the memory pointed
														
 
															+to by the FFI <tt>cdata</tt> object to the buffer. The object needs to
														
 
															+be convertible to a (constant) pointer.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="buffer_set"><tt>buf = buf:set(str)<br>
														
 
															+buf = buf:set(cdata, len)</tt><span class="lib">FFI</span></h3>
														
 
															+<p>
														
 
															+This method allows zero-copy consumption of a string or an FFI cdata
														
 
															+object as a buffer. It stores a reference to the passed string
														
 
															+<tt>str</tt> or the FFI <tt>cdata</tt> object in the buffer. Any buffer
														
 
															+space originally allocated is freed. This is <i>not</i> an append
														
 
															+operation, unlike the <tt>buf:put*()</tt> methods.
														
 
															+</p>
														
 
															+<p>
														
 
															+After calling this method, the buffer behaves as if
														
 
															+<tt>buf:free():put(str)</tt> or <tt>buf:free():put(cdata,&nbsp;len)</tt>
														
 
															+had been called. However, the data is only referenced and not copied, as
														
 
															+long as the buffer is only consumed.
														
 
															+</p>
														
 
															+<p>
														
 
															+In case the buffer is written to later on, the referenced data is copied
														
 
															+and the object reference is removed (copy-on-write semantics).
														
 
															+</p>
														
 
															+<p>
														
 
															+The stored reference is an anchor for the garbage collector and keeps the
														
 
															+originally passed string or FFI cdata object alive.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="buffer_reserve"><tt>ptr, len = buf:reserve(size)</tt><span class="lib">FFI</span><br>
														
 
															+<tt>buf = buf:commit(used)</tt><span class="lib">FFI</span></h3>
														
 
															+<p>
														
 
															+The <tt>reserve</tt> method reserves at least <tt>size</tt> bytes of
														
 
															+write space in the buffer. It returns an <tt>uint8_t&nbsp;*</tt> FFI
														
 
															+cdata pointer <tt>ptr</tt> that points to this space.
														
 
															+</p>
														
 
															+<p>
														
 
															+The available length in bytes is returned in <tt>len</tt>. This is at
														
 
															+least <tt>size</tt> bytes, but may be more to facilitate efficient
														
 
															+buffer growth. You can either make use of the additional space or ignore
														
 
															+<tt>len</tt> and only use <tt>size</tt> bytes.
														
 
															+</p>
														
 
															+<p>
														
 
															+The <tt>commit</tt> method appends the <tt>used</tt> bytes of the
														
 
															+previously returned write space to the buffer data.
														
 
															+</p>
														
 
															+<p>
														
 
															+This pair of methods allows zero-copy use of C read-style APIs:
														
 
															+</p>
														
 
															+<pre class="code">
														
 
															+local MIN_SIZE = 65536
														
 
															+repeat
														
 
															+  local ptr, len = buf:reserve(MIN_SIZE)
														
 
															+  local n = C.read(fd, ptr, len)
														
 
															+  if n == 0 then break end -- EOF.
														
 
															+  if n &lt; 0 then error("read error") end
														
 
															+  buf:commit(n)
														
 
															+until false
														
 
															+</pre>
														
 
															+<p>
														
 
															+The reserved write space is <i>not</i> initialized. At least the
														
 
															+<tt>used</tt> bytes <b>must</b> be written to before calling the
														
 
															+<tt>commit</tt> method. There's no need to call the <tt>commit</tt>
														
 
															+method, if nothing is added to the buffer (e.g. on error).
														
 
															+</p>
														
 
															+
														
 
															+<h2 id="read">Buffer Readers</h2>
														
 
															+
														
 
															+<h3 id="buffer_length"><tt>len = #buf</tt></h3>
														
 
															+<p>
														
 
															+Returns the current length of the buffer data in bytes.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="buffer_concat"><tt>res = str|num|buf .. str|num|buf […]</tt></h3>
														
 
															+<p>
														
 
															+The Lua concatenation operator <tt>..</tt> also accepts buffers, just
														
 
															+like strings or numbers. It always returns a string and not a buffer.
														
 
															+</p>
														
 
															+<p>
														
 
															+Note that although this is supported for convenience, this thwarts one
														
 
															+of the main reasons to use buffers, which is to avoid string
														
 
															+allocations. Rewrite it with <tt>buf:put()</tt> and <tt>buf:get()</tt>.
														
 
															+</p>
														
 
															+<p>
														
 
															+Mixing this with unrelated objects that have a <tt>__concat</tt>
														
 
															+metamethod may not work, since these probably only expect strings.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="buffer_skip"><tt>buf = buf:skip(len)</tt></h3>
														
 
															+<p>
														
 
															+Skips (consumes) <tt>len</tt> bytes from the buffer up to the current
														
 
															+length of the buffer data.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="buffer_get"><tt>str, … = buf:get([len|nil] [,…])</tt></h3>
														
 
															+<p>
														
 
															+Consumes the buffer data and returns one or more strings. If called
														
 
															+without arguments, the whole buffer data is consumed. If called with a
														
 
															+number, up to <tt>len</tt> bytes are consumed. A <tt>nil</tt> argument
														
 
															+consumes the remaining buffer space (this only makes sense as the last
														
 
															+argument). Multiple arguments consume the buffer data in the given
														
 
															+order.
														
 
															+</p>
														
 
															+<p>
														
 
															+Note: a zero length or no remaining buffer data returns an empty string
														
 
															+and not <tt>nil</tt>.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="buffer_tostring"><tt>str = buf:tostring()<br>
														
 
															+str = tostring(buf)</tt></h3>
														
 
															+<p>
														
 
															+Creates a string from the buffer data, but doesn't consume it. The
														
 
															+buffer remains unchanged.
														
 
															+</p>
														
 
															+<p>
														
 
															+Buffer objects also define a <tt>__tostring</tt> metamethod. This means
														
 
															+buffers can be passed to the global <tt>tostring()</tt> function and
														
 
															+many other functions that accept this in place of strings. The important
														
 
															+internal uses in functions like <tt>io.write()</tt> are short-circuited
														
 
															+to avoid the creation of an intermediate string object.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="buffer_ref"><tt>ptr, len = buf:ref()</tt><span class="lib">FFI</span></h3>
														
 
															+<p>
														
 
															+Returns an <tt>uint8_t&nbsp;*</tt> FFI cdata pointer <tt>ptr</tt> that
														
 
															+points to the buffer data. The length of the buffer data in bytes is
														
 
															+returned in <tt>len</tt>.
														
 
															+</p>
														
 
															+<p>
														
 
															+The returned pointer can be directly passed to C functions that expect a
														
 
															+buffer and a length. You can also do bytewise reads
														
 
															+(<tt>local&nbsp;x&nbsp;=&nbsp;ptr[i]</tt>) or writes
														
 
															+(<tt>ptr[i]&nbsp;=&nbsp;0x40</tt>) of the buffer data.
														
 
															+</p>
														
 
															+<p>
														
 
															+In conjunction with the <tt>skip</tt> method, this allows zero-copy use
														
 
															+of C write-style APIs:
														
 
															+</p>
														
 
															+<pre class="code">
														
 
															+repeat
														
 
															+  local ptr, len = buf:ref()
														
 
															+  if len == 0 then break end
														
 
															+  local n = C.write(fd, ptr, len)
														
 
															+  if n &lt; 0 then error("write error") end
														
 
															+  buf:skip(n)
														
 
															+until n >= len
														
 
															+</pre>
														
 
															+<p>
														
 
															+Unlike Lua strings, buffer data is <i>not</i> implicitly
														
 
															+zero-terminated. It's not safe to pass <tt>ptr</tt> to C functions that
														
 
															+expect zero-terminated strings. If you're not using <tt>len</tt>, then
														
 
															+you're doing something wrong.
														
 
															+</p>
														
 
															+
														
 
															+<h2 id="serialize">Serialization of Lua Objects</h2>
														
 
															+<p>
														
 
															+The following functions and methods allow <b>high-speed serialization</b>
														
 
															+(encoding) of a Lua object into a string and decoding it back to a Lua
														
 
															+object. This allows convenient storage and transport of <b>structured
														
 
															+data</b>.
														
 
															+</p>
														
 
															+<p>
														
 
															+The encoded data is in an <a href="#serialize_format">internal binary
														
 
															+format</a>. The data can be stored in files, binary-transparent
														
 
															+databases or transmitted to other LuaJIT instances across threads,
														
 
															+processes or networks.
														
 
															+</p>
														
 
															+<p>
														
 
															+Encoding speed can reach up to 1 Gigabyte/second on a modern desktop- or
														
 
															+server-class system, even when serializing many small objects. Decoding
														
 
															+speed is mostly constrained by object creation cost.
														
 
															+</p>
														
 
															+<p>
														
 
															+The serializer handles most Lua types, common FFI number types and
														
 
															+nested structures. Functions, thread objects, other FFI cdata and full
														
 
															+userdata cannot be serialized (yet).
														
 
															+</p>
														
 
															+<p>
														
 
															+The encoder serializes nested structures as trees. Multiple references
														
 
															+to a single object will be stored separately and create distinct objects
														
 
															+after decoding. Circular references cause an error.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="serialize_methods">Serialization Functions and Methods</h3>
														
 
															+
														
 
															+<h3 id="buffer_encode"><tt>str = buffer.encode(obj)<br>
														
 
															+buf = buf:encode(obj)</tt></h3>
														
 
															+<p>
														
 
															+Serializes (encodes) the Lua object <tt>obj</tt>. The stand-alone
														
 
															+function returns a string <tt>str</tt>. The buffer method appends the
														
 
															+encoding to the buffer.
														
 
															+</p>
														
 
															+<p>
														
 
															+<tt>obj</tt> can be any of the supported Lua types &mdash; it doesn't
														
 
															+need to be a Lua table.
														
 
															+</p>
														
 
															+<p>
														
 
															+This function may throw an error when attempting to serialize
														
 
															+unsupported object types, circular references or deeply nested tables.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="buffer_decode"><tt>obj = buffer.decode(str)<br>
														
 
															+obj = buf:decode()</tt></h3>
														
 
															+<p>
														
 
															+The stand-alone function de-serializes (decodes) the string
														
 
															+<tt>str</tt>, the buffer method de-serializes one object from the
														
 
															+buffer. Both return a Lua object <tt>obj</tt>.
														
 
															+</p>
														
 
															+<p>
														
 
															+The returned object may be any of the supported Lua types &mdash;
														
 
															+even <tt>nil</tt>.
														
 
															+</p>
														
 
															+<p>
														
 
															+This function may throw an error when fed with malformed or incomplete
														
 
															+encoded data. The stand-alone function throws when there's left-over
														
 
															+data after decoding a single top-level object. The buffer method leaves
														
 
															+any left-over data in the buffer.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="serialize_options">Serialization Options</h3>
														
 
															+<p>
														
 
															+The <tt>options</tt> table passed to <tt>buffer.new()</tt> may contain
														
 
															+the following members (all optional):
														
 
															+</p>
														
 
															+<ul>
														
 
															+<li>
														
 
															+<tt>dict</tt> is a Lua table holding a <b>dictionary of strings</b> that
														
 
															+commonly occur as table keys of objects you are serializing. These keys
														
 
															+are compactly encoded as indexes during serialization. A well chosen
														
 
															+dictionary saves space and improves serialization performance.
														
 
															+</li>
														
 
															+<li>
														
 
															+<tt>metatable</tt> is a Lua table holding a <b>dictionary of metatables</b>
														
 
															+for the table objects you are serializing.
														
 
															+</li>
														
 
															+</ul>
														
 
															+<p>
														
 
															+<tt>dict</tt> needs to be an array of strings and <tt>metatable</tt> needs
														
 
															+to be an array of tables. Both starting at index 1 and without holes (no
														
 
															+<tt>nil</tt> inbetween). The tables are anchored in the buffer object and
														
 
															+internally modified into a two-way index (don't do this yourself, just pass
														
 
															+a plain array). The tables must not be modified after they have been passed
														
 
															+to <tt>buffer.new()</tt>.
														
 
															+</p>
														
 
															+<p>
														
 
															+The <tt>dict</tt> and <tt>metatable</tt> tables used by the encoder and
														
 
															+decoder must be the same. Put the most common entries at the front. Extend
														
 
															+at the end to ensure backwards-compatibility &mdash; older encodings can
														
 
															+then still be read. You may also set some indexes to <tt>false</tt> to
														
 
															+explicitly drop backwards-compatibility. Old encodings that use these
														
 
															+indexes will throw an error when decoded.
														
 
															+</p>
														
 
															+<p>
														
 
															+Metatables that are not found in the <tt>metatable</tt> dictionary are
														
 
															+ignored when encoding. Decoding returns a table with a <tt>nil</tt>
														
 
															+metatable.
														
 
															+</p>
														
 
															+<p>
														
 
															+Note: parsing and preparation of the options table is somewhat
														
 
															+expensive. Create a buffer object only once and recycle it for multiple
														
 
															+uses. Avoid mixing encoder and decoder buffers, since the
														
 
															+<tt>buf:set()</tt> method frees the already allocated buffer space:
														
 
															+</p>
														
 
															+<pre class="code">
														
 
															+local options = {
														
 
															+  dict = { "commonly", "used", "string", "keys" },
														
 
															+}
														
 
															+local buf_enc = buffer.new(options)
														
 
															+local buf_dec = buffer.new(options)
														
 
															+
														
 
															+local function encode(obj)
														
 
															+  return buf_enc:reset():encode(obj):get()
														
 
															+end
														
 
															+
														
 
															+local function decode(str)
														
 
															+  return buf_dec:set(str):decode()
														
 
															+end
														
 
															+</pre>
														
 
															+
														
 
															+<h3 id="serialize_stream">Streaming Serialization</h3>
														
 
															+<p>
														
 
															+In some contexts, it's desirable to do piecewise serialization of large
														
 
															+datasets, also known as <i>streaming</i>.
														
 
															+</p>
														
 
															+<p>
														
 
															+This serialization format can be safely concatenated and supports streaming.
														
 
															+Multiple encodings can simply be appended to a buffer and later decoded
														
 
															+individually:
														
 
															+</p>
														
 
															+<pre class="code">
														
 
															+local buf = buffer.new()
														
 
															+buf:encode(obj1)
														
 
															+buf:encode(obj2)
														
 
															+local copy1 = buf:decode()
														
 
															+local copy2 = buf:decode()
														
 
															+</pre>
														
 
															+<p>
														
 
															+Here's how to iterate over a stream:
														
 
															+</p>
														
 
															+<pre class="code">
														
 
															+while #buf ~= 0 do
														
 
															+  local obj = buf:decode()
														
 
															+  -- Do something with obj.
														
 
															+end
														
 
															+</pre>
														
 
															+<p>
														
 
															+Since the serialization format doesn't prepend a length to its encoding,
														
 
															+network applications may need to transmit the length, too.
														
 
															+</p>
														
 
															+
														
 
															+<h3 id="serialize_format">Serialization Format Specification</h3>
														
 
															+<p>
														
 
															+This serialization format is designed for <b>internal use</b> by LuaJIT
														
 
															+applications. Serialized data is upwards-compatible and portable across
														
 
															+all supported LuaJIT platforms.
														
 
															+</p>
														
 
															+<p>
														
 
															+It's an <b>8-bit binary format</b> and not human-readable. It uses e.g.
														
 
															+embedded zeroes and stores embedded Lua string objects unmodified, which
														
 
															+are 8-bit-clean, too. Encoded data can be safely concatenated for
														
 
															+streaming and later decoded one top-level object at a time.
														
 
															+</p>
														
 
															+<p>
														
 
															+The encoding is reasonably compact, but tuned for maximum performance,
														
 
															+not for minimum space usage. It compresses well with any of the common
														
 
															+byte-oriented data compression algorithms.
														
 
															+</p>
														
 
															+<p>
														
 
															+Although documented here for reference, this format is explicitly
														
 
															+<b>not</b> intended to be a 'public standard' for structured data
														
 
															+interchange across computer languages (like JSON or MessagePack). Please
														
 
															+do not use it as such.
														
 
															+</p>
														
 
															+<p>
														
 
															+The specification is given below as a context-free grammar with a
														
 
															+top-level <tt>object</tt> as the starting point. Alternatives are
														
 
															+separated by the <tt>|</tt> symbol and <tt>*</tt> indicates repeats.
														
 
															+Grouping is implicit or indicated by <tt>{…}</tt>. Terminals are
														
 
															+either plain hex numbers, encoded as bytes, or have a <tt>.format</tt>
														
 
															+suffix.
														
 
															+</p>
														
 
															+<pre>
														
 
															+object    → nil | false | true
														
 
															+          | null | lightud32 | lightud64
														
 
															+          | int | num | tab | tab_mt
														
 
															+          | int64 | uint64 | complex
														
 
															+          | string
														
 
															+
														
 
															+nil       → 0x00
														
 
															+false     → 0x01
														
 
															+true      → 0x02
														
 
															+
														
 
															+null      → 0x03                            // NULL lightuserdata
														
 
															+lightud32 → 0x04 data.I                   // 32 bit lightuserdata
														
 
															+lightud64 → 0x05 data.L                   // 64 bit lightuserdata
														
 
															+
														
 
															+int       → 0x06 int.I                                 // int32_t
														
 
															+num       → 0x07 double.L
														
 
															+
														
 
															+tab       → 0x08                                   // Empty table
														
 
															+          | 0x09 h.U h*{object object}          // Key/value hash
														
 
															+          | 0x0a a.U a*object                    // 0-based array
														
 
															+          | 0x0b a.U a*object h.U h*{object object}      // Mixed
														
 
															+          | 0x0c a.U (a-1)*object                // 1-based array
														
 
															+          | 0x0d a.U (a-1)*object h.U h*{object object}  // Mixed
														
 
															+tab_mt    → 0x0e (index-1).U tab          // Metatable dict entry
														
 
															+
														
 
															+int64     → 0x10 int.L                             // FFI int64_t
														
 
															+uint64    → 0x11 uint.L                           // FFI uint64_t
														
 
															+complex   → 0x12 re.L im.L                         // FFI complex
														
 
															+
														
 
															+string    → (0x20+len).U len*char.B
														
 
															+          | 0x0f (index-1).U                 // String dict entry
														
 
															+
														
 
															+.B = 8 bit
														
 
															+.I = 32 bit little-endian
														
 
															+.L = 64 bit little-endian
														
 
															+.U = prefix-encoded 32 bit unsigned number n:
														
 
															+     0x00..0xdf   → n.B
														
 
															+     0xe0..0x1fdf → (0xe0|(((n-0xe0)>>8)&0x1f)).B ((n-0xe0)&0xff).B
														
 
															+   0x1fe0..       → 0xff n.I
														
 
															+</pre>
														
 
															+
														
 
															+<h2 id="error">Error handling</h2>
														
 
															+<p>
														
 
															+Many of the buffer methods can throw an error. Out-of-memory or usage
														
 
															+errors are best caught with an outer wrapper for larger parts of code.
														
 
															+There's not much one can do after that, anyway.
														
 
															+</p>
														
 
															+<p>
														
 
															+OTOH you may want to catch some errors individually. Buffer methods need
														
 
															+to receive the buffer object as the first argument. The Lua colon-syntax
														
 
															+<tt>obj:method()</tt> does that implicitly. But to wrap a method with
														
 
															+<tt>pcall()</tt>, the arguments need to be passed like this:
														
 
															+</p>
														
 
															+<pre class="code">
														
 
															+local ok, err = pcall(buf.encode, buf, obj)
														
 
															+if not ok then
														
 
															+  -- Handle error in err.
														
 
															+end
														
 
															+</pre>
														
 
															+
														
 
															+<h2 id="ffi_caveats">FFI caveats</h2>
														
 
															+<p>
														
 
															+The string buffer library has been designed to work well together with
														
 
															+the FFI library. But due to the low-level nature of the FFI library,
														
 
															+some care needs to be taken:
														
 
															+</p>
														
 
															+<p>
														
 
															+First, please remember that FFI pointers are zero-indexed. The space
														
 
															+returned by <tt>buf:reserve()</tt> and <tt>buf:ref()</tt> starts at the
														
 
															+returned pointer and ends before <tt>len</tt> bytes after that.
														
 
															+</p>
														
 
															+<p>
														
 
															+I.e. the first valid index is <tt>ptr[0]</tt> and the last valid index
														
 
															+is <tt>ptr[len-1]</tt>. If the returned length is zero, there's no valid
														
 
															+index at all. The returned pointer may even be <tt>NULL</tt>.
														
 
															+</p>
														
 
															+<p>
														
 
															+The space pointed to by the returned pointer is only valid as long as
														
 
															+the buffer is not modified in any way (neither append, nor consume, nor
														
 
															+reset, etc.). The pointer is also not a GC anchor for the buffer object
														
 
															+itself.
														
 
															+</p>
														
 
															+<p>
														
 
															+Buffer data is only guaranteed to be byte-aligned. Casting the returned
														
 
															+pointer to a data type with higher alignment may cause unaligned
														
 
															+accesses. It depends on the CPU architecture whether this is allowed or
														
 
															+not (it's always OK on x86/x64 and mostly OK on other modern
														
 
															+architectures).
														
 
															+</p>
														
 
															+<p>
														
 
															+FFI pointers or references do not count as GC anchors for an underlying
														
 
															+object. E.g. an <tt>array</tt> allocated with <tt>ffi.new()</tt> is
														
 
															+anchored by <tt>buf:set(array,&nbsp;len)</tt>, but not by
														
 
															+<tt>buf:set(array+offset,&nbsp;len)</tt>. The addition of the offset
														
 
															+creates a new pointer, even when the offset is zero. In this case, you
														
 
															+need to make sure there's still a reference to the original array as
														
 
															+long as its contents are in use by the buffer.
														
 
															+</p>
														
 
															+<p>
														
 
															+Even though each LuaJIT VM instance is single-threaded (but you can
														
 
															+create multiple VMs), FFI data structures can be accessed concurrently.
														
 
															+Be careful when reading/writing FFI cdata from/to buffers to avoid
														
 
															+concurrent accesses or modifications. In particular, the memory
														
 
															+referenced by <tt>buf:set(cdata,&nbsp;len)</tt> must not be modified
														
 
															+while buffer readers are working on it. Shared, but read-only memory
														
 
															+mappings of files are OK, but only if the file does not change.
														
 
															+</p>
														
 
															+<br class="flush">
														
 
															+</div>
														
 
															+<div id="foot">
														
 
															+<hr class="hide">
														
 
															+Copyright &copy; 2005-2021
														
 
															+<span class="noprint">
														
 
															+&middot;
														
 
															+<a href="contact.html">Contact</a>
														
 
															+</span>
														
 
															+</div>
														
 
															+</body>
														
 
															+</html>
														
--- a/libs/LuaJIT/doc/ext_c_api.html
+++ b/libs/LuaJIT/doc/ext_c_api.html
@@ -1,8 +1,8 @@
 
															-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
														
 
															+<!DOCTYPE html>
														
 
															 <html>
														
 
															 <head>
														
 
															 <title>Lua/C API Extensions</title>
														
 
															-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
														
 
															+<meta charset="utf-8">
														
 
															 <meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															 <meta name="Language" content="en">
														
 
															 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
@@ -37,6 +37,8 @@
 
															 <a href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															 </li></ul>
														
 
															 </li><li>
														
 
															+<a href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															 <a href="ext_jit.html">jit.* Library</a>
														
 
															 </li><li>
														
 
															 <a class="current" href="ext_c_api.html">Lua/C API</a>
														
--- a/libs/LuaJIT/doc/ext_ffi.html
+++ b/libs/LuaJIT/doc/ext_ffi.html
@@ -1,8 +1,8 @@
 
															-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
														
 
															+<!DOCTYPE html>
														
 
															 <html>
														
 
															 <head>
														
 
															 <title>FFI Library</title>
														
 
															-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
														
 
															+<meta charset="utf-8">
														
 
															 <meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															 <meta name="Language" content="en">
														
 
															 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
@@ -37,6 +37,8 @@
 
															 <a href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															 </li></ul>
														
 
															 </li><li>
														
 
															+<a href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															 <a href="ext_jit.html">jit.* Library</a>
														
 
															 </li><li>
														
 
															 <a href="ext_c_api.html">Lua/C API</a>
														
--- a/libs/LuaJIT/doc/ext_ffi_api.html
+++ b/libs/LuaJIT/doc/ext_ffi_api.html
@@ -1,8 +1,8 @@
 
															-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
														
 
															+<!DOCTYPE html>
														
 
															 <html>
														
 
															 <head>
														
 
															 <title>ffi.* API Functions</title>
														
 
															-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
														
 
															+<meta charset="utf-8">
														
 
															 <meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															 <meta name="Language" content="en">
														
 
															 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
@@ -42,6 +42,8 @@ td.abiparam { font-weight: bold; width: 6em; }
 
															 <a href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															 </li></ul>
														
 
															 </li><li>
														
 
															+<a href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															 <a href="ext_jit.html">jit.* Library</a>
														
 
															 </li><li>
														
 
															 <a href="ext_c_api.html">Lua/C API</a>
														
--- a/libs/LuaJIT/doc/ext_ffi_semantics.html
+++ b/libs/LuaJIT/doc/ext_ffi_semantics.html
@@ -1,8 +1,8 @@
 
															-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
														
 
															+<!DOCTYPE html>
														
 
															 <html>
														
 
															 <head>
														
 
															 <title>FFI Semantics</title>
														
 
															-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
														
 
															+<meta charset="utf-8">
														
 
															 <meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															 <meta name="Language" content="en">
														
 
															 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
@@ -42,6 +42,8 @@ td.convop { font-style: italic; width: 40%; }
 
															 <a class="current" href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															 </li></ul>
														
 
															 </li><li>
														
 
															+<a href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															 <a href="ext_jit.html">jit.* Library</a>
														
 
															 </li><li>
														
 
															 <a href="ext_c_api.html">Lua/C API</a>
														
--- a/libs/LuaJIT/doc/ext_ffi_tutorial.html
+++ b/libs/LuaJIT/doc/ext_ffi_tutorial.html
@@ -1,8 +1,8 @@
 
															-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
														
 
															+<!DOCTYPE html>
														
 
															 <html>
														
 
															 <head>
														
 
															 <title>FFI Tutorial</title>
														
 
															-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
														
 
															+<meta charset="utf-8">
														
 
															 <meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															 <meta name="Language" content="en">
														
 
															 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
@@ -44,6 +44,8 @@ td.idiomlua b { font-weight: normal; color: #2142bf; }
 
															 <a href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															 </li></ul>
														
 
															 </li><li>
														
 
															+<a href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															 <a href="ext_jit.html">jit.* Library</a>
														
 
															 </li><li>
														
 
															 <a href="ext_c_api.html">Lua/C API</a>
														
--- a/libs/LuaJIT/doc/ext_jit.html
+++ b/libs/LuaJIT/doc/ext_jit.html
@@ -1,8 +1,8 @@
 
															-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
														
 
															+<!DOCTYPE html>
														
 
															 <html>
														
 
															 <head>
														
 
															 <title>jit.* Library</title>
														
 
															-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
														
 
															+<meta charset="utf-8">
														
 
															 <meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															 <meta name="Language" content="en">
														
 
															 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
@@ -37,6 +37,8 @@
 
															 <a href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															 </li></ul>
														
 
															 </li><li>
														
 
															+<a href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															 <a class="current" href="ext_jit.html">jit.* Library</a>
														
 
															 </li><li>
														
 
															 <a href="ext_c_api.html">Lua/C API</a>
														
--- a/libs/LuaJIT/doc/ext_profiler.html
+++ b/libs/LuaJIT/doc/ext_profiler.html
@@ -1,8 +1,8 @@
 
															-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
														
 
															+<!DOCTYPE html>
														
 
															 <html>
														
 
															 <head>
														
 
															 <title>Profiler</title>
														
 
															-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
														
 
															+<meta charset="utf-8">
														
 
															 <meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															 <meta name="Language" content="en">
														
 
															 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
@@ -37,6 +37,8 @@
 
															 <a href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															 </li></ul>
														
 
															 </li><li>
														
 
															+<a href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															 <a href="ext_jit.html">jit.* Library</a>
														
 
															 </li><li>
														
 
															 <a href="ext_c_api.html">Lua/C API</a>
														
--- a/libs/LuaJIT/doc/extensions.html
+++ b/libs/LuaJIT/doc/extensions.html
@@ -1,8 +1,8 @@
 
															-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
														
 
															+<!DOCTYPE html>
														
 
															 <html>
														
 
															 <head>
														
 
															 <title>Extensions</title>
														
 
															-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
														
 
															+<meta charset="utf-8">
														
 
															 <meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															 <meta name="Language" content="en">
														
 
															 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
@@ -54,6 +54,8 @@ td.excinterop {
 
															 <a href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															 </li></ul>
														
 
															 </li><li>
														
 
															+<a href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															 <a href="ext_jit.html">jit.* Library</a>
														
 
															 </li><li>
														
 
															 <a href="ext_c_api.html">Lua/C API</a>
														
@@ -392,29 +394,19 @@ the toolchain used to compile LuaJIT:
 
															 <td class="excinterop">Interoperability</td>
														
 
															 </tr>
														
 
															 <tr class="odd separate">
														
 
															-<td class="excplatform">POSIX/x64, DWARF2 unwinding</td>
														
 
															-<td class="exccompiler">GCC 4.3+, Clang</td>
														
 
															+<td class="excplatform">External frame unwinding</td>
														
 
															+<td class="exccompiler">GCC, Clang, MSVC</td>
														
 
															 <td class="excinterop"><b style="color: #00a000;">Full</b></td>
														
 
															 </tr>
														
 
															 <tr class="even">
														
 
															-<td class="excplatform">ARM <tt>-DLUAJIT_UNWIND_EXTERNAL</tt></td>
														
 
															-<td class="exccompiler">GCC, Clang</td>
														
 
															-<td class="excinterop"><b style="color: #00a000;">Full</b></td>
														
 
															-</tr>
														
 
															-<tr class="odd">
														
 
															-<td class="excplatform">Other platforms, DWARF2 unwinding</td>
														
 
															+<td class="excplatform">Internal frame unwinding + DWARF2</td>
														
 
															 <td class="exccompiler">GCC, Clang</td>
														
 
															 <td class="excinterop"><b style="color: #c06000;">Limited</b></td>
														
 
															 </tr>
														
 
															-<tr class="even">
														
 
															-<td class="excplatform">Windows/x64</td>
														
 
															-<td class="exccompiler">MSVC</td>
														
 
															-<td class="excinterop"><b style="color: #00a000;">Full</b></td>
														
 
															-</tr>
														
 
															 <tr class="odd">
														
 
															-<td class="excplatform">Windows/x86</td>
														
 
															-<td class="exccompiler">Any</td>
														
 
															-<td class="excinterop"><b style="color: #00a000;">Full</b></td>
														
 
															+<td class="excplatform">Windows 64 bit</td>
														
 
															+<td class="exccompiler">non-MSVC</td>
														
 
															+<td class="excinterop"><b style="color: #c06000;">Limited</b></td>
														
 
															 </tr>
														
 
															 <tr class="even">
														
 
															 <td class="excplatform">Other platforms</td>
														
@@ -435,7 +427,9 @@ the toolchain used to compile LuaJIT:
 
															 on the C&nbsp;stack. The contents of the C++&nbsp;exception object
														
 
															 pass through unmodified.</li>
														
 
															 <li>Lua errors can be caught on the C++ side with <tt>catch(...)</tt>.
														
 
															-The corresponding Lua error message can be retrieved from the Lua stack.</li>
														
 
															+The corresponding Lua error message can be retrieved from the Lua stack.<br>
														
 
															+For MSVC for Windows 64 bit this requires compilation of your C++ code
														
 
															+with <tt>/EHa</tt>.</li>
														
 
															 <li>Throwing Lua errors across C++ frames is safe. C++ destructors
														
 
															 will be called.</li>
														
 
															 </ul>
														
--- a/libs/LuaJIT/doc/faq.html
+++ b/libs/LuaJIT/doc/faq.html
@@ -1,8 +1,8 @@
 
															-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
														
 
															+<!DOCTYPE html>
														
 
															 <html>
														
 
															 <head>
														
 
															 <title>Frequently Asked Questions (FAQ)</title>
														
 
															-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
														
 
															+<meta charset="utf-8">
														
 
															 <meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															 <meta name="Language" content="en">
														
 
															 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
@@ -40,6 +40,8 @@ dd { margin-left: 1.5em; }
 
															 <a href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															 </li></ul>
														
 
															 </li><li>
														
 
															+<a href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															 <a href="ext_jit.html">jit.* Library</a>
														
 
															 </li><li>
														
 
															 <a href="ext_c_api.html">Lua/C API</a>
														
@@ -74,7 +76,7 @@ about LuaJIT.</li>
 
															 and links to books and papers about Lua.</li>
														
 
															 <li>The community-managed <a href="http://lua-users.org/wiki/"><span class="ext">&raquo;</span>&nbsp;Lua Wiki</a>
														
 
															 has information about diverse topics.</li>
														
 
															-</ul>
														
 
															+</ul></dd>
														
 
															 </dl>
														
 
															 <dl id="tech">
														
@@ -119,8 +121,7 @@ Consider testing your application with older versions, too.<br>
 
															 Similarly, the Borland/Delphi runtime modifies the FPU control word and
														
 
															 enables FP exceptions. Of course this violates the Windows ABI, too.
														
 
															-Please check the Delphi docs for the Set8087CW method.
														
 
															-
														
 
															+Please check the Delphi docs for the Set8087CW method.</dd>
														
 
															 </dl>
														
 
															 <dl id="ctrlc">
														
@@ -133,6 +134,19 @@ You have to press Ctrl-C twice to get stop your program. That's similar
 
															 to when it's stuck running inside a C function under the Lua interpreter.</dd>
														
 
															 </dl>
														
 
															+<dl id="order">
														
 
															+<dt>Q: Table iteration with <tt>pairs()</tt> does not result in the same order?</dt>
														
 
															+<dd>The order of table iteration is explicitly <b>undefined</b> by
														
 
															+the Lua language standard.<br>
														
 
															+Different Lua implementations or versions may use different orders for
														
 
															+otherwise identical tables. Different ways of constructing a table may
														
 
															+result in different orders, too.<br>
														
 
															+Due to improved VM security, LuaJIT 2.1 may even use a different order
														
 
															+on separate VM invocations or when string keys are newly interned.<br><br>
														
 
															+If your program relies on a deterministic order, it has a bug. Rewrite it,
														
 
															+so it doesn't rely on the key order. Or sort the table keys, if you must.</dd>
														
 
															+</dl>
														
 
															+
														
 
															 <dl id="sandbox">
														
 
															 <dt>Q: Can Lua code be safely sandboxed?</dt>
														
 
															 <dd>
														
--- a/libs/LuaJIT/doc/install.html
+++ b/libs/LuaJIT/doc/install.html
@@ -1,8 +1,8 @@
 
															-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
														
 
															+<!DOCTYPE html>
														
 
															 <html>
														
 
															 <head>
														
 
															 <title>Installation</title>
														
 
															-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
														
 
															+<meta charset="utf-8">
														
 
															 <meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															 <meta name="Language" content="en">
														
 
															 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
@@ -65,6 +65,8 @@ td.compatno {
 
															 <a href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															 </li></ul>
														
 
															 </li><li>
														
 
															+<a href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															 <a href="ext_jit.html">jit.* Library</a>
														
 
															 </li><li>
														
 
															 <a href="ext_c_api.html">Lua/C API</a>
														
@@ -186,14 +188,18 @@ Debian/Ubuntu, install <tt>libc6-dev</tt> with the package manager.
 
															 </p>
														
 
															 <p>
														
 
															 The recommended way to fetch the latest version is to do a pull from
														
 
															-the git repository. Alternatively download the latest source package of
														
 
															-LuaJIT (pick the .tar.gz). Move it to a directory of your choice,
														
 
															-open a terminal window and change to this directory. Now unpack the archive
														
 
															-and change to the newly created directory:
														
 
															+the git repository.
														
 
															+</p>
														
 
															+<p>
														
 
															+Alternatively download the latest source package of LuaJIT (pick the .tar.gz).
														
 
															+Move it to a directory of your choice, open a terminal window and change
														
 
															+to this directory. Now unpack the archive and change to the newly created
														
 
															+directory (replace XX.YY.ZZ with the version you downloaded):
														
 
															 </p>
														
 
															 <pre class="code">
														
 
															-tar zxf LuaJIT-2.1.0-beta3.tar.gz
														
 
															-cd LuaJIT-2.1.0-beta3</pre>
														
 
															+tar zxf LuaJIT-XX.YY.ZZ.tar.gz
														
 
															+cd LuaJIT-XX.YY.ZZ
														
 
															+</pre>
														
 
															 <h3>Building LuaJIT</h3>
														
 
															 <p>
														
 
															 The supplied Makefiles try to auto-detect the settings needed for your
														
@@ -405,7 +411,8 @@ NDKCROSS=$NDKBIN/aarch64-linux-android-
 
															 NDKCC=$NDKBIN/aarch64-linux-android21-clang
														
 
															 make CROSS=$NDKCROSS \
														
 
															      STATIC_CC=$NDKCC DYNAMIC_CC="$NDKCC -fPIC" \
														
 
															-     TARGET_LD=$NDKCC
														
 
															+     TARGET_LD=$NDKCC TARGET_AR=$NDKBIN/llvm-ar
														
 
															+     TARGET_STRIP=$NDKBIN/llvm-strip
														
 
															 # Android/ARM, armeabi-v7a (ARMv7 VFP), Android 4.1+ (JB)
														
 
															 NDKDIR=/opt/android/ndk
														
@@ -414,7 +421,8 @@ NDKCROSS=$NDKBIN/arm-linux-androideabi-
 
															 NDKCC=$NDKBIN/armv7a-linux-androideabi16-clang
														
 
															 make HOST_CC="gcc -m32" CROSS=$NDKCROSS \
														
 
															      STATIC_CC=$NDKCC DYNAMIC_CC="$NDKCC -fPIC" \
														
 
															-     TARGET_LD=$NDKCC
														
 
															+     TARGET_LD=$NDKCC TARGET_AR=$NDKBIN/llvm-ar
														
 
															+     TARGET_STRIP=$NDKBIN/llvm-strip
														
 
															 </pre>
														
 
															 <p>
														
 
															 You can cross-compile for <b id="ios">iOS 3.0+</b> (iPhone/iPad) using the <a href="https://developer.apple.com/ios/"><span class="ext">&raquo;</span>&nbsp;iOS SDK</a>:
														
--- a/libs/LuaJIT/doc/luajit.html
+++ b/libs/LuaJIT/doc/luajit.html
@@ -1,8 +1,8 @@
 
															-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
														
 
															+<!DOCTYPE html>
														
 
															 <html>
														
 
															 <head>
														
 
															 <title>LuaJIT</title>
														
 
															-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
														
 
															+<meta charset="utf-8">
														
 
															 <meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															 <meta name="Language" content="en">
														
 
															 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
@@ -122,6 +122,8 @@ table.feature small {
 
															 <a href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															 </li></ul>
														
 
															 </li><li>
														
 
															+<a href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															 <a href="ext_jit.html">jit.* Library</a>
														
 
															 </li><li>
														
 
															 <a href="ext_c_api.html">Lua/C API</a>
														
--- a/libs/LuaJIT/doc/running.html
+++ b/libs/LuaJIT/doc/running.html
@@ -1,8 +1,8 @@
 
															-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
														
 
															+<!DOCTYPE html>
														
 
															 <html>
														
 
															 <head>
														
 
															 <title>Running LuaJIT</title>
														
 
															-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
														
 
															+<meta charset="utf-8">
														
 
															 <meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															 <meta name="Language" content="en">
														
 
															 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
@@ -59,6 +59,8 @@ td.param_default {
 
															 <a href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															 </li></ul>
														
 
															 </li><li>
														
 
															+<a href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															 <a href="ext_jit.html">jit.* Library</a>
														
 
															 </li><li>
														
 
															 <a href="ext_c_api.html">Lua/C API</a>
														
@@ -183,8 +185,8 @@ itself. For a description of their options and output format, please
 
															 read the comment block at the start of their source.
														
 
															 They can be found in the <tt>lib</tt> directory of the source
														
 
															 distribution or installed under the <tt>jit</tt> directory. By default
														
 
															-this is <tt>/usr/local/share/luajit-2.1.0-beta3/jit</tt> on POSIX
														
 
															-systems.
														
 
															+this is <tt>/usr/local/share/luajit-XX.YY.ZZ>/jit</tt> on POSIX
														
 
															+systems (replace XX.YY.ZZ by the installed version).
														
 
															 </p>
														
 
															 <h3 id="opt_O"><tt>-O[level]</tt><br>
														
--- a/libs/LuaJIT/doc/status.html
+++ b/libs/LuaJIT/doc/status.html
@@ -1,8 +1,8 @@
 
															-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
														
 
															+<!DOCTYPE html>
														
 
															 <html>
														
 
															 <head>
														
 
															 <title>Status</title>
														
 
															-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
														
 
															+<meta charset="utf-8">
														
 
															 <meta name="Copyright" content="Copyright (C) 2005-2021">
														
 
															 <meta name="Language" content="en">
														
 
															 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
														
@@ -40,6 +40,8 @@ ul li { padding-bottom: 0.3em; }
 
															 <a href="ext_ffi_semantics.html">FFI Semantics</a>
														
 
															 </li></ul>
														
 
															 </li><li>
														
 
															+<a href="ext_buffer.html">String Buffers</a>
														
 
															+</li><li>
														
 
															 <a href="ext_jit.html">jit.* Library</a>
														
 
															 </li><li>
														
 
															 <a href="ext_c_api.html">Lua/C API</a>
														
@@ -90,12 +92,6 @@ The Lua <b>debug API</b> is missing a couple of features (return
 
															 hooks for non-Lua functions) and shows slightly different behavior
														
 
															 in LuaJIT (no per-coroutine hooks, no tail call counting).
														
 
															 </li>
														
 
															-<li>
														
 
															-Currently some <b>out-of-memory</b> errors from <b>on-trace code</b> are not
														
 
															-handled correctly. The error may fall through an on-trace
														
 
															-<tt>pcall</tt> or it may be passed on to the function set with
														
 
															-<tt>lua_atpanic</tt> on x64.
														
 
															-</li>
														
 
															 </ul>
														
 
															 <br class="flush">
														
 
															 </div>
														
--- a/libs/LuaJIT/dynasm/dasm_arm.h
+++ b/libs/LuaJIT/dynasm/dasm_arm.h
@@ -294,7 +294,7 @@ int dasm_link(Dst_DECL, size_t *szp)
 
															   { /* Handle globals not defined in this translation unit. */
														
 
															     int idx;
														
 
															-    for (idx = 20; idx*sizeof(int) < D->lgsize; 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; }
														
@@ -371,7 +371,10 @@ int dasm_encode(Dst_DECL, void *buffer)
 
															 	  ins &= 255; while ((((char *)cp - base) & ins)) *cp++ = 0xe1a00000;
														
 
															 	  break;
														
 
															 	case DASM_REL_LG:
														
 
															-	  CK(n >= 0, UNDEF_LG);
														
 
															+	  if (n < 0) {
														
 
															+	    n = (int)((ptrdiff_t)D->globals[-n] - (ptrdiff_t)cp - 4);
														
 
															+	    goto patchrel;
														
 
															+	  }
														
 
															 	  /* fallthrough */
														
 
															 	case DASM_REL_PC:
														
 
															 	  CK(n >= 0, UNDEF_PC);
														
--- a/libs/LuaJIT/dynasm/dasm_arm.lua
+++ b/libs/LuaJIT/dynasm/dasm_arm.lua
@@ -9,9 +9,9 @@
 
															 local _info = {
														
 
															   arch =	"arm",
														
 
															   description =	"DynASM ARM module",
														
 
															-  version =	"1.4.0",
														
 
															-  vernum =	 10400,
														
 
															-  release =	"2015-10-18",
														
 
															+  version =	"1.5.0",
														
 
															+  vernum =	 10500,
														
 
															+  release =	"2021-05-02",
														
 
															   author =	"Mike Pall",
														
 
															   license =	"MIT",
														
 
															 }
														
--- a/libs/LuaJIT/dynasm/dasm_arm64.h
+++ b/libs/LuaJIT/dynasm/dasm_arm64.h
@@ -21,8 +21,9 @@ enum {
 
															   /* 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_REL_PC, DASM_LABEL_PC, DASM_REL_A,
														
 
															   DASM_IMM, DASM_IMM6, DASM_IMM12, DASM_IMM13W, DASM_IMM13X, DASM_IMML,
														
 
															+  DASM_IMMV, DASM_VREG,
														
 
															   DASM__MAX
														
 
															 };
														
@@ -39,6 +40,7 @@ enum {
 
															 #define DASM_S_RANGE_LG		0x13000000
														
 
															 #define DASM_S_RANGE_PC		0x14000000
														
 
															 #define DASM_S_RANGE_REL	0x15000000
														
 
															+#define DASM_S_RANGE_VREG	0x16000000
														
 
															 #define DASM_S_UNDEF_LG		0x21000000
														
 
															 #define DASM_S_UNDEF_PC		0x22000000
														
@@ -247,7 +249,7 @@ void dasm_put(Dst_DECL, int start, ...)
 
															 	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_REL_EXT: if ((ins & 0x8000)) ofs += 8; break;
														
 
															       case DASM_ALIGN: ofs += (ins & 255); b[pos++] = ofs; break;
														
 
															       case DASM_REL_LG:
														
 
															 	n = (ins & 2047) - 10; pl = D->lglabels + n;
														
@@ -268,6 +270,11 @@ void dasm_put(Dst_DECL, int start, ...)
 
															 	  *pl = pos;
														
 
															 	}
														
 
															 	pos++;
														
 
															+	if ((ins & 0x8000)) ofs += 8;
														
 
															+	break;
														
 
															+      case DASM_REL_A:
														
 
															+	b[pos++] = n;
														
 
															+	b[pos++] = va_arg(ap, int);
														
 
															 	break;
														
 
															       case DASM_LABEL_LG:
														
 
															 	pl = D->lglabels + (ins & 2047) - 10; CKPL(lg, LG); goto putlabel;
														
@@ -312,13 +319,21 @@ void dasm_put(Dst_DECL, int start, ...)
 
															 	}
														
 
															       case DASM_IMML: {
														
 
															 #ifdef DASM_CHECKS
														
 
															-	int scale = (p[-2] >> 30);
														
 
															+	int scale = (ins & 3);
														
 
															 	CK((!(n & ((1<<scale)-1)) && (unsigned int)(n>>scale) < 4096) ||
														
 
															 	   (unsigned int)(n+256) < 512, RANGE_I);
														
 
															 #endif
														
 
															 	b[pos++] = n;
														
 
															 	break;
														
 
															 	}
														
 
															+      case DASM_IMMV:
														
 
															+	ofs += 4;
														
 
															+	b[pos++] = n;
														
 
															+	break;
														
 
															+      case DASM_VREG:
														
 
															+	CK(n < 32, RANGE_VREG);
														
 
															+	b[pos++] = n;
														
 
															+	break;
														
 
															       }
														
 
															     }
														
 
															   }
														
@@ -348,7 +363,7 @@ int dasm_link(Dst_DECL, size_t *szp)
 
															   { /* Handle globals not defined in this translation unit. */
														
 
															     int idx;
														
 
															-    for (idx = 20; idx*sizeof(int) < D->lgsize; 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; }
														
@@ -375,8 +390,8 @@ int dasm_link(Dst_DECL, size_t *szp)
 
															 	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: case DASM_IMM6: case DASM_IMM12: case DASM_IMM13W:
														
 
															-	case DASM_IMML: pos++; break;
														
 
															-	case DASM_IMM13X: pos += 2; break;
														
 
															+	case DASM_IMML: case DASM_IMMV: case DASM_VREG: pos++; break;
														
 
															+	case DASM_IMM13X: case DASM_REL_A: pos += 2; break;
														
 
															 	}
														
 
															       }
														
 
															       stop: (void)0;
														
@@ -426,7 +441,12 @@ int dasm_encode(Dst_DECL, void *buffer)
 
															 	  ins &= 255; while ((((char *)cp - base) & ins)) *cp++ = 0xe1a00000;
														
 
															 	  break;
														
 
															 	case DASM_REL_LG:
														
 
															-	  CK(n >= 0, UNDEF_LG);
														
 
															+	  if (n < 0) {
														
 
															+	    ptrdiff_t na = (ptrdiff_t)D->globals[-n] - (ptrdiff_t)cp + 4;
														
 
															+	    n = (int)na;
														
 
															+	    CK((ptrdiff_t)n == na, RANGE_REL);
														
 
															+	    goto patchrel;
														
 
															+	  }
														
 
															 	  /* fallthrough */
														
 
															 	case DASM_REL_PC:
														
 
															 	  CK(n >= 0, UNDEF_PC);
														
@@ -446,8 +466,24 @@ int dasm_encode(Dst_DECL, void *buffer)
 
															 	  } else if ((ins & 0x1000)) {  /* TBZ, TBNZ */
														
 
															 	    CK((n & 3) == 0 && ((n+0x00008000) >> 16) == 0, RANGE_REL);
														
 
															 	    cp[-1] |= ((n << 3) & 0x0007ffe0);
														
 
															+	  } else if ((ins & 0x8000)) {  /* absolute */
														
 
															+	    cp[0] = (unsigned int)((ptrdiff_t)cp - 4 + n);
														
 
															+	    cp[1] = (unsigned int)(((ptrdiff_t)cp - 4 + n) >> 32);
														
 
															+	    cp += 2;
														
 
															 	  }
														
 
															 	  break;
														
 
															+	case DASM_REL_A: {
														
 
															+	  ptrdiff_t na = (((ptrdiff_t)(*b++) << 32) | (unsigned int)n);
														
 
															+	  if ((ins & 0x3000) == 0x3000) {  /* ADRP */
														
 
															+	    ins &= ~0x1000;
														
 
															+	    na = (na >> 12) - (((ptrdiff_t)cp - 4) >> 12);
														
 
															+	  } else {
														
 
															+	    na = na - (ptrdiff_t)cp + 4;
														
 
															+	  }
														
 
															+	  n = (int)na;
														
 
															+	  CK((ptrdiff_t)n == na, RANGE_REL);
														
 
															+	  goto patchrel;
														
 
															+	}
														
 
															 	case DASM_LABEL_LG:
														
 
															 	  ins &= 2047; if (ins >= 20) D->globals[ins-10] = (void *)(base + n);
														
 
															 	  break;
														
@@ -468,11 +504,17 @@ int dasm_encode(Dst_DECL, void *buffer)
 
															 	  cp[-1] |= (dasm_imm13(n, *b++) << 10);
														
 
															 	  break;
														
 
															 	case DASM_IMML: {
														
 
															-	  int scale = (p[-2] >> 30);
														
 
															+	  int scale = (ins & 3);
														
 
															 	  cp[-1] |= (!(n & ((1<<scale)-1)) && (unsigned int)(n>>scale) < 4096) ?
														
 
															 	    ((n << (10-scale)) | 0x01000000) : ((n & 511) << 12);
														
 
															 	  break;
														
 
															 	  }
														
 
															+	case DASM_IMMV:
														
 
															+	  *cp++ = n;
														
 
															+	  break;
														
 
															+	case DASM_VREG:
														
 
															+	  cp[-1] |= (n & 0x1f) << (ins & 0x1f);
														
 
															+	  break;
														
 
															 	default: *cp++ = ins; break;
														
 
															 	}
														
 
															       }
														
--- a/libs/LuaJIT/dynasm/dasm_arm64.lua
+++ b/libs/LuaJIT/dynasm/dasm_arm64.lua
@@ -9,9 +9,9 @@
 
															 local _info = {
														
 
															   arch =	"arm",
														
 
															   description =	"DynASM ARM64 module",
														
 
															-  version =	"1.4.0",
														
 
															-  vernum =	 10400,
														
 
															-  release =	"2015-10-18",
														
 
															+  version =	"1.5.0",
														
 
															+  vernum =	 10500,
														
 
															+  release =	"2021-05-02",
														
 
															   author =	"Mike Pall",
														
 
															   license =	"MIT",
														
 
															 }
														
@@ -23,12 +23,12 @@ local _M = { _info = _info }
 
															 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 format, byte, char = _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
														
 
															 local bit = bit or require("bit")
														
 
															 local band, shl, shr, sar = bit.band, bit.lshift, bit.rshift, bit.arshift
														
 
															-local ror, tohex = bit.ror, bit.tohex
														
 
															+local ror, tohex, tobit = bit.ror, bit.tohex, bit.tobit
														
 
															 -- Inherited tables and callbacks.
														
 
															 local g_opt, g_arch
														
@@ -39,7 +39,9 @@ local wline, werror, wfatal, wwarn
 
															 local action_names = {
														
 
															   "STOP", "SECTION", "ESC", "REL_EXT",
														
 
															   "ALIGN", "REL_LG", "LABEL_LG",
														
 
															-  "REL_PC", "LABEL_PC", "IMM", "IMM6", "IMM12", "IMM13W", "IMM13X", "IMML",
														
 
															+  "REL_PC", "LABEL_PC", "REL_A",
														
 
															+  "IMM", "IMM6", "IMM12", "IMM13W", "IMM13X", "IMML", "IMMV",
														
 
															+  "VREG",
														
 
															 }
														
 
															 -- Maximum number of section buffer positions for dasm_put().
														
@@ -246,9 +248,12 @@ local map_cond = {
 
															 local parse_reg_type
														
 
															-local function parse_reg(expr)
														
 
															+local function parse_reg(expr, shift)
														
 
															   if not expr then werror("expected register name") end
														
 
															   local tname, ovreg = match(expr, "^([%w_]+):(@?%l%d+)$")
														
 
															+  if not tname then
														
 
															+    tname, ovreg = match(expr, "^([%w_]+):(R[xwqdshb]%b())$")
														
 
															+  end
														
 
															   local tp = map_type[tname or expr]
														
 
															   if tp then
														
 
															     local reg = ovreg or tp.reg
														
@@ -266,18 +271,28 @@ local function parse_reg(expr)
 
															       elseif parse_reg_type ~= rt then
														
 
															 	werror("register size mismatch")
														
 
															       end
														
 
															-      return r, tp
														
 
															+      return shl(r, shift), tp
														
 
															+    end
														
 
															+  end
														
 
															+  local vrt, vreg = match(expr, "^R([xwqdshb])(%b())$")
														
 
															+  if vreg then
														
 
															+    if not parse_reg_type then
														
 
															+      parse_reg_type = vrt
														
 
															+    elseif parse_reg_type ~= vrt then
														
 
															+      werror("register size mismatch")
														
 
															     end
														
 
															+    if shift then waction("VREG", shift, vreg) end
														
 
															+    return 0
														
 
															   end
														
 
															   werror("bad register name `"..expr.."'")
														
 
															 end
														
 
															 local function parse_reg_base(expr)
														
 
															   if expr == "sp" then return 0x3e0 end
														
 
															-  local base, tp = parse_reg(expr)
														
 
															+  local base, tp = parse_reg(expr, 5)
														
 
															   if parse_reg_type ~= "x" then werror("bad register type") end
														
 
															   parse_reg_type = false
														
 
															-  return shl(base, 5), tp
														
 
															+  return base, tp
														
 
															 end
														
 
															 local parse_ctx = {}
														
@@ -297,7 +312,7 @@ local function parse_number(n)
 
															   local code = loadenv("return "..n)
														
 
															   if code then
														
 
															     local ok, y = pcall(code)
														
 
															-    if ok then return y end
														
 
															+    if ok and type(y) == "number" then return y end
														
 
															   end
														
 
															   return nil
														
 
															 end
														
@@ -403,7 +418,7 @@ local function parse_imm_load(imm, scale)
 
															     end
														
 
															     werror("out of range immediate `"..imm.."'")
														
 
															   else
														
 
															-    waction("IMML", 0, imm)
														
 
															+    waction("IMML", scale, imm)
														
 
															     return 0
														
 
															   end
														
 
															 end
														
@@ -462,6 +477,7 @@ end
 
															 local function parse_load(params, nparams, n, op)
														
 
															   if params[n+2] then werror("too many operands") end
														
 
															+  local scale = shr(op, 30)
														
 
															   local pn, p2 = params[n], params[n+1]
														
 
															   local p1, wb = match(pn, "^%[%s*(.-)%s*%](!?)$")
														
 
															   if not p1 then
														
@@ -470,14 +486,13 @@ local function parse_load(params, nparams, n, op)
 
															       if reg and tailr ~= "" then
														
 
															 	local base, tp = parse_reg_base(reg)
														
 
															 	if tp then
														
 
															-	  waction("IMML", 0, format(tp.ctypefmt, tailr))
														
 
															+	  waction("IMML", scale, format(tp.ctypefmt, tailr))
														
 
															 	  return op + base
														
 
															 	end
														
 
															       end
														
 
															     end
														
 
															     werror("expected address operand")
														
 
															   end
														
 
															-  local scale = shr(op, 30)
														
 
															   if p2 then
														
 
															     if wb == "!" then werror("bad use of '!'") end
														
 
															     op = op + parse_reg_base(p1) + parse_imm(p2, 9, 12, 0, true) + 0x400
														
@@ -494,7 +509,7 @@ local function parse_load(params, nparams, n, op)
 
															 	op = op + parse_imm_load(imm, scale)
														
 
															       else
														
 
															 	local p2b, p3b, p3s = match(p2a, "^,%s*([^,%s]*)%s*,?%s*(%S*)%s*(.*)$")
														
 
															-	op = op + shl(parse_reg(p2b), 16) + 0x00200800
														
 
															+	op = op + parse_reg(p2b, 16) + 0x00200800
														
 
															 	if parse_reg_type ~= "x" and parse_reg_type ~= "w" then
														
 
															 	  werror("bad index register type")
														
 
															 	end
														
@@ -561,14 +576,14 @@ local function parse_load_pair(params, nparams, n, op)
 
															 end
														
 
															 local function parse_label(label, def)
														
 
															-  local prefix = sub(label, 1, 2)
														
 
															+  local prefix = label:sub(1, 2)
														
 
															   -- =>label (pc label reference)
														
 
															   if prefix == "=>" then
														
 
															-    return "PC", 0, sub(label, 3)
														
 
															+    return "PC", 0, label:sub(3)
														
 
															   end
														
 
															   -- ->name (global label reference)
														
 
															   if prefix == "->" then
														
 
															-    return "LG", map_global[sub(label, 3)]
														
 
															+    return "LG", map_global[label:sub(3)]
														
 
															   end
														
 
															   if def then
														
 
															     -- [1-9] (local label definition)
														
@@ -586,8 +601,11 @@ local function parse_label(label, def)
 
															     if extname then
														
 
															       return "EXT", map_extern[extname]
														
 
															     end
														
 
															+    -- &expr (pointer)
														
 
															+    if label:sub(1, 1) == "&" then
														
 
															+      return "A", 0, format("(ptrdiff_t)(%s)", label:sub(2))
														
 
															+    end
														
 
															   end
														
 
															-  werror("bad label `"..label.."'")
														
 
															 end
														
 
															 local function branch_type(op)
														
@@ -620,24 +638,24 @@ local function alias_bfx(p)
 
															 end
														
 
															 local function alias_bfiz(p)
														
 
															-  parse_reg(p[1])
														
 
															+  parse_reg(p[1], 0)
														
 
															   if parse_reg_type == "w" then
														
 
															-    p[3] = "#-("..p[3]:sub(2)..")%32"
														
 
															+    p[3] = "#(32-("..p[3]:sub(2).."))%32"
														
 
															     p[4] = "#("..p[4]:sub(2)..")-1"
														
 
															   else
														
 
															-    p[3] = "#-("..p[3]:sub(2)..")%64"
														
 
															+    p[3] = "#(64-("..p[3]:sub(2).."))%64"
														
 
															     p[4] = "#("..p[4]:sub(2)..")-1"
														
 
															   end
														
 
															 end
														
 
															 local alias_lslimm = op_alias("ubfm_4", function(p)
														
 
															-  parse_reg(p[1])
														
 
															+  parse_reg(p[1], 0)
														
 
															   local sh = p[3]:sub(2)
														
 
															   if parse_reg_type == "w" then
														
 
															-    p[3] = "#-("..sh..")%32"
														
 
															+    p[3] = "#(32-("..sh.."))%32"
														
 
															     p[4] = "#31-("..sh..")"
														
 
															   else
														
 
															-    p[3] = "#-("..sh..")%64"
														
 
															+    p[3] = "#(64-("..sh.."))%64"
														
 
															     p[4] = "#63-("..sh..")"
														
 
															   end
														
 
															 end)
														
@@ -881,25 +899,25 @@ end
 
															 -- Handle opcodes defined with template strings.
														
 
															 local function parse_template(params, template, nparams, pos)
														
 
															-  local op = tonumber(sub(template, 1, 8), 16)
														
 
															+  local op = tonumber(template:sub(1, 8), 16)
														
 
															   local n = 1
														
 
															   local rtt = {}
														
 
															   parse_reg_type = false
														
 
															   -- Process each character.
														
 
															-  for p in gmatch(sub(template, 9), ".") do
														
 
															+  for p in gmatch(template:sub(9), ".") do
														
 
															     local q = params[n]
														
 
															     if p == "D" then
														
 
															-      op = op + parse_reg(q); n = n + 1
														
 
															+      op = op + parse_reg(q, 0); n = n + 1
														
 
															     elseif p == "N" then
														
 
															-      op = op + shl(parse_reg(q), 5); n = n + 1
														
 
															+      op = op + parse_reg(q, 5); n = n + 1
														
 
															     elseif p == "M" then
														
 
															-      op = op + shl(parse_reg(q), 16); n = n + 1
														
 
															+      op = op + parse_reg(q, 16); n = n + 1
														
 
															     elseif p == "A" then
														
 
															-      op = op + shl(parse_reg(q), 10); n = n + 1
														
 
															+      op = op + parse_reg(q, 10); n = n + 1
														
 
															     elseif p == "m" then
														
 
															-      op = op + shl(parse_reg(params[n-1]), 16)
														
 
															+      op = op + parse_reg(params[n-1], 16)
														
 
															     elseif p == "p" then
														
 
															       if q == "sp" then params[n] = "@x31" end
														
@@ -930,8 +948,14 @@ local function parse_template(params, template, nparams, pos)
 
															     elseif p == "B" then
														
 
															       local mode, v, s = parse_label(q, false); n = n + 1
														
 
															+      if not mode then werror("bad label `"..q.."'") end
														
 
															       local m = branch_type(op)
														
 
															-      waction("REL_"..mode, v+m, s, 1)
														
 
															+      if mode == "A" then
														
 
															+	waction("REL_"..mode, v+m, format("(unsigned int)(%s)", s))
														
 
															+	actargs[#actargs+1] = format("(unsigned int)((%s)>>32)", s)
														
 
															+      else
														
 
															+	waction("REL_"..mode, v+m, s, 1)
														
 
															+      end
														
 
															     elseif p == "I" then
														
 
															       op = op + parse_imm12(q); n = n + 1
														
@@ -977,8 +1001,8 @@ function op_template(params, template, nparams)
 
															   if not params then return template:gsub("%x%x%x%x%x%x%x%x", "") end
														
 
															   -- 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
														
 
															+  -- A single opcode needs a maximum of 4 positions.
														
 
															+  if secpos+4 > maxsecpos then wflush() end
														
 
															   local pos = wpos()
														
 
															   local lpos, apos, spos = #actlist, #actargs, secpos
														
@@ -990,9 +1014,11 @@ function op_template(params, template, nparams)
 
															     actlist[lpos+1] = nil
														
 
															     actlist[lpos+2] = nil
														
 
															     actlist[lpos+3] = nil
														
 
															+    actlist[lpos+4] = nil
														
 
															     actargs[apos+1] = nil
														
 
															     actargs[apos+2] = nil
														
 
															     actargs[apos+3] = nil
														
 
															+    actargs[apos+4] = nil
														
 
															   end
														
 
															   error(err, 0)
														
 
															 end
														
@@ -1036,23 +1062,50 @@ 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
														
 
															+  if not mode or 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)
														
 
															+local function op_data(params)
														
 
															   if not params then return "imm..." end
														
 
															+  local sz = params.op == ".long" and 4 or 8
														
 
															   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)
														
 
															+    local imm = parse_number(p)
														
 
															+    if imm then
														
 
															+      local n = tobit(imm)
														
 
															+      if n == imm or (n < 0 and n + 2^32 == imm) then
														
 
															+	wputw(n < 0 and n + 2^32 or n)
														
 
															+	if sz == 8 then
														
 
															+	  wputw(imm < 0 and 0xffffffff or 0)
														
 
															+	end
														
 
															+      elseif sz == 4 then
														
 
															+	werror("bad immediate `"..p.."'")
														
 
															+      else
														
 
															+	imm = nil
														
 
															+      end
														
 
															+    end
														
 
															+    if not imm then
														
 
															+      local mode, v, s = parse_label(p, false)
														
 
															+      if sz == 4 then
														
 
															+	if mode then werror("label does not fit into .long") end
														
 
															+	waction("IMMV", 0, p)
														
 
															+      elseif mode and mode ~= "A" then
														
 
															+	waction("REL_"..mode, v+0x8000, s, 1)
														
 
															+      else
														
 
															+	if mode == "A" then p = s end
														
 
															+	waction("IMMV", 0, format("(unsigned int)(%s)", p))
														
 
															+	waction("IMMV", 0, format("(unsigned int)((unsigned long long)(%s)>>32)", p))
														
 
															+      end
														
 
															+    end
														
 
															     if secpos+2 > maxsecpos then wflush() end
														
 
															   end
														
 
															 end
														
 
															+map_op[".long_*"] = op_data
														
 
															+map_op[".quad_*"] = op_data
														
 
															+map_op[".addr_*"] = op_data
														
 
															 -- Alignment pseudo-opcode.
														
 
															 map_op[".align_1"] = function(params)
														
--- a/libs/LuaJIT/dynasm/dasm_mips.h
+++ b/libs/LuaJIT/dynasm/dasm_mips.h
@@ -273,7 +273,7 @@ int dasm_link(Dst_DECL, size_t *szp)
 
															   { /* Handle globals not defined in this translation unit. */
														
 
															     int idx;
														
 
															-    for (idx = 20; idx*sizeof(int) < D->lgsize; 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; }
														
@@ -349,7 +349,10 @@ int dasm_encode(Dst_DECL, void *buffer)
 
															 	  ins &= 255; while ((((char *)cp - base) & ins)) *cp++ = 0x60000000;
														
 
															 	  break;
														
 
															 	case DASM_REL_LG:
														
 
															-	  CK(n >= 0, UNDEF_LG);
														
 
															+	  if (n < 0) {
														
 
															+	    n = (int)((ptrdiff_t)D->globals[-n] - (ptrdiff_t)cp);
														
 
															+	    goto patchrel;
														
 
															+	  }
														
 
															 	  /* fallthrough */
														
 
															 	case DASM_REL_PC:
														
 
															 	  CK(n >= 0, UNDEF_PC);
														
--- a/libs/LuaJIT/dynasm/dasm_mips.lua
+++ b/libs/LuaJIT/dynasm/dasm_mips.lua
@@ -12,9 +12,9 @@ local mipsr6 = _map_def.MIPSR6
 
															 local _info = {
														
 
															   arch =	mips64 and "mips64" or "mips",
														
 
															   description =	"DynASM MIPS32/MIPS64 module",
														
 
															-  version =	"1.4.0",
														
 
															-  vernum =	 10400,
														
 
															-  release =	"2020-01-20",
														
 
															+  version =	"1.5.0",
														
 
															+  vernum =	 10500,
														
 
															+  release =	"2021-05-02",
														
 
															   author =	"Mike Pall",
														
 
															   license =	"MIT",
														
 
															 }
														
--- a/libs/LuaJIT/dynasm/dasm_ppc.h
+++ b/libs/LuaJIT/dynasm/dasm_ppc.h
@@ -277,7 +277,7 @@ int dasm_link(Dst_DECL, size_t *szp)
 
															   { /* Handle globals not defined in this translation unit. */
														
 
															     int idx;
														
 
															-    for (idx = 20; idx*sizeof(int) < D->lgsize; 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; }
														
@@ -353,7 +353,10 @@ int dasm_encode(Dst_DECL, void *buffer)
 
															 	  ins &= 255; while ((((char *)cp - base) & ins)) *cp++ = 0x60000000;
														
 
															 	  break;
														
 
															 	case DASM_REL_LG:
														
 
															-	  CK(n >= 0, UNDEF_LG);
														
 
															+	  if (n < 0) {
														
 
															+	    n = (int)((ptrdiff_t)D->globals[-n] - (ptrdiff_t)cp);
														
 
															+	    goto patchrel;
														
 
															+	  }
														
 
															 	  /* fallthrough */
														
 
															 	case DASM_REL_PC:
														
 
															 	  CK(n >= 0, UNDEF_PC);
														
--- a/libs/LuaJIT/dynasm/dasm_ppc.lua
+++ b/libs/LuaJIT/dynasm/dasm_ppc.lua
@@ -11,9 +11,9 @@
 
															 local _info = {
														
 
															   arch =	"ppc",
														
 
															   description =	"DynASM PPC module",
														
 
															-  version =	"1.4.0",
														
 
															-  vernum =	 10400,
														
 
															-  release =	"2015-10-18",
														
 
															+  version =	"1.5.0",
														
 
															+  vernum =	 10500,
														
 
															+  release =	"2021-05-02",
														
 
															   author =	"Mike Pall",
														
 
															   license =	"MIT",
														
 
															 }
														
--- a/libs/LuaJIT/dynasm/dasm_proto.h
+++ b/libs/LuaJIT/dynasm/dasm_proto.h
@@ -10,8 +10,8 @@
 
															 #include <stddef.h>
														
 
															 #include <stdarg.h>
														
 
															-#define DASM_IDENT	"DynASM 1.4.0"
														
 
															-#define DASM_VERSION	10400	/* 1.4.0 */
														
 
															+#define DASM_IDENT	"DynASM 1.5.0"
														
 
															+#define DASM_VERSION	10500	/* 1.5.0 */
														
 
															 #ifndef Dst_DECL
														
 
															 #define Dst_DECL	dasm_State **Dst
														
--- a/libs/LuaJIT/dynasm/dasm_x86.h
+++ b/libs/LuaJIT/dynasm/dasm_x86.h
@@ -239,8 +239,11 @@ void dasm_put(Dst_DECL, int start, ...)
 
															 	}
														
 
															 	pos++;
														
 
															 	ofs += 4;  /* Maximum offset needed. */
														
 
															-	if (action == DASM_REL_LG || action == DASM_REL_PC)
														
 
															+	if (action == DASM_REL_LG || action == DASM_REL_PC) {
														
 
															 	  b[pos++] = ofs;  /* Store pass1 offset estimate. */
														
 
															+	} else if (sizeof(ptrdiff_t) == 8) {
														
 
															+	  ofs += 4;
														
 
															+	}
														
 
															 	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);
														
@@ -365,10 +368,22 @@ int dasm_link(Dst_DECL, size_t *szp)
 
															   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)
														
 
															+#define dasmq(x) \
														
 
															+  do { *((unsigned long long *)cp) = (unsigned long long)(x); cp+=8; } 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)
														
 
															+#define dasmq(x)	do { dasmd(x); dasmd((x)>>32); } while (0)
														
 
															 #endif
														
 
															+static unsigned char *dasma_(unsigned char *cp, ptrdiff_t x)
														
 
															+{
														
 
															+  if (sizeof(ptrdiff_t) == 8)
														
 
															+    dasmq((unsigned long long)x);
														
 
															+  else
														
 
															+    dasmd((unsigned int)x);
														
 
															+  return cp;
														
 
															+}
														
 
															+#define dasma(x)	(cp = dasma_(cp, (x)))
														
 
															 /* Pass 3: Encode sections. */
														
 
															 int dasm_encode(Dst_DECL, void *buffer)
														
@@ -443,12 +458,13 @@ int dasm_encode(Dst_DECL, void *buffer)
 
															 	  goto wb;
														
 
															 	}
														
 
															 	case DASM_IMM_LG:
														
 
															-	  p++; if (n < 0) { n = (int)(ptrdiff_t)D->globals[-n]; goto wd; }
														
 
															+	  p++;
														
 
															+	  if (n < 0) { dasma((ptrdiff_t)D->globals[-n]); break; }
														
 
															 	  /* fallthrough */
														
 
															 	case DASM_IMM_PC: {
														
 
															 	  int *pb = DASM_POS2PTR(D, n);
														
 
															-	  n = *pb < 0 ? pb[1] : (*pb + (int)(ptrdiff_t)base);
														
 
															-	  goto wd;
														
 
															+	  dasma(*pb < 0 ? (ptrdiff_t)pb[1] : (*pb + (ptrdiff_t)base));
														
 
															+	  break;
														
 
															 	}
														
 
															 	case DASM_LABEL_LG: {
														
 
															 	  int idx = *p++;
														
--- a/libs/LuaJIT/dynasm/dasm_x86.lua
+++ b/libs/LuaJIT/dynasm/dasm_x86.lua
@@ -11,9 +11,9 @@ local x64 = x64
 
															 local _info = {
														
 
															   arch =	x64 and "x64" or "x86",
														
 
															   description =	"DynASM x86/x64 module",
														
 
															-  version =	"1.4.0",
														
 
															-  vernum =	 10400,
														
 
															-  release =	"2015-10-18",
														
 
															+  version =	"1.5.0",
														
 
															+  vernum =	 10500,
														
 
															+  release =	"2021-05-02",
														
 
															   author =	"Mike Pall",
														
 
															   license =	"MIT",
														
 
															 }
														
@@ -484,6 +484,22 @@ local function wputdarg(n)
 
															   end
														
 
															 end
														
 
															+-- Put signed or unsigned qword or arg.
														
 
															+local function wputqarg(n)
														
 
															+  local tn = type(n)
														
 
															+  if tn == "number" then -- This is only used for numbers from -2^31..2^32-1.
														
 
															+    wputb(band(n, 255))
														
 
															+    wputb(band(shr(n, 8), 255))
														
 
															+    wputb(band(shr(n, 16), 255))
														
 
															+    wputb(shr(n, 24))
														
 
															+    local sign = n < 0 and 255 or 0
														
 
															+    wputb(sign); wputb(sign); wputb(sign); wputb(sign)
														
 
															+  else
														
 
															+    waction("IMM_D", format("(unsigned int)(%s)", n))
														
 
															+    waction("IMM_D", format("(unsigned int)((unsigned long long)(%s)>>32)", 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)
														
@@ -663,10 +679,16 @@ local function opmodestr(op, args)
 
															 end
														
 
															 -- Convert number to valid integer or nil.
														
 
															-local function toint(expr)
														
 
															+local function toint(expr, isqword)
														
 
															   local n = tonumber(expr)
														
 
															   if n then
														
 
															-    if n % 1 ~= 0 or n < -2147483648 or n > 4294967295 then
														
 
															+    if n % 1 ~= 0 then
														
 
															+      werror("not an integer number `"..expr.."'")
														
 
															+    elseif isqword then
														
 
															+      if n < -2147483648 or n > 2147483647 then
														
 
															+	n = nil -- Handle it as an expression to avoid precision loss.
														
 
															+      end
														
 
															+    elseif n < -2147483648 or n > 4294967295 then
														
 
															       werror("bad integer number `"..expr.."'")
														
 
															     end
														
 
															     return n
														
@@ -749,7 +771,7 @@ local function rtexpr(expr)
 
															 end
														
 
															 -- Parse operand and return { mode, opsize, reg, xreg, xsc, disp, imm }.
														
 
															-local function parseoperand(param)
														
 
															+local function parseoperand(param, isqword)
														
 
															   local t = {}
														
 
															   local expr = param
														
@@ -810,7 +832,7 @@ local function parseoperand(param)
 
															       if t.disp then break end
														
 
															       -- [reg+xreg...]
														
 
															-      local xreg, tailx = match(tailr, "^+%s*([@%w_:]+)%s*(.*)$")
														
 
															+      local xreg, tailx = match(tailr, "^%+%s*([@%w_:]+)%s*(.*)$")
														
 
															       xreg, t.xreg, tp = rtexpr(xreg)
														
 
															       if not t.xreg then
														
 
															 	-- [reg+-expr]
														
@@ -837,7 +859,7 @@ local function parseoperand(param)
 
															       t.disp = dispexpr(tailx)
														
 
															     else
														
 
															       -- imm or opsize*imm
														
 
															-      local imm = toint(expr)
														
 
															+      local imm = toint(expr, isqword)
														
 
															       if not imm and sub(expr, 1, 1) == "*" and t.opsize then
														
 
															 	imm = toint(sub(expr, 2))
														
 
															 	if imm then
														
@@ -1952,7 +1974,7 @@ local function dopattern(pat, args, sz, op, needrex)
 
															 	local a = args[narg]
														
 
															 	narg = narg + 1
														
 
															 	local mode, imm = a.mode, a.imm
														
 
															-	if mode == "iJ" and not match("iIJ", c) then
														
 
															+	if mode == "iJ" and not match(x64 and "J" or "iIJ", c) then
														
 
															 	  werror("bad operand size for label")
														
 
															 	end
														
 
															 	if c == "S" then
														
@@ -2144,14 +2166,16 @@ end
 
															 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
														
 
															+  if sz == "l" then sz = "d" elseif sz == "a" then sz = addrsize end
														
 
															   for _,p in ipairs(params) do
														
 
															-    local a = parseoperand(p)
														
 
															+    local a = parseoperand(p, sz == "q")
														
 
															     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)
														
 
															+    elseif sz == "q" then
														
 
															+      wputqarg(a.imm)
														
 
															     else
														
 
															       wputszarg(sz, a.imm)
														
 
															     end
														
@@ -2163,7 +2187,11 @@ map_op[".byte_*"] = op_data
 
															 map_op[".sbyte_*"] = op_data
														
 
															 map_op[".word_*"] = op_data
														
 
															 map_op[".dword_*"] = op_data
														
 
															+map_op[".qword_*"] = op_data
														
 
															 map_op[".aword_*"] = op_data
														
 
															+map_op[".long_*"] = op_data
														
 
															+map_op[".quad_*"] = op_data
														
 
															+map_op[".addr_*"] = op_data
														
 
															 ------------------------------------------------------------------------------
														
--- a/libs/LuaJIT/dynasm/dynasm.lua
+++ b/libs/LuaJIT/dynasm/dynasm.lua
@@ -10,9 +10,9 @@
 
															 local _info = {
														
 
															   name =	"DynASM",
														
 
															   description =	"A dynamic assembler for code generation engines",
														
 
															-  version =	"1.4.0",
														
 
															-  vernum =	 10400,
														
 
															-  release =	"2015-10-18",
														
 
															+  version =	"1.5.0",
														
 
															+  vernum =	 10500,
														
 
															+  release =	"2021-05-02",
														
 
															   author =	"Mike Pall",
														
 
															   url =		"https://luajit.org/dynasm.html",
														
 
															   license =	"MIT",
														
--- a/libs/LuaJIT/src/Makefile
+++ b/libs/LuaJIT/src/Makefile
@@ -211,7 +211,7 @@ TARGET_CC= $(STATIC_CC)
 
															 TARGET_STCC= $(STATIC_CC)
														
 
															 TARGET_DYNCC= $(DYNAMIC_CC)
														
 
															 TARGET_LD= $(CROSS)$(CC)
														
 
															-TARGET_AR= $(CROSS)ar rcus 2>/dev/null
														
 
															+TARGET_AR= $(CROSS)ar rcus
														
 
															 TARGET_STRIP= $(CROSS)strip
														
 
															 TARGET_LIBPATH= $(or $(PREFIX),/usr/local)/$(or $(MULTILIB),lib)
														
@@ -311,6 +311,7 @@ ifeq (Windows,$(TARGET_SYS))
 
															   TARGET_XSHLDFLAGS= -shared -Wl,--out-implib,$(TARGET_DLLDOTANAME)
														
 
															   TARGET_DYNXLDOPTS=
														
 
															 else
														
 
															+  TARGET_AR+= 2>/dev/null
														
 
															 ifeq (,$(shell $(TARGET_CC) -o /dev/null -c -x c /dev/null -fno-stack-protector 2>/dev/null || echo 1))
														
 
															   TARGET_XCFLAGS+= -fno-stack-protector
														
 
															 endif
														
@@ -319,13 +320,10 @@ ifeq (Darwin,$(TARGET_SYS))
 
															     $(error missing: export MACOSX_DEPLOYMENT_TARGET=XX.YY)
														
 
															   endif
														
 
															   TARGET_STRIP+= -x
														
 
															+  TARGET_XCFLAGS+= -DLUAJIT_UNWIND_EXTERNAL
														
 
															   TARGET_XSHLDFLAGS= -dynamiclib -single_module -undefined dynamic_lookup -fPIC
														
 
															   TARGET_DYNXLDOPTS=
														
 
															   TARGET_XSHLDFLAGS+= -install_name $(TARGET_DYLIBPATH) -compatibility_version $(MAJVER).$(MINVER) -current_version $(MAJVER).$(MINVER).$(RELVER)
														
 
															-  ifeq (x64,$(TARGET_LJARCH))
														
 
															-    TARGET_XLDFLAGS+= -pagezero_size 10000 -image_base 100000000
														
 
															-    TARGET_XSHLDFLAGS+= -image_base 7fff04c4a000
														
 
															-  endif
														
 
															 else
														
 
															 ifeq (iOS,$(TARGET_SYS))
														
 
															   TARGET_STRIP+= -x
														
@@ -336,6 +334,13 @@ ifeq (iOS,$(TARGET_SYS))
 
															     TARGET_XCFLAGS+= -fno-omit-frame-pointer
														
 
															   endif
														
 
															 else
														
 
															+  ifeq (,$(findstring LJ_NO_UNWIND 1,$(TARGET_TESTARCH)))
														
 
															+    # Find out whether the target toolchain always generates unwind tables.
														
 
															+    TARGET_TESTUNWIND=$(shell exec 2>/dev/null; echo 'extern void b(void);int a(void){b();return 0;}' | $(TARGET_CC) -c -x c - -o tmpunwind.o && { grep -qa -e eh_frame -e __unwind_info tmpunwind.o || grep -qU -e eh_frame -e __unwind_info tmpunwind.o; } && echo E; rm -f tmpunwind.o)
														
 
															+    ifneq (,$(findstring E,$(TARGET_TESTUNWIND)))
														
 
															+      TARGET_XCFLAGS+= -DLUAJIT_UNWIND_EXTERNAL
														
 
															+    endif
														
 
															+  endif
														
 
															   ifneq (SunOS,$(TARGET_SYS))
														
 
															     ifneq (PS3,$(TARGET_SYS))
														
 
															       TARGET_XLDFLAGS+= -Wl,-E
														
@@ -479,13 +484,15 @@ LJVM_BOUT= $(LJVM_S)
 
															 LJVM_MODE= elfasm
														
 
															 LJLIB_O= lib_base.o lib_math.o lib_bit.o lib_string.o lib_table.o \
														
 
															-	 lib_io.o lib_os.o lib_package.o lib_debug.o lib_jit.o lib_ffi.o
														
 
															+	 lib_io.o lib_os.o lib_package.o lib_debug.o lib_jit.o lib_ffi.o \
														
 
															+	 lib_buffer.o
														
 
															 LJLIB_C= $(LJLIB_O:.o=.c)
														
 
															 LJCORE_O= lj_assert.o lj_gc.o lj_err.o lj_char.o lj_bc.o lj_obj.o lj_buf.o \
														
 
															 	  lj_str.o lj_tab.o lj_func.o lj_udata.o lj_meta.o lj_debug.o \
														
 
															 	  lj_prng.o lj_state.o lj_dispatch.o lj_vmevent.o lj_vmmath.o \
														
 
															-	  lj_strscan.o lj_strfmt.o lj_strfmt_num.o lj_api.o lj_profile.o \
														
 
															+	  lj_strscan.o lj_strfmt.o lj_strfmt_num.o lj_serialize.o \
														
 
															+	  lj_api.o lj_profile.o \
														
 
															 	  lj_lex.o lj_parse.o lj_bcread.o lj_bcwrite.o lj_load.o \
														
 
															 	  lj_ir.o lj_opt_mem.o lj_opt_fold.o lj_opt_narrow.o \
														
 
															 	  lj_opt_dce.o lj_opt_loop.o lj_opt_split.o lj_opt_sink.o \
														
--- a/libs/LuaJIT/src/Makefile.dep
+++ b/libs/LuaJIT/src/Makefile.dep
@@ -2,14 +2,18 @@ lib_aux.o: lib_aux.c lua.h luaconf.h lauxlib.h lj_obj.h lj_def.h \
 
															  lj_arch.h lj_err.h lj_errmsg.h lj_state.h lj_trace.h lj_jit.h lj_ir.h \
														
 
															  lj_dispatch.h lj_bc.h lj_traceerr.h lj_lib.h
														
 
															 lib_base.o: lib_base.c lua.h luaconf.h lauxlib.h lualib.h lj_obj.h \
														
 
															- lj_def.h lj_arch.h lj_gc.h lj_err.h lj_errmsg.h lj_debug.h lj_str.h \
														
 
															- lj_tab.h lj_meta.h lj_state.h lj_frame.h lj_bc.h lj_ctype.h lj_cconv.h \
														
 
															- lj_ff.h lj_ffdef.h lj_dispatch.h lj_jit.h lj_ir.h lj_char.h lj_strscan.h \
														
 
															- lj_strfmt.h lj_lib.h lj_libdef.h
														
 
															+ lj_def.h lj_arch.h lj_gc.h lj_err.h lj_errmsg.h lj_debug.h lj_buf.h \
														
 
															+ lj_str.h lj_tab.h lj_meta.h lj_state.h lj_frame.h lj_bc.h lj_ctype.h \
														
 
															+ lj_cconv.h lj_ff.h lj_ffdef.h lj_dispatch.h lj_jit.h lj_ir.h lj_char.h \
														
 
															+ lj_strscan.h lj_strfmt.h lj_lib.h lj_libdef.h
														
 
															 lib_bit.o: lib_bit.c lua.h luaconf.h lauxlib.h lualib.h lj_obj.h lj_def.h \
														
 
															  lj_arch.h lj_err.h lj_errmsg.h lj_buf.h lj_gc.h lj_str.h lj_strscan.h \
														
 
															  lj_strfmt.h lj_ctype.h lj_cdata.h lj_cconv.h lj_carith.h lj_ff.h \
														
 
															  lj_ffdef.h lj_lib.h lj_libdef.h
														
 
															+lib_buffer.o: lib_buffer.c lua.h luaconf.h lauxlib.h lualib.h lj_obj.h \
														
 
															+ lj_def.h lj_arch.h lj_gc.h lj_err.h lj_errmsg.h lj_buf.h lj_str.h \
														
 
															+ lj_tab.h lj_udata.h lj_meta.h lj_ctype.h lj_cdata.h lj_cconv.h \
														
 
															+ lj_strfmt.h lj_serialize.h lj_lib.h lj_libdef.h
														
 
															 lib_debug.o: lib_debug.c lua.h luaconf.h lauxlib.h lualib.h lj_obj.h \
														
 
															  lj_def.h lj_arch.h lj_gc.h lj_err.h lj_errmsg.h lj_debug.h lj_lib.h \
														
 
															  lj_libdef.h
														
@@ -48,10 +52,10 @@ lj_api.o: lj_api.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_gc.h \
 
															  lj_meta.h lj_state.h lj_bc.h lj_frame.h lj_trace.h lj_jit.h lj_ir.h \
														
 
															  lj_dispatch.h lj_traceerr.h lj_vm.h lj_strscan.h lj_strfmt.h
														
 
															 lj_asm.o: lj_asm.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_gc.h \
														
 
															- lj_str.h lj_tab.h lj_frame.h lj_bc.h lj_ctype.h lj_ir.h lj_jit.h \
														
 
															- lj_ircall.h lj_iropt.h lj_mcode.h lj_trace.h lj_dispatch.h lj_traceerr.h \
														
 
															- lj_snap.h lj_asm.h lj_vm.h lj_target.h lj_target_*.h lj_emit_*.h \
														
 
															- lj_asm_*.h
														
 
															+ lj_buf.h lj_str.h lj_tab.h lj_frame.h lj_bc.h lj_ctype.h lj_ir.h \
														
 
															+ lj_jit.h lj_ircall.h lj_iropt.h lj_mcode.h lj_trace.h lj_dispatch.h \
														
 
															+ lj_traceerr.h lj_snap.h lj_asm.h lj_vm.h lj_target.h lj_target_*.h \
														
 
															+ lj_emit_*.h lj_asm_*.h
														
 
															 lj_assert.o: lj_assert.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h
														
 
															 lj_bc.o: lj_bc.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_bc.h \
														
 
															  lj_bcdef.h
														
@@ -77,8 +81,8 @@ lj_ccallback.o: lj_ccallback.c lj_obj.h lua.h luaconf.h lj_def.h \
 
															  lj_target_*.h lj_mcode.h lj_jit.h lj_ir.h lj_trace.h lj_dispatch.h \
														
 
															  lj_traceerr.h lj_vm.h
														
 
															 lj_cconv.o: lj_cconv.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
														
 
															- lj_err.h lj_errmsg.h lj_tab.h lj_ctype.h lj_gc.h lj_cdata.h lj_cconv.h \
														
 
															- lj_ccallback.h
														
 
															+ lj_err.h lj_errmsg.h lj_buf.h lj_gc.h lj_str.h lj_tab.h lj_ctype.h \
														
 
															+ lj_cdata.h lj_cconv.h lj_ccallback.h
														
 
															 lj_cdata.o: lj_cdata.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
														
 
															  lj_gc.h lj_err.h lj_errmsg.h lj_tab.h lj_ctype.h lj_cconv.h lj_cdata.h
														
 
															 lj_char.o: lj_char.c lj_char.h lj_def.h lua.h luaconf.h
														
@@ -110,10 +114,10 @@ lj_err.o: lj_err.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_err.h \
 
															  lj_ff.h lj_ffdef.h lj_trace.h lj_jit.h lj_ir.h lj_dispatch.h \
														
 
															  lj_traceerr.h lj_vm.h lj_strfmt.h
														
 
															 lj_ffrecord.o: lj_ffrecord.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
														
 
															- lj_err.h lj_errmsg.h lj_str.h lj_tab.h lj_frame.h lj_bc.h lj_ff.h \
														
 
															- lj_ffdef.h lj_ir.h lj_jit.h lj_ircall.h lj_iropt.h lj_trace.h \
														
 
															- lj_dispatch.h lj_traceerr.h lj_record.h lj_ffrecord.h lj_crecord.h \
														
 
															- lj_vm.h lj_strscan.h lj_strfmt.h lj_recdef.h
														
 
															+ lj_err.h lj_errmsg.h lj_buf.h lj_gc.h lj_str.h lj_tab.h lj_frame.h \
														
 
															+ lj_bc.h lj_ff.h lj_ffdef.h lj_ir.h lj_jit.h lj_ircall.h lj_iropt.h \
														
 
															+ lj_trace.h lj_dispatch.h lj_traceerr.h lj_record.h lj_ffrecord.h \
														
 
															+ lj_crecord.h lj_vm.h lj_strscan.h lj_strfmt.h lj_serialize.h lj_recdef.h
														
 
															 lj_func.o: lj_func.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_gc.h \
														
 
															  lj_func.h lj_trace.h lj_jit.h lj_ir.h lj_dispatch.h lj_bc.h \
														
 
															  lj_traceerr.h lj_vm.h
														
@@ -127,15 +131,15 @@ lj_gdbjit.o: lj_gdbjit.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
 
															 lj_ir.o: lj_ir.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_gc.h \
														
 
															  lj_buf.h lj_str.h lj_tab.h lj_ir.h lj_jit.h lj_ircall.h lj_iropt.h \
														
 
															  lj_trace.h lj_dispatch.h lj_bc.h lj_traceerr.h lj_ctype.h lj_cdata.h \
														
 
															- lj_carith.h lj_vm.h lj_strscan.h lj_strfmt.h lj_prng.h
														
 
															+ lj_carith.h lj_vm.h lj_strscan.h lj_serialize.h lj_strfmt.h lj_prng.h
														
 
															 lj_lex.o: lj_lex.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_gc.h \
														
 
															  lj_err.h lj_errmsg.h lj_buf.h lj_str.h lj_tab.h lj_ctype.h lj_cdata.h \
														
 
															  lualib.h lj_state.h lj_lex.h lj_parse.h lj_char.h lj_strscan.h \
														
 
															  lj_strfmt.h
														
 
															 lj_lib.o: lj_lib.c lauxlib.h lua.h luaconf.h lj_obj.h lj_def.h lj_arch.h \
														
 
															  lj_gc.h lj_err.h lj_errmsg.h lj_str.h lj_tab.h lj_func.h lj_bc.h \
														
 
															- lj_dispatch.h lj_jit.h lj_ir.h lj_vm.h lj_strscan.h lj_strfmt.h lj_lex.h \
														
 
															- lj_bcdump.h lj_lib.h
														
 
															+ lj_dispatch.h lj_jit.h lj_ir.h lj_ctype.h lj_vm.h lj_strscan.h \
														
 
															+ lj_strfmt.h lj_lex.h lj_bcdump.h lj_lib.h
														
 
															 lj_load.o: lj_load.c lua.h luaconf.h lauxlib.h lj_obj.h lj_def.h \
														
 
															  lj_arch.h lj_gc.h lj_err.h lj_errmsg.h lj_buf.h lj_str.h lj_func.h \
														
 
															  lj_frame.h lj_bc.h lj_vm.h lj_lex.h lj_bcdump.h lj_parse.h
														
@@ -170,15 +174,18 @@ lj_parse.o: lj_parse.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
 
															  lj_gc.h lj_err.h lj_errmsg.h lj_debug.h lj_buf.h lj_str.h lj_tab.h \
														
 
															  lj_func.h lj_state.h lj_bc.h lj_ctype.h lj_strfmt.h lj_lex.h lj_parse.h \
														
 
															  lj_vm.h lj_vmevent.h
														
 
															+lj_prng.o: lj_prng.c lj_def.h lua.h luaconf.h lj_arch.h lj_prng.h
														
 
															 lj_profile.o: lj_profile.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
														
 
															  lj_buf.h lj_gc.h lj_str.h lj_frame.h lj_bc.h lj_debug.h lj_dispatch.h \
														
 
															  lj_jit.h lj_ir.h lj_trace.h lj_traceerr.h lj_profile.h luajit.h
														
 
															-lj_prng.o: lj_prng.c lj_def.h lua.h luaconf.h lj_arch.h lj_prng.h
														
 
															 lj_record.o: lj_record.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
														
 
															  lj_err.h lj_errmsg.h lj_str.h lj_tab.h lj_meta.h lj_frame.h lj_bc.h \
														
 
															  lj_ctype.h lj_gc.h lj_ff.h lj_ffdef.h lj_debug.h lj_ir.h lj_jit.h \
														
 
															  lj_ircall.h lj_iropt.h lj_trace.h lj_dispatch.h lj_traceerr.h \
														
 
															  lj_record.h lj_ffrecord.h lj_snap.h lj_vm.h lj_prng.h
														
 
															+lj_serialize.o: lj_serialize.c lj_obj.h lua.h luaconf.h lj_def.h \
														
 
															+ lj_arch.h lj_err.h lj_errmsg.h lj_buf.h lj_gc.h lj_str.h lj_tab.h \
														
 
															+ lj_udata.h lj_ctype.h lj_cdata.h lj_ir.h lj_serialize.h
														
 
															 lj_snap.o: lj_snap.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_gc.h \
														
 
															  lj_tab.h lj_state.h lj_frame.h lj_bc.h lj_ir.h lj_jit.h lj_iropt.h \
														
 
															  lj_trace.h lj_dispatch.h lj_traceerr.h lj_snap.h lj_target.h \
														
@@ -189,9 +196,10 @@ lj_state.o: lj_state.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
 
															  lj_ir.h lj_dispatch.h lj_traceerr.h lj_vm.h lj_prng.h lj_lex.h \
														
 
															  lj_alloc.h luajit.h
														
 
															 lj_str.o: lj_str.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_gc.h \
														
 
															- lj_err.h lj_errmsg.h lj_str.h lj_char.h
														
 
															+ lj_err.h lj_errmsg.h lj_str.h lj_char.h lj_prng.h
														
 
															 lj_strfmt.o: lj_strfmt.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
														
 
															- lj_buf.h lj_gc.h lj_str.h lj_state.h lj_char.h lj_strfmt.h
														
 
															+ lj_err.h lj_errmsg.h lj_buf.h lj_gc.h lj_str.h lj_meta.h lj_state.h \
														
 
															+ lj_char.h lj_strfmt.h lj_ctype.h lj_lib.h
														
 
															 lj_strfmt_num.o: lj_strfmt_num.c lj_obj.h lua.h luaconf.h lj_def.h \
														
 
															  lj_arch.h lj_buf.h lj_gc.h lj_str.h lj_strfmt.h
														
 
															 lj_strscan.o: lj_strscan.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
														
@@ -204,7 +212,7 @@ lj_trace.o: lj_trace.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
 
															  lj_dispatch.h lj_traceerr.h lj_snap.h lj_gdbjit.h lj_record.h lj_asm.h \
														
 
															  lj_vm.h lj_vmevent.h lj_target.h lj_target_*.h lj_prng.h
														
 
															 lj_udata.o: lj_udata.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
														
 
															- lj_gc.h lj_udata.h
														
 
															+ lj_gc.h lj_err.h lj_errmsg.h lj_udata.h
														
 
															 lj_vmevent.o: lj_vmevent.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
														
 
															  lj_str.h lj_tab.h lj_state.h lj_dispatch.h lj_bc.h lj_jit.h lj_ir.h \
														
 
															  lj_vm.h lj_vmevent.h
														
@@ -216,23 +224,23 @@ ljamalg.o: ljamalg.c lua.h luaconf.h lauxlib.h lj_assert.c lj_obj.h \
 
															  lj_bc.h lj_ctype.h lj_cdata.h lj_trace.h lj_jit.h lj_ir.h lj_dispatch.h \
														
 
															  lj_traceerr.h lj_vm.h lj_err.c lj_debug.h lj_ff.h lj_ffdef.h lj_strfmt.h \
														
 
															  lj_char.c lj_char.h lj_bc.c lj_bcdef.h lj_obj.c lj_buf.c lj_str.c \
														
 
															- lj_tab.c lj_func.c lj_udata.c lj_meta.c lj_strscan.h lj_lib.h lj_debug.c \
														
 
															- lj_prng.c lj_prng.h lj_state.c lj_lex.h lj_alloc.h luajit.h \
														
 
															+ lj_prng.h lj_tab.c lj_func.c lj_udata.c lj_meta.c lj_strscan.h lj_lib.h \
														
 
															+ lj_debug.c lj_prng.c lj_state.c lj_lex.h lj_alloc.h luajit.h \
														
 
															  lj_dispatch.c lj_ccallback.h lj_profile.h lj_vmevent.c lj_vmevent.h \
														
 
															- lj_vmmath.c lj_strscan.c lj_strfmt.c lj_strfmt_num.c lj_api.c \
														
 
															- lj_profile.c lj_lex.c lualib.h lj_parse.h lj_parse.c lj_bcread.c \
														
 
															- lj_bcdump.h lj_bcwrite.c lj_load.c lj_ctype.c lj_cdata.c lj_cconv.h \
														
 
															- lj_cconv.c lj_ccall.c lj_ccall.h lj_ccallback.c lj_target.h \
														
 
															- lj_target_*.h lj_mcode.h lj_carith.c lj_carith.h lj_clib.c lj_clib.h \
														
 
															- lj_cparse.c lj_cparse.h lj_lib.c lj_ir.c lj_ircall.h lj_iropt.h \
														
 
															- lj_opt_mem.c lj_opt_fold.c lj_folddef.h lj_opt_narrow.c lj_opt_dce.c \
														
 
															- lj_opt_loop.c lj_snap.h lj_opt_split.c lj_opt_sink.c lj_mcode.c \
														
 
															- lj_snap.c lj_record.c lj_record.h lj_ffrecord.h lj_crecord.c \
														
 
															+ lj_vmmath.c lj_strscan.c lj_strfmt.c lj_strfmt_num.c lj_serialize.c \
														
 
															+ lj_serialize.h lj_api.c lj_profile.c lj_lex.c lualib.h lj_parse.h \
														
 
															+ lj_parse.c lj_bcread.c lj_bcdump.h lj_bcwrite.c lj_load.c lj_ctype.c \
														
 
															+ lj_cdata.c lj_cconv.h lj_cconv.c lj_ccall.c lj_ccall.h lj_ccallback.c \
														
 
															+ lj_target.h lj_target_*.h lj_mcode.h lj_carith.c lj_carith.h lj_clib.c \
														
 
															+ lj_clib.h lj_cparse.c lj_cparse.h lj_lib.c lj_ir.c lj_ircall.h \
														
 
															+ lj_iropt.h lj_opt_mem.c lj_opt_fold.c lj_folddef.h lj_opt_narrow.c \
														
 
															+ lj_opt_dce.c lj_opt_loop.c lj_snap.h lj_opt_split.c lj_opt_sink.c \
														
 
															+ lj_mcode.c lj_snap.c lj_record.c lj_record.h lj_ffrecord.h lj_crecord.c \
														
 
															  lj_crecord.h lj_ffrecord.c lj_recdef.h lj_asm.c lj_asm.h lj_emit_*.h \
														
 
															  lj_asm_*.h lj_trace.c lj_gdbjit.h lj_gdbjit.c lj_alloc.c lib_aux.c \
														
 
															  lib_base.c lj_libdef.h lib_math.c lib_string.c lib_table.c lib_io.c \
														
 
															  lib_os.c lib_package.c lib_debug.c lib_bit.c lib_jit.c lib_ffi.c \
														
 
															- lib_init.c
														
 
															+ lib_buffer.c lib_init.c
														
 
															 luajit.o: luajit.c lua.h luaconf.h lauxlib.h lualib.h luajit.h lj_arch.h
														
 
															 host/buildvm.o: host/buildvm.c host/buildvm.h lj_def.h lua.h luaconf.h \
														
 
															  lj_arch.h lj_obj.h lj_def.h lj_arch.h lj_gc.h lj_obj.h lj_bc.h lj_ir.h \
														
--- a/libs/LuaJIT/src/host/buildvm_lib.c
+++ b/libs/LuaJIT/src/host/buildvm_lib.c
@@ -385,6 +385,8 @@ void emit_lib(BuildCtx *ctx)
 
															 	  ok = LJ_HASJIT;
														
 
															 	else if (!strcmp(buf, "#if LJ_HASFFI\n"))
														
 
															 	  ok = LJ_HASFFI;
														
 
															+	else if (!strcmp(buf, "#if LJ_HASBUFFER\n"))
														
 
															+	  ok = LJ_HASBUFFER;
														
 
															 	if (!ok) {
														
 
															 	  int lvl = 1;
														
 
															 	  while (fgets(buf, sizeof(buf), fp) != NULL) {
														
--- a/libs/LuaJIT/src/host/minilua.c
+++ b/libs/LuaJIT/src/host/minilua.c
@@ -1134,7 +1134,7 @@ if(!cl->isC){
 
															 CallInfo*ci;
														
 
															 StkId st,base;
														
 
															 Proto*p=cl->p;
														
 
															-luaD_checkstack(L,p->maxstacksize);
														
 
															+luaD_checkstack(L,p->maxstacksize+p->numparams);
														
 
															 func=restorestack(L,funcr);
														
 
															 if(!p->is_vararg){
														
 
															 base=func+1;
														
--- a/libs/LuaJIT/src/jit/dis_arm64.lua
+++ b/libs/LuaJIT/src/jit/dis_arm64.lua
@@ -1089,7 +1089,7 @@ local function disass_ins(ctx)
 
															 	  last = "#"..(sf+32 - immr)
														
 
															 	  operands[#operands] = last
														
 
															 	  x = x + 1
														
 
															-	elseif x >= immr then
														
 
															+	else
														
 
															 	  name = a2
														
 
															 	  x = x - immr + 1
														
 
															 	end
														
--- a/libs/LuaJIT/src/jit/dump.lua
+++ b/libs/LuaJIT/src/jit/dump.lua
@@ -102,10 +102,12 @@ end
 
															 local function fillsymtab(tr, nexit)
														
 
															   local t = symtab
														
 
															   if nexitsym == 0 then
														
 
															+    local maskaddr = jit.arch == "arm" and -2
														
 
															     local ircall = vmdef.ircall
														
 
															     for i=0,#ircall do
														
 
															       local addr = ircalladdr(i)
														
 
															       if addr ~= 0 then
														
 
															+	if maskaddr then addr = band(addr, maskaddr) end
														
 
															 	if addr < 0 then addr = addr + 2^32 end
														
 
															 	t[addr] = ircall[i]
														
 
															       end
														
@@ -217,8 +219,10 @@ local function colorize_text(s)
 
															   return s
														
 
															 end
														
 
															-local function colorize_ansi(s, t)
														
 
															-  return format(colortype_ansi[t], s)
														
 
															+local function colorize_ansi(s, t, extra)
														
 
															+  local out = format(colortype_ansi[t], s)
														
 
															+  if extra then out = "\027[3m"..out end
														
 
															+  return out
														
 
															 end
														
 
															 local irtype_ansi = setmetatable({},
														
@@ -227,9 +231,10 @@ local irtype_ansi = setmetatable({},
 
															 local html_escape = { ["<"] = "&lt;", [">"] = "&gt;", ["&"] = "&amp;", }
														
 
															-local function colorize_html(s, t)
														
 
															+local function colorize_html(s, t, extra)
														
 
															   s = gsub(s, "[<>&]", html_escape)
														
 
															-  return format('<span class="irt_%s">%s</span>', irtype_text[t], s)
														
 
															+  return format('<span class="irt_%s%s">%s</span>',
														
 
															+		irtype_text[t], extra and " irt_extra" or "", s)
														
 
															 end
														
 
															 local irtype_html = setmetatable({},
														
@@ -254,6 +259,7 @@ span.irt_tab { color: #c00000; }
 
															 span.irt_udt, span.irt_lud { color: #00c0c0; }
														
 
															 span.irt_num { color: #4040c0; }
														
 
															 span.irt_int, span.irt_i8, span.irt_u8, span.irt_i16, span.irt_u16 { color: #b040b0; }
														
 
															+span.irt_extra { font-style: italic; }
														
 
															 </style>
														
 
															 ]]
														
@@ -269,6 +275,7 @@ local litname = {
 
															     if band(mode, 8) ~= 0 then s = s.."C" end
														
 
															     if band(mode, 16) ~= 0 then s = s.."R" end
														
 
															     if band(mode, 32) ~= 0 then s = s.."I" end
														
 
															+    if band(mode, 64) ~= 0 then s = s.."K" end
														
 
															     t[mode] = s
														
 
															     return s
														
 
															   end}),
														
@@ -277,15 +284,18 @@ local litname = {
 
															     local s = irtype[band(mode, 31)]
														
 
															     s = irtype[band(shr(mode, 5), 31)].."."..s
														
 
															     if band(mode, 0x800) ~= 0 then s = s.." sext" end
														
 
															-    local c = shr(mode, 14)
														
 
															-    if c == 2 then s = s.." index" elseif c == 3 then s = s.." check" end
														
 
															+    local c = shr(mode, 12)
														
 
															+    if c == 1 then s = s.." none"
														
 
															+    elseif c == 2 then s = s.." index"
														
 
															+    elseif c == 3 then s = s.." check" end
														
 
															     t[mode] = s
														
 
															     return s
														
 
															   end}),
														
 
															   ["FLOAD "] = vmdef.irfield,
														
 
															   ["FREF  "] = vmdef.irfield,
														
 
															   ["FPMATH"] = vmdef.irfpm,
														
 
															-  ["BUFHDR"] = { [0] = "RESET", "APPEND" },
														
 
															+  ["TMPREF"] = { [0] = "", "IN", "OUT", "INOUT", "", "", "OUT2", "INOUT2" },
														
 
															+  ["BUFHDR"] = { [0] = "RESET", "APPEND", "WRITE" },
														
 
															   ["TOSTR "] = { [0] = "INT", "NUM", "CHAR" },
														
 
															 }
														
@@ -345,7 +355,7 @@ local function formatk(tr, idx, sn)
 
															   else
														
 
															     s = tostring(k) -- For primitives.
														
 
															   end
														
 
															-  s = colorize(format("%-4s", s), t)
														
 
															+  s = colorize(format("%-4s", s), t, band(sn or 0, 0x100000) ~= 0)
														
 
															   if slot then
														
 
															     s = format("%s @%d", s, slot)
														
 
															   end
														
@@ -365,7 +375,7 @@ local function printsnap(tr, snap)
 
															 	out:write(colorize(format("%04d/%04d", ref, ref+1), 14))
														
 
															       else
														
 
															 	local m, ot, op1, op2 = traceir(tr, ref)
														
 
															-	out:write(colorize(format("%04d", ref), band(ot, 31)))
														
 
															+	out:write(colorize(format("%04d", ref), band(ot, 31), band(sn, 0x100000) ~= 0))
														
 
															       end
														
 
															       out:write(band(sn, 0x10000) == 0 and " " or "|") -- SNAP_FRAME
														
 
															     else
														
--- a/libs/LuaJIT/src/jit/p.lua
+++ b/libs/LuaJIT/src/jit/p.lua
@@ -238,6 +238,7 @@ local function prof_finish()
 
															     prof_count1 = nil
														
 
															     prof_count2 = nil
														
 
															     prof_ud = nil
														
 
															+    if out ~= stdout then out:close() end
														
 
															   end
														
 
															 end
														
--- a/libs/LuaJIT/src/lib_base.c
+++ b/libs/LuaJIT/src/lib_base.c
@@ -19,6 +19,7 @@
 
															 #include "lj_gc.h"
														
 
															 #include "lj_err.h"
														
 
															 #include "lj_debug.h"
														
 
															+#include "lj_buf.h"
														
 
															 #include "lj_str.h"
														
 
															 #include "lj_tab.h"
														
 
															 #include "lj_meta.h"
														
@@ -75,9 +76,10 @@ LJLIB_ASM_(type)		LJLIB_REC(.)
 
															 /* This solves a circular dependency problem -- change FF_next_N as needed. */
														
 
															 LJ_STATIC_ASSERT((int)FF_next == FF_next_N);
														
 
															-LJLIB_ASM(next)
														
 
															+LJLIB_ASM(next)			LJLIB_REC(.)
														
 
															 {
														
 
															   lj_lib_checktab(L, 1);
														
 
															+  lj_err_msg(L, LJ_ERR_NEXTIDX);
														
 
															   return FFH_UNREACHABLE;
														
 
															 }
														
@@ -406,10 +408,22 @@ LJLIB_CF(load)
 
															   GCstr *name = lj_lib_optstr(L, 2);
														
 
															   GCstr *mode = lj_lib_optstr(L, 3);
														
 
															   int status;
														
 
															-  if (L->base < L->top && (tvisstr(L->base) || tvisnumber(L->base))) {
														
 
															-    GCstr *s = lj_lib_checkstr(L, 1);
														
 
															+  if (L->base < L->top &&
														
 
															+      (tvisstr(L->base) || tvisnumber(L->base) || tvisbuf(L->base))) {
														
 
															+    const char *s;
														
 
															+    MSize len;
														
 
															+    if (tvisbuf(L->base)) {
														
 
															+      SBufExt *sbx = bufV(L->base);
														
 
															+      s = sbx->r;
														
 
															+      len = sbufxlen(sbx);
														
 
															+      if (!name) name = &G(L)->strempty;  /* Buffers are not NUL-terminated. */
														
 
															+    } else {
														
 
															+      GCstr *str = lj_lib_checkstr(L, 1);
														
 
															+      s = strdata(str);
														
 
															+      len = str->len;
														
 
															+    }
														
 
															     lua_settop(L, 4);  /* Ensure env arg exists. */
														
 
															-    status = luaL_loadbufferx(L, strdata(s), s->len, strdata(name ? name : s),
														
 
															+    status = luaL_loadbufferx(L, s, len, name ? strdata(name) : s,
														
 
															 			      mode ? strdata(mode) : NULL);
														
 
															   } else {
														
 
															     lj_lib_checkfunc(L, 1);
														
--- a/libs/LuaJIT/src/lib_buffer.c
+++ b/libs/LuaJIT/src/lib_buffer.c
@@ -0,0 +1,356 @@
 
															+/*
														
 
															+** Buffer library.
														
 
															+** Copyright (C) 2005-2021 Mike Pall. See Copyright Notice in luajit.h
														
 
															+*/
														
 
															+
														
 
															+#define lib_buffer_c
														
 
															+#define LUA_LIB
														
 
															+
														
 
															+#include "lua.h"
														
 
															+#include "lauxlib.h"
														
 
															+#include "lualib.h"
														
 
															+
														
 
															+#include "lj_obj.h"
														
 
															+
														
 
															+#if LJ_HASBUFFER
														
 
															+#include "lj_gc.h"
														
 
															+#include "lj_err.h"
														
 
															+#include "lj_buf.h"
														
 
															+#include "lj_str.h"
														
 
															+#include "lj_tab.h"
														
 
															+#include "lj_udata.h"
														
 
															+#include "lj_meta.h"
														
 
															+#if LJ_HASFFI
														
 
															+#include "lj_ctype.h"
														
 
															+#include "lj_cdata.h"
														
 
															+#include "lj_cconv.h"
														
 
															+#endif
														
 
															+#include "lj_strfmt.h"
														
 
															+#include "lj_serialize.h"
														
 
															+#include "lj_lib.h"
														
 
															+
														
 
															+/* -- Helper functions ---------------------------------------------------- */
														
 
															+
														
 
															+/* Check that the first argument is a string buffer. */
														
 
															+static SBufExt *buffer_tobuf(lua_State *L)
														
 
															+{
														
 
															+  if (!(L->base < L->top && tvisbuf(L->base)))
														
 
															+    lj_err_argtype(L, 1, "buffer");
														
 
															+  return bufV(L->base);
														
 
															+}
														
 
															+
														
 
															+/* Ditto, but for writers. */
														
 
															+static LJ_AINLINE SBufExt *buffer_tobufw(lua_State *L)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobuf(L);
														
 
															+  setsbufXL_(sbx, L);
														
 
															+  return sbx;
														
 
															+}
														
 
															+
														
 
															+#define buffer_toudata(sbx)	((GCudata *)(sbx)-1)
														
 
															+
														
 
															+/* -- Buffer methods ------------------------------------------------------ */
														
 
															+
														
 
															+#define LJLIB_MODULE_buffer_method
														
 
															+
														
 
															+LJLIB_CF(buffer_method_free)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobuf(L);
														
 
															+  lj_bufx_free(L, sbx);
														
 
															+  L->top = L->base+1;  /* Chain buffer object. */
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_method_reset)		LJLIB_REC(.)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobuf(L);
														
 
															+  lj_bufx_reset(sbx);
														
 
															+  L->top = L->base+1;  /* Chain buffer object. */
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_method_skip)		LJLIB_REC(.)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobuf(L);
														
 
															+  MSize n = (MSize)lj_lib_checkintrange(L, 2, 0, LJ_MAX_BUF);
														
 
															+  MSize len = sbufxlen(sbx);
														
 
															+  if (n < len) {
														
 
															+    sbx->r += n;
														
 
															+  } else {
														
 
															+    sbx->r = sbx->w = sbx->b;
														
 
															+  }
														
 
															+  L->top = L->base+1;  /* Chain buffer object. */
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_method_set)		LJLIB_REC(.)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobuf(L);
														
 
															+  GCobj *ref;
														
 
															+  const char *p;
														
 
															+  MSize len;
														
 
															+#if LJ_HASFFI
														
 
															+  if (tviscdata(L->base+1)) {
														
 
															+    CTState *cts = ctype_cts(L);
														
 
															+    lj_cconv_ct_tv(cts, ctype_get(cts, CTID_P_CVOID), (uint8_t *)&p,
														
 
															+		   L->base+1, CCF_ARG(2));
														
 
															+    len = (MSize)lj_lib_checkintrange(L, 3, 0, LJ_MAX_BUF);
														
 
															+  } else
														
 
															+#endif
														
 
															+  {
														
 
															+    GCstr *str = lj_lib_checkstrx(L, 2);
														
 
															+    p = strdata(str);
														
 
															+    len = str->len;
														
 
															+  }
														
 
															+  lj_bufx_free(L, sbx);
														
 
															+  lj_bufx_set_cow(L, sbx, p, len);
														
 
															+  ref = gcV(L->base+1);
														
 
															+  setgcref(sbx->cowref, ref);
														
 
															+  lj_gc_objbarrier(L, buffer_toudata(sbx), ref);
														
 
															+  L->top = L->base+1;  /* Chain buffer object. */
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_method_put)		LJLIB_REC(.)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobufw(L);
														
 
															+  ptrdiff_t arg, narg = L->top - L->base;
														
 
															+  for (arg = 1; arg < narg; arg++) {
														
 
															+    cTValue *o = &L->base[arg], *mo = NULL;
														
 
															+  retry:
														
 
															+    if (tvisstr(o)) {
														
 
															+      lj_buf_putstr((SBuf *)sbx, strV(o));
														
 
															+    } else if (tvisint(o)) {
														
 
															+      lj_strfmt_putint((SBuf *)sbx, intV(o));
														
 
															+    } else if (tvisnum(o)) {
														
 
															+      lj_strfmt_putfnum((SBuf *)sbx, STRFMT_G14, numV(o));
														
 
															+    } else if (tvisbuf(o)) {
														
 
															+      SBufExt *sbx2 = bufV(o);
														
 
															+      if (sbx2 == sbx) lj_err_arg(L, arg+1, LJ_ERR_BUFFER_SELF);
														
 
															+      lj_buf_putmem((SBuf *)sbx, sbx2->r, sbufxlen(sbx2));
														
 
															+    } else if (!mo && !tvisnil(mo = lj_meta_lookup(L, o, MM_tostring))) {
														
 
															+      /* Call __tostring metamethod inline. */
														
 
															+      copyTV(L, L->top++, mo);
														
 
															+      copyTV(L, L->top++, o);
														
 
															+      lua_call(L, 1, 1);
														
 
															+      o = &L->base[arg];  /* The stack may have been reallocated. */
														
 
															+      copyTV(L, &L->base[arg], L->top-1);
														
 
															+      L->top = L->base + narg;
														
 
															+      goto retry;  /* Retry with the result. */
														
 
															+    } else {
														
 
															+      lj_err_argtype(L, arg+1, "string/number/__tostring");
														
 
															+    }
														
 
															+    /* Probably not useful to inline other __tostring MMs, e.g. FFI numbers. */
														
 
															+  }
														
 
															+  L->top = L->base+1;  /* Chain buffer object. */
														
 
															+  lj_gc_check(L);
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_method_putf)		LJLIB_REC(.)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobufw(L);
														
 
															+  lj_strfmt_putarg(L, (SBuf *)sbx, 2, 2);
														
 
															+  L->top = L->base+1;  /* Chain buffer object. */
														
 
															+  lj_gc_check(L);
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_method_get)		LJLIB_REC(.)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobuf(L);
														
 
															+  ptrdiff_t arg, narg = L->top - L->base;
														
 
															+  if (narg == 1) {
														
 
															+    narg++;
														
 
															+    setnilV(L->top++);  /* get() is the same as get(nil). */
														
 
															+  }
														
 
															+  for (arg = 1; arg < narg; arg++) {
														
 
															+    TValue *o = &L->base[arg];
														
 
															+    MSize n = tvisnil(o) ? LJ_MAX_BUF :
														
 
															+	      (MSize) lj_lib_checkintrange(L, arg+1, 0, LJ_MAX_BUF);
														
 
															+    MSize len = sbufxlen(sbx);
														
 
															+    if (n > len) n = len;
														
 
															+    setstrV(L, o, lj_str_new(L, sbx->r, n));
														
 
															+    sbx->r += n;
														
 
															+  }
														
 
															+  if (sbx->r == sbx->w) sbx->r = sbx->w = sbx->b;
														
 
															+  lj_gc_check(L);
														
 
															+  return narg-1;
														
 
															+}
														
 
															+
														
 
															+#if LJ_HASFFI
														
 
															+LJLIB_CF(buffer_method_putcdata)	LJLIB_REC(.)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobufw(L);
														
 
															+  const char *p;
														
 
															+  MSize len;
														
 
															+  if (tviscdata(L->base+1)) {
														
 
															+    CTState *cts = ctype_cts(L);
														
 
															+    lj_cconv_ct_tv(cts, ctype_get(cts, CTID_P_CVOID), (uint8_t *)&p,
														
 
															+		   L->base+1, CCF_ARG(2));
														
 
															+  } else {
														
 
															+    lj_err_argtype(L, 2, "cdata");
														
 
															+  }
														
 
															+  len = (MSize)lj_lib_checkintrange(L, 3, 0, LJ_MAX_BUF);
														
 
															+  lj_buf_putmem((SBuf *)sbx, p, len);
														
 
															+  L->top = L->base+1;  /* Chain buffer object. */
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_method_reserve)		LJLIB_REC(.)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobufw(L);
														
 
															+  MSize sz = (MSize)lj_lib_checkintrange(L, 2, 0, LJ_MAX_BUF);
														
 
															+  GCcdata *cd;
														
 
															+  lj_buf_more((SBuf *)sbx, sz);
														
 
															+  ctype_loadffi(L);
														
 
															+  cd = lj_cdata_new_(L, CTID_P_UINT8, CTSIZE_PTR);
														
 
															+  *(void **)cdataptr(cd) = sbx->w;
														
 
															+  setcdataV(L, L->top++, cd);
														
 
															+  setintV(L->top++, sbufleft(sbx));
														
 
															+  return 2;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_method_commit)		LJLIB_REC(.)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobuf(L);
														
 
															+  MSize len = (MSize)lj_lib_checkintrange(L, 2, 0, LJ_MAX_BUF);
														
 
															+  if (len > sbufleft(sbx)) lj_err_arg(L, 2, LJ_ERR_NUMRNG);
														
 
															+  sbx->w += len;
														
 
															+  L->top = L->base+1;  /* Chain buffer object. */
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_method_ref)		LJLIB_REC(.)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobuf(L);
														
 
															+  GCcdata *cd;
														
 
															+  ctype_loadffi(L);
														
 
															+  cd = lj_cdata_new_(L, CTID_P_UINT8, CTSIZE_PTR);
														
 
															+  *(void **)cdataptr(cd) = sbx->r;
														
 
															+  setcdataV(L, L->top++, cd);
														
 
															+  setintV(L->top++, sbufxlen(sbx));
														
 
															+  return 2;
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															+LJLIB_CF(buffer_method_encode)		LJLIB_REC(.)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobufw(L);
														
 
															+  cTValue *o = lj_lib_checkany(L, 2);
														
 
															+  lj_serialize_put(sbx, o);
														
 
															+  lj_gc_check(L);
														
 
															+  L->top = L->base+1;  /* Chain buffer object. */
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_method_decode)		LJLIB_REC(.)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobufw(L);
														
 
															+  setnilV(L->top++);
														
 
															+  sbx->r = lj_serialize_get(sbx, L->top-1);
														
 
															+  lj_gc_check(L);
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_method___gc)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobuf(L);
														
 
															+  lj_bufx_free(L, sbx);
														
 
															+  return 0;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_method___tostring)	LJLIB_REC(.)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobuf(L);
														
 
															+  setstrV(L, L->top-1, lj_str_new(L, sbx->r, sbufxlen(sbx)));
														
 
															+  lj_gc_check(L);
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_method___len)		LJLIB_REC(.)
														
 
															+{
														
 
															+  SBufExt *sbx = buffer_tobuf(L);
														
 
															+  setintV(L->top-1, (int32_t)sbufxlen(sbx));
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+LJLIB_PUSH("buffer") LJLIB_SET(__metatable)
														
 
															+LJLIB_PUSH(top-1) LJLIB_SET(__index)
														
 
															+
														
 
															+/* -- Buffer library functions -------------------------------------------- */
														
 
															+
														
 
															+#define LJLIB_MODULE_buffer
														
 
															+
														
 
															+LJLIB_PUSH(top-2) LJLIB_SET(!)  /* Set environment. */
														
 
															+
														
 
															+LJLIB_CF(buffer_new)
														
 
															+{
														
 
															+  MSize sz = 0;
														
 
															+  int targ = 1;
														
 
															+  GCtab *env, *dict_str = NULL, *dict_mt = NULL;
														
 
															+  GCudata *ud;
														
 
															+  SBufExt *sbx;
														
 
															+  if (L->base < L->top && !tvistab(L->base)) {
														
 
															+    targ = 2;
														
 
															+    if (!tvisnil(L->base))
														
 
															+      sz = (MSize)lj_lib_checkintrange(L, 1, 0, LJ_MAX_BUF);
														
 
															+  }
														
 
															+  if (L->base+targ-1 < L->top) {
														
 
															+    GCtab *options = lj_lib_checktab(L, targ);
														
 
															+    cTValue *opt_dict, *opt_mt;
														
 
															+    opt_dict = lj_tab_getstr(options, lj_str_newlit(L, "dict"));
														
 
															+    if (opt_dict && tvistab(opt_dict)) {
														
 
															+      dict_str = tabV(opt_dict);
														
 
															+      lj_serialize_dict_prep_str(L, dict_str);
														
 
															+    }
														
 
															+    opt_mt = lj_tab_getstr(options, lj_str_newlit(L, "metatable"));
														
 
															+    if (opt_mt && tvistab(opt_mt)) {
														
 
															+      dict_mt = tabV(opt_mt);
														
 
															+      lj_serialize_dict_prep_mt(L, dict_mt);
														
 
															+    }
														
 
															+  }
														
 
															+  env = tabref(curr_func(L)->c.env);
														
 
															+  ud = lj_udata_new(L, sizeof(SBufExt), env);
														
 
															+  ud->udtype = UDTYPE_BUFFER;
														
 
															+  /* NOBARRIER: The GCudata is new (marked white). */
														
 
															+  setgcref(ud->metatable, obj2gco(env));
														
 
															+  setudataV(L, L->top++, ud);
														
 
															+  sbx = (SBufExt *)uddata(ud);
														
 
															+  lj_bufx_init(L, sbx);
														
 
															+  setgcref(sbx->dict_str, obj2gco(dict_str));
														
 
															+  setgcref(sbx->dict_mt, obj2gco(dict_mt));
														
 
															+  if (sz > 0) lj_buf_need2((SBuf *)sbx, sz);
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_encode)			LJLIB_REC(.)
														
 
															+{
														
 
															+  cTValue *o = lj_lib_checkany(L, 1);
														
 
															+  setstrV(L, L->top++, lj_serialize_encode(L, o));
														
 
															+  lj_gc_check(L);
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+LJLIB_CF(buffer_decode)			LJLIB_REC(.)
														
 
															+{
														
 
															+  GCstr *str = lj_lib_checkstrx(L, 1);
														
 
															+  setnilV(L->top++);
														
 
															+  lj_serialize_decode(L, L->top-1, str);
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+/* ------------------------------------------------------------------------ */
														
 
															+
														
 
															+#include "lj_libdef.h"
														
 
															+
														
 
															+int luaopen_string_buffer(lua_State *L)
														
 
															+{
														
 
															+  LJ_LIB_REG(L, NULL, buffer_method);
														
 
															+  lua_getfield(L, -1, "__tostring");
														
 
															+  lua_setfield(L, -2, "tostring");
														
 
															+  LJ_LIB_REG(L, NULL, buffer);
														
 
															+  return 1;
														
 
															+}
														
 
															+
														
 
															+#endif
														
--- a/libs/LuaJIT/src/lib_ffi.c
+++ b/libs/LuaJIT/src/lib_ffi.c
@@ -573,6 +573,7 @@ LJLIB_CF(ffi_typeinfo)
 
															       setintV(lj_tab_setstr(L, t, lj_str_newlit(L, "sib")), (int32_t)ct->sib);
														
 
															     if (gcref(ct->name)) {
														
 
															       GCstr *s = gco2str(gcref(ct->name));
														
 
															+      if (isdead(G(L), obj2gco(s))) flipwhite(obj2gco(s));
														
 
															       setstrV(L, lj_tab_setstr(L, t, lj_str_newlit(L, "name")), s);
														
 
															     }
														
 
															     lj_gc_check(L);
														
--- a/libs/LuaJIT/src/lib_io.c
+++ b/libs/LuaJIT/src/lib_io.c
@@ -60,12 +60,12 @@ static IOFileUD *io_tofile(lua_State *L)
 
															   return iof;
														
 
															 }
														
 
															-static FILE *io_stdfile(lua_State *L, ptrdiff_t id)
														
 
															+static IOFileUD *io_stdfile(lua_State *L, ptrdiff_t id)
														
 
															 {
														
 
															   IOFileUD *iof = IOSTDF_IOF(L, id);
														
 
															   if (iof->fp == NULL)
														
 
															     lj_err_caller(L, LJ_ERR_IOSTDCL);
														
 
															-  return iof->fp;
														
 
															+  return iof;
														
 
															 }
														
 
															 static IOFileUD *io_file_new(lua_State *L)
														
@@ -178,7 +178,7 @@ static int io_file_readlen(lua_State *L, FILE *fp, MSize m)
 
															     MSize n = (MSize)fread(buf, 1, m, fp);
														
 
															     setstrV(L, L->top++, lj_str_new(L, buf, (size_t)n));
														
 
															     lj_gc_check(L);
														
 
															-    return (n > 0 || m == 0);
														
 
															+    return n > 0;
														
 
															   } else {
														
 
															     int c = getc(fp);
														
 
															     ungetc(c, fp);
														
@@ -187,8 +187,9 @@ static int io_file_readlen(lua_State *L, FILE *fp, MSize m)
 
															   }
														
 
															 }
														
 
															-static int io_file_read(lua_State *L, FILE *fp, int start)
														
 
															+static int io_file_read(lua_State *L, IOFileUD *iof, int start)
														
 
															 {
														
 
															+  FILE *fp = iof->fp;
														
 
															   int ok, n, nargs = (int)(L->top - L->base) - start;
														
 
															   clearerr(fp);
														
 
															   if (nargs == 0) {
														
@@ -224,8 +225,9 @@ static int io_file_read(lua_State *L, FILE *fp, int start)
 
															   return n - start;
														
 
															 }
														
 
															-static int io_file_write(lua_State *L, FILE *fp, int start)
														
 
															+static int io_file_write(lua_State *L, IOFileUD *iof, int start)
														
 
															 {
														
 
															+  FILE *fp = iof->fp;
														
 
															   cTValue *tv;
														
 
															   int status = 1;
														
 
															   for (tv = L->base+start; tv < L->top; tv++) {
														
@@ -253,13 +255,11 @@ static int io_file_iter(lua_State *L)
 
															     lj_err_caller(L, LJ_ERR_IOCLFL);
														
 
															   L->top = L->base;
														
 
															   if (n) {  /* Copy upvalues with options to stack. */
														
 
															-    if (n > LUAI_MAXCSTACK)
														
 
															-      lj_err_caller(L, LJ_ERR_STKOV);
														
 
															     lj_state_checkstack(L, (MSize)n);
														
 
															     memcpy(L->top, &fn->c.upvalue[1], n*sizeof(TValue));
														
 
															     L->top += n;
														
 
															   }
														
 
															-  n = io_file_read(L, iof->fp, 0);
														
 
															+  n = io_file_read(L, iof, 0);
														
 
															   if (ferror(iof->fp))
														
 
															     lj_err_callermsg(L, strVdata(L->top-2));
														
 
															   if (tvisnil(L->base) && (iof->type & IOFILE_FLAG_CLOSE)) {
														
@@ -284,19 +284,25 @@ static int io_file_lines(lua_State *L)
 
															 LJLIB_CF(io_method_close)
														
 
															 {
														
 
															-  IOFileUD *iof = L->base < L->top ? io_tofile(L) :
														
 
															-		  IOSTDF_IOF(L, GCROOT_IO_OUTPUT);
														
 
															+  IOFileUD *iof;
														
 
															+  if (L->base < L->top) {
														
 
															+    iof = io_tofile(L);
														
 
															+  } else {
														
 
															+    iof = IOSTDF_IOF(L, GCROOT_IO_OUTPUT);
														
 
															+    if (iof->fp == NULL)
														
 
															+      lj_err_caller(L, LJ_ERR_IOCLFL);
														
 
															+  }
														
 
															   return io_file_close(L, iof);
														
 
															 }
														
 
															 LJLIB_CF(io_method_read)
														
 
															 {
														
 
															-  return io_file_read(L, io_tofile(L)->fp, 1);
														
 
															+  return io_file_read(L, io_tofile(L), 1);
														
 
															 }
														
 
															 LJLIB_CF(io_method_write)		LJLIB_REC(io_write 0)
														
 
															 {
														
 
															-  return io_file_write(L, io_tofile(L)->fp, 1);
														
 
															+  return io_file_write(L, io_tofile(L), 1);
														
 
															 }
														
 
															 LJLIB_CF(io_method_flush)		LJLIB_REC(io_flush 0)
														
@@ -458,7 +464,7 @@ LJLIB_CF(io_write)		LJLIB_REC(io_write GCROOT_IO_OUTPUT)
 
															 LJLIB_CF(io_flush)		LJLIB_REC(io_flush GCROOT_IO_OUTPUT)
														
 
															 {
														
 
															-  return luaL_fileresult(L, fflush(io_stdfile(L, GCROOT_IO_OUTPUT)) == 0, NULL);
														
 
															+  return luaL_fileresult(L, fflush(io_stdfile(L, GCROOT_IO_OUTPUT)->fp) == 0, NULL);
														
 
															 }
														
 
															 static int io_std_getset(lua_State *L, ptrdiff_t id, const char *mode)
														
--- a/libs/LuaJIT/src/lib_jit.c
+++ b/libs/LuaJIT/src/lib_jit.c
@@ -346,11 +346,7 @@ LJLIB_CF(jit_util_tracek)
 
															       ir = &T->ir[ir->op1];
														
 
															     }
														
 
															 #if LJ_HASFFI
														
 
															-    if (ir->o == IR_KINT64 && !ctype_ctsG(G(L))) {
														
 
															-      ptrdiff_t oldtop = savestack(L, L->top);
														
 
															-      luaopen_ffi(L);  /* Load FFI library on-demand. */
														
 
															-      L->top = restorestack(L, oldtop);
														
 
															-    }
														
 
															+    if (ir->o == IR_KINT64) ctype_loadffi(L);
														
 
															 #endif
														
 
															     lj_ir_kvalue(L, L->top-2, ir);
														
 
															     setintV(L->top-1, (int32_t)irt_type(ir->t));
														
--- a/libs/LuaJIT/src/lib_string.c
+++ b/libs/LuaJIT/src/lib_string.c
@@ -640,89 +640,14 @@ LJLIB_CF(string_gsub)
 
															 /* ------------------------------------------------------------------------ */
														
 
															-/* Emulate tostring() inline. */
														
 
															-static GCstr *string_fmt_tostring(lua_State *L, int arg, int retry)
														
 
															-{
														
 
															-  TValue *o = L->base+arg-1;
														
 
															-  cTValue *mo;
														
 
															-  lj_assertL(o < L->top, "bad usage");  /* Caller already checks for existence. */
														
 
															-  if (LJ_LIKELY(tvisstr(o)))
														
 
															-    return strV(o);
														
 
															-  if (retry != 2 && !tvisnil(mo = lj_meta_lookup(L, o, MM_tostring))) {
														
 
															-    copyTV(L, L->top++, mo);
														
 
															-    copyTV(L, L->top++, o);
														
 
															-    lua_call(L, 1, 1);
														
 
															-    copyTV(L, L->base+arg-1, --L->top);
														
 
															-    return NULL;  /* Buffer may be overwritten, retry. */
														
 
															-  }
														
 
															-  return lj_strfmt_obj(L, o);
														
 
															-}
														
 
															-
														
 
															 LJLIB_CF(string_format)		LJLIB_REC(.)
														
 
															 {
														
 
															-  int arg, top = (int)(L->top - L->base);
														
 
															-  GCstr *fmt;
														
 
															-  SBuf *sb;
														
 
															-  FormatState fs;
														
 
															-  SFormat sf;
														
 
															   int retry = 0;
														
 
															-again:
														
 
															-  arg = 1;
														
 
															-  sb = lj_buf_tmp_(L);
														
 
															-  fmt = lj_lib_checkstr(L, arg);
														
 
															-  lj_strfmt_init(&fs, strdata(fmt), fmt->len);
														
 
															-  while ((sf = lj_strfmt_parse(&fs)) != STRFMT_EOF) {
														
 
															-    if (sf == STRFMT_LIT) {
														
 
															-      lj_buf_putmem(sb, fs.str, fs.len);
														
 
															-    } else if (sf == STRFMT_ERR) {
														
 
															-      lj_err_callerv(L, LJ_ERR_STRFMT, strdata(lj_str_new(L, fs.str, fs.len)));
														
 
															-    } else {
														
 
															-      if (++arg > top)
														
 
															-	luaL_argerror(L, arg, lj_obj_typename[0]);
														
 
															-      switch (STRFMT_TYPE(sf)) {
														
 
															-      case STRFMT_INT:
														
 
															-	if (tvisint(L->base+arg-1)) {
														
 
															-	  int32_t k = intV(L->base+arg-1);
														
 
															-	  if (sf == STRFMT_INT)
														
 
															-	    lj_strfmt_putint(sb, k);  /* Shortcut for plain %d. */
														
 
															-	  else
														
 
															-	    lj_strfmt_putfxint(sb, sf, k);
														
 
															-	} else {
														
 
															-	  lj_strfmt_putfnum_int(sb, sf, lj_lib_checknum(L, arg));
														
 
															-	}
														
 
															-	break;
														
 
															-      case STRFMT_UINT:
														
 
															-	if (tvisint(L->base+arg-1))
														
 
															-	  lj_strfmt_putfxint(sb, sf, intV(L->base+arg-1));
														
 
															-	else
														
 
															-	  lj_strfmt_putfnum_uint(sb, sf, lj_lib_checknum(L, arg));
														
 
															-	break;
														
 
															-      case STRFMT_NUM:
														
 
															-	lj_strfmt_putfnum(sb, sf, lj_lib_checknum(L, arg));
														
 
															-	break;
														
 
															-      case STRFMT_STR: {
														
 
															-	GCstr *str = string_fmt_tostring(L, arg, retry);
														
 
															-	if (str == NULL)
														
 
															-	  retry = 1;
														
 
															-	else if ((sf & STRFMT_T_QUOTED))
														
 
															-	  lj_strfmt_putquoted(sb, str);  /* No formatting. */
														
 
															-	else
														
 
															-	  lj_strfmt_putfstr(sb, sf, str);
														
 
															-	break;
														
 
															-	}
														
 
															-      case STRFMT_CHAR:
														
 
															-	lj_strfmt_putfchar(sb, sf, lj_lib_checkint(L, arg));
														
 
															-	break;
														
 
															-      case STRFMT_PTR:  /* No formatting. */
														
 
															-	lj_strfmt_putptr(sb, lj_obj_ptr(G(L), L->base+arg-1));
														
 
															-	break;
														
 
															-      default:
														
 
															-	lj_assertL(0, "bad string format type");
														
 
															-	break;
														
 
															-      }
														
 
															-    }
														
 
															-  }
														
 
															-  if (retry++ == 1) goto again;
														
 
															+  SBuf *sb;
														
 
															+  do {
														
 
															+    sb = lj_buf_tmp_(L);
														
 
															+    retry = lj_strfmt_putarg(L, sb, 1, -retry);
														
 
															+  } while (retry > 0);
														
 
															   setstrV(L, L->top-1, lj_buf_str(L, sb));
														
 
															   lj_gc_check(L);
														
 
															   return 1;
														
@@ -743,6 +668,9 @@ LUALIB_API int luaopen_string(lua_State *L)
 
															   setgcref(basemt_it(g, LJ_TSTR), obj2gco(mt));
														
 
															   settabV(L, lj_tab_setstr(L, mt, mmname_str(g, MM_index)), tabV(L->top-1));
														
 
															   mt->nomm = (uint8_t)(~(1u<<MM_index));
														
 
															+#if LJ_HASBUFFER
														
 
															+  lj_lib_prereg(L, LUA_STRLIBNAME ".buffer", luaopen_string_buffer, tabV(L->top-1));
														
 
															+#endif
														
 
															   return 1;
														
 
															 }
														
--- a/libs/LuaJIT/src/lib_table.c
+++ b/libs/LuaJIT/src/lib_table.c
@@ -159,7 +159,7 @@ LJLIB_CF(table_concat)		LJLIB_REC(.)
 
															   SBuf *sb = lj_buf_tmp_(L);
														
 
															   SBuf *sbx = lj_buf_puttab(sb, t, sep, i, e);
														
 
															   if (LJ_UNLIKELY(!sbx)) {  /* Error: bad element type. */
														
 
															-    int32_t idx = (int32_t)(intptr_t)sbufP(sb);
														
 
															+    int32_t idx = (int32_t)(intptr_t)sb->w;
														
 
															     cTValue *o = lj_tab_getint(t, idx);
														
 
															     lj_err_callerv(L, LJ_ERR_TABCAT,
														
 
															 		   lj_obj_itypename[o ? itypemap(o) : ~LJ_TNIL], idx);
														
--- a/libs/LuaJIT/src/lj_alloc.c
+++ b/libs/LuaJIT/src/lj_alloc.c
@@ -365,7 +365,7 @@ static void *CALL_MREMAP_(void *ptr, size_t osz, size_t nsz, int flags)
 
															 #define CALL_MREMAP(addr, osz, nsz, mv) CALL_MREMAP_((addr), (osz), (nsz), (mv))
														
 
															 #define CALL_MREMAP_NOMOVE	0
														
 
															 #define CALL_MREMAP_MAYMOVE	1
														
 
															-#if LJ_64 && !LJ_GC64
														
 
															+#if LJ_64 && (!LJ_GC64 || LJ_TARGET_ARM64)
														
 
															 #define CALL_MREMAP_MV		CALL_MREMAP_NOMOVE
														
 
															 #else
														
 
															 #define CALL_MREMAP_MV		CALL_MREMAP_MAYMOVE
														
--- a/libs/LuaJIT/src/lj_api.c
+++ b/libs/LuaJIT/src/lj_api.c
@@ -707,36 +707,10 @@ LUA_API void lua_pushboolean(lua_State *L, int b)
 
															   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)
														
 
															 {
														
 
															 #if LJ_64
														
 
															-  p = lightud_intern(L, p);
														
 
															+  p = lj_lightud_intern(L, p);
														
 
															 #endif
														
 
															   setrawlightudV(L->top, p);
														
 
															   incr_top(L);
														
@@ -919,11 +893,13 @@ LUA_API int lua_next(lua_State *L, int idx)
 
															   cTValue *t = index2adr(L, idx);
														
 
															   int more;
														
 
															   lj_checkapi(tvistab(t), "stack slot %d is not a table", idx);
														
 
															-  more = lj_tab_next(L, tabV(t), L->top-1);
														
 
															-  if (more) {
														
 
															+  more = lj_tab_next(tabV(t), L->top-1, L->top-1);
														
 
															+  if (more > 0) {
														
 
															     incr_top(L);  /* Return new key and value slot. */
														
 
															-  } else {  /* End of traversal. */
														
 
															+  } else if (!more) {  /* End of traversal. */
														
 
															     L->top--;  /* Remove key slot. */
														
 
															+  } else {
														
 
															+    lj_err_msg(L, LJ_ERR_NEXTIDX);
														
 
															   }
														
 
															   return more;
														
 
															 }
														
@@ -1179,7 +1155,7 @@ static TValue *cpcall(lua_State *L, lua_CFunction func, void *ud)
 
															   setfuncV(L, top++, fn);
														
 
															   if (LJ_FR2) setnilV(top++);
														
 
															 #if LJ_64
														
 
															-  ud = lightud_intern(L, ud);
														
 
															+  ud = lj_lightud_intern(L, ud);
														
 
															 #endif
														
 
															   setrawlightudV(top++, ud);
														
 
															   cframe_nres(L->cframe) = 1+0;  /* Zero results. */
														
--- a/libs/LuaJIT/src/lj_arch.h
+++ b/libs/LuaJIT/src/lj_arch.h
@@ -170,14 +170,10 @@
 
															 #define LJ_ARCH_NAME		"x86"
														
 
															 #define LJ_ARCH_BITS		32
														
 
															 #define LJ_ARCH_ENDIAN		LUAJIT_LE
														
 
															-#if LJ_TARGET_WINDOWS || LJ_TARGET_CYGWIN
														
 
															-#define LJ_ABI_WIN		1
														
 
															-#else
														
 
															-#define LJ_ABI_WIN		0
														
 
															-#endif
														
 
															 #define LJ_TARGET_X86		1
														
 
															 #define LJ_TARGET_X86ORX64	1
														
 
															 #define LJ_TARGET_EHRETREG	0
														
 
															+#define LJ_TARGET_EHRAREG	8
														
 
															 #define LJ_TARGET_MASKSHIFT	1
														
 
															 #define LJ_TARGET_MASKROT	1
														
 
															 #define LJ_TARGET_UNALIGNED	1
														
@@ -188,14 +184,10 @@
 
															 #define LJ_ARCH_NAME		"x64"
														
 
															 #define LJ_ARCH_BITS		64
														
 
															 #define LJ_ARCH_ENDIAN		LUAJIT_LE
														
 
															-#if LJ_TARGET_WINDOWS || LJ_TARGET_CYGWIN
														
 
															-#define LJ_ABI_WIN		1
														
 
															-#else
														
 
															-#define LJ_ABI_WIN		0
														
 
															-#endif
														
 
															 #define LJ_TARGET_X64		1
														
 
															 #define LJ_TARGET_X86ORX64	1
														
 
															 #define LJ_TARGET_EHRETREG	0
														
 
															+#define LJ_TARGET_EHRAREG	16
														
 
															 #define LJ_TARGET_JUMPRANGE	31	/* +-2^31 = +-2GB */
														
 
															 #define LJ_TARGET_MASKSHIFT	1
														
 
															 #define LJ_TARGET_MASKROT	1
														
@@ -203,6 +195,8 @@
 
															 #define LJ_ARCH_NUMMODE		LJ_NUMMODE_SINGLE_DUAL
														
 
															 #ifndef LUAJIT_DISABLE_GC64
														
 
															 #define LJ_TARGET_GC64		1
														
 
															+#elif LJ_TARGET_OSX
														
 
															+#error "macOS requires GC64 -- don't disable it"
														
 
															 #endif
														
 
															 #elif LUAJIT_TARGET == LUAJIT_ARCH_ARM
														
@@ -219,6 +213,7 @@
 
															 #define LJ_ABI_EABI		1
														
 
															 #define LJ_TARGET_ARM		1
														
 
															 #define LJ_TARGET_EHRETREG	0
														
 
															+#define LJ_TARGET_EHRAREG	14
														
 
															 #define LJ_TARGET_JUMPRANGE	25	/* +-2^25 = +-32MB */
														
 
															 #define LJ_TARGET_MASKSHIFT	0
														
 
															 #define LJ_TARGET_MASKROT	1
														
@@ -249,6 +244,7 @@
 
															 #endif
														
 
															 #define LJ_TARGET_ARM64		1
														
 
															 #define LJ_TARGET_EHRETREG	0
														
 
															+#define LJ_TARGET_EHRAREG	30
														
 
															 #define LJ_TARGET_JUMPRANGE	27	/* +-2^27 = +-128MB */
														
 
															 #define LJ_TARGET_MASKSHIFT	1
														
 
															 #define LJ_TARGET_MASKROT	1
														
@@ -304,6 +300,7 @@
 
															 #define LJ_TARGET_PPC		1
														
 
															 #define LJ_TARGET_EHRETREG	3
														
 
															+#define LJ_TARGET_EHRAREG	65
														
 
															 #define LJ_TARGET_JUMPRANGE	25	/* +-2^25 = +-32MB */
														
 
															 #define LJ_TARGET_MASKSHIFT	0
														
 
															 #define LJ_TARGET_MASKROT	1
														
@@ -406,6 +403,7 @@
 
															 #endif
														
 
															 #define LJ_TARGET_MIPS		1
														
 
															 #define LJ_TARGET_EHRETREG	4
														
 
															+#define LJ_TARGET_EHRAREG	31
														
 
															 #define LJ_TARGET_JUMPRANGE	27	/* 2*2^27 = 256MB-aligned region */
														
 
															 #define LJ_TARGET_MASKSHIFT	1
														
 
															 #define LJ_TARGET_MASKROT	1
														
@@ -551,6 +549,13 @@
 
															 #define LJ_HASFFI		1
														
 
															 #endif
														
 
															+/* Disable or enable the string buffer extension. */
														
 
															+#if defined(LUAJIT_DISABLE_BUFFER)
														
 
															+#define LJ_HASBUFFER		0
														
 
															+#else
														
 
															+#define LJ_HASBUFFER		1
														
 
															+#endif
														
 
															+
														
 
															 #if defined(LUAJIT_DISABLE_PROFILE)
														
 
															 #define LJ_HASPROFILE		0
														
 
															 #elif LJ_TARGET_POSIX
														
@@ -611,13 +616,10 @@
 
															 #define LJ_NO_SYSTEM		1
														
 
															 #endif
														
 
															-#if !defined(LUAJIT_NO_UNWIND) && __GNU_COMPACT_EH__
														
 
															-/* NYI: no support for compact unwind specification, yet. */
														
 
															-#define LUAJIT_NO_UNWIND	1
														
 
															-#endif
														
 
															-
														
 
															-#if defined(LUAJIT_NO_UNWIND) || defined(__symbian__) || LJ_TARGET_IOS || LJ_TARGET_PS3 || LJ_TARGET_PS4
														
 
															-#define LJ_NO_UNWIND		1
														
 
															+#if LJ_TARGET_WINDOWS || LJ_TARGET_CYGWIN
														
 
															+#define LJ_ABI_WIN		1
														
 
															+#else
														
 
															+#define LJ_ABI_WIN		0
														
 
															 #endif
														
 
															 #if LJ_TARGET_WINDOWS
														
@@ -632,6 +634,22 @@ extern void *LJ_WIN_LOADLIBA(const char *path);
 
															 #endif
														
 
															 #endif
														
 
															+#if defined(LUAJIT_NO_UNWIND) || __GNU_COMPACT_EH__ || defined(__symbian__) || LJ_TARGET_IOS || LJ_TARGET_PS3 || LJ_TARGET_PS4
														
 
															+#define LJ_NO_UNWIND		1
														
 
															+#endif
														
 
															+
														
 
															+#if !LJ_NO_UNWIND && !defined(LUAJIT_UNWIND_INTERNAL) && (LJ_ABI_WIN || (defined(LUAJIT_UNWIND_EXTERNAL) && (defined(__GNUC__) || defined(__clang__))))
														
 
															+#define LJ_UNWIND_EXT		1
														
 
															+#else
														
 
															+#define LJ_UNWIND_EXT		0
														
 
															+#endif
														
 
															+
														
 
															+#if LJ_UNWIND_EXT && LJ_HASJIT && !LJ_TARGET_ARM && !(LJ_ABI_WIN && LJ_TARGET_X86)
														
 
															+#define LJ_UNWIND_JIT		1
														
 
															+#else
														
 
															+#define LJ_UNWIND_JIT		0
														
 
															+#endif
														
 
															+
														
 
															 /* Compatibility with Lua 5.1 vs. 5.2. */
														
 
															 #ifdef LUAJIT_ENABLE_LUA52COMPAT
														
 
															 #define LJ_52			1
														
--- a/libs/LuaJIT/src/lj_asm.c
+++ b/libs/LuaJIT/src/lj_asm.c
@@ -11,6 +11,7 @@
 
															 #if LJ_HASJIT
														
 
															 #include "lj_gc.h"
														
 
															+#include "lj_buf.h"
														
 
															 #include "lj_str.h"
														
 
															 #include "lj_tab.h"
														
 
															 #include "lj_frame.h"
														
@@ -71,6 +72,8 @@ typedef struct ASMState {
 
															   IRRef snaprename;	/* Rename highwater mark for snapshot check. */
														
 
															   SnapNo snapno;	/* Current snapshot number. */
														
 
															   SnapNo loopsnapno;	/* Loop snapshot number. */
														
 
															+  int snapalloc;	/* Current snapshot needs allocation. */
														
 
															+  BloomFilter snapfilt1, snapfilt2;	/* Filled with snapshot refs. */
														
 
															   IRRef fuseref;	/* Fusion limit (loopref, 0 or FUSE_DISABLED). */
														
 
															   IRRef sectref;	/* Section base reference (loopref or 0). */
														
@@ -84,6 +87,7 @@ typedef struct ASMState {
 
															   MCode *mcbot;		/* Bottom of reserved MCode. */
														
 
															   MCode *mctop;		/* Top of generated MCode. */
														
 
															+  MCode *mctoporig;	/* Original top of generated MCode. */
														
 
															   MCode *mcloop;	/* Pointer to loop MCode (or NULL). */
														
 
															   MCode *invmcp;	/* Points to invertible loop branch (or NULL). */
														
 
															   MCode *flagmcp;	/* Pending opportunity to merge flag setting ins. */
														
@@ -694,7 +698,14 @@ static void ra_rename(ASMState *as, Reg down, Reg up)
 
															   RA_DBGX((as, "rename    $f $r $r", regcost_ref(as->cost[up]), down, up));
														
 
															   emit_movrr(as, ir, down, up);  /* Backwards codegen needs inverse move. */
														
 
															   if (!ra_hasspill(IR(ref)->s)) {  /* Add the rename to the IR. */
														
 
															-    ra_addrename(as, down, ref, as->snapno);
														
 
															+    /*
														
 
															+    ** The rename is effective at the subsequent (already emitted) exit
														
 
															+    ** branch. This is for the current snapshot (as->snapno). Except if we
														
 
															+    ** haven't yet allocated any refs for the snapshot (as->snapalloc == 1),
														
 
															+    ** then it belongs to the next snapshot.
														
 
															+    ** See also the discussion at asm_snap_checkrename().
														
 
															+    */
														
 
															+    ra_addrename(as, down, ref, as->snapno + as->snapalloc);
														
 
															   }
														
 
															 }
														
@@ -807,11 +818,11 @@ static void ra_leftov(ASMState *as, Reg dest, IRRef lref)
 
															 }
														
 
															 #endif
														
 
															-#if !LJ_64
														
 
															 /* Force a RID_RETLO/RID_RETHI destination register pair (marked as free). */
														
 
															 static void ra_destpair(ASMState *as, IRIns *ir)
														
 
															 {
														
 
															   Reg destlo = ir->r, desthi = (ir+1)->r;
														
 
															+  IRIns *irx = (LJ_64 && !irt_is64(ir->t)) ? ir+1 : ir;
														
 
															   /* First spill unrelated refs blocking the destination registers. */
														
 
															   if (!rset_test(as->freeset, RID_RETLO) &&
														
 
															       destlo != RID_RETLO && desthi != RID_RETLO)
														
@@ -835,29 +846,28 @@ static void ra_destpair(ASMState *as, IRIns *ir)
 
															   /* Check for conflicts and shuffle the registers as needed. */
														
 
															   if (destlo == RID_RETHI) {
														
 
															     if (desthi == RID_RETLO) {
														
 
															-#if LJ_TARGET_X86
														
 
															-      *--as->mcp = XI_XCHGa + RID_RETHI;
														
 
															+#if LJ_TARGET_X86ORX64
														
 
															+      *--as->mcp = REX_64IR(irx, XI_XCHGa + RID_RETHI);
														
 
															 #else
														
 
															-      emit_movrr(as, ir, RID_RETHI, RID_TMP);
														
 
															-      emit_movrr(as, ir, RID_RETLO, RID_RETHI);
														
 
															-      emit_movrr(as, ir, RID_TMP, RID_RETLO);
														
 
															+      emit_movrr(as, irx, RID_RETHI, RID_TMP);
														
 
															+      emit_movrr(as, irx, RID_RETLO, RID_RETHI);
														
 
															+      emit_movrr(as, irx, RID_TMP, RID_RETLO);
														
 
															 #endif
														
 
															     } else {
														
 
															-      emit_movrr(as, ir, RID_RETHI, RID_RETLO);
														
 
															-      if (desthi != RID_RETHI) emit_movrr(as, ir, desthi, RID_RETHI);
														
 
															+      emit_movrr(as, irx, RID_RETHI, RID_RETLO);
														
 
															+      if (desthi != RID_RETHI) emit_movrr(as, irx, desthi, RID_RETHI);
														
 
															     }
														
 
															   } else if (desthi == RID_RETLO) {
														
 
															-    emit_movrr(as, ir, RID_RETLO, RID_RETHI);
														
 
															-    if (destlo != RID_RETLO) emit_movrr(as, ir, destlo, RID_RETLO);
														
 
															+    emit_movrr(as, irx, RID_RETLO, RID_RETHI);
														
 
															+    if (destlo != RID_RETLO) emit_movrr(as, irx, destlo, RID_RETLO);
														
 
															   } else {
														
 
															-    if (desthi != RID_RETHI) emit_movrr(as, ir, desthi, RID_RETHI);
														
 
															-    if (destlo != RID_RETLO) emit_movrr(as, ir, destlo, RID_RETLO);
														
 
															+    if (desthi != RID_RETHI) emit_movrr(as, irx, desthi, RID_RETHI);
														
 
															+    if (destlo != RID_RETLO) emit_movrr(as, irx, destlo, RID_RETLO);
														
 
															   }
														
 
															   /* Restore spill slots (if any). */
														
 
															   if (ra_hasspill((ir+1)->s)) ra_save(as, ir+1, RID_RETHI);
														
 
															   if (ra_hasspill(ir->s)) ra_save(as, ir, RID_RETLO);
														
 
															 }
														
 
															-#endif
														
 
															 /* -- Snapshot handling --------- ----------------------------------------- */
														
@@ -892,7 +902,10 @@ static int asm_sunk_store(ASMState *as, IRIns *ira, IRIns *irs)
 
															 static void asm_snap_alloc1(ASMState *as, IRRef ref)
														
 
															 {
														
 
															   IRIns *ir = IR(ref);
														
 
															-  if (!irref_isk(ref) && (!(ra_used(ir) || ir->r == RID_SUNK))) {
														
 
															+  if (!irref_isk(ref) && ir->r != RID_SUNK) {
														
 
															+    bloomset(as->snapfilt1, ref);
														
 
															+    bloomset(as->snapfilt2, hashrot(ref, ref + HASH_BIAS));
														
 
															+    if (ra_used(ir)) return;
														
 
															     if (ir->r == RID_SINK) {
														
 
															       ir->r = RID_SUNK;
														
 
															 #if LJ_HASFFI
														
@@ -947,11 +960,12 @@ static void asm_snap_alloc1(ASMState *as, IRRef ref)
 
															 }
														
 
															 /* Allocate refs escaping to a snapshot. */
														
 
															-static void asm_snap_alloc(ASMState *as)
														
 
															+static void asm_snap_alloc(ASMState *as, int snapno)
														
 
															 {
														
 
															-  SnapShot *snap = &as->T->snap[as->snapno];
														
 
															+  SnapShot *snap = &as->T->snap[snapno];
														
 
															   SnapEntry *map = &as->T->snapmap[snap->mapofs];
														
 
															   MSize n, nent = snap->nent;
														
 
															+  as->snapfilt1 = as->snapfilt2 = 0;
														
 
															   for (n = 0; n < nent; n++) {
														
 
															     SnapEntry sn = map[n];
														
 
															     IRRef ref = snap_ref(sn);
														
@@ -960,7 +974,7 @@ static void asm_snap_alloc(ASMState *as)
 
															       if (LJ_SOFTFP && (sn & SNAP_SOFTFPNUM)) {
														
 
															 	lj_assertA(irt_type(IR(ref+1)->t) == IRT_SOFTFP,
														
 
															 		   "snap %d[%d] points to bad SOFTFP IR %04d",
														
 
															-		   as->snapno, n, ref - REF_BIAS);
														
 
															+		   snapno, n, ref - REF_BIAS);
														
 
															 	asm_snap_alloc1(as, ref+1);
														
 
															       }
														
 
															     }
														
@@ -976,35 +990,26 @@ static void asm_snap_alloc(ASMState *as)
 
															 */
														
 
															 static int asm_snap_checkrename(ASMState *as, IRRef ren)
														
 
															 {
														
 
															-  SnapShot *snap = &as->T->snap[as->snapno];
														
 
															-  SnapEntry *map = &as->T->snapmap[snap->mapofs];
														
 
															-  MSize n, nent = snap->nent;
														
 
															-  for (n = 0; n < nent; n++) {
														
 
															-    SnapEntry sn = map[n];
														
 
															-    IRRef ref = snap_ref(sn);
														
 
															-    if (ref == ren || (LJ_SOFTFP && (sn & SNAP_SOFTFPNUM) && ++ref == ren)) {
														
 
															-      IRIns *ir = IR(ref);
														
 
															-      ra_spill(as, ir);  /* Register renamed, so force a spill slot. */
														
 
															-      RA_DBGX((as, "snaprensp $f $s", ref, ir->s));
														
 
															-      return 1;  /* Found. */
														
 
															-    }
														
 
															+  if (bloomtest(as->snapfilt1, ren) &&
														
 
															+      bloomtest(as->snapfilt2, hashrot(ren, ren + HASH_BIAS))) {
														
 
															+    IRIns *ir = IR(ren);
														
 
															+    ra_spill(as, ir);  /* Register renamed, so force a spill slot. */
														
 
															+    RA_DBGX((as, "snaprensp $f $s", ren, ir->s));
														
 
															+    return 1;  /* Found. */
														
 
															   }
														
 
															   return 0;  /* Not found. */
														
 
															 }
														
 
															-/* Prepare snapshot for next guard instruction. */
														
 
															+/* Prepare snapshot for next guard or throwing instruction. */
														
 
															 static void asm_snap_prep(ASMState *as)
														
 
															 {
														
 
															-  if (as->curins < as->snapref) {
														
 
															-    do {
														
 
															-      if (as->snapno == 0) return;  /* Called by sunk stores before snap #0. */
														
 
															-      as->snapno--;
														
 
															-      as->snapref = as->T->snap[as->snapno].ref;
														
 
															-    } while (as->curins < as->snapref);
														
 
															-    asm_snap_alloc(as);
														
 
															+  if (as->snapalloc) {
														
 
															+    /* Alloc on first invocation for each snapshot. */
														
 
															+    as->snapalloc = 0;
														
 
															+    asm_snap_alloc(as, as->snapno);
														
 
															     as->snaprename = as->T->nins;
														
 
															   } else {
														
 
															-    /* Process any renames above the highwater mark. */
														
 
															+    /* Check any renames above the highwater mark. */
														
 
															     for (; as->snaprename < as->T->nins; as->snaprename++) {
														
 
															       IRIns *ir = &as->T->ir[as->snaprename];
														
 
															       if (asm_snap_checkrename(as, ir->op1))
														
@@ -1013,6 +1018,35 @@ static void asm_snap_prep(ASMState *as)
 
															   }
														
 
															 }
														
 
															+/* Move to previous snapshot when we cross the current snapshot ref. */
														
 
															+static void asm_snap_prev(ASMState *as)
														
 
															+{
														
 
															+  if (as->curins < as->snapref) {
														
 
															+    uintptr_t ofs = (uintptr_t)(as->mctoporig - as->mcp);
														
 
															+    if (ofs >= 0x10000) lj_trace_err(as->J, LJ_TRERR_MCODEOV);
														
 
															+    do {
														
 
															+      if (as->snapno == 0) return;
														
 
															+      as->snapno--;
														
 
															+      as->snapref = as->T->snap[as->snapno].ref;
														
 
															+      as->T->snap[as->snapno].mcofs = (uint16_t)ofs;  /* Remember mcode ofs. */
														
 
															+    } while (as->curins < as->snapref);  /* May have no ins inbetween. */
														
 
															+    as->snapalloc = 1;
														
 
															+  }
														
 
															+}
														
 
															+
														
 
															+/* Fixup snapshot mcode offsetst. */
														
 
															+static void asm_snap_fixup_mcofs(ASMState *as)
														
 
															+{
														
 
															+  uint32_t sz = (uint32_t)(as->mctoporig - as->mcp);
														
 
															+  SnapShot *snap = as->T->snap;
														
 
															+  SnapNo i;
														
 
															+  for (i = as->T->nsnap-1; i > 0; i--) {
														
 
															+    /* Compute offset from mcode start and store in correct snapshot. */
														
 
															+    snap[i].mcofs = (uint16_t)(sz - snap[i-1].mcofs);
														
 
															+  }
														
 
															+  snap[0].mcofs = 0;
														
 
															+}
														
 
															+
														
 
															 /* -- Miscellaneous helpers ----------------------------------------------- */
														
 
															 /* Calculate stack adjustment. */
														
@@ -1057,6 +1091,7 @@ static void asm_snew(ASMState *as, IRIns *ir)
 
															 {
														
 
															   const CCallInfo *ci = &lj_ir_callinfo[IRCALL_lj_str_new];
														
 
															   IRRef args[3];
														
 
															+  asm_snap_prep(as);
														
 
															   args[0] = ASMREF_L;  /* lua_State *L    */
														
 
															   args[1] = ir->op1;   /* const char *str */
														
 
															   args[2] = ir->op2;   /* size_t len      */
														
@@ -1069,6 +1104,7 @@ static void asm_tnew(ASMState *as, IRIns *ir)
 
															 {
														
 
															   const CCallInfo *ci = &lj_ir_callinfo[IRCALL_lj_tab_new1];
														
 
															   IRRef args[2];
														
 
															+  asm_snap_prep(as);
														
 
															   args[0] = ASMREF_L;     /* lua_State *L    */
														
 
															   args[1] = ASMREF_TMP1;  /* uint32_t ahsize */
														
 
															   as->gcsteps++;
														
@@ -1081,6 +1117,7 @@ static void asm_tdup(ASMState *as, IRIns *ir)
 
															 {
														
 
															   const CCallInfo *ci = &lj_ir_callinfo[IRCALL_lj_tab_dup];
														
 
															   IRRef args[2];
														
 
															+  asm_snap_prep(as);
														
 
															   args[0] = ASMREF_L;  /* lua_State *L    */
														
 
															   args[1] = ir->op1;   /* const GCtab *kt */
														
 
															   as->gcsteps++;
														
@@ -1106,28 +1143,43 @@ static void asm_gcstep(ASMState *as, IRIns *ir)
 
															 /* -- Buffer operations --------------------------------------------------- */
														
 
															-static void asm_tvptr(ASMState *as, Reg dest, IRRef ref);
														
 
															+static void asm_tvptr(ASMState *as, Reg dest, IRRef ref, MSize mode);
														
 
															+#if LJ_HASBUFFER
														
 
															+static void asm_bufhdr_write(ASMState *as, Reg sb);
														
 
															+#endif
														
 
															 static void asm_bufhdr(ASMState *as, IRIns *ir)
														
 
															 {
														
 
															   Reg sb = ra_dest(as, ir, RSET_GPR);
														
 
															-  if ((ir->op2 & IRBUFHDR_APPEND)) {
														
 
															+  switch (ir->op2) {
														
 
															+  case IRBUFHDR_RESET: {
														
 
															+    Reg tmp = ra_scratch(as, rset_exclude(RSET_GPR, sb));
														
 
															+    IRIns irbp;
														
 
															+    irbp.ot = IRT(0, IRT_PTR);  /* Buffer data pointer type. */
														
 
															+    emit_storeofs(as, &irbp, tmp, sb, offsetof(SBuf, w));
														
 
															+    emit_loadofs(as, &irbp, tmp, sb, offsetof(SBuf, b));
														
 
															+    break;
														
 
															+    }
														
 
															+  case IRBUFHDR_APPEND: {
														
 
															     /* Rematerialize const buffer pointer instead of likely spill. */
														
 
															     IRIns *irp = IR(ir->op1);
														
 
															     if (!(ra_hasreg(irp->r) || irp == ir-1 ||
														
 
															 	  (irp == ir-2 && !ra_used(ir-1)))) {
														
 
															-      while (!(irp->o == IR_BUFHDR && !(irp->op2 & IRBUFHDR_APPEND)))
														
 
															+      while (!(irp->o == IR_BUFHDR && irp->op2 == IRBUFHDR_RESET))
														
 
															 	irp = IR(irp->op1);
														
 
															       if (irref_isk(irp->op1)) {
														
 
															 	ra_weak(as, ra_allocref(as, ir->op1, RSET_GPR));
														
 
															 	ir = irp;
														
 
															       }
														
 
															     }
														
 
															-  } else {
														
 
															-    Reg tmp = ra_scratch(as, rset_exclude(RSET_GPR, sb));
														
 
															-    /* Passing ir isn't strictly correct, but it's an IRT_PGC, too. */
														
 
															-    emit_storeofs(as, ir, tmp, sb, offsetof(SBuf, p));
														
 
															-    emit_loadofs(as, ir, tmp, sb, offsetof(SBuf, b));
														
 
															+    break;
														
 
															+    }
														
 
															+#if LJ_HASBUFFER
														
 
															+  case IRBUFHDR_WRITE:
														
 
															+    asm_bufhdr_write(as, sb);
														
 
															+    break;
														
 
															+#endif
														
 
															+  default: lj_assertA(0, "bad BUFHDR op2 %d", ir->op2); break;
														
 
															   }
														
 
															 #if LJ_TARGET_X86ORX64
														
 
															   ra_left(as, sb, ir->op1);
														
@@ -1179,7 +1231,7 @@ static void asm_bufput(ASMState *as, IRIns *ir)
 
															   if (args[1] == ASMREF_TMP1) {
														
 
															     Reg tmp = ra_releasetmp(as, ASMREF_TMP1);
														
 
															     if (kchar == -129)
														
 
															-      asm_tvptr(as, tmp, irs->op1);
														
 
															+      asm_tvptr(as, tmp, irs->op1, IRTMPREF_IN1);
														
 
															     else
														
 
															       ra_allockreg(as, kchar, tmp);
														
 
															   }
														
@@ -1201,6 +1253,7 @@ static void asm_tostr(ASMState *as, IRIns *ir)
 
															 {
														
 
															   const CCallInfo *ci;
														
 
															   IRRef args[2];
														
 
															+  asm_snap_prep(as);
														
 
															   args[0] = ASMREF_L;
														
 
															   as->gcsteps++;
														
 
															   if (ir->op2 == IRTOSTR_NUM) {
														
@@ -1216,7 +1269,7 @@ static void asm_tostr(ASMState *as, IRIns *ir)
 
															   asm_setupresult(as, ir, ci);  /* GCstr * */
														
 
															   asm_gencall(as, ci, args);
														
 
															   if (ir->op2 == IRTOSTR_NUM)
														
 
															-    asm_tvptr(as, ra_releasetmp(as, ASMREF_TMP1), ir->op1);
														
 
															+    asm_tvptr(as, ra_releasetmp(as, ASMREF_TMP1), ir->op1, IRTMPREF_IN1);
														
 
															 }
														
 
															 #if LJ_32 && LJ_HASFFI && !LJ_SOFTFP && !LJ_TARGET_X86
														
@@ -1257,12 +1310,19 @@ static void asm_newref(ASMState *as, IRIns *ir)
 
															   IRRef args[3];
														
 
															   if (ir->r == RID_SINK)
														
 
															     return;
														
 
															+  asm_snap_prep(as);
														
 
															   args[0] = ASMREF_L;     /* lua_State *L */
														
 
															   args[1] = ir->op1;      /* GCtab *t     */
														
 
															   args[2] = ASMREF_TMP1;  /* cTValue *key */
														
 
															   asm_setupresult(as, ir, ci);  /* TValue * */
														
 
															   asm_gencall(as, ci, args);
														
 
															-  asm_tvptr(as, ra_releasetmp(as, ASMREF_TMP1), ir->op2);
														
 
															+  asm_tvptr(as, ra_releasetmp(as, ASMREF_TMP1), ir->op2, IRTMPREF_IN1);
														
 
															+}
														
 
															+
														
 
															+static void asm_tmpref(ASMState *as, IRIns *ir)
														
 
															+{
														
 
															+  Reg r = ra_dest(as, ir, RSET_GPR);
														
 
															+  asm_tvptr(as, r, ir->op1, ir->op2);
														
 
															 }
														
 
															 static void asm_lref(ASMState *as, IRIns *ir)
														
@@ -1744,6 +1804,7 @@ static void asm_ir(ASMState *as, IRIns *ir)
 
															   case IR_NEWREF: asm_newref(as, ir); break;
														
 
															   case IR_UREFO: case IR_UREFC: asm_uref(as, ir); break;
														
 
															   case IR_FREF: asm_fref(as, ir); break;
														
 
															+  case IR_TMPREF: asm_tmpref(as, ir); break;
														
 
															   case IR_STRREF: asm_strref(as, ir); break;
														
 
															   case IR_LREF: asm_lref(as, ir); break;
														
@@ -1838,8 +1899,7 @@ static void asm_head_side(ASMState *as)
 
															   if (as->snapno && as->topslot > as->parent->topslot) {
														
 
															     /* Force snap #0 alloc to prevent register overwrite in stack check. */
														
 
															-    as->snapno = 0;
														
 
															-    asm_snap_alloc(as);
														
 
															+    asm_snap_alloc(as, 0);
														
 
															   }
														
 
															   allow = asm_head_side_base(as, irp, allow);
														
@@ -2078,6 +2138,9 @@ static void asm_setup_regsp(ASMState *as)
 
															 #endif
														
 
															   ra_setup(as);
														
 
															+#if LJ_TARGET_ARM64
														
 
															+  ra_setkref(as, RID_GL, (intptr_t)J2G(as->J));
														
 
															+#endif
														
 
															   /* Clear reg/sp for constants. */
														
 
															   for (ir = IR(T->nk), lastir = IR(REF_BASE); ir < lastir; ir++) {
														
@@ -2100,6 +2163,7 @@ static void asm_setup_regsp(ASMState *as)
 
															   as->snaprename = nins;
														
 
															   as->snapref = nins;
														
 
															   as->snapno = T->nsnap;
														
 
															+  as->snapalloc = 0;
														
 
															   as->stopins = REF_BASE;
														
 
															   as->orignins = nins;
														
@@ -2148,6 +2212,10 @@ static void asm_setup_regsp(ASMState *as)
 
															       ir->prev = (uint16_t)REGSP_HINT((rload & 15));
														
 
															       rload = lj_ror(rload, 4);
														
 
															       continue;
														
 
															+    case IR_TMPREF:
														
 
															+      if ((ir->op2 & IRTMPREF_OUT2) && as->evenspill < 4)
														
 
															+	as->evenspill = 4;  /* TMPREF OUT2 needs two TValues on the stack. */
														
 
															+      break;
														
 
															 #endif
														
 
															     case IR_CALLXS: {
														
 
															       CCallInfo ci;
														
@@ -2157,7 +2225,17 @@ static void asm_setup_regsp(ASMState *as)
 
															 	as->modset |= RSET_SCRATCH;
														
 
															       continue;
														
 
															       }
														
 
															-    case IR_CALLN: case IR_CALLA: case IR_CALLL: case IR_CALLS: {
														
 
															+    case IR_CALLL:
														
 
															+      /* lj_vm_next needs two TValues on the stack. */
														
 
															+#if LJ_TARGET_X64 && LJ_ABI_WIN
														
 
															+      if (ir->op2 == IRCALL_lj_vm_next && as->evenspill < SPS_FIRST + 4)
														
 
															+	as->evenspill = SPS_FIRST + 4;
														
 
															+#else
														
 
															+      if (SPS_FIRST < 4 && ir->op2 == IRCALL_lj_vm_next && as->evenspill < 4)
														
 
															+	as->evenspill = 4;
														
 
															+#endif
														
 
															+      /* fallthrough */
														
 
															+    case IR_CALLN: case IR_CALLA: case IR_CALLS: {
														
 
															       const CCallInfo *ci = &lj_ir_callinfo[ir->op2];
														
 
															       ir->prev = asm_setup_call_slots(as, ir, ci);
														
 
															       if (inloop)
														
@@ -2165,7 +2243,6 @@ static void asm_setup_regsp(ASMState *as)
 
															 		      (RSET_SCRATCH & ~RSET_FPR) : RSET_SCRATCH;
														
 
															       continue;
														
 
															       }
														
 
															-#if LJ_SOFTFP || (LJ_32 && LJ_HASFFI)
														
 
															     case IR_HIOP:
														
 
															       switch ((ir-1)->o) {
														
 
															 #if LJ_SOFTFP && LJ_TARGET_ARM
														
@@ -2176,7 +2253,7 @@ static void asm_setup_regsp(ASMState *as)
 
															 	}
														
 
															 	break;
														
 
															 #endif
														
 
															-#if !LJ_SOFTFP && LJ_NEED_FP64
														
 
															+#if !LJ_SOFTFP && LJ_NEED_FP64 && LJ_32 && LJ_HASFFI
														
 
															       case IR_CONV:
														
 
															 	if (irt_isfp((ir-1)->t)) {
														
 
															 	  ir->prev = REGSP_HINT(RID_FPRET);
														
@@ -2184,7 +2261,7 @@ static void asm_setup_regsp(ASMState *as)
 
															 	}
														
 
															 #endif
														
 
															       /* fallthrough */
														
 
															-      case IR_CALLN: case IR_CALLXS:
														
 
															+      case IR_CALLN: case IR_CALLL: case IR_CALLS: case IR_CALLXS:
														
 
															 #if LJ_SOFTFP
														
 
															       case IR_MIN: case IR_MAX:
														
 
															 #endif
														
@@ -2195,7 +2272,6 @@ static void asm_setup_regsp(ASMState *as)
 
															 	break;
														
 
															       }
														
 
															       break;
														
 
															-#endif
														
 
															 #if LJ_SOFTFP
														
 
															     case IR_MIN: case IR_MAX:
														
 
															       if ((ir+1)->o != IR_HIOP) break;
														
@@ -2250,13 +2326,23 @@ static void asm_setup_regsp(ASMState *as)
 
															       }
														
 
															       /* fallthrough */ /* for integer POW */
														
 
															     case IR_DIV: case IR_MOD:
														
 
															-      if (!irt_isnum(ir->t)) {
														
 
															+      if ((LJ_64 && LJ_SOFTFP) || !irt_isnum(ir->t)) {
														
 
															 	ir->prev = REGSP_HINT(RID_RET);
														
 
															 	if (inloop)
														
 
															 	  as->modset |= (RSET_SCRATCH & RSET_GPR);
														
 
															 	continue;
														
 
															       }
														
 
															       break;
														
 
															+#if LJ_64 && LJ_SOFTFP
														
 
															+    case IR_ADD: case IR_SUB: case IR_MUL:
														
 
															+      if (irt_isnum(ir->t)) {
														
 
															+	ir->prev = REGSP_HINT(RID_RET);
														
 
															+	if (inloop)
														
 
															+	  as->modset |= (RSET_SCRATCH & RSET_GPR);
														
 
															+	continue;
														
 
															+      }
														
 
															+      break;
														
 
															+#endif
														
 
															     case IR_FPMATH:
														
 
															 #if LJ_TARGET_X86ORX64
														
 
															       if (ir->op2 <= IRFPM_TRUNC) {
														
@@ -2327,7 +2413,6 @@ void lj_asm_trace(jit_State *J, GCtrace *T)
 
															 {
														
 
															   ASMState as_;
														
 
															   ASMState *as = &as_;
														
 
															-  MCode *origtop;
														
 
															   /* Remove nops/renames left over from ASM restart due to LJ_TRERR_MCODELM. */
														
 
															   {
														
@@ -2355,7 +2440,7 @@ void lj_asm_trace(jit_State *J, GCtrace *T)
 
															   as->parent = J->parent ? traceref(J, J->parent) : NULL;
														
 
															   /* Reserve MCode memory. */
														
 
															-  as->mctop = origtop = lj_mcode_reserve(J, &as->mcbot);
														
 
															+  as->mctop = as->mctoporig = lj_mcode_reserve(J, &as->mcbot);
														
 
															   as->mcp = as->mctop;
														
 
															   as->mclim = as->mcbot + MCLIM_REDZONE;
														
 
															   asm_setup_target(as);
														
@@ -2417,6 +2502,7 @@ void lj_asm_trace(jit_State *J, GCtrace *T)
 
															       lj_assertA(!(LJ_32 && irt_isint64(ir->t)),
														
 
															 		 "IR %04d has unsplit 64 bit type",
														
 
															 		 (int)(ir - as->ir) - REF_BIAS);
														
 
															+      asm_snap_prev(as);
														
 
															       if (!ra_used(ir) && !ir_sideeff(ir) && (as->flags & JIT_F_OPT_DCE))
														
 
															 	continue;  /* Dead-code elimination can be soooo easy. */
														
 
															       if (irt_isguard(ir->t))
														
@@ -2450,6 +2536,9 @@ void lj_asm_trace(jit_State *J, GCtrace *T)
 
															       memcpy(J->curfinal->ir + as->orignins, T->ir + as->orignins,
														
 
															 	     (T->nins - as->orignins) * sizeof(IRIns));  /* Copy RENAMEs. */
														
 
															       T->nins = J->curfinal->nins;
														
 
															+      /* Fill mcofs of any unprocessed snapshots. */
														
 
															+      as->curins = REF_FIRST;
														
 
															+      asm_snap_prev(as);
														
 
															       break;  /* Done. */
														
 
															     }
														
@@ -2468,13 +2557,16 @@ void lj_asm_trace(jit_State *J, GCtrace *T)
 
															   /* Set trace entry point before fixing up tail to allow link to self. */
														
 
															   T->mcode = as->mcp;
														
 
															   T->mcloop = as->mcloop ? (MSize)((char *)as->mcloop - (char *)as->mcp) : 0;
														
 
															-  if (!as->loopref)
														
 
															+  if (as->loopref)
														
 
															+    asm_loop_tail_fixup(as);
														
 
															+  else
														
 
															     asm_tail_fixup(as, T->link);  /* Note: this may change as->mctop! */
														
 
															   T->szmcode = (MSize)((char *)as->mctop - (char *)as->mcp);
														
 
															+  asm_snap_fixup_mcofs(as);
														
 
															 #if LJ_TARGET_MCODE_FIXUP
														
 
															   asm_mcode_fixup(T->mcode, T->szmcode);
														
 
															 #endif
														
 
															-  lj_mcode_sync(T->mcode, origtop);
														
 
															+  lj_mcode_sync(T->mcode, as->mctoporig);
														
 
															 }
														
 
															 #undef IR
														
--- a/libs/LuaJIT/src/lj_asm_arm.h
+++ b/libs/LuaJIT/src/lj_asm_arm.h
@@ -185,6 +185,9 @@ static Reg asm_fuseahuref(ASMState *as, IRRef ref, int32_t *ofsp, RegSet allow,
 
															 	*ofsp = (ofs & 255);  /* Mask out less bits to allow LDRD. */
														
 
															 	return ra_allock(as, (ofs & ~255), allow);
														
 
															       }
														
 
															+    } else if (ir->o == IR_TMPREF) {
														
 
															+      *ofsp = 0;
														
 
															+      return RID_SP;
														
 
															     }
														
 
															   }
														
 
															   *ofsp = 0;
														
@@ -498,6 +501,30 @@ static void asm_retf(ASMState *as, IRIns *ir)
 
															   emit_lso(as, ARMI_LDR, RID_TMP, base, -4);
														
 
															 }
														
 
															+/* -- Buffer operations --------------------------------------------------- */
														
 
															+
														
 
															+#if LJ_HASBUFFER
														
 
															+static void asm_bufhdr_write(ASMState *as, Reg sb)
														
 
															+{
														
 
															+  Reg tmp = ra_scratch(as, rset_exclude(RSET_GPR, sb));
														
 
															+  IRIns irgc;
														
 
															+  int32_t addr = i32ptr((void *)&J2G(as->J)->cur_L);
														
 
															+  irgc.ot = IRT(0, IRT_PGC);  /* GC type. */
														
 
															+  emit_storeofs(as, &irgc, RID_TMP, sb, offsetof(SBuf, L));
														
 
															+  if ((as->flags & JIT_F_ARMV6T2)) {
														
 
															+    emit_dnm(as, ARMI_BFI, RID_TMP, lj_fls(SBUF_MASK_FLAG), tmp);
														
 
															+  } else {
														
 
															+    emit_dnm(as, ARMI_ORR, RID_TMP, RID_TMP, tmp);
														
 
															+    emit_dn(as, ARMI_AND|ARMI_K12|SBUF_MASK_FLAG, tmp, tmp);
														
 
															+  }
														
 
															+  emit_lso(as, ARMI_LDR, RID_TMP,
														
 
															+	   ra_allock(as, (addr & ~4095),
														
 
															+		     rset_exclude(rset_exclude(RSET_GPR, sb), tmp)),
														
 
															+	   (addr & 4095));
														
 
															+  emit_loadofs(as, &irgc, tmp, sb, offsetof(SBuf, L));
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															 /* -- Type conversions ---------------------------------------------------- */
														
 
															 #if !LJ_SOFTFP
														
@@ -666,35 +693,55 @@ static void asm_strto(ASMState *as, IRIns *ir)
 
															 /* -- Memory references --------------------------------------------------- */
														
 
															 /* Get pointer to TValue. */
														
 
															-static void asm_tvptr(ASMState *as, Reg dest, IRRef ref)
														
 
															+static void asm_tvptr(ASMState *as, Reg dest, IRRef ref, MSize mode)
														
 
															 {
														
 
															-  IRIns *ir = IR(ref);
														
 
															-  if (irt_isnum(ir->t)) {
														
 
															-    if (irref_isk(ref)) {
														
 
															-      /* Use the number constant itself as a TValue. */
														
 
															-      ra_allockreg(as, i32ptr(ir_knum(ir)), dest);
														
 
															-    } else {
														
 
															+  if ((mode & IRTMPREF_IN1)) {
														
 
															+    IRIns *ir = IR(ref);
														
 
															+    if (irt_isnum(ir->t)) {
														
 
															+      if ((mode & IRTMPREF_OUT1)) {
														
 
															+#if LJ_SOFTFP
														
 
															+	lj_assertA(irref_isk(ref), "unsplit FP op");
														
 
															+	emit_dm(as, ARMI_MOV, dest, RID_SP);
														
 
															+	emit_lso(as, ARMI_STR,
														
 
															+		 ra_allock(as, (int32_t)ir_knum(ir)->u32.lo, RSET_GPR),
														
 
															+		 RID_SP, 0);
														
 
															+	emit_lso(as, ARMI_STR,
														
 
															+		 ra_allock(as, (int32_t)ir_knum(ir)->u32.hi, RSET_GPR),
														
 
															+		 RID_SP, 4);
														
 
															+#else
														
 
															+	Reg src = ra_alloc1(as, ref, RSET_FPR);
														
 
															+	emit_dm(as, ARMI_MOV, dest, RID_SP);
														
 
															+	emit_vlso(as, ARMI_VSTR_D, src, RID_SP, 0);
														
 
															+#endif
														
 
															+      } else if (irref_isk(ref)) {
														
 
															+	/* Use the number constant itself as a TValue. */
														
 
															+	ra_allockreg(as, i32ptr(ir_knum(ir)), dest);
														
 
															+      } else {
														
 
															 #if LJ_SOFTFP
														
 
															-      lj_assertA(0, "unsplit FP op");
														
 
															+	lj_assertA(0, "unsplit FP op");
														
 
															 #else
														
 
															-      /* Otherwise force a spill and use the spill slot. */
														
 
															-      emit_opk(as, ARMI_ADD, dest, RID_SP, ra_spill(as, ir), RSET_GPR);
														
 
															+	/* Otherwise force a spill and use the spill slot. */
														
 
															+	emit_opk(as, ARMI_ADD, dest, RID_SP, ra_spill(as, ir), RSET_GPR);
														
 
															 #endif
														
 
															+      }
														
 
															+    } else {
														
 
															+      /* Otherwise use [sp] and [sp+4] to hold the TValue.
														
 
															+      ** This assumes the following call has max. 4 args.
														
 
															+      */
														
 
															+      Reg type;
														
 
															+      emit_dm(as, ARMI_MOV, dest, RID_SP);
														
 
															+      if (!irt_ispri(ir->t)) {
														
 
															+	Reg src = ra_alloc1(as, ref, RSET_GPR);
														
 
															+	emit_lso(as, ARMI_STR, src, RID_SP, 0);
														
 
															+      }
														
 
															+      if (LJ_SOFTFP && (ir+1)->o == IR_HIOP && !irt_isnil((ir+1)->t))
														
 
															+	type = ra_alloc1(as, ref+1, RSET_GPR);
														
 
															+      else
														
 
															+	type = ra_allock(as, irt_toitype(ir->t), RSET_GPR);
														
 
															+      emit_lso(as, ARMI_STR, type, RID_SP, 4);
														
 
															     }
														
 
															   } else {
														
 
															-    /* Otherwise use [sp] and [sp+4] to hold the TValue. */
														
 
															-    RegSet allow = rset_exclude(RSET_GPR, dest);
														
 
															-    Reg type;
														
 
															     emit_dm(as, ARMI_MOV, dest, RID_SP);
														
 
															-    if (!irt_ispri(ir->t)) {
														
 
															-      Reg src = ra_alloc1(as, ref, allow);
														
 
															-      emit_lso(as, ARMI_STR, src, RID_SP, 0);
														
 
															-    }
														
 
															-    if (LJ_SOFTFP && (ir+1)->o == IR_HIOP)
														
 
															-      type = ra_alloc1(as, ref+1, allow);
														
 
															-    else
														
 
															-      type = ra_allock(as, irt_toitype(ir->t), allow);
														
 
															-    emit_lso(as, ARMI_STR, type, RID_SP, 4);
														
 
															   }
														
 
															 }
														
@@ -1086,6 +1133,7 @@ static void asm_ahuvload(ASMState *as, IRIns *ir)
 
															   }
														
 
															   idx = asm_fuseahuref(as, ir->op1, &ofs, allow,
														
 
															 		       (!LJ_SOFTFP && t == IRT_NUM) ? 1024 : 4096);
														
 
															+  if (ir->o == IR_VLOAD) ofs += 8 * ir->op2;
														
 
															   if (!hiop || type == RID_NONE) {
														
 
															     rset_clear(allow, idx);
														
 
															     if (ofs < 256 && ra_hasreg(dest) && (dest & 1) == 0 &&
														
@@ -1837,15 +1885,15 @@ static void asm_int64comp(ASMState *as, IRIns *ir)
 
															 }
														
 
															 #endif
														
 
															-/* -- Support for 64 bit ops in 32 bit mode ------------------------------- */
														
 
															+/* -- Split register ops -------------------------------------------------- */
														
 
															-/* Hiword op of a split 64 bit op. Previous op must be the loword op. */
														
 
															+/* Hiword op of a split 32/32 bit op. Previous op is the loword op. */
														
 
															 static void asm_hiop(ASMState *as, IRIns *ir)
														
 
															 {
														
 
															-#if LJ_HASFFI || LJ_SOFTFP
														
 
															   /* HIOP is marked as a store because it needs its own DCE logic. */
														
 
															   int uselo = ra_used(ir-1), usehi = ra_used(ir);  /* Loword/hiword used? */
														
 
															   if (LJ_UNLIKELY(!(as->flags & JIT_F_OPT_DCE))) uselo = usehi = 1;
														
 
															+#if LJ_HASFFI || LJ_SOFTFP
														
 
															   if ((ir-1)->o <= IR_NE) {  /* 64 bit integer or FP comparisons. ORDER IR. */
														
 
															     as->curins--;  /* Always skip the loword comparison. */
														
 
															 #if LJ_SOFTFP
														
@@ -1876,6 +1924,7 @@ static void asm_hiop(ASMState *as, IRIns *ir)
 
															       asm_xstore_(as, ir, 4);
														
 
															     return;
														
 
															   }
														
 
															+#endif
														
 
															   if (!usehi) return;  /* Skip unused hiword op for all remaining ops. */
														
 
															   switch ((ir-1)->o) {
														
 
															 #if LJ_HASFFI
														
@@ -1894,6 +1943,9 @@ static void asm_hiop(ASMState *as, IRIns *ir)
 
															     asm_intneg(as, ir, ARMI_RSC);
														
 
															     asm_intneg(as, ir-1, ARMI_RSB|ARMI_S);
														
 
															     break;
														
 
															+  case IR_CNEWI:
														
 
															+    /* Nothing to do here. Handled by lo op itself. */
														
 
															+    break;
														
 
															 #endif
														
 
															 #if LJ_SOFTFP
														
 
															   case IR_SLOAD: case IR_ALOAD: case IR_HLOAD: case IR_ULOAD: case IR_VLOAD:
														
@@ -1901,25 +1953,16 @@ static void asm_hiop(ASMState *as, IRIns *ir)
 
															     if (!uselo)
														
 
															       ra_allocref(as, ir->op1, RSET_GPR);  /* Mark lo op as used. */
														
 
															     break;
														
 
															+  case IR_ASTORE: case IR_HSTORE: case IR_USTORE: case IR_TOSTR: case IR_TMPREF:
														
 
															+    /* Nothing to do here. Handled by lo op itself. */
														
 
															+    break;
														
 
															 #endif
														
 
															-  case IR_CALLN:
														
 
															-  case IR_CALLS:
														
 
															-  case IR_CALLXS:
														
 
															+  case IR_CALLN: case IR_CALLL: case IR_CALLS: case IR_CALLXS:
														
 
															     if (!uselo)
														
 
															       ra_allocref(as, ir->op1, RID2RSET(RID_RETLO));  /* Mark lo op as used. */
														
 
															     break;
														
 
															-#if LJ_SOFTFP
														
 
															-  case IR_ASTORE: case IR_HSTORE: case IR_USTORE: case IR_TOSTR:
														
 
															-#endif
														
 
															-  case IR_CNEWI:
														
 
															-    /* Nothing to do here. Handled by lo op itself. */
														
 
															-    break;
														
 
															   default: lj_assertA(0, "bad HIOP for op %d", (ir-1)->o); break;
														
 
															   }
														
 
															-#else
														
 
															-  /* Unused without SOFTFP or FFI. */
														
 
															-  UNUSED(as); UNUSED(ir); lj_assertA(0, "unexpected HIOP");
														
 
															-#endif
														
 
															 }
														
 
															 /* -- Profiling ----------------------------------------------------------- */
														
@@ -2021,6 +2064,8 @@ static void asm_stack_restore(ASMState *as, SnapShot *snap)
 
															       } else if ((sn & SNAP_SOFTFPNUM)) {
														
 
															 	type = ra_alloc1(as, ref+1, rset_exclude(RSET_GPRODD, RID_BASE));
														
 
															 #endif
														
 
															+      } else if ((sn & SNAP_KEYINDEX)) {
														
 
															+	type = ra_allock(as, (int32_t)LJ_KEYINDEX, odd);
														
 
															       } else {
														
 
															 	type = ra_allock(as, (int32_t)irt_toitype(ir->t), odd);
														
 
															       }
														
@@ -2082,6 +2127,12 @@ static void asm_loop_fixup(ASMState *as)
 
															   }
														
 
															 }
														
 
															+/* Fixup the tail of the loop. */
														
 
															+static void asm_loop_tail_fixup(ASMState *as)
														
 
															+{
														
 
															+  UNUSED(as);  /* Nothing to do. */
														
 
															+}
														
 
															+
														
 
															 /* -- Head of trace ------------------------------------------------------- */
														
 
															 /* Reload L register from g->cur_L. */
														
--- a/libs/LuaJIT/src/lj_asm_arm64.h
+++ b/libs/LuaJIT/src/lj_asm_arm64.h
@@ -198,6 +198,9 @@ static Reg asm_fuseahuref(ASMState *as, IRRef ref, int32_t *ofsp, RegSet allow,
 
															 	  return RID_GL;
														
 
															 	}
														
 
															       }
														
 
															+    } else if (ir->o == IR_TMPREF) {
														
 
															+      *ofsp = (int32_t)glofs(as, &J2G(as->J)->tmptv);
														
 
															+      return RID_GL;
														
 
															     }
														
 
															   }
														
 
															   *ofsp = 0;
														
@@ -457,8 +460,11 @@ static void asm_gencall(ASMState *as, const CCallInfo *ci, IRRef *args)
 
															 static void asm_setupresult(ASMState *as, IRIns *ir, const CCallInfo *ci)
														
 
															 {
														
 
															   RegSet drop = RSET_SCRATCH;
														
 
															+  int hiop = ((ir+1)->o == IR_HIOP && !irt_isnil((ir+1)->t));
														
 
															   if (ra_hasreg(ir->r))
														
 
															     rset_clear(drop, ir->r); /* Dest reg handled below. */
														
 
															+  if (hiop && ra_hasreg((ir+1)->r))
														
 
															+    rset_clear(drop, (ir+1)->r);  /* Dest reg handled below. */
														
 
															   ra_evictset(as, drop); /* Evictions must be performed first. */
														
 
															   if (ra_used(ir)) {
														
 
															     lj_assertA(!irt_ispri(ir->t), "PRI dest");
														
@@ -470,6 +476,8 @@ static void asm_setupresult(ASMState *as, IRIns *ir, const CCallInfo *ci)
 
															       } else {
														
 
															 	ra_destreg(as, ir, RID_FPRET);
														
 
															       }
														
 
															+    } else if (hiop) {
														
 
															+      ra_destpair(as, ir);
														
 
															     } else {
														
 
															       ra_destreg(as, ir, RID_RET);
														
 
															     }
														
@@ -519,6 +527,21 @@ static void asm_retf(ASMState *as, IRIns *ir)
 
															   emit_lso(as, A64I_LDRx, RID_TMP, base, -8);
														
 
															 }
														
 
															+/* -- Buffer operations --------------------------------------------------- */
														
 
															+
														
 
															+#if LJ_HASBUFFER
														
 
															+static void asm_bufhdr_write(ASMState *as, Reg sb)
														
 
															+{
														
 
															+  Reg tmp = ra_scratch(as, rset_exclude(RSET_GPR, sb));
														
 
															+  IRIns irgc;
														
 
															+  irgc.ot = IRT(0, IRT_PGC);  /* GC type. */
														
 
															+  emit_storeofs(as, &irgc, RID_TMP, sb, offsetof(SBuf, L));
														
 
															+  emit_dn(as, A64I_BFMx | A64F_IMMS(lj_fls(SBUF_MASK_FLAG)) | A64F_IMMR(0), RID_TMP, tmp);
														
 
															+  emit_getgl(as, RID_TMP, cur_L);
														
 
															+  emit_loadofs(as, &irgc, tmp, sb, offsetof(SBuf, L));
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															 /* -- Type conversions ---------------------------------------------------- */
														
 
															 static void asm_tointg(ASMState *as, IRIns *ir, Reg left)
														
@@ -602,7 +625,7 @@ static void asm_conv(ASMState *as, IRIns *ir)
 
															 	emit_dn(as, A64I_SXTW, dest, left);
														
 
															       }
														
 
															     } else {
														
 
															-      if (st64) {
														
 
															+      if (st64 && !(ir->op2 & IRCONV_NONE)) {
														
 
															 	/* This is either a 32 bit reg/reg mov which zeroes the hiword
														
 
															 	** or a load of the loword from a 64 bit address.
														
 
															 	*/
														
@@ -675,22 +698,23 @@ static void asm_tvstore64(ASMState *as, Reg base, int32_t ofs, IRRef ref)
 
															 }
														
 
															 /* Get pointer to TValue. */
														
 
															-static void asm_tvptr(ASMState *as, Reg dest, IRRef ref)
														
 
															+static void asm_tvptr(ASMState *as, Reg dest, IRRef ref, MSize mode)
														
 
															 {
														
 
															-  IRIns *ir = IR(ref);
														
 
															-  if (irt_isnum(ir->t)) {
														
 
															-    if (irref_isk(ref)) {
														
 
															-      /* Use the number constant itself as a TValue. */
														
 
															-      ra_allockreg(as, i64ptr(ir_knum(ir)), dest);
														
 
															+  if ((mode & IRTMPREF_IN1)) {
														
 
															+    IRIns *ir = IR(ref);
														
 
															+    if (irt_isnum(ir->t)) {
														
 
															+      if (irref_isk(ref) && !(mode & IRTMPREF_OUT1)) {
														
 
															+	/* Use the number constant itself as a TValue. */
														
 
															+	ra_allockreg(as, i64ptr(ir_knum(ir)), dest);
														
 
															+	return;
														
 
															+      }
														
 
															+      emit_lso(as, A64I_STRd, (ra_alloc1(as, ref, RSET_FPR) & 31), dest, 0);
														
 
															     } else {
														
 
															-      /* Otherwise force a spill and use the spill slot. */
														
 
															-      emit_opk(as, A64I_ADDx, dest, RID_SP, ra_spill(as, ir), RSET_GPR);
														
 
															+      asm_tvstore64(as, dest, 0, ref);
														
 
															     }
														
 
															-  } else {
														
 
															-    /* Otherwise use g->tmptv to hold the TValue. */
														
 
															-    asm_tvstore64(as, dest, 0, ref);
														
 
															-    ra_allockreg(as, i64ptr(&J2G(as->J)->tmptv), dest);
														
 
															   }
														
 
															+  /* g->tmptv holds the TValue(s). */
														
 
															+  emit_dn(as, A64I_ADDx^emit_isk12(glofs(as, &J2G(as->J)->tmptv)), dest, RID_GL);
														
 
															 }
														
 
															 static void asm_aref(ASMState *as, IRIns *ir)
														
@@ -767,7 +791,7 @@ static void asm_href(ASMState *as, IRIns *ir, IROp merge)
 
															     }
														
 
															   } else if (irt_isaddr(kt)) {
														
 
															     if (isk) {
														
 
															-      int64_t kk = ((int64_t)irt_toitype(irkey->t) << 47) | irkey[1].tv.u64;
														
 
															+      int64_t kk = ((int64_t)irt_toitype(kt) << 47) | irkey[1].tv.u64;
														
 
															       scr = ra_allock(as, kk, allow);
														
 
															     } else {
														
 
															       scr = ra_scratch(as, allow);
														
@@ -775,7 +799,7 @@ static void asm_href(ASMState *as, IRIns *ir, IROp merge)
 
															     rset_clear(allow, scr);
														
 
															   } else {
														
 
															     lj_assertA(irt_ispri(kt) && !irt_isnil(kt), "bad HREF key type");
														
 
															-    type = ra_allock(as, ~((int64_t)~irt_toitype(ir->t) << 47), allow);
														
 
															+    type = ra_allock(as, ~((int64_t)~irt_toitype(kt) << 47), allow);
														
 
															     scr = ra_scratch(as, rset_clear(allow, type));
														
 
															     rset_clear(allow, scr);
														
 
															   }
														
@@ -824,7 +848,7 @@ static void asm_href(ASMState *as, IRIns *ir, IROp merge)
 
															       emit_lso(as, A64I_LDRx, scr, dest, offsetof(Node, key.u64));
														
 
															     }
														
 
															   } else {
														
 
															-    emit_nm(as, A64I_CMPw, scr, type);
														
 
															+    emit_nm(as, A64I_CMPx, scr, type);
														
 
															     emit_lso(as, A64I_LDRx, scr, dest, offsetof(Node, key));
														
 
															   }
														
@@ -1059,6 +1083,7 @@ static void asm_ahuvload(ASMState *as, IRIns *ir)
 
															   }
														
 
															   type = ra_scratch(as, rset_clear(gpr, tmp));
														
 
															   idx = asm_fuseahuref(as, ir->op1, &ofs, rset_clear(gpr, type), A64I_LDRx);
														
 
															+  if (ir->o == IR_VLOAD) ofs += 8 * ir->op2;
														
 
															   /* Always do the type check, even if the load result is unused. */
														
 
															   asm_guardcc(as, irt_isnum(ir->t) ? CC_LS : CC_NE);
														
 
															   if (irt_type(ir->t) >= IRT_NUM) {
														
@@ -1261,17 +1286,13 @@ static void asm_tbar(ASMState *as, IRIns *ir)
 
															 {
														
 
															   Reg tab = ra_alloc1(as, ir->op1, RSET_GPR);
														
 
															   Reg link = ra_scratch(as, rset_exclude(RSET_GPR, tab));
														
 
															-  Reg gr = ra_allock(as, i64ptr(J2G(as->J)),
														
 
															-		     rset_exclude(rset_exclude(RSET_GPR, tab), link));
														
 
															   Reg mark = RID_TMP;
														
 
															   MCLabel l_end = emit_label(as);
														
 
															   emit_lso(as, A64I_STRx, link, tab, (int32_t)offsetof(GCtab, gclist));
														
 
															   emit_lso(as, A64I_STRB, mark, tab, (int32_t)offsetof(GCtab, marked));
														
 
															-  emit_lso(as, A64I_STRx, tab, gr,
														
 
															-	   (int32_t)offsetof(global_State, gc.grayagain));
														
 
															+  emit_setgl(as, tab, gc.grayagain);
														
 
															   emit_dn(as, A64I_ANDw^emit_isk13(~LJ_GC_BLACK, 0), mark, mark);
														
 
															-  emit_lso(as, A64I_LDRx, link, gr,
														
 
															-	   (int32_t)offsetof(global_State, gc.grayagain));
														
 
															+  emit_getgl(as, link, gc.grayagain);
														
 
															   emit_cond_branch(as, CC_EQ, l_end);
														
 
															   emit_n(as, A64I_TSTw^emit_isk13(LJ_GC_BLACK, 0), mark);
														
 
															   emit_lso(as, A64I_LDRB, mark, tab, (int32_t)offsetof(GCtab, marked));
														
@@ -1291,7 +1312,7 @@ static void asm_obar(ASMState *as, IRIns *ir)
 
															   args[0] = ASMREF_TMP1;  /* global_State *g */
														
 
															   args[1] = ir->op1;      /* TValue *tv      */
														
 
															   asm_gencall(as, ci, args);
														
 
															-  ra_allockreg(as, i64ptr(J2G(as->J)), ra_releasetmp(as, ASMREF_TMP1) );
														
 
															+  emit_dm(as, A64I_MOVx, ra_releasetmp(as, ASMREF_TMP1), RID_GL);
														
 
															   obj = IR(ir->op1)->r;
														
 
															   tmp = ra_scratch(as, rset_exclude(allow, obj));
														
 
															   emit_cond_branch(as, CC_EQ, l_end);
														
@@ -1704,13 +1725,25 @@ static void asm_comp(ASMState *as, IRIns *ir)
 
															 #define asm_equal(as, ir)	asm_comp(as, ir)
														
 
															-/* -- Support for 64 bit ops in 32 bit mode ------------------------------- */
														
 
															+/* -- Split register ops -------------------------------------------------- */
														
 
															-/* Hiword op of a split 64 bit op. Previous op must be the loword op. */
														
 
															+/* Hiword op of a split 64/64 bit op. Previous op is the loword op. */
														
 
															 static void asm_hiop(ASMState *as, IRIns *ir)
														
 
															 {
														
 
															-  UNUSED(as); UNUSED(ir);
														
 
															-  lj_assertA(0, "unexpected HIOP");  /* Unused on 64 bit. */
														
 
															+  /* HIOP is marked as a store because it needs its own DCE logic. */
														
 
															+  int uselo = ra_used(ir-1), usehi = ra_used(ir);  /* Loword/hiword used? */
														
 
															+  if (LJ_UNLIKELY(!(as->flags & JIT_F_OPT_DCE))) uselo = usehi = 1;
														
 
															+  if (!usehi) return;  /* Skip unused hiword op for all remaining ops. */
														
 
															+  switch ((ir-1)->o) {
														
 
															+  case IR_CALLN:
														
 
															+  case IR_CALLL:
														
 
															+  case IR_CALLS:
														
 
															+  case IR_CALLXS:
														
 
															+    if (!uselo)
														
 
															+      ra_allocref(as, ir->op1, RID2RSET(RID_RETLO));  /* Mark lo op as used. */
														
 
															+    break;
														
 
															+  default: lj_assertA(0, "bad HIOP for op %d", (ir-1)->o); break;
														
 
															+  }
														
 
															 }
														
 
															 /* -- Profiling ----------------------------------------------------------- */
														
@@ -1781,7 +1814,14 @@ static void asm_stack_restore(ASMState *as, SnapShot *snap)
 
															     IRIns *ir = IR(ref);
														
 
															     if ((sn & SNAP_NORESTORE))
														
 
															       continue;
														
 
															-    if (irt_isnum(ir->t)) {
														
 
															+    if ((sn & SNAP_KEYINDEX)) {
														
 
															+      RegSet allow = rset_exclude(RSET_GPR, RID_BASE);
														
 
															+      Reg r = irref_isk(ref) ? ra_allock(as, ir->i, allow) :
														
 
															+			       ra_alloc1(as, ref, allow);
														
 
															+      rset_clear(allow, r);
														
 
															+      emit_lso(as, A64I_STRw, r, RID_BASE, ofs);
														
 
															+      emit_lso(as, A64I_STRw, ra_allock(as, LJ_KEYINDEX, allow), RID_BASE, ofs+4);
														
 
															+    } else if (irt_isnum(ir->t)) {
														
 
															       Reg src = ra_alloc1(as, ref, RSET_FPR);
														
 
															       emit_lso(as, A64I_STRd, (src & 31), RID_BASE, ofs);
														
 
															     } else {
														
@@ -1804,7 +1844,7 @@ static void asm_gc_check(ASMState *as)
 
															   const CCallInfo *ci = &lj_ir_callinfo[IRCALL_lj_gc_step_jit];
														
 
															   IRRef args[2];
														
 
															   MCLabel l_end;
														
 
															-  Reg tmp1, tmp2;
														
 
															+  Reg tmp2;
														
 
															   ra_evictset(as, RSET_SCRATCH);
														
 
															   l_end = emit_label(as);
														
 
															   /* Exit trace if in GCSatomic or GCSfinalize. Avoids syncing GC objects. */
														
@@ -1813,17 +1853,14 @@ static void asm_gc_check(ASMState *as)
 
															   args[0] = ASMREF_TMP1;  /* global_State *g */
														
 
															   args[1] = ASMREF_TMP2;  /* MSize steps     */
														
 
															   asm_gencall(as, ci, args);
														
 
															-  tmp1 = ra_releasetmp(as, ASMREF_TMP1);
														
 
															+  emit_dm(as, A64I_MOVx, ra_releasetmp(as, ASMREF_TMP1), RID_GL);
														
 
															   tmp2 = ra_releasetmp(as, ASMREF_TMP2);
														
 
															   emit_loadi(as, tmp2, as->gcsteps);
														
 
															   /* Jump around GC step if GC total < GC threshold. */
														
 
															   emit_cond_branch(as, CC_LS, l_end);
														
 
															   emit_nm(as, A64I_CMPx, RID_TMP, tmp2);
														
 
															-  emit_lso(as, A64I_LDRx, tmp2, tmp1,
														
 
															-	   (int32_t)offsetof(global_State, gc.threshold));
														
 
															-  emit_lso(as, A64I_LDRx, RID_TMP, tmp1,
														
 
															-	   (int32_t)offsetof(global_State, gc.total));
														
 
															-  ra_allockreg(as, i64ptr(J2G(as->J)), tmp1);
														
 
															+  emit_getgl(as, tmp2, gc.threshold);
														
 
															+  emit_getgl(as, RID_TMP, gc.total);
														
 
															   as->gcsteps = 0;
														
 
															   checkmclim(as);
														
 
															 }
														
@@ -1846,6 +1883,12 @@ static void asm_loop_fixup(ASMState *as)
 
															   }
														
 
															 }
														
 
															+/* Fixup the tail of the loop. */
														
 
															+static void asm_loop_tail_fixup(ASMState *as)
														
 
															+{
														
 
															+  UNUSED(as);  /* Nothing to do. */
														
 
															+}
														
 
															+
														
 
															 /* -- Head of trace ------------------------------------------------------- */
														
 
															 /* Reload L register from g->cur_L. */
														
--- a/libs/LuaJIT/src/lj_asm_mips.h
+++ b/libs/LuaJIT/src/lj_asm_mips.h
@@ -64,17 +64,29 @@ static Reg ra_alloc2(ASMState *as, IRIns *ir, RegSet allow)
 
															 /* Setup spare long-range jump slots per mcarea. */
														
 
															 static void asm_sparejump_setup(ASMState *as)
														
 
															 {
														
 
															-  MCode *mxp = as->mcbot;
														
 
															-  if (((uintptr_t)mxp & (LJ_PAGESIZE-1)) == sizeof(MCLink)) {
														
 
															+  MCode *mxp = as->mctop;
														
 
															+  if ((char *)mxp == (char *)as->J->mcarea + as->J->szmcarea) {
														
 
															+    mxp -= MIPS_SPAREJUMP*2;
														
 
															     lj_assertA(MIPSI_NOP == 0, "bad NOP");
														
 
															     memset(mxp, 0, MIPS_SPAREJUMP*2*sizeof(MCode));
														
 
															-    mxp += MIPS_SPAREJUMP*2;
														
 
															-    lj_assertA(mxp < as->mctop, "MIPS_SPAREJUMP too big");
														
 
															-    lj_mcode_sync(as->mcbot, mxp);
														
 
															-    lj_mcode_commitbot(as->J, mxp);
														
 
															-    as->mcbot = mxp;
														
 
															-    as->mclim = as->mcbot + MCLIM_REDZONE;
														
 
															+    as->mctop = mxp;
														
 
															+  }
														
 
															+}
														
 
															+
														
 
															+static MCode *asm_sparejump_use(MCode *mcarea, MCode tjump)
														
 
															+{
														
 
															+  MCode *mxp = (MCode *)((char *)mcarea + ((MCLink *)mcarea)->size);
														
 
															+  int slot = MIPS_SPAREJUMP;
														
 
															+  while (slot--) {
														
 
															+    mxp -= 2;
														
 
															+    if (*mxp == tjump) {
														
 
															+      return mxp;
														
 
															+    } else if (*mxp == MIPSI_NOP) {
														
 
															+      *mxp = tjump;
														
 
															+      return mxp;
														
 
															+    }
														
 
															   }
														
 
															+  return NULL;
														
 
															 }
														
 
															 /* Setup exit stub after the end of each trace. */
														
@@ -181,6 +193,9 @@ static Reg asm_fuseahuref(ASMState *as, IRRef ref, int32_t *ofsp, RegSet allow)
 
															 	  return ra_allock(as, ofs-(int16_t)ofs, allow);
														
 
															 	}
														
 
															       }
														
 
															+    } else if (ir->o == IR_TMPREF) {
														
 
															+      *ofsp = (int32_t)(offsetof(global_State, tmptv)-32768);
														
 
															+      return RID_JGL;
														
 
															     }
														
 
															   }
														
 
															   *ofsp = 0;
														
@@ -336,19 +351,15 @@ static void asm_gencall(ASMState *as, const CCallInfo *ci, IRRef *args)
 
															 static void asm_setupresult(ASMState *as, IRIns *ir, const CCallInfo *ci)
														
 
															 {
														
 
															   RegSet drop = RSET_SCRATCH;
														
 
															-#if LJ_32
														
 
															   int hiop = ((ir+1)->o == IR_HIOP && !irt_isnil((ir+1)->t));
														
 
															-#endif
														
 
															 #if !LJ_SOFTFP
														
 
															   if ((ci->flags & CCI_NOFPRCLOBBER))
														
 
															     drop &= ~RSET_FPR;
														
 
															 #endif
														
 
															   if (ra_hasreg(ir->r))
														
 
															     rset_clear(drop, ir->r);  /* Dest reg handled below. */
														
 
															-#if LJ_32
														
 
															   if (hiop && ra_hasreg((ir+1)->r))
														
 
															     rset_clear(drop, (ir+1)->r);  /* Dest reg handled below. */
														
 
															-#endif
														
 
															   ra_evictset(as, drop);  /* Evictions must be performed first. */
														
 
															   if (ra_used(ir)) {
														
 
															     lj_assertA(!irt_ispri(ir->t), "PRI dest");
														
@@ -377,10 +388,8 @@ static void asm_setupresult(ASMState *as, IRIns *ir, const CCallInfo *ci)
 
															       } else {
														
 
															 	ra_destreg(as, ir, RID_FPRET);
														
 
															       }
														
 
															-#if LJ_32
														
 
															     } else if (hiop) {
														
 
															       ra_destpair(as, ir);
														
 
															-#endif
														
 
															     } else {
														
 
															       ra_destreg(as, ir, RID_RET);
														
 
															     }
														
@@ -450,6 +459,27 @@ static void asm_retf(ASMState *as, IRIns *ir)
 
															   emit_tsi(as, MIPSI_AL, RID_TMP, base, -8);
														
 
															 }
														
 
															+/* -- Buffer operations --------------------------------------------------- */
														
 
															+
														
 
															+#if LJ_HASBUFFER
														
 
															+static void asm_bufhdr_write(ASMState *as, Reg sb)
														
 
															+{
														
 
															+  Reg tmp = ra_scratch(as, rset_exclude(RSET_GPR, sb));
														
 
															+  IRIns irgc;
														
 
															+  irgc.ot = IRT(0, IRT_PGC);  /* GC type. */
														
 
															+  emit_storeofs(as, &irgc, RID_TMP, sb, offsetof(SBuf, L));
														
 
															+  if ((as->flags & JIT_F_MIPSXXR2)) {
														
 
															+    emit_tsml(as, LJ_64 ? MIPSI_DINS : MIPSI_INS, RID_TMP, tmp,
														
 
															+	      lj_fls(SBUF_MASK_FLAG), 0);
														
 
															+  } else {
														
 
															+    emit_dst(as, MIPSI_OR, RID_TMP, RID_TMP, tmp);
														
 
															+    emit_tsi(as, MIPSI_ANDI, tmp, tmp, SBUF_MASK_FLAG);
														
 
															+  }
														
 
															+  emit_getgl(as, RID_TMP, cur_L);
														
 
															+  emit_loadofs(as, &irgc, tmp, sb, offsetof(SBuf, L));
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															 /* -- Type conversions ---------------------------------------------------- */
														
 
															 #if !LJ_SOFTFP
														
@@ -739,7 +769,7 @@ static void asm_conv(ASMState *as, IRIns *ir)
 
															 	  }
														
 
															 	}
														
 
															       } else {
														
 
															-	if (st64) {
														
 
															+	if (st64 && !(ir->op2 & IRCONV_NONE)) {
														
 
															 	  /* This is either a 32 bit reg/reg mov which zeroes the hiword
														
 
															 	  ** or a load of the loword from a 64 bit address.
														
 
															 	  */
														
@@ -827,34 +857,63 @@ static void asm_tvstore64(ASMState *as, Reg base, int32_t ofs, IRRef ref)
 
															 #endif
														
 
															 /* Get pointer to TValue. */
														
 
															-static void asm_tvptr(ASMState *as, Reg dest, IRRef ref)
														
 
															+static void asm_tvptr(ASMState *as, Reg dest, IRRef ref, MSize mode)
														
 
															 {
														
 
															-  IRIns *ir = IR(ref);
														
 
															-  if (irt_isnum(ir->t)) {
														
 
															-    if (irref_isk(ref))  /* Use the number constant itself as a TValue. */
														
 
															-      ra_allockreg(as, igcptr(ir_knum(ir)), dest);
														
 
															-    else  /* Otherwise force a spill and use the spill slot. */
														
 
															-      emit_tsi(as, MIPSI_AADDIU, dest, RID_SP, ra_spill(as, ir));
														
 
															-  } else {
														
 
															-    /* Otherwise use g->tmptv to hold the TValue. */
														
 
															+  int32_t tmpofs = (int32_t)(offsetof(global_State, tmptv)-32768);
														
 
															+  if ((mode & IRTMPREF_IN1)) {
														
 
															+    IRIns *ir = IR(ref);
														
 
															+    if (irt_isnum(ir->t)) {
														
 
															+      if ((mode & IRTMPREF_OUT1)) {
														
 
															+#if LJ_SOFTFP
														
 
															+	emit_tsi(as, MIPSI_AADDIU, dest, RID_JGL, tmpofs);
														
 
															+#if LJ_64
														
 
															+	emit_setgl(as, ra_alloc1(as, ref, RSET_GPR), tmptv.u64);
														
 
															+#else
														
 
															+	lj_assertA(irref_isk(ref), "unsplit FP op");
														
 
															+	emit_setgl(as,
														
 
															+		   ra_allock(as, (int32_t)ir_knum(ir)->u32.lo, RSET_GPR),
														
 
															+		   tmptv.u32.lo);
														
 
															+	emit_setgl(as,
														
 
															+		   ra_allock(as, (int32_t)ir_knum(ir)->u32.hi, RSET_GPR),
														
 
															+		   tmptv.u32.hi);
														
 
															+#endif
														
 
															+#else
														
 
															+	Reg src = ra_alloc1(as, ref, RSET_FPR);
														
 
															+	emit_tsi(as, MIPSI_AADDIU, dest, RID_JGL, tmpofs);
														
 
															+	emit_tsi(as, MIPSI_SDC1, (src & 31),  RID_JGL, tmpofs);
														
 
															+#endif
														
 
															+      } else if (irref_isk(ref)) {
														
 
															+	/* Use the number constant itself as a TValue. */
														
 
															+	ra_allockreg(as, igcptr(ir_knum(ir)), dest);
														
 
															+      } else {
														
 
															+#if LJ_SOFTFP32
														
 
															+	lj_assertA(0, "unsplit FP op");
														
 
															+#else
														
 
															+	/* Otherwise force a spill and use the spill slot. */
														
 
															+	emit_tsi(as, MIPSI_AADDIU, dest, RID_SP, ra_spill(as, ir));
														
 
															+#endif
														
 
															+      }
														
 
															+    } else {
														
 
															+      /* Otherwise use g->tmptv to hold the TValue. */
														
 
															 #if LJ_32
														
 
															-    RegSet allow = rset_exclude(RSET_GPR, dest);
														
 
															-    Reg type;
														
 
															-    emit_tsi(as, MIPSI_ADDIU, dest, RID_JGL, (int32_t)(offsetof(global_State, tmptv)-32768));
														
 
															-    if (!irt_ispri(ir->t)) {
														
 
															-      Reg src = ra_alloc1(as, ref, allow);
														
 
															-      emit_setgl(as, src, tmptv.gcr);
														
 
															-    }
														
 
															-    if (LJ_SOFTFP && (ir+1)->o == IR_HIOP)
														
 
															-      type = ra_alloc1(as, ref+1, allow);
														
 
															-    else
														
 
															-      type = ra_allock(as, (int32_t)irt_toitype(ir->t), allow);
														
 
															-    emit_setgl(as, type, tmptv.it);
														
 
															+      Reg type;
														
 
															+      emit_tsi(as, MIPSI_ADDIU, dest, RID_JGL, tmpofs);
														
 
															+      if (!irt_ispri(ir->t)) {
														
 
															+	Reg src = ra_alloc1(as, ref, RSET_GPR);
														
 
															+	emit_setgl(as, src, tmptv.gcr);
														
 
															+      }
														
 
															+      if (LJ_SOFTFP && (ir+1)->o == IR_HIOP && !irt_isnil((ir+1)->t))
														
 
															+	type = ra_alloc1(as, ref+1, RSET_GPR);
														
 
															+      else
														
 
															+	type = ra_allock(as, (int32_t)irt_toitype(ir->t), RSET_GPR);
														
 
															+      emit_setgl(as, type, tmptv.it);
														
 
															 #else
														
 
															-    asm_tvstore64(as, dest, 0, ref);
														
 
															-    emit_tsi(as, MIPSI_DADDIU, dest, RID_JGL,
														
 
															-	     (int32_t)(offsetof(global_State, tmptv)-32768));
														
 
															+      asm_tvstore64(as, dest, 0, ref);
														
 
															+      emit_tsi(as, MIPSI_DADDIU, dest, RID_JGL, tmpofs);
														
 
															 #endif
														
 
															+    }
														
 
															+  } else {
														
 
															+    emit_tsi(as, MIPSI_AADDIU, dest, RID_JGL, tmpofs);
														
 
															   }
														
 
															 }
														
@@ -909,11 +968,16 @@ static void asm_href(ASMState *as, IRIns *ir, IROp merge)
 
															   MCLabel l_end, l_loop, l_next;
														
 
															   rset_clear(allow, tab);
														
 
															-#if LJ_SOFTFP32
														
 
															-  if (!isk) {
														
 
															-    key = ra_alloc1(as, refkey, allow);
														
 
															-    rset_clear(allow, key);
														
 
															-    if (irkey[1].o == IR_HIOP) {
														
 
															+  if (!LJ_SOFTFP && irt_isnum(kt)) {
														
 
															+    key = ra_alloc1(as, refkey, RSET_FPR);
														
 
															+    tmpnum = ra_scratch(as, rset_exclude(RSET_FPR, key));
														
 
															+  } else {
														
 
															+    if (!irt_ispri(kt)) {
														
 
															+      key = ra_alloc1(as, refkey, allow);
														
 
															+      rset_clear(allow, key);
														
 
															+    }
														
 
															+#if LJ_32
														
 
															+    if (LJ_SOFTFP && irkey[1].o == IR_HIOP) {
														
 
															       if (ra_hasreg((irkey+1)->r)) {
														
 
															 	type = tmpnum = (irkey+1)->r;
														
 
															 	tmp1 = ra_scratch(as, allow);
														
@@ -924,23 +988,11 @@ static void asm_href(ASMState *as, IRIns *ir, IROp merge)
 
															       }
														
 
															       rset_clear(allow, tmpnum);
														
 
															     } else {
														
 
															-      type = ra_allock(as, (int32_t)irt_toitype(irkey->t), allow);
														
 
															+      type = ra_allock(as, (int32_t)irt_toitype(kt), allow);
														
 
															       rset_clear(allow, type);
														
 
															     }
														
 
															-  }
														
 
															-#else
														
 
															-  if (!LJ_SOFTFP && irt_isnum(kt)) {
														
 
															-    key = ra_alloc1(as, refkey, RSET_FPR);
														
 
															-    tmpnum = ra_scratch(as, rset_exclude(RSET_FPR, key));
														
 
															-  } else if (!irt_ispri(kt)) {
														
 
															-    key = ra_alloc1(as, refkey, allow);
														
 
															-    rset_clear(allow, key);
														
 
															-#if LJ_32
														
 
															-    type = ra_allock(as, (int32_t)irt_toitype(irkey->t), allow);
														
 
															-    rset_clear(allow, type);
														
 
															 #endif
														
 
															   }
														
 
															-#endif
														
 
															   tmp2 = ra_scratch(as, allow);
														
 
															   rset_clear(allow, tmp2);
														
 
															 #if LJ_64
														
@@ -953,10 +1005,10 @@ static void asm_href(ASMState *as, IRIns *ir, IROp merge)
 
															     } else {
														
 
															       int64_t k;
														
 
															       if (isk && irt_isaddr(kt)) {
														
 
															-	k = ((int64_t)irt_toitype(irkey->t) << 47) | irkey[1].tv.u64;
														
 
															+	k = ((int64_t)irt_toitype(kt) << 47) | irkey[1].tv.u64;
														
 
															       } else {
														
 
															 	lj_assertA(irt_ispri(kt) && !irt_isnil(kt), "bad HREF key type");
														
 
															-	k = ~((int64_t)~irt_toitype(ir->t) << 47);
														
 
															+	k = ~((int64_t)~irt_toitype(kt) << 47);
														
 
															       }
														
 
															       cmp64 = ra_allock(as, k, allow);
														
 
															       rset_clear(allow, cmp64);
														
@@ -1352,6 +1404,7 @@ static void asm_ahuvload(ASMState *as, IRIns *ir)
 
															 #endif
														
 
															   }
														
 
															   idx = asm_fuseahuref(as, ir->op1, &ofs, allow);
														
 
															+  if (ir->o == IR_VLOAD) ofs += 8 * ir->op2;
														
 
															   rset_clear(allow, idx);
														
 
															   if (irt_isnum(t)) {
														
 
															     asm_guard(as, MIPSI_BEQ, RID_TMP, RID_ZERO);
														
@@ -2327,15 +2380,15 @@ static void asm_comp64eq(ASMState *as, IRIns *ir)
 
															 }
														
 
															 #endif
														
 
															-/* -- Support for 64 bit ops in 32 bit mode ------------------------------- */
														
 
															+/* -- Split register ops -------------------------------------------------- */
														
 
															-/* Hiword op of a split 64 bit op. Previous op must be the loword op. */
														
 
															+/* Hiword op of a split 32/32 or 64/64 bit op. Previous op is the loword op. */
														
 
															 static void asm_hiop(ASMState *as, IRIns *ir)
														
 
															 {
														
 
															-#if LJ_32 && (LJ_HASFFI || LJ_SOFTFP)
														
 
															   /* HIOP is marked as a store because it needs its own DCE logic. */
														
 
															   int uselo = ra_used(ir-1), usehi = ra_used(ir);  /* Loword/hiword used? */
														
 
															   if (LJ_UNLIKELY(!(as->flags & JIT_F_OPT_DCE))) uselo = usehi = 1;
														
 
															+#if LJ_32 && (LJ_HASFFI || LJ_SOFTFP)
														
 
															   if ((ir-1)->o == IR_CONV) {  /* Conversions to/from 64 bit. */
														
 
															     as->curins--;  /* Always skip the CONV. */
														
 
															 #if LJ_HASFFI && !LJ_SOFTFP
														
@@ -2382,38 +2435,33 @@ static void asm_hiop(ASMState *as, IRIns *ir)
 
															     }
														
 
															     return;
														
 
															   }
														
 
															+#endif
														
 
															   if (!usehi) return;  /* Skip unused hiword op for all remaining ops. */
														
 
															   switch ((ir-1)->o) {
														
 
															-#if LJ_HASFFI
														
 
															+#if LJ_32 && LJ_HASFFI
														
 
															   case IR_ADD: as->curins--; asm_add64(as, ir); break;
														
 
															   case IR_SUB: as->curins--; asm_sub64(as, ir); break;
														
 
															   case IR_NEG: as->curins--; asm_neg64(as, ir); break;
														
 
															+  case IR_CNEWI:
														
 
															+    /* Nothing to do here. Handled by lo op itself. */
														
 
															+    break;
														
 
															 #endif
														
 
															-#if LJ_SOFTFP
														
 
															+#if LJ_32 && LJ_SOFTFP
														
 
															   case IR_SLOAD: case IR_ALOAD: case IR_HLOAD: case IR_ULOAD: case IR_VLOAD:
														
 
															   case IR_STRTO:
														
 
															     if (!uselo)
														
 
															       ra_allocref(as, ir->op1, RSET_GPR);  /* Mark lo op as used. */
														
 
															     break;
														
 
															+  case IR_ASTORE: case IR_HSTORE: case IR_USTORE: case IR_TOSTR: case IR_TMPREF:
														
 
															+    /* Nothing to do here. Handled by lo op itself. */
														
 
															+    break;
														
 
															 #endif
														
 
															-  case IR_CALLN:
														
 
															-  case IR_CALLS:
														
 
															-  case IR_CALLXS:
														
 
															+  case IR_CALLN: case IR_CALLL: case IR_CALLS: case IR_CALLXS:
														
 
															     if (!uselo)
														
 
															       ra_allocref(as, ir->op1, RID2RSET(RID_RETLO));  /* Mark lo op as used. */
														
 
															     break;
														
 
															-#if LJ_SOFTFP
														
 
															-  case IR_ASTORE: case IR_HSTORE: case IR_USTORE: case IR_TOSTR:
														
 
															-#endif
														
 
															-  case IR_CNEWI:
														
 
															-    /* Nothing to do here. Handled by lo op itself. */
														
 
															-    break;
														
 
															   default: lj_assertA(0, "bad HIOP for op %d", (ir-1)->o); break;
														
 
															   }
														
 
															-#else
														
 
															-  /* Unused on MIPS64 or without SOFTFP or FFI. */
														
 
															-  UNUSED(as); UNUSED(ir); lj_assertA(0, "unexpected HIOP");
														
 
															-#endif
														
 
															 }
														
 
															 /* -- Profiling ----------------------------------------------------------- */
														
@@ -2513,6 +2561,8 @@ static void asm_stack_restore(ASMState *as, SnapShot *snap)
 
															       } else if ((sn & SNAP_SOFTFPNUM)) {
														
 
															 	type = ra_alloc1(as, ref+1, rset_exclude(RSET_GPR, RID_BASE));
														
 
															 #endif
														
 
															+      } else if ((sn & SNAP_KEYINDEX)) {
														
 
															+	type = ra_allock(as, (int32_t)LJ_KEYINDEX, allow);
														
 
															       } else {
														
 
															 	type = ra_allock(as, (int32_t)irt_toitype(ir->t), allow);
														
 
															       }
														
@@ -2575,6 +2625,12 @@ static void asm_loop_fixup(ASMState *as)
 
															   }
														
 
															 }
														
 
															+/* Fixup the tail of the loop. */
														
 
															+static void asm_loop_tail_fixup(ASMState *as)
														
 
															+{
														
 
															+  if (as->loopinv) as->mctop--;
														
 
															+}
														
 
															+
														
 
															 /* -- Head of trace ------------------------------------------------------- */
														
 
															 /* Coalesce BASE register for a root trace. */
														
@@ -2582,7 +2638,6 @@ static void asm_head_root_base(ASMState *as)
 
															 {
														
 
															   IRIns *ir = IR(REF_BASE);
														
 
															   Reg r = ir->r;
														
 
															-  if (as->loopinv) as->mctop--;
														
 
															   if (ra_hasreg(r)) {
														
 
															     ra_free(as, r);
														
 
															     if (rset_test(as->modset, r) || irt_ismarked(ir->t))
														
@@ -2597,7 +2652,6 @@ static RegSet asm_head_side_base(ASMState *as, IRIns *irp, RegSet allow)
 
															 {
														
 
															   IRIns *ir = IR(REF_BASE);
														
 
															   Reg r = ir->r;
														
 
															-  if (as->loopinv) as->mctop--;
														
 
															   if (ra_hasreg(r)) {
														
 
															     ra_free(as, r);
														
 
															     if (rset_test(as->modset, r) || irt_ismarked(ir->t))
														
@@ -2704,21 +2758,17 @@ void lj_asm_patchexit(jit_State *J, GCtrace *T, ExitNo exitno, MCode *target)
 
															 	patchbranch:
														
 
															 	  p[-1] = (p[-1] & 0xffff0000u) | (delta & 0xffffu);
														
 
															 	  *p = MIPSI_NOP;  /* Replace the load of the exit number. */
														
 
															-	  cstop = p;
														
 
															+	  cstop = p+1;
														
 
															 	  if (!cstart) cstart = p-1;
														
 
															 	} else {  /* Branch out of range. Use spare jump slot in mcarea. */
														
 
															-	  int i;
														
 
															-	  for (i = (int)(sizeof(MCLink)/sizeof(MCode));
														
 
															-	       i < (int)(sizeof(MCLink)/sizeof(MCode)+MIPS_SPAREJUMP*2);
														
 
															-	       i += 2) {
														
 
															-	    if (mcarea[i] == tjump) {
														
 
															-	      delta = mcarea+i - p;
														
 
															-	      goto patchbranch;
														
 
															-	    } else if (mcarea[i] == MIPSI_NOP) {
														
 
															-	      mcarea[i] = tjump;
														
 
															-	      cstart = mcarea+i;
														
 
															-	      delta = mcarea+i - p;
														
 
															+	  MCode *mcjump = asm_sparejump_use(mcarea, tjump);
														
 
															+	  if (mcjump) {
														
 
															+	    lj_mcode_sync(mcjump, mcjump+1);
														
 
															+	    delta = mcjump - p;
														
 
															+	    if (((delta + 0x8000) >> 16) == 0) {
														
 
															 	      goto patchbranch;
														
 
															+	    } else {
														
 
															+	      lj_assertJ(0, "spare jump out of range: -Osizemcode too big");
														
 
															 	    }
														
 
															 	  }
														
 
															 	  /* Ignore jump slot overflow. Child trace is simply not attached. */
														
--- a/libs/LuaJIT/src/lj_asm_ppc.h
+++ b/libs/LuaJIT/src/lj_asm_ppc.h
@@ -156,6 +156,9 @@ static Reg asm_fuseahuref(ASMState *as, IRRef ref, int32_t *ofsp, RegSet allow)
 
															 	  return ra_allock(as, ofs-(int16_t)ofs, allow);
														
 
															 	}
														
 
															       }
														
 
															+    } else if (ir->o == IR_TMPREF) {
														
 
															+      *ofsp = (int32_t)(offsetof(global_State, tmptv)-32768);
														
 
															+      return RID_JGL;
														
 
															     }
														
 
															   }
														
 
															   *ofsp = 0;
														
@@ -337,10 +340,8 @@ static void asm_setupresult(ASMState *as, IRIns *ir, const CCallInfo *ci)
 
															       } else {
														
 
															 	ra_destreg(as, ir, RID_FPRET);
														
 
															       }
														
 
															-#if LJ_32
														
 
															     } else if (hiop) {
														
 
															       ra_destpair(as, ir);
														
 
															-#endif
														
 
															     } else {
														
 
															       ra_destreg(as, ir, RID_RET);
														
 
															     }
														
@@ -389,6 +390,21 @@ static void asm_retf(ASMState *as, IRIns *ir)
 
															   emit_tai(as, PPCI_LWZ, RID_TMP, base, -8);
														
 
															 }
														
 
															+/* -- Buffer operations --------------------------------------------------- */
														
 
															+
														
 
															+#if LJ_HASBUFFER
														
 
															+static void asm_bufhdr_write(ASMState *as, Reg sb)
														
 
															+{
														
 
															+  Reg tmp = ra_scratch(as, rset_exclude(RSET_GPR, sb));
														
 
															+  IRIns irgc;
														
 
															+  irgc.ot = IRT(0, IRT_PGC);  /* GC type. */
														
 
															+  emit_storeofs(as, &irgc, RID_TMP, sb, offsetof(SBuf, L));
														
 
															+  emit_rot(as, PPCI_RLWIMI, RID_TMP, tmp, 0, 31-lj_fls(SBUF_MASK_FLAG), 31);
														
 
															+  emit_getgl(as, RID_TMP, cur_L);
														
 
															+  emit_loadofs(as, &irgc, tmp, sb, offsetof(SBuf, L));
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															 /* -- Type conversions ---------------------------------------------------- */
														
 
															 #if !LJ_SOFTFP
														
@@ -567,28 +583,54 @@ static void asm_strto(ASMState *as, IRIns *ir)
 
															 /* -- Memory references --------------------------------------------------- */
														
 
															 /* Get pointer to TValue. */
														
 
															-static void asm_tvptr(ASMState *as, Reg dest, IRRef ref)
														
 
															+static void asm_tvptr(ASMState *as, Reg dest, IRRef ref, MSize mode)
														
 
															 {
														
 
															-  IRIns *ir = IR(ref);
														
 
															-  if (irt_isnum(ir->t)) {
														
 
															-    if (irref_isk(ref))  /* Use the number constant itself as a TValue. */
														
 
															-      ra_allockreg(as, i32ptr(ir_knum(ir)), dest);
														
 
															-    else  /* Otherwise force a spill and use the spill slot. */
														
 
															-      emit_tai(as, PPCI_ADDI, dest, RID_SP, ra_spill(as, ir));
														
 
															-  } else {
														
 
															-    /* Otherwise use g->tmptv to hold the TValue. */
														
 
															-    RegSet allow = rset_exclude(RSET_GPR, dest);
														
 
															-    Reg type;
														
 
															-    emit_tai(as, PPCI_ADDI, dest, RID_JGL, (int32_t)offsetof(global_State, tmptv)-32768);
														
 
															-    if (!irt_ispri(ir->t)) {
														
 
															-      Reg src = ra_alloc1(as, ref, allow);
														
 
															-      emit_setgl(as, src, tmptv.gcr);
														
 
															+  int32_t tmpofs = (int32_t)(offsetof(global_State, tmptv)-32768);
														
 
															+  if ((mode & IRTMPREF_IN1)) {
														
 
															+    IRIns *ir = IR(ref);
														
 
															+    if (irt_isnum(ir->t)) {
														
 
															+      if ((mode & IRTMPREF_OUT1)) {
														
 
															+#if LJ_SOFTFP
														
 
															+	lj_assertA(irref_isk(ref), "unsplit FP op");
														
 
															+	emit_tai(as, PPCI_ADDI, dest, RID_JGL, tmpofs);
														
 
															+	emit_setgl(as,
														
 
															+		   ra_allock(as, (int32_t)ir_knum(ir)->u32.lo, RSET_GPR),
														
 
															+		   tmptv.u32.lo);
														
 
															+	emit_setgl(as,
														
 
															+		   ra_allock(as, (int32_t)ir_knum(ir)->u32.hi, RSET_GPR),
														
 
															+		   tmptv.u32.hi);
														
 
															+#else
														
 
															+	Reg src = ra_alloc1(as, ref, RSET_FPR);
														
 
															+	emit_tai(as, PPCI_ADDI, dest, RID_JGL, tmpofs);
														
 
															+	emit_fai(as, PPCI_STFD, src, RID_JGL, tmpofs);
														
 
															+#endif
														
 
															+      } else if (irref_isk(ref)) {
														
 
															+	/* Use the number constant itself as a TValue. */
														
 
															+	ra_allockreg(as, i32ptr(ir_knum(ir)), dest);
														
 
															+      } else {
														
 
															+#if LJ_SOFTFP
														
 
															+	lj_assertA(0, "unsplit FP op");
														
 
															+#else
														
 
															+	/* Otherwise force a spill and use the spill slot. */
														
 
															+	emit_tai(as, PPCI_ADDI, dest, RID_SP, ra_spill(as, ir));
														
 
															+#endif
														
 
															+      }
														
 
															+    } else {
														
 
															+      /* Otherwise use g->tmptv to hold the TValue. */
														
 
															+      Reg type;
														
 
															+      emit_tai(as, PPCI_ADDI, dest, RID_JGL, tmpofs);
														
 
															+      if (!irt_ispri(ir->t)) {
														
 
															+	Reg src = ra_alloc1(as, ref, RSET_GPR);
														
 
															+	emit_setgl(as, src, tmptv.gcr);
														
 
															+      }
														
 
															+      if (LJ_SOFTFP && (ir+1)->o == IR_HIOP && !irt_isnil((ir+1)->t))
														
 
															+	type = ra_alloc1(as, ref+1, RSET_GPR);
														
 
															+      else
														
 
															+	type = ra_allock(as, irt_toitype(ir->t), RSET_GPR);
														
 
															+      emit_setgl(as, type, tmptv.it);
														
 
															     }
														
 
															-    if (LJ_SOFTFP && (ir+1)->o == IR_HIOP)
														
 
															-      type = ra_alloc1(as, ref+1, allow);
														
 
															-    else
														
 
															-      type = ra_allock(as, irt_toitype(ir->t), allow);
														
 
															-    emit_setgl(as, type, tmptv.it);
														
 
															+  } else {
														
 
															+    emit_tai(as, PPCI_ADDI, dest, RID_JGL, tmpofs);
														
 
															   }
														
 
															 }
														
@@ -894,7 +936,7 @@ static void asm_fload(ASMState *as, IRIns *ir)
 
															   int32_t ofs;
														
 
															   if (ir->op1 == REF_NIL) {  /* FLOAD from GG_State with offset. */
														
 
															     idx = RID_JGL;
														
 
															-    ofs = (ir->op2 << 2) - 32768;
														
 
															+    ofs = (ir->op2 << 2) - 32768 - GG_OFS(g);
														
 
															   } else {
														
 
															     idx = ra_alloc1(as, ir->op1, RSET_GPR);
														
 
															     if (ir->op2 == IRFL_TAB_ARRAY) {
														
@@ -975,6 +1017,10 @@ static void asm_ahuvload(ASMState *as, IRIns *ir)
 
															     rset_clear(allow, dest);
														
 
															   }
														
 
															   idx = asm_fuseahuref(as, ir->op1, &ofs, allow);
														
 
															+  if (ir->o == IR_VLOAD) {
														
 
															+    ofs = ofs != AHUREF_LSX ? ofs + 8 * ir->op2 :
														
 
															+	  ir->op2 ? 8 * ir->op2 : AHUREF_LSX;
														
 
															+  }
														
 
															   if (irt_isnum(t)) {
														
 
															     Reg tisnum = ra_allock(as, (int32_t)LJ_TISNUM, rset_exclude(allow, idx));
														
 
															     asm_guardcc(as, CC_GE);
														
@@ -1057,7 +1103,8 @@ static void asm_sload(ASMState *as, IRIns *ir)
 
															   lj_assertA(irt_isguard(ir->t) || !(ir->op2 & IRSLOAD_TYPECHECK),
														
 
															 	     "inconsistent SLOAD variant");
														
 
															   lj_assertA(LJ_DUALNUM ||
														
 
															-	     !irt_isint(t) || (ir->op2 & (IRSLOAD_CONVERT|IRSLOAD_FRAME)),
														
 
															+	     !irt_isint(t) ||
														
 
															+	     (ir->op2 & (IRSLOAD_CONVERT|IRSLOAD_FRAME|IRSLOAD_KEYINDEX)),
														
 
															 	     "bad SLOAD type");
														
 
															 #if LJ_SOFTFP
														
 
															   lj_assertA(!(ir->op2 & IRSLOAD_CONVERT),
														
@@ -1894,15 +1941,15 @@ static void asm_comp64(ASMState *as, IRIns *ir)
 
															 }
														
 
															 #endif
														
 
															-/* -- Support for 64 bit ops in 32 bit mode ------------------------------- */
														
 
															+/* -- Split register ops -------------------------------------------------- */
														
 
															-/* Hiword op of a split 64 bit op. Previous op must be the loword op. */
														
 
															+/* Hiword op of a split 32/32 bit op. Previous op is be the loword op. */
														
 
															 static void asm_hiop(ASMState *as, IRIns *ir)
														
 
															 {
														
 
															-#if LJ_HASFFI || LJ_SOFTFP
														
 
															   /* HIOP is marked as a store because it needs its own DCE logic. */
														
 
															   int uselo = ra_used(ir-1), usehi = ra_used(ir);  /* Loword/hiword used? */
														
 
															   if (LJ_UNLIKELY(!(as->flags & JIT_F_OPT_DCE))) uselo = usehi = 1;
														
 
															+#if LJ_HASFFI || LJ_SOFTFP
														
 
															   if ((ir-1)->o == IR_CONV) {  /* Conversions to/from 64 bit. */
														
 
															     as->curins--;  /* Always skip the CONV. */
														
 
															 #if LJ_HASFFI && !LJ_SOFTFP
														
@@ -1937,12 +1984,16 @@ static void asm_hiop(ASMState *as, IRIns *ir)
 
															     }
														
 
															     return;
														
 
															   }
														
 
															+#endif
														
 
															   if (!usehi) return;  /* Skip unused hiword op for all remaining ops. */
														
 
															   switch ((ir-1)->o) {
														
 
															 #if LJ_HASFFI
														
 
															   case IR_ADD: as->curins--; asm_add64(as, ir); break;
														
 
															   case IR_SUB: as->curins--; asm_sub64(as, ir); break;
														
 
															   case IR_NEG: as->curins--; asm_neg64(as, ir); break;
														
 
															+  case IR_CNEWI:
														
 
															+    /* Nothing to do here. Handled by lo op itself. */
														
 
															+    break;
														
 
															 #endif
														
 
															 #if LJ_SOFTFP
														
 
															   case IR_SLOAD: case IR_ALOAD: case IR_HLOAD: case IR_ULOAD: case IR_VLOAD:
														
@@ -1950,25 +2001,16 @@ static void asm_hiop(ASMState *as, IRIns *ir)
 
															     if (!uselo)
														
 
															       ra_allocref(as, ir->op1, RSET_GPR);  /* Mark lo op as used. */
														
 
															     break;
														
 
															+  case IR_ASTORE: case IR_HSTORE: case IR_USTORE: case IR_TOSTR: case IR_TMPREF:
														
 
															+    /* Nothing to do here. Handled by lo op itself. */
														
 
															+    break;
														
 
															 #endif
														
 
															-  case IR_CALLN:
														
 
															-  case IR_CALLS:
														
 
															-  case IR_CALLXS:
														
 
															+  case IR_CALLN: case IR_CALLL: case IR_CALLS: case IR_CALLXS:
														
 
															     if (!uselo)
														
 
															       ra_allocref(as, ir->op1, RID2RSET(RID_RETLO));  /* Mark lo op as used. */
														
 
															     break;
														
 
															-#if LJ_SOFTFP
														
 
															-  case IR_ASTORE: case IR_HSTORE: case IR_USTORE: case IR_TOSTR:
														
 
															-#endif
														
 
															-  case IR_CNEWI:
														
 
															-    /* Nothing to do here. Handled by lo op itself. */
														
 
															-    break;
														
 
															   default: lj_assertA(0, "bad HIOP for op %d", (ir-1)->o); break;
														
 
															   }
														
 
															-#else
														
 
															-  /* Unused without SOFTFP or FFI. */
														
 
															-  UNUSED(as); UNUSED(ir); lj_assertA(0, "unexpected HIOP");
														
 
															-#endif
														
 
															 }
														
 
															 /* -- Profiling ----------------------------------------------------------- */
														
@@ -2055,6 +2097,8 @@ static void asm_stack_restore(ASMState *as, SnapShot *snap)
 
															       } else if ((sn & SNAP_SOFTFPNUM)) {
														
 
															 	type = ra_alloc1(as, ref+1, rset_exclude(RSET_GPR, RID_BASE));
														
 
															 #endif
														
 
															+      } else if ((sn & SNAP_KEYINDEX)) {
														
 
															+	type = ra_allock(as, (int32_t)LJ_KEYINDEX, allow);
														
 
															       } else {
														
 
															 	type = ra_allock(as, (int32_t)irt_toitype(ir->t), allow);
														
 
															       }
														
@@ -2113,6 +2157,12 @@ static void asm_loop_fixup(ASMState *as)
 
															   }
														
 
															 }
														
 
															+/* Fixup the tail of the loop. */
														
 
															+static void asm_loop_tail_fixup(ASMState *as)
														
 
															+{
														
 
															+  UNUSED(as);  /* Nothing to do. */
														
 
															+}
														
 
															+
														
 
															 /* -- Head of trace ------------------------------------------------------- */
														
 
															 /* Coalesce BASE register for a root trace. */
														
--- a/libs/LuaJIT/src/lj_asm_x86.h
+++ b/libs/LuaJIT/src/lj_asm_x86.h
@@ -216,10 +216,17 @@ static void asm_fuseahuref(ASMState *as, IRRef ref, RegSet allow)
 
															 #endif
														
 
															       }
														
 
															       break;
														
 
															+    case IR_TMPREF:
														
 
															+#if LJ_GC64
														
 
															+      as->mrm.ofs = (int32_t)dispofs(as, &J2G(as->J)->tmptv);
														
 
															+      as->mrm.base = RID_DISPATCH;
														
 
															+      as->mrm.idx = RID_NONE;
														
 
															+#else
														
 
															+      as->mrm.ofs = igcptr(&J2G(as->J)->tmptv);
														
 
															+      as->mrm.base = as->mrm.idx = RID_NONE;
														
 
															+#endif
														
 
															+      return;
														
 
															     default:
														
 
															-      lj_assertA(ir->o == IR_HREF || ir->o == IR_NEWREF || ir->o == IR_UREFO ||
														
 
															-		 ir->o == IR_KKPTR,
														
 
															-		 "bad IR op %d", ir->o);
														
 
															       break;
														
 
															     }
														
 
															   }
														
@@ -480,6 +487,7 @@ static Reg asm_fuseload(ASMState *as, IRRef ref, RegSet allow)
 
															       }
														
 
															     } else if (ir->o == IR_VLOAD && !(LJ_GC64 && irt_isaddr(ir->t))) {
														
 
															       asm_fuseahuref(as, ir->op1, xallow);
														
 
															+      as->mrm.ofs += 8 * ir->op2;
														
 
															       return RID_MRM;
														
 
															     }
														
 
															   }
														
@@ -651,7 +659,7 @@ static void asm_gencall(ASMState *as, const CCallInfo *ci, IRRef *args)
 
															 static void asm_setupresult(ASMState *as, IRIns *ir, const CCallInfo *ci)
														
 
															 {
														
 
															   RegSet drop = RSET_SCRATCH;
														
 
															-  int hiop = (LJ_32 && (ir+1)->o == IR_HIOP && !irt_isnil((ir+1)->t));
														
 
															+  int hiop = ((ir+1)->o == IR_HIOP && !irt_isnil((ir+1)->t));
														
 
															   if ((ci->flags & CCI_NOFPRCLOBBER))
														
 
															     drop &= ~RSET_FPR;
														
 
															   if (ra_hasreg(ir->r))
														
@@ -691,10 +699,8 @@ static void asm_setupresult(ASMState *as, IRIns *ir, const CCallInfo *ci)
 
															 		  irt_isnum(ir->t) ? XOg_FSTPq : XOg_FSTPd, RID_ESP, ofs);
														
 
															       }
														
 
															 #endif
														
 
															-#if LJ_32
														
 
															     } else if (hiop) {
														
 
															       ra_destpair(as, ir);
														
 
															-#endif
														
 
															     } else {
														
 
															       lj_assertA(!irt_ispri(ir->t), "PRI dest");
														
 
															       ra_destreg(as, ir, RID_RET);
														
@@ -781,6 +787,21 @@ static void asm_retf(ASMState *as, IRIns *ir)
 
															 #endif
														
 
															 }
														
 
															+/* -- Buffer operations --------------------------------------------------- */
														
 
															+
														
 
															+#if LJ_HASBUFFER
														
 
															+static void asm_bufhdr_write(ASMState *as, Reg sb)
														
 
															+{
														
 
															+  Reg tmp = ra_scratch(as, rset_exclude(RSET_GPR, sb));
														
 
															+  IRIns irgc;
														
 
															+  irgc.ot = IRT(0, IRT_PGC);  /* GC type. */
														
 
															+  emit_storeofs(as, &irgc, tmp, sb, offsetof(SBuf, L));
														
 
															+  emit_opgl(as, XO_ARITH(XOg_OR), tmp|REX_GC64, cur_L);
														
 
															+  emit_gri(as, XG_ARITHi(XOg_AND), tmp, SBUF_MASK_FLAG);
														
 
															+  emit_loadofs(as, &irgc, tmp, sb, offsetof(SBuf, L));
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															 /* -- Type conversions ---------------------------------------------------- */
														
 
															 static void asm_tointg(ASMState *as, IRIns *ir, Reg left)
														
@@ -924,7 +945,7 @@ static void asm_conv(ASMState *as, IRIns *ir)
 
															       }
														
 
															     } else {
														
 
															       Reg dest = ra_dest(as, ir, RSET_GPR);
														
 
															-      if (st64) {
														
 
															+      if (st64 && !(ir->op2 & IRCONV_NONE)) {
														
 
															 	Reg left = asm_fuseload(as, lref, RSET_GPR);
														
 
															 	/* This is either a 32 bit reg/reg mov which zeroes the hiword
														
 
															 	** or a load of the loword from a 64 bit address.
														
@@ -1050,47 +1071,48 @@ static void asm_strto(ASMState *as, IRIns *ir)
 
															 /* -- Memory references --------------------------------------------------- */
														
 
															 /* Get pointer to TValue. */
														
 
															-static void asm_tvptr(ASMState *as, Reg dest, IRRef ref)
														
 
															+static void asm_tvptr(ASMState *as, Reg dest, IRRef ref, MSize mode)
														
 
															 {
														
 
															-  IRIns *ir = IR(ref);
														
 
															-  if (irt_isnum(ir->t)) {
														
 
															-    /* For numbers use the constant itself or a spill slot as a TValue. */
														
 
															-    if (irref_isk(ref))
														
 
															-      emit_loada(as, dest, ir_knum(ir));
														
 
															-    else
														
 
															-      emit_rmro(as, XO_LEA, dest|REX_64, RID_ESP, ra_spill(as, ir));
														
 
															-  } else {
														
 
															-    /* Otherwise use g->tmptv to hold the TValue. */
														
 
															-#if LJ_GC64
														
 
															-    if (irref_isk(ref)) {
														
 
															-      TValue k;
														
 
															-      lj_ir_kvalue(as->J->L, &k, ir);
														
 
															-      emit_movmroi(as, dest, 4, k.u32.hi);
														
 
															-      emit_movmroi(as, dest, 0, k.u32.lo);
														
 
															+  if ((mode & IRTMPREF_IN1)) {
														
 
															+    IRIns *ir = IR(ref);
														
 
															+    if (irt_isnum(ir->t)) {
														
 
															+      if (irref_isk(ref) && !(mode & IRTMPREF_OUT1)) {
														
 
															+	/* Use the number constant itself as a TValue. */
														
 
															+	emit_loada(as, dest, ir_knum(ir));
														
 
															+	return;
														
 
															+      }
														
 
															+      emit_rmro(as, XO_MOVSDto, ra_alloc1(as, ref, RSET_FPR), dest, 0);
														
 
															     } else {
														
 
															-      /* TODO: 64 bit store + 32 bit load-modify-store is suboptimal. */
														
 
															-      Reg src = ra_alloc1(as, ref, rset_exclude(RSET_GPR, dest));
														
 
															-      if (irt_is64(ir->t)) {
														
 
															-	emit_u32(as, irt_toitype(ir->t) << 15);
														
 
															-	emit_rmro(as, XO_ARITHi, XOg_OR, dest, 4);
														
 
															+#if LJ_GC64
														
 
															+      if (irref_isk(ref)) {
														
 
															+	TValue k;
														
 
															+	lj_ir_kvalue(as->J->L, &k, ir);
														
 
															+	emit_movmroi(as, dest, 4, k.u32.hi);
														
 
															+	emit_movmroi(as, dest, 0, k.u32.lo);
														
 
															       } else {
														
 
															-	/* Currently, no caller passes integers that might end up here. */
														
 
															-	emit_movmroi(as, dest, 4, (irt_toitype(ir->t) << 15));
														
 
															+	/* TODO: 64 bit store + 32 bit load-modify-store is suboptimal. */
														
 
															+	Reg src = ra_alloc1(as, ref, rset_exclude(RSET_GPR, dest));
														
 
															+	if (irt_is64(ir->t)) {
														
 
															+	  emit_u32(as, irt_toitype(ir->t) << 15);
														
 
															+	  emit_rmro(as, XO_ARITHi, XOg_OR, dest, 4);
														
 
															+	} else {
														
 
															+	  emit_movmroi(as, dest, 4, (irt_toitype(ir->t) << 15));
														
 
															+	}
														
 
															+	emit_movtomro(as, REX_64IR(ir, src), dest, 0);
														
 
															       }
														
 
															-      emit_movtomro(as, REX_64IR(ir, src), dest, 0);
														
 
															-    }
														
 
															 #else
														
 
															-    if (!irref_isk(ref)) {
														
 
															-      Reg src = ra_alloc1(as, ref, rset_exclude(RSET_GPR, dest));
														
 
															-      emit_movtomro(as, REX_64IR(ir, src), dest, 0);
														
 
															-    } else if (!irt_ispri(ir->t)) {
														
 
															-      emit_movmroi(as, dest, 0, ir->i);
														
 
															-    }
														
 
															-    if (!(LJ_64 && irt_islightud(ir->t)))
														
 
															-      emit_movmroi(as, dest, 4, irt_toitype(ir->t));
														
 
															+      if (!irref_isk(ref)) {
														
 
															+	Reg src = ra_alloc1(as, ref, rset_exclude(RSET_GPR, dest));
														
 
															+	emit_movtomro(as, REX_64IR(ir, src), dest, 0);
														
 
															+      } else if (!irt_ispri(ir->t)) {
														
 
															+	emit_movmroi(as, dest, 0, ir->i);
														
 
															+      }
														
 
															+      if (!(LJ_64 && irt_islightud(ir->t)))
														
 
															+	emit_movmroi(as, dest, 4, irt_toitype(ir->t));
														
 
															 #endif
														
 
															-    emit_loada(as, dest, &J2G(as->J)->tmptv);
														
 
															+    }
														
 
															   }
														
 
															+  emit_loada(as, dest, &J2G(as->J)->tmptv); /* g->tmptv holds the TValue(s). */
														
 
															 }
														
 
															 static void asm_aref(ASMState *as, IRIns *ir)
														
@@ -1524,6 +1546,7 @@ static void asm_ahuvload(ASMState *as, IRIns *ir)
 
															     Reg dest = asm_load_lightud64(as, ir, 1);
														
 
															     if (ra_hasreg(dest)) {
														
 
															       asm_fuseahuref(as, ir->op1, RSET_GPR);
														
 
															+      if (ir->o == IR_VLOAD) as->mrm.ofs += 8 * ir->op2;
														
 
															       emit_mrm(as, XO_MOV, dest|REX_64, RID_MRM);
														
 
															     }
														
 
															     return;
														
@@ -1533,6 +1556,7 @@ static void asm_ahuvload(ASMState *as, IRIns *ir)
 
															     RegSet allow = irt_isnum(ir->t) ? RSET_FPR : RSET_GPR;
														
 
															     Reg dest = ra_dest(as, ir, allow);
														
 
															     asm_fuseahuref(as, ir->op1, RSET_GPR);
														
 
															+    if (ir->o == IR_VLOAD) as->mrm.ofs += 8 * ir->op2;
														
 
															 #if LJ_GC64
														
 
															     if (irt_isaddr(ir->t)) {
														
 
															       emit_shifti(as, XOg_SHR|REX_64, dest, 17);
														
@@ -1560,6 +1584,7 @@ static void asm_ahuvload(ASMState *as, IRIns *ir)
 
															     }
														
 
															 #endif
														
 
															     asm_fuseahuref(as, ir->op1, gpr);
														
 
															+    if (ir->o == IR_VLOAD) as->mrm.ofs += 8 * ir->op2;
														
 
															   }
														
 
															   /* Always do the type check, even if the load result is unused. */
														
 
															   as->mrm.ofs += 4;
														
@@ -1675,7 +1700,8 @@ static void asm_sload(ASMState *as, IRIns *ir)
 
															   lj_assertA(irt_isguard(t) || !(ir->op2 & IRSLOAD_TYPECHECK),
														
 
															 	     "inconsistent SLOAD variant");
														
 
															   lj_assertA(LJ_DUALNUM ||
														
 
															-	     !irt_isint(t) || (ir->op2 & (IRSLOAD_CONVERT|IRSLOAD_FRAME)),
														
 
															+	     !irt_isint(t) ||
														
 
															+	     (ir->op2 & (IRSLOAD_CONVERT|IRSLOAD_FRAME|IRSLOAD_KEYINDEX)),
														
 
															 	     "bad SLOAD type");
														
 
															   if ((ir->op2 & IRSLOAD_CONVERT) && irt_isguard(t) && irt_isint(t)) {
														
 
															     Reg left = ra_scratch(as, RSET_FPR);
														
@@ -2584,15 +2610,15 @@ static void asm_comp_int64(ASMState *as, IRIns *ir)
 
															 }
														
 
															 #endif
														
 
															-/* -- Support for 64 bit ops in 32 bit mode ------------------------------- */
														
 
															+/* -- Split register ops -------------------------------------------------- */
														
 
															-/* Hiword op of a split 64 bit op. Previous op must be the loword op. */
														
 
															+/* Hiword op of a split 32/32 or 64/64 bit op. Previous op is the loword op. */
														
 
															 static void asm_hiop(ASMState *as, IRIns *ir)
														
 
															 {
														
 
															-#if LJ_32 && LJ_HASFFI
														
 
															   /* HIOP is marked as a store because it needs its own DCE logic. */
														
 
															   int uselo = ra_used(ir-1), usehi = ra_used(ir);  /* Loword/hiword used? */
														
 
															   if (LJ_UNLIKELY(!(as->flags & JIT_F_OPT_DCE))) uselo = usehi = 1;
														
 
															+#if LJ_32 && LJ_HASFFI
														
 
															   if ((ir-1)->o == IR_CONV) {  /* Conversions to/from 64 bit. */
														
 
															     as->curins--;  /* Always skip the CONV. */
														
 
															     if (usehi || uselo)
														
@@ -2606,8 +2632,10 @@ static void asm_hiop(ASMState *as, IRIns *ir)
 
															       asm_fxstore(as, ir);
														
 
															     return;
														
 
															   }
														
 
															+#endif
														
 
															   if (!usehi) return;  /* Skip unused hiword op for all remaining ops. */
														
 
															   switch ((ir-1)->o) {
														
 
															+#if LJ_32 && LJ_HASFFI
														
 
															   case IR_ADD:
														
 
															     as->flagmcp = NULL;
														
 
															     as->curins--;
														
@@ -2630,20 +2658,16 @@ static void asm_hiop(ASMState *as, IRIns *ir)
 
															     asm_neg_not(as, ir-1, XOg_NEG);
														
 
															     break;
														
 
															     }
														
 
															-  case IR_CALLN:
														
 
															-  case IR_CALLXS:
														
 
															-    if (!uselo)
														
 
															-      ra_allocref(as, ir->op1, RID2RSET(RID_RETLO));  /* Mark lo op as used. */
														
 
															-    break;
														
 
															   case IR_CNEWI:
														
 
															     /* Nothing to do here. Handled by CNEWI itself. */
														
 
															     break;
														
 
															+#endif
														
 
															+  case IR_CALLN: case IR_CALLL: case IR_CALLS: case IR_CALLXS:
														
 
															+    if (!uselo)
														
 
															+      ra_allocref(as, ir->op1, RID2RSET(RID_RETLO));  /* Mark lo op as used. */
														
 
															+    break;
														
 
															   default: lj_assertA(0, "bad HIOP for op %d", (ir-1)->o); break;
														
 
															   }
														
 
															-#else
														
 
															-  /* Unused on x64 or without FFI. */
														
 
															-  UNUSED(as); UNUSED(ir); lj_assertA(0, "unexpected HIOP");
														
 
															-#endif
														
 
															 }
														
 
															 /* -- Profiling ----------------------------------------------------------- */
														
@@ -2704,7 +2728,15 @@ static void asm_stack_restore(ASMState *as, SnapShot *snap)
 
															     IRIns *ir = IR(ref);
														
 
															     if ((sn & SNAP_NORESTORE))
														
 
															       continue;
														
 
															-    if (irt_isnum(ir->t)) {
														
 
															+    if ((sn & SNAP_KEYINDEX)) {
														
 
															+      emit_movmroi(as, RID_BASE, ofs+4, LJ_KEYINDEX);
														
 
															+      if (irref_isk(ref)) {
														
 
															+	emit_movmroi(as, RID_BASE, ofs, ir->i);
														
 
															+      } else {
														
 
															+	Reg src = ra_alloc1(as, ref, rset_exclude(RSET_GPR, RID_BASE));
														
 
															+	emit_movtomro(as, src, RID_BASE, ofs);
														
 
															+      }
														
 
															+    } else if (irt_isnum(ir->t)) {
														
 
															       Reg src = ra_alloc1(as, ref, RSET_FPR);
														
 
															       emit_rmro(as, XO_MOVSDto, src, RID_BASE, ofs);
														
 
															     } else {
														
@@ -2837,6 +2869,12 @@ static void asm_loop_fixup(ASMState *as)
 
															   }
														
 
															 }
														
 
															+/* Fixup the tail of the loop. */
														
 
															+static void asm_loop_tail_fixup(ASMState *as)
														
 
															+{
														
 
															+  UNUSED(as);  /* Nothing to do. */
														
 
															+}
														
 
															+
														
 
															 /* -- Head of trace ------------------------------------------------------- */
														
 
															 /* Coalesce BASE register for a root trace. */
														
--- a/libs/LuaJIT/src/lj_bcread.c
+++ b/libs/LuaJIT/src/lj_bcread.c
@@ -53,11 +53,11 @@ static LJ_NOINLINE void bcread_fill(LexState *ls, MSize len, int need)
 
															   do {
														
 
															     const char *buf;
														
 
															     size_t sz;
														
 
															-    char *p = sbufB(&ls->sb);
														
 
															+    char *p = ls->sb.b;
														
 
															     MSize n = (MSize)(ls->pe - ls->p);
														
 
															     if (n) {  /* Copy remainder to buffer. */
														
 
															       if (sbuflen(&ls->sb)) {  /* Move down in buffer. */
														
 
															-	lj_assertLS(ls->pe == sbufP(&ls->sb), "bad buffer pointer");
														
 
															+	lj_assertLS(ls->pe == ls->sb.w, "bad buffer pointer");
														
 
															 	if (ls->p != p) memmove(p, ls->p, n);
														
 
															       } else {  /* Copy from buffer provided by reader. */
														
 
															 	p = lj_buf_need(&ls->sb, len);
														
@@ -66,7 +66,7 @@ static LJ_NOINLINE void bcread_fill(LexState *ls, MSize len, int need)
 
															       ls->p = p;
														
 
															       ls->pe = p + n;
														
 
															     }
														
 
															-    setsbufP(&ls->sb, p + n);
														
 
															+    ls->sb.w = p + n;
														
 
															     buf = ls->rfunc(ls->L, ls->rdata, &sz);  /* Get more data from reader. */
														
 
															     if (buf == NULL || sz == 0) {  /* EOF? */
														
 
															       if (need) bcread_error(ls, LJ_ERR_BCBAD);
														
@@ -77,8 +77,8 @@ static LJ_NOINLINE void bcread_fill(LexState *ls, MSize len, int need)
 
															     if (n) {  /* Append to buffer. */
														
 
															       n += (MSize)sz;
														
 
															       p = lj_buf_need(&ls->sb, n < len ? len : n);
														
 
															-      memcpy(sbufP(&ls->sb), buf, sz);
														
 
															-      setsbufP(&ls->sb, p + n);
														
 
															+      memcpy(ls->sb.w, buf, sz);
														
 
															+      ls->sb.w = p + n;
														
 
															       ls->p = p;
														
 
															       ls->pe = p + n;
														
 
															     } else {  /* Return buffer provided by reader. */
														
@@ -399,11 +399,7 @@ static int bcread_header(LexState *ls)
 
															   if ((flags & BCDUMP_F_FFI)) {
														
 
															 #if LJ_HASFFI
														
 
															     lua_State *L = ls->L;
														
 
															-    if (!ctype_ctsG(G(L))) {
														
 
															-      ptrdiff_t oldtop = savestack(L, L->top);
														
 
															-      luaopen_ffi(L);  /* Load FFI library on-demand. */
														
 
															-      L->top = restorestack(L, oldtop);
														
 
															-    }
														
 
															+    ctype_loadffi(L);
														
 
															 #else
														
 
															     return 0;
														
 
															 #endif
														
--- a/libs/LuaJIT/src/lj_bcwrite.c
+++ b/libs/LuaJIT/src/lj_bcwrite.c
@@ -62,7 +62,7 @@ static void bcwrite_ktabk(BCWriteCtx *ctx, cTValue *o, int narrow)
 
															       if (num == (lua_Number)k) {  /* -0 is never a constant. */
														
 
															 	*p++ = BCDUMP_KTAB_INT;
														
 
															 	p = lj_strfmt_wuleb128(p, k);
														
 
															-	setsbufP(&ctx->sb, p);
														
 
															+	ctx->sb.w = p;
														
 
															 	return;
														
 
															       }
														
 
															     }
														
@@ -73,7 +73,7 @@ static void bcwrite_ktabk(BCWriteCtx *ctx, cTValue *o, int narrow)
 
															     lj_assertBCW(tvispri(o), "unhandled type %d", itype(o));
														
 
															     *p++ = BCDUMP_KTAB_NIL+~itype(o);
														
 
															   }
														
 
															-  setsbufP(&ctx->sb, p);
														
 
															+  ctx->sb.w = p;
														
 
															 }
														
 
															 /* Write a template table. */
														
@@ -97,7 +97,7 @@ static void bcwrite_ktab(BCWriteCtx *ctx, char *p, const GCtab *t)
 
															   /* Write number of array slots and hash slots. */
														
 
															   p = lj_strfmt_wuleb128(p, narray);
														
 
															   p = lj_strfmt_wuleb128(p, nhash);
														
 
															-  setsbufP(&ctx->sb, p);
														
 
															+  ctx->sb.w = p;
														
 
															   if (narray) {  /* Write array entries (may contain nil). */
														
 
															     MSize i;
														
 
															     TValue *o = tvref(t->array);
														
@@ -172,7 +172,7 @@ static void bcwrite_kgc(BCWriteCtx *ctx, GCproto *pt)
 
															       }
														
 
															 #endif
														
 
															     }
														
 
															-    setsbufP(&ctx->sb, p);
														
 
															+    ctx->sb.w = p;
														
 
															   }
														
 
															 }
														
@@ -206,7 +206,7 @@ static void bcwrite_knum(BCWriteCtx *ctx, GCproto *pt)
 
															       p = lj_strfmt_wuleb128(p, o->u32.hi);
														
 
															     }
														
 
															   }
														
 
															-  setsbufP(&ctx->sb, p);
														
 
															+  ctx->sb.w = p;
														
 
															 }
														
 
															 /* Write bytecode instructions. */
														
@@ -281,7 +281,7 @@ static void bcwrite_proto(BCWriteCtx *ctx, GCproto *pt)
 
															   /* Write bytecode instructions and upvalue refs. */
														
 
															   p = bcwrite_bytecode(ctx, p, pt);
														
 
															   p = lj_buf_wmem(p, proto_uv(pt), pt->sizeuv*2);
														
 
															-  setsbufP(&ctx->sb, p);
														
 
															+  ctx->sb.w = p;
														
 
															   /* Write constants. */
														
 
															   bcwrite_kgc(ctx, pt);
														
@@ -291,16 +291,16 @@ static void bcwrite_proto(BCWriteCtx *ctx, GCproto *pt)
 
															   if (sizedbg) {
														
 
															     p = lj_buf_more(&ctx->sb, sizedbg);
														
 
															     p = lj_buf_wmem(p, proto_lineinfo(pt), sizedbg);
														
 
															-    setsbufP(&ctx->sb, p);
														
 
															+    ctx->sb.w = p;
														
 
															   }
														
 
															   /* Pass buffer to writer function. */
														
 
															   if (ctx->status == 0) {
														
 
															     MSize n = sbuflen(&ctx->sb) - 5;
														
 
															     MSize nn = (lj_fls(n)+8)*9 >> 6;
														
 
															-    char *q = sbufB(&ctx->sb) + (5 - nn);
														
 
															+    char *q = ctx->sb.b + (5 - nn);
														
 
															     p = lj_strfmt_wuleb128(q, n);  /* Fill in final size. */
														
 
															-    lj_assertBCW(p == sbufB(&ctx->sb) + 5, "bad ULEB128 write");
														
 
															+    lj_assertBCW(p == ctx->sb.b + 5, "bad ULEB128 write");
														
 
															     ctx->status = ctx->wfunc(sbufL(&ctx->sb), q, nn+n, ctx->wdata);
														
 
															   }
														
 
															 }
														
@@ -324,8 +324,8 @@ static void bcwrite_header(BCWriteCtx *ctx)
 
															     p = lj_strfmt_wuleb128(p, len);
														
 
															     p = lj_buf_wmem(p, name, len);
														
 
															   }
														
 
															-  ctx->status = ctx->wfunc(sbufL(&ctx->sb), sbufB(&ctx->sb),
														
 
															-			   (MSize)(p - sbufB(&ctx->sb)), ctx->wdata);
														
 
															+  ctx->status = ctx->wfunc(sbufL(&ctx->sb), ctx->sb.b,
														
 
															+			   (MSize)(p - ctx->sb.b), ctx->wdata);
														
 
															 }
														
 
															 /* Write footer of bytecode dump. */
														
--- a/libs/LuaJIT/src/lj_buf.c
+++ b/libs/LuaJIT/src/lj_buf.c
@@ -20,12 +20,32 @@ static void buf_grow(SBuf *sb, MSize sz)
 
															 {
														
 
															   MSize osz = sbufsz(sb), len = sbuflen(sb), nsz = osz;
														
 
															   char *b;
														
 
															+  GCSize flag;
														
 
															   if (nsz < LJ_MIN_SBUF) nsz = LJ_MIN_SBUF;
														
 
															   while (nsz < sz) nsz += nsz;
														
 
															-  b = (char *)lj_mem_realloc(sbufL(sb), sbufB(sb), osz, nsz);
														
 
															-  setmref(sb->b, b);
														
 
															-  setmref(sb->p, b + len);
														
 
															-  setmref(sb->e, b + nsz);
														
 
															+  flag = sbufflag(sb);
														
 
															+  if ((flag & SBUF_FLAG_COW)) {  /* Copy-on-write semantics. */
														
 
															+    lj_assertG_(G(sbufL(sb)), sb->w == sb->e, "bad SBuf COW");
														
 
															+    b = (char *)lj_mem_new(sbufL(sb), nsz);
														
 
															+    setsbufflag(sb, flag & ~(GCSize)SBUF_FLAG_COW);
														
 
															+    setgcrefnull(sbufX(sb)->cowref);
														
 
															+    memcpy(b, sb->b, osz);
														
 
															+  } else {
														
 
															+    b = (char *)lj_mem_realloc(sbufL(sb), sb->b, osz, nsz);
														
 
															+  }
														
 
															+  if ((flag & SBUF_FLAG_EXT)) {
														
 
															+    sbufX(sb)->r = sbufX(sb)->r - sb->b + b;  /* Adjust read pointer, too. */
														
 
															+  }
														
 
															+  /* Adjust buffer pointers. */
														
 
															+  sb->b = b;
														
 
															+  sb->w = b + len;
														
 
															+  sb->e = b + nsz;
														
 
															+  if ((flag & SBUF_FLAG_BORROW)) {  /* Adjust borrowed buffer pointers. */
														
 
															+    SBuf *bsb = mref(sbufX(sb)->bsb, SBuf);
														
 
															+    bsb->b = b;
														
 
															+    bsb->w = b + len;
														
 
															+    bsb->e = b + nsz;
														
 
															+  }
														
 
															 }
														
 
															 LJ_NOINLINE char *LJ_FASTCALL lj_buf_need2(SBuf *sb, MSize sz)
														
@@ -34,30 +54,51 @@ LJ_NOINLINE char *LJ_FASTCALL lj_buf_need2(SBuf *sb, MSize sz)
 
															   if (LJ_UNLIKELY(sz > LJ_MAX_BUF))
														
 
															     lj_err_mem(sbufL(sb));
														
 
															   buf_grow(sb, sz);
														
 
															-  return sbufB(sb);
														
 
															+  return sb->b;
														
 
															 }
														
 
															 LJ_NOINLINE char *LJ_FASTCALL lj_buf_more2(SBuf *sb, MSize sz)
														
 
															 {
														
 
															-  MSize len = sbuflen(sb);
														
 
															-  lj_assertG_(G(sbufL(sb)), sz > sbufleft(sb), "SBuf overflow");
														
 
															-  if (LJ_UNLIKELY(sz > LJ_MAX_BUF || len + sz > LJ_MAX_BUF))
														
 
															-    lj_err_mem(sbufL(sb));
														
 
															-  buf_grow(sb, len + sz);
														
 
															-  return sbufP(sb);
														
 
															+  if (sbufisext(sb)) {
														
 
															+    SBufExt *sbx = (SBufExt *)sb;
														
 
															+    MSize len = sbufxlen(sbx);
														
 
															+    if (LJ_UNLIKELY(sz > LJ_MAX_BUF || len + sz > LJ_MAX_BUF))
														
 
															+      lj_err_mem(sbufL(sbx));
														
 
															+    if (len + sz > sbufsz(sbx)) {  /* Must grow. */
														
 
															+      buf_grow((SBuf *)sbx, len + sz);
														
 
															+    } else if (sbufxslack(sbx) < (sbufsz(sbx) >> 3)) {
														
 
															+      /* Also grow to avoid excessive compactions, if slack < size/8. */
														
 
															+      buf_grow((SBuf *)sbx, sbuflen(sbx) + sz);  /* Not sbufxlen! */
														
 
															+      return sbx->w;
														
 
															+    }
														
 
															+    if (sbx->r != sbx->b) {  /* Compact by moving down. */
														
 
															+      memmove(sbx->b, sbx->r, len);
														
 
															+      sbx->r = sbx->b;
														
 
															+      sbx->w = sbx->b + len;
														
 
															+      lj_assertG_(G(sbufL(sbx)), len + sz <= sbufsz(sbx), "bad SBuf compact");
														
 
															+    }
														
 
															+  } else {
														
 
															+    MSize len = sbuflen(sb);
														
 
															+    lj_assertG_(G(sbufL(sb)), sz > sbufleft(sb), "SBuf overflow");
														
 
															+    if (LJ_UNLIKELY(sz > LJ_MAX_BUF || len + sz > LJ_MAX_BUF))
														
 
															+      lj_err_mem(sbufL(sb));
														
 
															+    buf_grow(sb, len + sz);
														
 
															+  }
														
 
															+  return sb->w;
														
 
															 }
														
 
															 void LJ_FASTCALL lj_buf_shrink(lua_State *L, SBuf *sb)
														
 
															 {
														
 
															-  char *b = sbufB(sb);
														
 
															-  MSize osz = (MSize)(sbufE(sb) - b);
														
 
															+  char *b = sb->b;
														
 
															+  MSize osz = (MSize)(sb->e - b);
														
 
															   if (osz > 2*LJ_MIN_SBUF) {
														
 
															-    MSize n = (MSize)(sbufP(sb) - b);
														
 
															+    MSize n = (MSize)(sb->w - b);
														
 
															     b = lj_mem_realloc(L, b, osz, (osz >> 1));
														
 
															-    setmref(sb->b, b);
														
 
															-    setmref(sb->p, b + n);
														
 
															-    setmref(sb->e, b + (osz >> 1));
														
 
															+    sb->b = b;
														
 
															+    sb->w = b + n;
														
 
															+    sb->e = b + (osz >> 1);
														
 
															   }
														
 
															+  lj_assertG_(G(sbufL(sb)), !sbufisext(sb), "YAGNI shrink SBufExt");
														
 
															 }
														
 
															 char * LJ_FASTCALL lj_buf_tmp(lua_State *L, MSize sz)
														
@@ -67,30 +108,62 @@ char * LJ_FASTCALL lj_buf_tmp(lua_State *L, MSize sz)
 
															   return lj_buf_need(sb, sz);
														
 
															 }
														
 
															+#if LJ_HASBUFFER && LJ_HASJIT
														
 
															+void lj_bufx_set(SBufExt *sbx, const char *p, MSize len, GCobj *ref)
														
 
															+{
														
 
															+  lua_State *L = sbufL(sbx);
														
 
															+  lj_bufx_free(L, sbx);
														
 
															+  lj_bufx_set_cow(L, sbx, p, len);
														
 
															+  setgcref(sbx->cowref, ref);
														
 
															+  lj_gc_objbarrier(L, (GCudata *)sbx - 1, ref);
														
 
															+}
														
 
															+
														
 
															+#if LJ_HASFFI
														
 
															+MSize LJ_FASTCALL lj_bufx_more(SBufExt *sbx, MSize sz)
														
 
															+{
														
 
															+  lj_buf_more((SBuf *)sbx, sz);
														
 
															+  return sbufleft(sbx);
														
 
															+}
														
 
															+#endif
														
 
															+#endif
														
 
															+
														
 
															 /* -- Low-level buffer put operations ------------------------------------- */
														
 
															 SBuf *lj_buf_putmem(SBuf *sb, const void *q, MSize len)
														
 
															 {
														
 
															-  char *p = lj_buf_more(sb, len);
														
 
															-  p = lj_buf_wmem(p, q, len);
														
 
															-  setsbufP(sb, p);
														
 
															+  char *w = lj_buf_more(sb, len);
														
 
															+  w = lj_buf_wmem(w, q, len);
														
 
															+  sb->w = w;
														
 
															   return sb;
														
 
															 }
														
 
															-SBuf * LJ_FASTCALL lj_buf_putchar(SBuf *sb, int c)
														
 
															+#if LJ_HASJIT || LJ_HASFFI
														
 
															+static LJ_NOINLINE SBuf * LJ_FASTCALL lj_buf_putchar2(SBuf *sb, int c)
														
 
															 {
														
 
															-  char *p = lj_buf_more(sb, 1);
														
 
															-  *p++ = (char)c;
														
 
															-  setsbufP(sb, p);
														
 
															+  char *w = lj_buf_more2(sb, 1);
														
 
															+  *w++ = (char)c;
														
 
															+  sb->w = w;
														
 
															   return sb;
														
 
															 }
														
 
															+SBuf * LJ_FASTCALL lj_buf_putchar(SBuf *sb, int c)
														
 
															+{
														
 
															+  char *w = sb->w;
														
 
															+  if (LJ_LIKELY(w < sb->e)) {
														
 
															+    *w++ = (char)c;
														
 
															+    sb->w = w;
														
 
															+    return sb;
														
 
															+  }
														
 
															+  return lj_buf_putchar2(sb, c);
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															 SBuf * LJ_FASTCALL lj_buf_putstr(SBuf *sb, GCstr *s)
														
 
															 {
														
 
															   MSize len = s->len;
														
 
															-  char *p = lj_buf_more(sb, len);
														
 
															-  p = lj_buf_wmem(p, strdata(s), len);
														
 
															-  setsbufP(sb, p);
														
 
															+  char *w = lj_buf_more(sb, len);
														
 
															+  w = lj_buf_wmem(w, strdata(s), len);
														
 
															+  sb->w = w;
														
 
															   return sb;
														
 
															 }
														
@@ -99,47 +172,47 @@ SBuf * LJ_FASTCALL lj_buf_putstr(SBuf *sb, GCstr *s)
 
															 SBuf * LJ_FASTCALL lj_buf_putstr_reverse(SBuf *sb, GCstr *s)
														
 
															 {
														
 
															   MSize len = s->len;
														
 
															-  char *p = lj_buf_more(sb, len), *e = p+len;
														
 
															+  char *w = lj_buf_more(sb, len), *e = w+len;
														
 
															   const char *q = strdata(s)+len-1;
														
 
															-  while (p < e)
														
 
															-    *p++ = *q--;
														
 
															-  setsbufP(sb, p);
														
 
															+  while (w < e)
														
 
															+    *w++ = *q--;
														
 
															+  sb->w = w;
														
 
															   return sb;
														
 
															 }
														
 
															 SBuf * LJ_FASTCALL lj_buf_putstr_lower(SBuf *sb, GCstr *s)
														
 
															 {
														
 
															   MSize len = s->len;
														
 
															-  char *p = lj_buf_more(sb, len), *e = p+len;
														
 
															+  char *w = lj_buf_more(sb, len), *e = w+len;
														
 
															   const char *q = strdata(s);
														
 
															-  for (; p < e; p++, q++) {
														
 
															+  for (; w < e; w++, q++) {
														
 
															     uint32_t c = *(unsigned char *)q;
														
 
															 #if LJ_TARGET_PPC
														
 
															-    *p = c + ((c >= 'A' && c <= 'Z') << 5);
														
 
															+    *w = c + ((c >= 'A' && c <= 'Z') << 5);
														
 
															 #else
														
 
															     if (c >= 'A' && c <= 'Z') c += 0x20;
														
 
															-    *p = c;
														
 
															+    *w = c;
														
 
															 #endif
														
 
															   }
														
 
															-  setsbufP(sb, p);
														
 
															+  sb->w = w;
														
 
															   return sb;
														
 
															 }
														
 
															 SBuf * LJ_FASTCALL lj_buf_putstr_upper(SBuf *sb, GCstr *s)
														
 
															 {
														
 
															   MSize len = s->len;
														
 
															-  char *p = lj_buf_more(sb, len), *e = p+len;
														
 
															+  char *w = lj_buf_more(sb, len), *e = w+len;
														
 
															   const char *q = strdata(s);
														
 
															-  for (; p < e; p++, q++) {
														
 
															+  for (; w < e; w++, q++) {
														
 
															     uint32_t c = *(unsigned char *)q;
														
 
															 #if LJ_TARGET_PPC
														
 
															-    *p = c - ((c >= 'a' && c <= 'z') << 5);
														
 
															+    *w = c - ((c >= 'a' && c <= 'z') << 5);
														
 
															 #else
														
 
															     if (c >= 'a' && c <= 'z') c -= 0x20;
														
 
															-    *p = c;
														
 
															+    *w = c;
														
 
															 #endif
														
 
															   }
														
 
															-  setsbufP(sb, p);
														
 
															+  sb->w = w;
														
 
															   return sb;
														
 
															 }
														
@@ -148,21 +221,21 @@ SBuf *lj_buf_putstr_rep(SBuf *sb, GCstr *s, int32_t rep)
 
															   MSize len = s->len;
														
 
															   if (rep > 0 && len) {
														
 
															     uint64_t tlen = (uint64_t)rep * len;
														
 
															-    char *p;
														
 
															+    char *w;
														
 
															     if (LJ_UNLIKELY(tlen > LJ_MAX_STR))
														
 
															       lj_err_mem(sbufL(sb));
														
 
															-    p = lj_buf_more(sb, (MSize)tlen);
														
 
															+    w = lj_buf_more(sb, (MSize)tlen);
														
 
															     if (len == 1) {  /* Optimize a common case. */
														
 
															       uint32_t c = strdata(s)[0];
														
 
															-      do { *p++ = c; } while (--rep > 0);
														
 
															+      do { *w++ = c; } while (--rep > 0);
														
 
															     } else {
														
 
															       const char *e = strdata(s) + len;
														
 
															       do {
														
 
															 	const char *q = strdata(s);
														
 
															-	do { *p++ = *q++; } while (q < e);
														
 
															+	do { *w++ = *q++; } while (q < e);
														
 
															       } while (--rep > 0);
														
 
															     }
														
 
															-    setsbufP(sb, p);
														
 
															+    sb->w = w;
														
 
															   }
														
 
															   return sb;
														
 
															 }
														
@@ -173,27 +246,27 @@ SBuf *lj_buf_puttab(SBuf *sb, GCtab *t, GCstr *sep, int32_t i, int32_t e)
 
															   if (i <= e) {
														
 
															     for (;;) {
														
 
															       cTValue *o = lj_tab_getint(t, i);
														
 
															-      char *p;
														
 
															+      char *w;
														
 
															       if (!o) {
														
 
															       badtype:  /* Error: bad element type. */
														
 
															-	setsbufP(sb, (void *)(intptr_t)i);  /* Store failing index. */
														
 
															+	sb->w = (char *)(intptr_t)i;  /* Store failing index. */
														
 
															 	return NULL;
														
 
															       } else if (tvisstr(o)) {
														
 
															 	MSize len = strV(o)->len;
														
 
															-	p = lj_buf_wmem(lj_buf_more(sb, len + seplen), strVdata(o), len);
														
 
															+	w = lj_buf_wmem(lj_buf_more(sb, len + seplen), strVdata(o), len);
														
 
															       } else if (tvisint(o)) {
														
 
															-	p = lj_strfmt_wint(lj_buf_more(sb, STRFMT_MAXBUF_INT+seplen), intV(o));
														
 
															+	w = lj_strfmt_wint(lj_buf_more(sb, STRFMT_MAXBUF_INT+seplen), intV(o));
														
 
															       } else if (tvisnum(o)) {
														
 
															-	p = lj_buf_more(lj_strfmt_putfnum(sb, STRFMT_G14, numV(o)), seplen);
														
 
															+	w = lj_buf_more(lj_strfmt_putfnum(sb, STRFMT_G14, numV(o)), seplen);
														
 
															       } else {
														
 
															 	goto badtype;
														
 
															       }
														
 
															       if (i++ == e) {
														
 
															-	setsbufP(sb, p);
														
 
															+	sb->w = w;
														
 
															 	break;
														
 
															       }
														
 
															-      if (seplen) p = lj_buf_wmem(p, strdata(sep), seplen);
														
 
															-      setsbufP(sb, p);
														
 
															+      if (seplen) w = lj_buf_wmem(w, strdata(sep), seplen);
														
 
															+      sb->w = w;
														
 
															     }
														
 
															   }
														
 
															   return sb;
														
@@ -203,7 +276,7 @@ SBuf *lj_buf_puttab(SBuf *sb, GCtab *t, GCstr *sep, int32_t i, int32_t e)
 
															 GCstr * LJ_FASTCALL lj_buf_tostr(SBuf *sb)
														
 
															 {
														
 
															-  return lj_str_new(sbufL(sb), sbufB(sb), sbuflen(sb));
														
 
															+  return lj_str_new(sbufL(sb), sb->b, sbuflen(sb));
														
 
															 }
														
 
															 /* Concatenate two strings. */
														
@@ -219,14 +292,14 @@ GCstr *lj_buf_cat2str(lua_State *L, GCstr *s1, GCstr *s2)
 
															 /* Read ULEB128 from buffer. */
														
 
															 uint32_t LJ_FASTCALL lj_buf_ruleb128(const char **pp)
														
 
															 {
														
 
															-  const uint8_t *p = (const uint8_t *)*pp;
														
 
															-  uint32_t v = *p++;
														
 
															+  const uint8_t *w = (const uint8_t *)*pp;
														
 
															+  uint32_t v = *w++;
														
 
															   if (LJ_UNLIKELY(v >= 0x80)) {
														
 
															     int sh = 0;
														
 
															     v &= 0x7f;
														
 
															-    do { v |= ((*p & 0x7f) << (sh += 7)); } while (*p++ >= 0x80);
														
 
															+    do { v |= ((*w & 0x7f) << (sh += 7)); } while (*w++ >= 0x80);
														
 
															   }
														
 
															-  *pp = (const char *)p;
														
 
															+  *pp = (const char *)w;
														
 
															   return v;
														
 
															 }
														
--- a/libs/LuaJIT/src/lj_buf.h
+++ b/libs/LuaJIT/src/lj_buf.h
@@ -10,16 +10,60 @@
 
															 #include "lj_gc.h"
														
 
															 #include "lj_str.h"
														
 
															-/* Resizable string buffers. Struct definition in lj_obj.h. */
														
 
															-#define sbufB(sb)	(mref((sb)->b, char))
														
 
															-#define sbufP(sb)	(mref((sb)->p, char))
														
 
															-#define sbufE(sb)	(mref((sb)->e, char))
														
 
															-#define sbufL(sb)	(mref((sb)->L, lua_State))
														
 
															-#define sbufsz(sb)	((MSize)(sbufE((sb)) - sbufB((sb))))
														
 
															-#define sbuflen(sb)	((MSize)(sbufP((sb)) - sbufB((sb))))
														
 
															-#define sbufleft(sb)	((MSize)(sbufE((sb)) - sbufP((sb))))
														
 
															-#define setsbufP(sb, q)	(setmref((sb)->p, (q)))
														
 
															-#define setsbufL(sb, l)	(setmref((sb)->L, (l)))
														
 
															+/* Resizable string buffers. */
														
 
															+
														
 
															+/* The SBuf struct definition is in lj_obj.h:
														
 
															+**   char *w;	Write pointer.
														
 
															+**   char *e;	End pointer.
														
 
															+**   char *b;	Base pointer.
														
 
															+**   MRef L;	lua_State, used for buffer resizing. Extension bits in 3 LSB.
														
 
															+*/
														
 
															+
														
 
															+/* Extended string buffer. */
														
 
															+typedef struct SBufExt {
														
 
															+  SBufHeader;
														
 
															+  union {
														
 
															+    GCRef cowref;	/* Copy-on-write object reference. */
														
 
															+    MRef bsb;		/* Borrowed string buffer. */
														
 
															+  };
														
 
															+  char *r;		/* Read pointer. */
														
 
															+  GCRef dict_str;	/* Serialization string dictionary table. */
														
 
															+  GCRef dict_mt;	/* Serialization metatable dictionary table. */
														
 
															+  int depth;		/* Remaining recursion depth. */
														
 
															+} SBufExt;
														
 
															+
														
 
															+#define sbufsz(sb)		((MSize)((sb)->e - (sb)->b))
														
 
															+#define sbuflen(sb)		((MSize)((sb)->w - (sb)->b))
														
 
															+#define sbufleft(sb)		((MSize)((sb)->e - (sb)->w))
														
 
															+#define sbufxlen(sbx)		((MSize)((sbx)->w - (sbx)->r))
														
 
															+#define sbufxslack(sbx)		((MSize)((sbx)->r - (sbx)->b))
														
 
															+
														
 
															+#define SBUF_MASK_FLAG		(7)
														
 
															+#define SBUF_MASK_L		(~(GCSize)SBUF_MASK_FLAG)
														
 
															+#define SBUF_FLAG_EXT		1	/* Extended string buffer. */
														
 
															+#define SBUF_FLAG_COW		2	/* Copy-on-write buffer. */
														
 
															+#define SBUF_FLAG_BORROW	4	/* Borrowed string buffer. */
														
 
															+
														
 
															+#define sbufL(sb) \
														
 
															+  ((lua_State *)(void *)(uintptr_t)(mrefu((sb)->L) & SBUF_MASK_L))
														
 
															+#define setsbufL(sb, l)		(setmref((sb)->L, (l)))
														
 
															+#define setsbufXL(sb, l, flag) \
														
 
															+  (setmrefu((sb)->L, (GCSize)(uintptr_t)(void *)(l) + (flag)))
														
 
															+#define setsbufXL_(sb, l) \
														
 
															+  (setmrefu((sb)->L, (GCSize)(uintptr_t)(void *)(l) | (mrefu((sb)->L) & SBUF_MASK_FLAG)))
														
 
															+
														
 
															+#define sbufflag(sb)		(mrefu((sb)->L))
														
 
															+#define sbufisext(sb)		(sbufflag((sb)) & SBUF_FLAG_EXT)
														
 
															+#define sbufiscow(sb)		(sbufflag((sb)) & SBUF_FLAG_COW)
														
 
															+#define sbufisborrow(sb)	(sbufflag((sb)) & SBUF_FLAG_BORROW)
														
 
															+#define sbufiscoworborrow(sb)	(sbufflag((sb)) & (SBUF_FLAG_COW|SBUF_FLAG_BORROW))
														
 
															+#define sbufX(sb) \
														
 
															+  (lj_assertG_(G(sbufL(sb)), sbufisext(sb), "not an SBufExt"), (SBufExt *)(sb))
														
 
															+#define setsbufflag(sb, flag)	(setmrefu((sb)->L, (flag)))
														
 
															+
														
 
															+#define tvisbuf(o) \
														
 
															+  (LJ_HASBUFFER && tvisudata(o) && udataV(o)->udtype == UDTYPE_BUFFER)
														
 
															+#define bufV(o)		check_exp(tvisbuf(o), ((SBufExt *)uddata(udataV(o))))
														
 
															 /* Buffer management */
														
 
															 LJ_FUNC char *LJ_FASTCALL lj_buf_need2(SBuf *sb, MSize sz);
														
@@ -30,12 +74,12 @@ LJ_FUNC char * LJ_FASTCALL lj_buf_tmp(lua_State *L, MSize sz);
 
															 static LJ_AINLINE void lj_buf_init(lua_State *L, SBuf *sb)
														
 
															 {
														
 
															   setsbufL(sb, L);
														
 
															-  setmref(sb->p, NULL); setmref(sb->e, NULL); setmref(sb->b, NULL);
														
 
															+  sb->w = sb->e = sb->b = NULL;
														
 
															 }
														
 
															 static LJ_AINLINE void lj_buf_reset(SBuf *sb)
														
 
															 {
														
 
															-  setmrefr(sb->p, sb->b);
														
 
															+  sb->w = sb->b;
														
 
															 }
														
 
															 static LJ_AINLINE SBuf *lj_buf_tmp_(lua_State *L)
														
@@ -48,26 +92,77 @@ static LJ_AINLINE SBuf *lj_buf_tmp_(lua_State *L)
 
															 static LJ_AINLINE void lj_buf_free(global_State *g, SBuf *sb)
														
 
															 {
														
 
															-  lj_mem_free(g, sbufB(sb), sbufsz(sb));
														
 
															+  lj_assertG(!sbufisext(sb), "bad free of SBufExt");
														
 
															+  lj_mem_free(g, sb->b, sbufsz(sb));
														
 
															 }
														
 
															 static LJ_AINLINE char *lj_buf_need(SBuf *sb, MSize sz)
														
 
															 {
														
 
															   if (LJ_UNLIKELY(sz > sbufsz(sb)))
														
 
															     return lj_buf_need2(sb, sz);
														
 
															-  return sbufB(sb);
														
 
															+  return sb->b;
														
 
															 }
														
 
															 static LJ_AINLINE char *lj_buf_more(SBuf *sb, MSize sz)
														
 
															 {
														
 
															   if (LJ_UNLIKELY(sz > sbufleft(sb)))
														
 
															     return lj_buf_more2(sb, sz);
														
 
															-  return sbufP(sb);
														
 
															+  return sb->w;
														
 
															+}
														
 
															+
														
 
															+/* Extended buffer management */
														
 
															+static LJ_AINLINE void lj_bufx_init(lua_State *L, SBufExt *sbx)
														
 
															+{
														
 
															+  memset(sbx, 0, sizeof(SBufExt));
														
 
															+  setsbufXL(sbx, L, SBUF_FLAG_EXT);
														
 
															+}
														
 
															+
														
 
															+static LJ_AINLINE void lj_bufx_set_borrow(lua_State *L, SBufExt *sbx, SBuf *sb)
														
 
															+{
														
 
															+  setsbufXL(sbx, L, SBUF_FLAG_EXT | SBUF_FLAG_BORROW);
														
 
															+  setmref(sbx->bsb, sb);
														
 
															+  sbx->r = sbx->w = sbx->b = sb->b;
														
 
															+  sbx->e = sb->e;
														
 
															+}
														
 
															+
														
 
															+static LJ_AINLINE void lj_bufx_set_cow(lua_State *L, SBufExt *sbx,
														
 
															+				       const char *p, MSize len)
														
 
															+{
														
 
															+  setsbufXL(sbx, L, SBUF_FLAG_EXT | SBUF_FLAG_COW);
														
 
															+  sbx->r = sbx->b = (char *)p;
														
 
															+  sbx->w = sbx->e = (char *)p + len;
														
 
															+}
														
 
															+
														
 
															+static LJ_AINLINE void lj_bufx_reset(SBufExt *sbx)
														
 
															+{
														
 
															+  if (sbufiscow(sbx)) {
														
 
															+    setmrefu(sbx->L, (mrefu(sbx->L) & ~(GCSize)SBUF_FLAG_COW));
														
 
															+    setgcrefnull(sbx->cowref);
														
 
															+    sbx->b = sbx->e = NULL;
														
 
															+  }
														
 
															+  sbx->r = sbx->w = sbx->b;
														
 
															 }
														
 
															+static LJ_AINLINE void lj_bufx_free(lua_State *L, SBufExt *sbx)
														
 
															+{
														
 
															+  if (!sbufiscoworborrow(sbx)) lj_mem_free(G(L), sbx->b, sbufsz(sbx));
														
 
															+  setsbufXL(sbx, L, SBUF_FLAG_EXT);
														
 
															+  setgcrefnull(sbx->cowref);
														
 
															+  sbx->r = sbx->w = sbx->b = sbx->e = NULL;
														
 
															+}
														
 
															+
														
 
															+#if LJ_HASBUFFER && LJ_HASJIT
														
 
															+LJ_FUNC void lj_bufx_set(SBufExt *sbx, const char *p, MSize len, GCobj *o);
														
 
															+#if LJ_HASFFI
														
 
															+LJ_FUNC MSize LJ_FASTCALL lj_bufx_more(SBufExt *sbx, MSize sz);
														
 
															+#endif
														
 
															+#endif
														
 
															+
														
 
															 /* Low-level buffer put operations */
														
 
															 LJ_FUNC SBuf *lj_buf_putmem(SBuf *sb, const void *q, MSize len);
														
 
															+#if LJ_HASJIT || LJ_HASFFI
														
 
															 LJ_FUNC SBuf * LJ_FASTCALL lj_buf_putchar(SBuf *sb, int c);
														
 
															+#endif
														
 
															 LJ_FUNC SBuf * LJ_FASTCALL lj_buf_putstr(SBuf *sb, GCstr *s);
														
 
															 static LJ_AINLINE char *lj_buf_wmem(char *p, const void *q, MSize len)
														
@@ -77,9 +172,9 @@ static LJ_AINLINE char *lj_buf_wmem(char *p, const void *q, MSize len)
 
															 static LJ_AINLINE void lj_buf_putb(SBuf *sb, int c)
														
 
															 {
														
 
															-  char *p = lj_buf_more(sb, 1);
														
 
															-  *p++ = (char)c;
														
 
															-  setsbufP(sb, p);
														
 
															+  char *w = lj_buf_more(sb, 1);
														
 
															+  *w++ = (char)c;
														
 
															+  sb->w = w;
														
 
															 }
														
 
															 /* High-level buffer put operations */
														
@@ -97,7 +192,7 @@ LJ_FUNC uint32_t LJ_FASTCALL lj_buf_ruleb128(const char **pp);
 
															 static LJ_AINLINE GCstr *lj_buf_str(lua_State *L, SBuf *sb)
														
 
															 {
														
 
															-  return lj_str_new(L, sbufB(sb), sbuflen(sb));
														
 
															+  return lj_str_new(L, sb->b, sbuflen(sb));
														
 
															 }
														
 
															 #endif
														
--- a/libs/LuaJIT/src/lj_ccall.c
+++ b/libs/LuaJIT/src/lj_ccall.c
@@ -334,7 +334,7 @@
 
															   isfp = sz == 2*sizeof(float) ? 2 : 1;
														
 
															 #define CCALL_HANDLE_REGARG \
														
 
															-  if (LJ_TARGET_IOS && isva) { \
														
 
															+  if (LJ_TARGET_OSX && isva) { \
														
 
															     /* IOS: All variadic arguments are on the stack. */ \
														
 
															   } else if (isfp) {  /* Try to pass argument in FPRs. */ \
														
 
															     int n2 = ctype_isvector(d->info) ? 1 : \
														
@@ -345,10 +345,10 @@
 
															       goto done; \
														
 
															     } else { \
														
 
															       nfpr = CCALL_NARG_FPR;  /* Prevent reordering. */ \
														
 
															-      if (LJ_TARGET_IOS && d->size < 8) goto err_nyi; \
														
 
															+      if (LJ_TARGET_OSX && d->size < 8) goto err_nyi; \
														
 
															     } \
														
 
															   } else {  /* Try to pass argument in GPRs. */ \
														
 
															-    if (!LJ_TARGET_IOS && (d->info & CTF_ALIGN) > CTALIGN_PTR) \
														
 
															+    if (!LJ_TARGET_OSX && (d->info & CTF_ALIGN) > CTALIGN_PTR) \
														
 
															       ngpr = (ngpr + 1u) & ~1u;  /* Align to regpair. */ \
														
 
															     if (ngpr + n <= maxgpr) { \
														
 
															       dp = &cc->gpr[ngpr]; \
														
@@ -356,7 +356,7 @@
 
															       goto done; \
														
 
															     } else { \
														
 
															       ngpr = maxgpr;  /* Prevent reordering. */ \
														
 
															-      if (LJ_TARGET_IOS && d->size < 8) goto err_nyi; \
														
 
															+      if (LJ_TARGET_OSX && d->size < 8) goto err_nyi; \
														
 
															     } \
														
 
															   }
														
--- a/libs/LuaJIT/src/lj_ccallback.c
+++ b/libs/LuaJIT/src/lj_ccallback.c
@@ -256,6 +256,11 @@ static void *callback_mcode_init(global_State *g, uint32_t *page)
 
															 #ifndef MAP_ANONYMOUS
														
 
															 #define MAP_ANONYMOUS   MAP_ANON
														
 
															 #endif
														
 
															+#ifdef PROT_MPROTECT
														
 
															+#define CCPROT_CREATE	(PROT_MPROTECT(PROT_EXEC))
														
 
															+#else
														
 
															+#define CCPROT_CREATE	0
														
 
															+#endif
														
 
															 #endif
														
@@ -271,7 +276,7 @@ static void callback_mcode_new(CTState *cts)
 
															   if (!p)
														
 
															     lj_err_caller(cts->L, LJ_ERR_FFI_CBACKOV);
														
 
															 #elif LJ_TARGET_POSIX
														
 
															-  p = mmap(NULL, sz, (PROT_READ|PROT_WRITE), MAP_PRIVATE|MAP_ANONYMOUS,
														
 
															+  p = mmap(NULL, sz, (PROT_READ|PROT_WRITE|CCPROT_CREATE), MAP_PRIVATE|MAP_ANONYMOUS,
														
 
															 	   -1, 0);
														
 
															   if (p == MAP_FAILED)
														
 
															     lj_err_caller(cts->L, LJ_ERR_FFI_CBACKOV);
														
@@ -409,7 +414,7 @@ void lj_ccallback_mcode_free(CTState *cts)
 
															       nfpr = CCALL_NARG_FPR;  /* Prevent reordering. */ \
														
 
															     } \
														
 
															   } else { \
														
 
															-    if (!LJ_TARGET_IOS && n > 1) \
														
 
															+    if (!LJ_TARGET_OSX && n > 1) \
														
 
															       ngpr = (ngpr + 1u) & ~1u;  /* Align to regpair. */ \
														
 
															     if (ngpr + n <= maxgpr) { \
														
 
															       sp = &cts->cb.gpr[ngpr]; \
														
--- a/libs/LuaJIT/src/lj_cconv.c
+++ b/libs/LuaJIT/src/lj_cconv.c
@@ -8,6 +8,7 @@
 
															 #if LJ_HASFFI
														
 
															 #include "lj_err.h"
														
 
															+#include "lj_buf.h"
														
 
															 #include "lj_tab.h"
														
 
															 #include "lj_ctype.h"
														
 
															 #include "lj_cdata.h"
														
@@ -568,7 +569,9 @@ void lj_cconv_ct_tv(CTState *cts, CType *d,
 
															     }
														
 
															     s = ctype_raw(cts, sid);
														
 
															     if (ctype_isfunc(s->info)) {
														
 
															+      CTypeID did = ctype_typeid(cts, d);
														
 
															       sid = lj_ctype_intern(cts, CTINFO(CT_PTR, CTALIGN_PTR|sid), CTSIZE_PTR);
														
 
															+      d = ctype_get(cts, did);  /* cts->tab may have been reallocated. */
														
 
															     } else {
														
 
															       if (ctype_isenum(s->info)) s = ctype_child(cts, s);
														
 
															       goto doconv;
														
@@ -619,6 +622,8 @@ void lj_cconv_ct_tv(CTState *cts, CType *d,
 
															     tmpptr = uddata(ud);
														
 
															     if (ud->udtype == UDTYPE_IO_FILE)
														
 
															       tmpptr = *(void **)tmpptr;
														
 
															+    else if (ud->udtype == UDTYPE_BUFFER)
														
 
															+      tmpptr = ((SBufExt *)tmpptr)->r;
														
 
															   } else if (tvislightud(o)) {
														
 
															     tmpptr = lightudV(cts->g, o);
														
 
															   } else if (tvisfunc(o)) {
														
--- a/libs/LuaJIT/src/lj_cparse.c
+++ b/libs/LuaJIT/src/lj_cparse.c
@@ -133,9 +133,9 @@ LJ_NORET static void cp_errmsg(CPState *cp, CPToken tok, ErrMsg em, ...)
 
															     tokstr = NULL;
														
 
															   } else if (tok == CTOK_IDENT || tok == CTOK_INTEGER || tok == CTOK_STRING ||
														
 
															 	     tok >= CTOK_FIRSTDECL) {
														
 
															-    if (sbufP(&cp->sb) == sbufB(&cp->sb)) cp_save(cp, '$');
														
 
															+    if (cp->sb.w == cp->sb.b) cp_save(cp, '$');
														
 
															     cp_save(cp, '\0');
														
 
															-    tokstr = sbufB(&cp->sb);
														
 
															+    tokstr = cp->sb.b;
														
 
															   } else {
														
 
															     tokstr = cp_tok2str(cp, tok);
														
 
															   }
														
@@ -175,7 +175,7 @@ static CPToken cp_number(CPState *cp)
 
															   TValue o;
														
 
															   do { cp_save(cp, cp->c); } while (lj_char_isident(cp_get(cp)));
														
 
															   cp_save(cp, '\0');
														
 
															-  fmt = lj_strscan_scan((const uint8_t *)sbufB(&cp->sb), sbuflen(&cp->sb)-1,
														
 
															+  fmt = lj_strscan_scan((const uint8_t *)(cp->sb.b), sbuflen(&cp->sb)-1,
														
 
															 			&o, STRSCAN_OPT_C);
														
 
															   if (fmt == STRSCAN_INT) cp->val.id = CTID_INT32;
														
 
															   else if (fmt == STRSCAN_U32) cp->val.id = CTID_UINT32;
														
@@ -279,7 +279,7 @@ static CPToken cp_string(CPState *cp)
 
															     return CTOK_STRING;
														
 
															   } else {
														
 
															     if (sbuflen(&cp->sb) != 1) cp_err_token(cp, '\'');
														
 
															-    cp->val.i32 = (int32_t)(char)*sbufB(&cp->sb);
														
 
															+    cp->val.i32 = (int32_t)(char)*cp->sb.b;
														
 
															     cp->val.id = CTID_INT32;
														
 
															     return CTOK_INTEGER;
														
 
															   }
														
--- a/libs/LuaJIT/src/lj_crecord.c
+++ b/libs/LuaJIT/src/lj_crecord.c
@@ -78,7 +78,7 @@ static CTypeID argv2ctype(jit_State *J, TRef tr, cTValue *o)
 
															     /* Specialize to the string containing the C type declaration. */
														
 
															     emitir(IRTG(IR_EQ, IRT_STR), tr, lj_ir_kstr(J, s));
														
 
															     cp.L = J->L;
														
 
															-    cp.cts = ctype_ctsG(J2G(J));
														
 
															+    cp.cts = ctype_cts(J->L);
														
 
															     oldtop = cp.cts->top;
														
 
															     cp.srcname = strdata(s);
														
 
															     cp.p = strdata(s);
														
@@ -616,10 +616,12 @@ static TRef crec_ct_tv(jit_State *J, CType *d, TRef dp, TRef sp, cTValue *sval)
 
															     sp = lj_ir_kptr(J, NULL);
														
 
															   } else if (tref_isudata(sp)) {
														
 
															     GCudata *ud = udataV(sval);
														
 
															-    if (ud->udtype == UDTYPE_IO_FILE) {
														
 
															+    if (ud->udtype == UDTYPE_IO_FILE || ud->udtype == UDTYPE_BUFFER) {
														
 
															       TRef tr = emitir(IRT(IR_FLOAD, IRT_U8), sp, IRFL_UDATA_UDTYPE);
														
 
															-      emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, UDTYPE_IO_FILE));
														
 
															-      sp = emitir(IRT(IR_FLOAD, IRT_PTR), sp, IRFL_UDATA_FILE);
														
 
															+      emitir(IRTGI(IR_EQ), tr, lj_ir_kint(J, ud->udtype));
														
 
															+      sp = emitir(IRT(IR_FLOAD, IRT_PTR), sp,
														
 
															+		  ud->udtype == UDTYPE_IO_FILE ? IRFL_UDATA_FILE :
														
 
															+						 IRFL_SBUF_R);
														
 
															     } else {
														
 
															       sp = emitir(IRT(IR_ADD, IRT_PTR), sp, lj_ir_kintp(J, sizeof(GCudata)));
														
 
															     }
														
@@ -1024,8 +1026,26 @@ static void crec_alloc(jit_State *J, RecordFFData *rd, CTypeID id)
 
															 	crec_ct_tv(J, dc, dp, sp, sval);
														
 
															       }
														
 
															     } else if (ctype_isstruct(d->info)) {
														
 
															-      CTypeID fid = d->sib;
														
 
															+      CTypeID fid;
														
 
															       MSize i = 1;
														
 
															+      if (!J->base[1]) {  /* Handle zero-fill of struct-of-NYI. */
														
 
															+	fid = d->sib;
														
 
															+	while (fid) {
														
 
															+	  CType *df = ctype_get(cts, fid);
														
 
															+	  fid = df->sib;
														
 
															+	  if (ctype_isfield(df->info)) {
														
 
															+	    CType *dc;
														
 
															+	    if (!gcref(df->name)) continue;  /* Ignore unnamed fields. */
														
 
															+	    dc = ctype_rawchild(cts, df);  /* Field type. */
														
 
															+	    if (!(ctype_isnum(dc->info) || ctype_isptr(dc->info) ||
														
 
															+		  ctype_isenum(dc->info)))
														
 
															+	      goto special;
														
 
															+	  } else if (!ctype_isconstval(df->info)) {
														
 
															+	    goto special;
														
 
															+	  }
														
 
															+	}
														
 
															+      }
														
 
															+      fid = d->sib;
														
 
															       while (fid) {
														
 
															 	CType *df = ctype_get(cts, fid);
														
 
															 	fid = df->sib;
														
@@ -1893,6 +1913,30 @@ void LJ_FASTCALL lj_crecord_tonumber(jit_State *J, RecordFFData *rd)
 
															   }
														
 
															 }
														
 
															+TRef lj_crecord_loadiu64(jit_State *J, TRef tr, cTValue *o)
														
 
															+{
														
 
															+  CTypeID id = argv2cdata(J, tr, o)->ctypeid;
														
 
															+  if (!(id == CTID_INT64 || id == CTID_UINT64))
														
 
															+    lj_trace_err(J, LJ_TRERR_BADTYPE);
														
 
															+  lj_needsplit(J);
														
 
															+  return emitir(IRT(IR_FLOAD, id == CTID_INT64 ? IRT_I64 : IRT_U64), tr,
														
 
															+		IRFL_CDATA_INT64);
														
 
															+}
														
 
															+
														
 
															+#if LJ_HASBUFFER
														
 
															+TRef lj_crecord_topcvoid(jit_State *J, TRef tr, cTValue *o)
														
 
															+{
														
 
															+  CTState *cts = ctype_ctsG(J2G(J));
														
 
															+  if (!tref_iscdata(tr)) lj_trace_err(J, LJ_TRERR_BADTYPE);
														
 
															+  return crec_ct_tv(J, ctype_get(cts, CTID_P_CVOID), 0, tr, o);
														
 
															+}
														
 
															+
														
 
															+TRef lj_crecord_topuint8(jit_State *J, TRef tr)
														
 
															+{
														
 
															+  return emitir(IRTG(IR_CNEWI, IRT_CDATA), lj_ir_kint(J, CTID_P_UINT8), tr);
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															 #undef IR
														
 
															 #undef emitir
														
 
															 #undef emitconv
														
--- a/libs/LuaJIT/src/lj_crecord.h
+++ b/libs/LuaJIT/src/lj_crecord.h
@@ -33,6 +33,11 @@ LJ_FUNC int LJ_FASTCALL recff_bit64_shift(jit_State *J, RecordFFData *rd);
 
															 LJ_FUNC TRef recff_bit64_tohex(jit_State *J, RecordFFData *rd, TRef hdr);
														
 
															 LJ_FUNC void LJ_FASTCALL lj_crecord_tonumber(jit_State *J, RecordFFData *rd);
														
 
															+LJ_FUNC TRef lj_crecord_loadiu64(jit_State *J, TRef tr, cTValue *o);
														
 
															+#if LJ_HASBUFFER
														
 
															+LJ_FUNC TRef lj_crecord_topcvoid(jit_State *J, TRef tr, cTValue *o);
														
 
															+LJ_FUNC TRef lj_crecord_topuint8(jit_State *J, TRef tr);
														
 
															+#endif
														
 
															 #endif
														
 
															 #endif
														
--- a/libs/LuaJIT/src/lj_ctype.c
+++ b/libs/LuaJIT/src/lj_ctype.c
@@ -583,7 +583,7 @@ GCstr *lj_ctype_repr_complex(lua_State *L, void *sp, CTSize size)
 
															   lj_strfmt_putfnum(sb, STRFMT_G14, re.n);
														
 
															   if (!(im.u32.hi & 0x80000000u) || im.n != im.n) lj_buf_putchar(sb, '+');
														
 
															   lj_strfmt_putfnum(sb, STRFMT_G14, im.n);
														
 
															-  lj_buf_putchar(sb, sbufP(sb)[-1] >= 'a' ? 'I' : 'i');
														
 
															+  lj_buf_putchar(sb, sb->w[-1] >= 'a' ? 'I' : 'i');
														
 
															   return lj_buf_str(L, sb);
														
 
															 }
														
--- a/libs/LuaJIT/src/lj_ctype.h
+++ b/libs/LuaJIT/src/lj_ctype.h
@@ -298,6 +298,7 @@ typedef struct CTState {
 
															   _(P_VOID,	CTSIZE_PTR,	CT_PTR, CTALIGN_PTR|CTID_VOID) \
														
 
															   _(P_CVOID,	CTSIZE_PTR,	CT_PTR, CTALIGN_PTR|CTID_CVOID) \
														
 
															   _(P_CCHAR,	CTSIZE_PTR,	CT_PTR, CTALIGN_PTR|CTID_CCHAR) \
														
 
															+  _(P_UINT8,	CTSIZE_PTR,	CT_PTR, CTALIGN_PTR|CTID_UINT8) \
														
 
															   _(A_CCHAR,		-1,	CT_ARRAY, CTF_CONST|CTALIGN(0)|CTID_CCHAR) \
														
 
															   _(CTYPEID,		4,	CT_ENUM, CTALIGN(2)|CTID_INT32) \
														
 
															   CTTYDEFP(_) \
														
@@ -389,6 +390,16 @@ static LJ_AINLINE CTState *ctype_cts(lua_State *L)
 
															   return cts;
														
 
															 }
														
 
															+/* Load FFI library on-demand. */
														
 
															+#define ctype_loadffi(L) \
														
 
															+  do { \
														
 
															+    if (!ctype_ctsG(G(L))) { \
														
 
															+      ptrdiff_t oldtop = (char *)L->top - mref(L->stack, char); \
														
 
															+      luaopen_ffi(L); \
														
 
															+      L->top = (TValue *)(mref(L->stack, char) + oldtop); \
														
 
															+    } \
														
 
															+  } while (0)
														
 
															+
														
 
															 /* Save and restore state of C type table. */
														
 
															 #define LJ_CTYPE_SAVE(cts)	CTState savects_ = *(cts)
														
 
															 #define LJ_CTYPE_RESTORE(cts) \
														
--- a/libs/LuaJIT/src/lj_debug.c
+++ b/libs/LuaJIT/src/lj_debug.c
@@ -648,7 +648,7 @@ void lj_debug_dumpstack(lua_State *L, SBuf *sb, const char *fmt, int depth)
 
															     level += dir;
														
 
															   }
														
 
															   if (lastlen)
														
 
															-    setsbufP(sb, sbufB(sb) + lastlen);  /* Zap trailing separator. */
														
 
															+    sb->w = sb->b + lastlen;  /* Zap trailing separator. */
														
 
															 }
														
 
															 #endif
														
--- a/libs/LuaJIT/src/lj_dispatch.c
+++ b/libs/LuaJIT/src/lj_dispatch.c
@@ -68,6 +68,8 @@ void lj_dispatch_init(GG_State *GG)
 
															   /* The JIT engine is off by default. luaopen_jit() turns it on. */
														
 
															   disp[BC_FORL] = disp[BC_IFORL];
														
 
															   disp[BC_ITERL] = disp[BC_IITERL];
														
 
															+  /* Workaround for stable v2.1 bytecode. TODO: Replace with BC_IITERN. */
														
 
															+  disp[BC_ITERN] = &lj_vm_IITERN;
														
 
															   disp[BC_LOOP] = disp[BC_ILOOP];
														
 
															   disp[BC_FUNCF] = disp[BC_IFUNCF];
														
 
															   disp[BC_FUNCV] = disp[BC_IFUNCV];
														
@@ -118,19 +120,21 @@ void lj_dispatch_update(global_State *g)
 
															   mode |= (g->hookmask & LUA_MASKRET) ? DISPMODE_RET : 0;
														
 
															   if (oldmode != mode) {  /* Mode changed? */
														
 
															     ASMFunction *disp = G2GG(g)->dispatch;
														
 
															-    ASMFunction f_forl, f_iterl, f_loop, f_funcf, f_funcv;
														
 
															+    ASMFunction f_forl, f_iterl, f_itern, f_loop, f_funcf, f_funcv;
														
 
															     g->dispatchmode = mode;
														
 
															     /* Hotcount if JIT is on, but not while recording. */
														
 
															     if ((mode & (DISPMODE_JIT|DISPMODE_REC)) == DISPMODE_JIT) {
														
 
															       f_forl = makeasmfunc(lj_bc_ofs[BC_FORL]);
														
 
															       f_iterl = makeasmfunc(lj_bc_ofs[BC_ITERL]);
														
 
															+      f_itern = makeasmfunc(lj_bc_ofs[BC_ITERN]);
														
 
															       f_loop = makeasmfunc(lj_bc_ofs[BC_LOOP]);
														
 
															       f_funcf = makeasmfunc(lj_bc_ofs[BC_FUNCF]);
														
 
															       f_funcv = makeasmfunc(lj_bc_ofs[BC_FUNCV]);
														
 
															     } else {  /* Otherwise use the non-hotcounting instructions. */
														
 
															       f_forl = disp[GG_LEN_DDISP+BC_IFORL];
														
 
															       f_iterl = disp[GG_LEN_DDISP+BC_IITERL];
														
 
															+      f_itern = &lj_vm_IITERN;
														
 
															       f_loop = disp[GG_LEN_DDISP+BC_ILOOP];
														
 
															       f_funcf = makeasmfunc(lj_bc_ofs[BC_IFUNCF]);
														
 
															       f_funcv = makeasmfunc(lj_bc_ofs[BC_IFUNCV]);
														
@@ -138,6 +142,7 @@ void lj_dispatch_update(global_State *g)
 
															     /* Init static counting instruction dispatch first (may be copied below). */
														
 
															     disp[GG_LEN_DDISP+BC_FORL] = f_forl;
														
 
															     disp[GG_LEN_DDISP+BC_ITERL] = f_iterl;
														
 
															+    disp[GG_LEN_DDISP+BC_ITERN] = f_itern;
														
 
															     disp[GG_LEN_DDISP+BC_LOOP] = f_loop;
														
 
															     /* Set dynamic instruction dispatch. */
														
@@ -165,6 +170,7 @@ void lj_dispatch_update(global_State *g)
 
															       /* Otherwise set dynamic counting ins. */
														
 
															       disp[BC_FORL] = f_forl;
														
 
															       disp[BC_ITERL] = f_iterl;
														
 
															+      disp[BC_ITERN] = f_itern;
														
 
															       disp[BC_LOOP] = f_loop;
														
 
															       /* Set dynamic return dispatch. */
														
 
															       if ((mode & DISPMODE_RET)) {
														
--- a/libs/LuaJIT/src/lj_dispatch.h
+++ b/libs/LuaJIT/src/lj_dispatch.h
@@ -31,7 +31,7 @@ extern double __divdf3(double a, double b);
 
															 #define SFGOTDEF(_)
														
 
															 #endif
														
 
															 #if LJ_HASJIT
														
 
															-#define JITGOTDEF(_)	_(lj_trace_exit) _(lj_trace_hot)
														
 
															+#define JITGOTDEF(_)	_(lj_err_trace) _(lj_trace_exit) _(lj_trace_hot)
														
 
															 #else
														
 
															 #define JITGOTDEF(_)
														
 
															 #endif
														
@@ -46,7 +46,7 @@ extern double __divdf3(double a, double b);
 
															   _(asin) _(acos) _(atan) _(sinh) _(cosh) _(tanh) _(frexp) _(modf) _(atan2) \
														
 
															   _(pow) _(fmod) _(ldexp) _(lj_vm_modi) \
														
 
															   _(lj_dispatch_call) _(lj_dispatch_ins) _(lj_dispatch_stitch) \
														
 
															-  _(lj_dispatch_profile) _(lj_err_throw) _(lj_err_run) \
														
 
															+  _(lj_dispatch_profile) _(lj_err_throw) \
														
 
															   _(lj_ffh_coroutine_wrap_err) _(lj_func_closeuv) _(lj_func_newL_gc) \
														
 
															   _(lj_gc_barrieruv) _(lj_gc_step) _(lj_gc_step_fixtop) _(lj_meta_arith) \
														
 
															   _(lj_meta_call) _(lj_meta_cat) _(lj_meta_comp) _(lj_meta_equal) \
														
--- a/libs/LuaJIT/src/lj_emit_arm64.h
+++ b/libs/LuaJIT/src/lj_emit_arm64.h
@@ -163,7 +163,7 @@ nopair:
 
															 /* Try to find an N-step delta relative to other consts with N < lim. */
														
 
															 static int emit_kdelta(ASMState *as, Reg rd, uint64_t k, int lim)
														
 
															 {
														
 
															-  RegSet work = ~as->freeset & RSET_GPR;
														
 
															+  RegSet work = (~as->freeset & RSET_GPR) | RID2RSET(RID_GL);
														
 
															   if (lim <= 1) return 0;  /* Can't beat that. */
														
 
															   while (work) {
														
 
															     Reg r = rset_picktop(work);
														
@@ -194,39 +194,41 @@ static int emit_kdelta(ASMState *as, Reg rd, uint64_t k, int lim)
 
															 static void emit_loadk(ASMState *as, Reg rd, uint64_t u64, int is64)
														
 
															 {
														
 
															-  uint32_t k13 = emit_isk13(u64, is64);
														
 
															-  if (k13) {  /* Can the constant be represented as a bitmask immediate? */
														
 
															-    emit_dn(as, (is64|A64I_ORRw)^k13, rd, RID_ZERO);
														
 
															-  } else {
														
 
															-    int i, zeros = 0, ones = 0, neg;
														
 
															-    if (!is64) u64 = (int64_t)(int32_t)u64;  /* Sign-extend. */
														
 
															-    /* Count homogeneous 16 bit fragments. */
														
 
															-    for (i = 0; i < 4; i++) {
														
 
															-      uint64_t frag = (u64 >> i*16) & 0xffff;
														
 
															-      zeros += (frag == 0);
														
 
															-      ones += (frag == 0xffff);
														
 
															+  int i, zeros = 0, ones = 0, neg;
														
 
															+  if (!is64) u64 = (int64_t)(int32_t)u64;  /* Sign-extend. */
														
 
															+  /* Count homogeneous 16 bit fragments. */
														
 
															+  for (i = 0; i < 4; i++) {
														
 
															+    uint64_t frag = (u64 >> i*16) & 0xffff;
														
 
															+    zeros += (frag == 0);
														
 
															+    ones += (frag == 0xffff);
														
 
															+  }
														
 
															+  neg = ones > zeros;  /* Use MOVN if it pays off. */
														
 
															+  if ((neg ? ones : zeros) < 3) {  /* Need 2+ ins. Try shorter K13 encoding. */
														
 
															+    uint32_t k13 = emit_isk13(u64, is64);
														
 
															+    if (k13) {
														
 
															+      emit_dn(as, (is64|A64I_ORRw)^k13, rd, RID_ZERO);
														
 
															+      return;
														
 
															     }
														
 
															-    neg = ones > zeros;  /* Use MOVN if it pays off. */
														
 
															-    if (!emit_kdelta(as, rd, u64, 4 - (neg ? ones : zeros))) {
														
 
															-      int shift = 0, lshift = 0;
														
 
															-      uint64_t n64 = neg ? ~u64 : u64;
														
 
															-      if (n64 != 0) {
														
 
															-	/* Find first/last fragment to be filled. */
														
 
															-	shift = (63-emit_clz64(n64)) & ~15;
														
 
															-	lshift = emit_ctz64(n64) & ~15;
														
 
															-      }
														
 
															-      /* MOVK requires the original value (u64). */
														
 
															-      while (shift > lshift) {
														
 
															-	uint32_t u16 = (u64 >> shift) & 0xffff;
														
 
															-	/* Skip fragments that are correctly filled by MOVN/MOVZ. */
														
 
															-	if (u16 != (neg ? 0xffff : 0))
														
 
															-	  emit_d(as, is64 | A64I_MOVKw | A64F_U16(u16) | A64F_LSL16(shift), rd);
														
 
															-	shift -= 16;
														
 
															-      }
														
 
															-      /* But MOVN needs an inverted value (n64). */
														
 
															-      emit_d(as, (neg ? A64I_MOVNx : A64I_MOVZx) |
														
 
															-		 A64F_U16((n64 >> lshift) & 0xffff) | A64F_LSL16(lshift), rd);
														
 
															+  }
														
 
															+  if (!emit_kdelta(as, rd, u64, 4 - (neg ? ones : zeros))) {
														
 
															+    int shift = 0, lshift = 0;
														
 
															+    uint64_t n64 = neg ? ~u64 : u64;
														
 
															+    if (n64 != 0) {
														
 
															+      /* Find first/last fragment to be filled. */
														
 
															+      shift = (63-emit_clz64(n64)) & ~15;
														
 
															+      lshift = emit_ctz64(n64) & ~15;
														
 
															+    }
														
 
															+    /* MOVK requires the original value (u64). */
														
 
															+    while (shift > lshift) {
														
 
															+      uint32_t u16 = (u64 >> shift) & 0xffff;
														
 
															+      /* Skip fragments that are correctly filled by MOVN/MOVZ. */
														
 
															+      if (u16 != (neg ? 0xffff : 0))
														
 
															+	emit_d(as, is64 | A64I_MOVKw | A64F_U16(u16) | A64F_LSL16(shift), rd);
														
 
															+      shift -= 16;
														
 
															     }
														
 
															+    /* But MOVN needs an inverted value (n64). */
														
 
															+    emit_d(as, (neg ? A64I_MOVNx : A64I_MOVZx) |
														
 
															+	       A64F_U16((n64 >> lshift) & 0xffff) | A64F_LSL16(lshift), rd);
														
 
															   }
														
 
															 }
														
--- a/libs/LuaJIT/src/lj_emit_mips.h
+++ b/libs/LuaJIT/src/lj_emit_mips.h
@@ -70,7 +70,7 @@ static void emit_rotr(ASMState *as, Reg dest, Reg src, Reg tmp, uint32_t shift)
 
															   }
														
 
															 }
														
 
															-#if LJ_64
														
 
															+#if LJ_64 || LJ_HASBUFFER
														
 
															 static void emit_tsml(ASMState *as, MIPSIns mi, Reg rt, Reg rs, uint32_t msb,
														
 
															 		      uint32_t lsb)
														
 
															 {
														
--- a/libs/LuaJIT/src/lj_err.c
+++ b/libs/LuaJIT/src/lj_err.c
@@ -29,12 +29,18 @@
 
															 ** Pros and Cons:
														
 
															 **
														
 
															 ** - EXT requires unwind tables for *all* functions on the C stack between
														
 
															-**   the pcall/catch and the error/throw. This is the default on x64,
														
 
															-**   but needs to be manually enabled on x86/PPC for non-C++ code.
														
 
															+**   the pcall/catch and the error/throw. C modules used by Lua code can
														
 
															+**   throw errors, so these need to have unwind tables, too. Transitively
														
 
															+**   this applies to all system libraries used by C modules -- at least
														
 
															+**   when they have callbacks which may throw an error.
														
 
															 **
														
 
															-** - INT is faster when actually throwing errors (but this happens rarely).
														
 
															+** - INT is faster when actually throwing errors, but this happens rarely.
														
 
															 **   Setting up error handlers is zero-cost in any case.
														
 
															 **
														
 
															+** - INT needs to save *all* callee-saved registers when entering the
														
 
															+**   interpreter. EXT only needs to save those actually used inside the
														
 
															+**   interpreter. JIT-compiled code may need to save some more.
														
 
															+**
														
 
															 ** - EXT provides full interoperability with C++ exceptions. You can throw
														
 
															 **   Lua errors or C++ exceptions through a mix of Lua frames and C++ frames.
														
 
															 **   C++ destructors are called as needed. C++ exceptions caught by pcall
														
@@ -46,27 +52,38 @@
 
															 **   the wrapper function feature. Lua errors thrown through C++ frames
														
 
															 **   cannot be caught by C++ code and C++ destructors are not run.
														
 
															 **
														
 
															-** EXT is the default on x64 systems and on Windows, INT is the default on all
														
 
															-** other systems.
														
 
															+** - EXT can handle errors from internal helper functions that are called
														
 
															+**   from JIT-compiled code (except for Windows/x86 and 32 bit ARM).
														
 
															+**   INT has no choice but to call the panic handler, if this happens.
														
 
															+**   Note: this is mainly relevant for out-of-memory errors.
														
 
															+**
														
 
															+** EXT is the default on all systems where the toolchain produces unwind
														
 
															+** tables by default (*). This is hard-coded and/or detected in src/Makefile.
														
 
															+** You can thwart the detection with: TARGET_XCFLAGS=-DLUAJIT_UNWIND_INTERNAL
														
 
															+**
														
 
															+** INT is the default on all other systems.
														
 
															+**
														
 
															+** EXT can be manually enabled for toolchains that are able to produce
														
 
															+** conforming unwind tables:
														
 
															+**   "TARGET_XCFLAGS=-funwind-tables -DLUAJIT_UNWIND_EXTERNAL"
														
 
															+** As explained above, *all* C code used directly or indirectly by LuaJIT
														
 
															+** must be compiled with -funwind-tables (or -fexceptions). C++ code must
														
 
															+** *not* be compiled with -fno-exceptions.
														
 
															+**
														
 
															+** If you're unsure whether error handling inside the VM works correctly,
														
 
															+** try running this and check whether it prints "OK":
														
 
															 **
														
 
															-** EXT can be manually enabled on POSIX systems using GCC and DWARF2 stack
														
 
															-** unwinding with -DLUAJIT_UNWIND_EXTERNAL. *All* C code must be compiled
														
 
															-** with -funwind-tables (or -fexceptions). This includes LuaJIT itself (set
														
 
															-** TARGET_CFLAGS), all of your C/Lua binding code, all loadable C modules
														
 
															-** and all C libraries that have callbacks which may be used to call back
														
 
															-** into Lua. C++ code must *not* be compiled with -fno-exceptions.
														
 
															+**   luajit -e "print(select(2, load('OK')):match('OK'))"
														
 
															 **
														
 
															-** EXT is mandatory on WIN64 since the calling convention has an abundance
														
 
															-** of callee-saved registers (rbx, rbp, rsi, rdi, r12-r15, xmm6-xmm15).
														
 
															-** The POSIX/x64 interpreter only saves r12/r13 for INT (e.g. PS4).
														
 
															+** (*) Originally, toolchains only generated unwind tables for C++ code. For
														
 
															+** interoperability reasons, this can be manually enabled for plain C code,
														
 
															+** too (with -funwind-tables). With the introduction of the x64 architecture,
														
 
															+** the corresponding POSIX and Windows ABIs mandated unwind tables for all
														
 
															+** code. Over the following years most desktop and server platforms have
														
 
															+** enabled unwind tables by default on all architectures. OTOH mobile and
														
 
															+** embedded platforms do not consistently mandate unwind tables.
														
 
															 */
														
 
															-#if (defined(__GNUC__) || defined(__clang__)) && (LJ_TARGET_X64 || defined(LUAJIT_UNWIND_EXTERNAL)) && !LJ_NO_UNWIND
														
 
															-#define LJ_UNWIND_EXT	1
														
 
															-#elif LJ_TARGET_WINDOWS
														
 
															-#define LJ_UNWIND_EXT	1
														
 
															-#endif
														
 
															-
														
 
															 /* -- Error messages ------------------------------------------------------ */
														
 
															 /* Error message strings. */
														
@@ -184,7 +201,172 @@ static void *err_unwind(lua_State *L, void *stopcf, int errcode)
 
															 /* -- External frame unwinding -------------------------------------------- */
														
 
															-#if (defined(__GNUC__) || defined(__clang__)) && !LJ_NO_UNWIND && !LJ_ABI_WIN
														
 
															+#if LJ_ABI_WIN
														
 
															+
														
 
															+/*
														
 
															+** Someone in Redmond owes me several days of my life. A lot of this is
														
 
															+** undocumented or just plain wrong on MSDN. Some of it can be gathered
														
 
															+** from 3rd party docs or must be found by trial-and-error. They really
														
 
															+** don't want you to write your own language-specific exception handler
														
 
															+** or to interact gracefully with MSVC. :-(
														
 
															+**
														
 
															+** Apparently MSVC doesn't call C++ destructors for foreign exceptions
														
 
															+** unless you compile your C++ code with /EHa. Unfortunately this means
														
 
															+** catch (...) also catches things like access violations. The use of
														
 
															+** _set_se_translator doesn't really help, because it requires /EHa, too.
														
 
															+*/
														
 
															+
														
 
															+#define WIN32_LEAN_AND_MEAN
														
 
															+#include <windows.h>
														
 
															+
														
 
															+#if LJ_TARGET_X86
														
 
															+typedef void *UndocumentedDispatcherContext;  /* Unused on x86. */
														
 
															+#else
														
 
															+/* Taken from: http://www.nynaeve.net/?p=99 */
														
 
															+typedef struct UndocumentedDispatcherContext {
														
 
															+  ULONG64 ControlPc;
														
 
															+  ULONG64 ImageBase;
														
 
															+  PRUNTIME_FUNCTION FunctionEntry;
														
 
															+  ULONG64 EstablisherFrame;
														
 
															+  ULONG64 TargetIp;
														
 
															+  PCONTEXT ContextRecord;
														
 
															+  void (*LanguageHandler)(void);
														
 
															+  PVOID HandlerData;
														
 
															+  PUNWIND_HISTORY_TABLE HistoryTable;
														
 
															+  ULONG ScopeIndex;
														
 
															+  ULONG Fill0;
														
 
															+} UndocumentedDispatcherContext;
														
 
															+#endif
														
 
															+
														
 
															+/* Another wild guess. */
														
 
															+extern void __DestructExceptionObject(EXCEPTION_RECORD *rec, int nothrow);
														
 
															+
														
 
															+#if LJ_TARGET_X64 && defined(MINGW_SDK_INIT)
														
 
															+/* Workaround for broken MinGW64 declaration. */
														
 
															+VOID RtlUnwindEx_FIXED(PVOID,PVOID,PVOID,PVOID,PVOID,PVOID) asm("RtlUnwindEx");
														
 
															+#define RtlUnwindEx RtlUnwindEx_FIXED
														
 
															+#endif
														
 
															+
														
 
															+#define LJ_MSVC_EXCODE		((DWORD)0xe06d7363)
														
 
															+#define LJ_GCC_EXCODE		((DWORD)0x20474343)
														
 
															+
														
 
															+#define LJ_EXCODE		((DWORD)0xe24c4a00)
														
 
															+#define LJ_EXCODE_MAKE(c)	(LJ_EXCODE | (DWORD)(c))
														
 
															+#define LJ_EXCODE_CHECK(cl)	(((cl) ^ LJ_EXCODE) <= 0xff)
														
 
															+#define LJ_EXCODE_ERRCODE(cl)	((int)((cl) & 0xff))
														
 
															+
														
 
															+/* Windows exception handler for interpreter frame. */
														
 
															+LJ_FUNCA int lj_err_unwind_win(EXCEPTION_RECORD *rec,
														
 
															+  void *f, CONTEXT *ctx, UndocumentedDispatcherContext *dispatch)
														
 
															+{
														
 
															+#if LJ_TARGET_X86
														
 
															+  void *cf = (char *)f - CFRAME_OFS_SEH;
														
 
															+#else
														
 
															+  void *cf = f;
														
 
															+#endif
														
 
															+  lua_State *L = cframe_L(cf);
														
 
															+  int errcode = LJ_EXCODE_CHECK(rec->ExceptionCode) ?
														
 
															+		LJ_EXCODE_ERRCODE(rec->ExceptionCode) : LUA_ERRRUN;
														
 
															+  if ((rec->ExceptionFlags & 6)) {  /* EH_UNWINDING|EH_EXIT_UNWIND */
														
 
															+    /* Unwind internal frames. */
														
 
															+    err_unwind(L, cf, errcode);
														
 
															+  } else {
														
 
															+    void *cf2 = err_unwind(L, cf, 0);
														
 
															+    if (cf2) {  /* We catch it, so start unwinding the upper frames. */
														
 
															+      if (rec->ExceptionCode == LJ_MSVC_EXCODE ||
														
 
															+	  rec->ExceptionCode == LJ_GCC_EXCODE) {
														
 
															+#if !LJ_TARGET_CYGWIN
														
 
															+	__DestructExceptionObject(rec, 1);
														
 
															+#endif
														
 
															+	setstrV(L, L->top++, lj_err_str(L, LJ_ERR_ERRCPP));
														
 
															+      } else if (!LJ_EXCODE_CHECK(rec->ExceptionCode)) {
														
 
															+	/* Don't catch access violations etc. */
														
 
															+	return 1;  /* ExceptionContinueSearch */
														
 
															+      }
														
 
															+#if LJ_TARGET_X86
														
 
															+      UNUSED(ctx);
														
 
															+      UNUSED(dispatch);
														
 
															+      /* Call all handlers for all lower C frames (including ourselves) again
														
 
															+      ** with EH_UNWINDING set. Then call the specified function, passing cf
														
 
															+      ** and errcode.
														
 
															+      */
														
 
															+      lj_vm_rtlunwind(cf, (void *)rec,
														
 
															+	(cframe_unwind_ff(cf2) && errcode != LUA_YIELD) ?
														
 
															+	(void *)lj_vm_unwind_ff : (void *)lj_vm_unwind_c, errcode);
														
 
															+      /* lj_vm_rtlunwind does not return. */
														
 
															+#else
														
 
															+      /* Unwind the stack and call all handlers for all lower C frames
														
 
															+      ** (including ourselves) again with EH_UNWINDING set. Then set
														
 
															+      ** stack pointer = cf, result = errcode and jump to the specified target.
														
 
															+      */
														
 
															+      RtlUnwindEx(cf, (void *)((cframe_unwind_ff(cf2) && errcode != LUA_YIELD) ?
														
 
															+			       lj_vm_unwind_ff_eh :
														
 
															+			       lj_vm_unwind_c_eh),
														
 
															+		  rec, (void *)(uintptr_t)errcode, ctx, dispatch->HistoryTable);
														
 
															+      /* RtlUnwindEx should never return. */
														
 
															+#endif
														
 
															+    }
														
 
															+  }
														
 
															+  return 1;  /* ExceptionContinueSearch */
														
 
															+}
														
 
															+
														
 
															+#if LJ_UNWIND_JIT
														
 
															+
														
 
															+#if LJ_TARGET_X64
														
 
															+#define CONTEXT_REG_PC	Rip
														
 
															+#elif LJ_TARGET_ARM64
														
 
															+#define CONTEXT_REG_PC	Pc
														
 
															+#else
														
 
															+#error "NYI: Windows arch-specific unwinder for JIT-compiled code"
														
 
															+#endif
														
 
															+
														
 
															+/* Windows unwinder for JIT-compiled code. */
														
 
															+static void err_unwind_win_jit(global_State *g, int errcode)
														
 
															+{
														
 
															+  CONTEXT ctx;
														
 
															+  UNWIND_HISTORY_TABLE hist;
														
 
															+
														
 
															+  memset(&hist, 0, sizeof(hist));
														
 
															+  RtlCaptureContext(&ctx);
														
 
															+  while (1) {
														
 
															+    uintptr_t frame, base, addr = ctx.CONTEXT_REG_PC;
														
 
															+    void *hdata;
														
 
															+    PRUNTIME_FUNCTION func = RtlLookupFunctionEntry(addr, &base, &hist);
														
 
															+    if (!func) {  /* Found frame without .pdata: must be JIT-compiled code. */
														
 
															+      ExitNo exitno;
														
 
															+      uintptr_t stub = lj_trace_unwind(G2J(g), addr - sizeof(MCode), &exitno);
														
 
															+      if (stub) {  /* Jump to side exit to unwind the trace. */
														
 
															+	ctx.CONTEXT_REG_PC = stub;
														
 
															+	G2J(g)->exitcode = errcode;
														
 
															+	RtlRestoreContext(&ctx, NULL);  /* Does not return. */
														
 
															+      }
														
 
															+      break;
														
 
															+    }
														
 
															+    RtlVirtualUnwind(UNW_FLAG_NHANDLER, base, addr, func,
														
 
															+		     &ctx, &hdata, &frame, NULL);
														
 
															+    if (!addr) break;
														
 
															+  }
														
 
															+  /* Unwinding failed, if we end up here. */
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															+/* Raise Windows exception. */
														
 
															+static void err_raise_ext(global_State *g, int errcode)
														
 
															+{
														
 
															+#if LJ_UNWIND_JIT
														
 
															+  if (tvref(g->jit_base)) {
														
 
															+    err_unwind_win_jit(g, errcode);
														
 
															+    return;  /* Unwinding failed. */
														
 
															+  }
														
 
															+#elif LJ_HASJIT
														
 
															+  /* Cannot catch on-trace errors for Windows/x86 SEH. Unwind to interpreter. */
														
 
															+  setmref(g->jit_base, NULL);
														
 
															+#endif
														
 
															+  UNUSED(g);
														
 
															+  RaiseException(LJ_EXCODE_MAKE(errcode), 1 /* EH_NONCONTINUABLE */, 0, NULL);
														
 
															+}
														
 
															+
														
 
															+#elif !LJ_NO_UNWIND && (defined(__GNUC__) || defined(__clang__))
														
 
															 /*
														
 
															 ** We have to use our own definitions instead of the mandatory (!) unwind.h,
														
@@ -194,6 +376,7 @@ static void *err_unwind(lua_State *L, void *stopcf, int errcode)
 
															 typedef struct _Unwind_Context _Unwind_Context;
														
 
															 #define _URC_OK			0
														
 
															+#define _URC_FATAL_PHASE2_ERROR	2
														
 
															 #define _URC_FATAL_PHASE1_ERROR	3
														
 
															 #define _URC_HANDLER_FOUND	6
														
 
															 #define _URC_INSTALL_CONTEXT	7
														
@@ -213,9 +396,11 @@ typedef struct _Unwind_Exception
 
															   void (*excleanup)(int, struct _Unwind_Exception *);
														
 
															   uintptr_t p1, p2;
														
 
															 } __attribute__((__aligned__)) _Unwind_Exception;
														
 
															+#define UNWIND_EXCEPTION_TYPE	_Unwind_Exception
														
 
															 extern uintptr_t _Unwind_GetCFA(_Unwind_Context *);
														
 
															 extern void _Unwind_SetGR(_Unwind_Context *, int, uintptr_t);
														
 
															+extern uintptr_t _Unwind_GetIP(_Unwind_Context *);
														
 
															 extern void _Unwind_SetIP(_Unwind_Context *, uintptr_t);
														
 
															 extern void _Unwind_DeleteException(_Unwind_Exception *);
														
 
															 extern int _Unwind_RaiseException(_Unwind_Exception *);
														
@@ -233,7 +418,6 @@ LJ_FUNCA int lj_err_unwind_dwarf(int version, int actions,
 
															   lua_State *L;
														
 
															   if (version != 1)
														
 
															     return _URC_FATAL_PHASE1_ERROR;
														
 
															-  UNUSED(uexclass);
														
 
															   cf = (void *)_Unwind_GetCFA(ctx);
														
 
															   L = cframe_L(cf);
														
 
															   if ((actions & _UA_SEARCH_PHASE)) {
														
@@ -281,20 +465,139 @@ LJ_FUNCA int lj_err_unwind_dwarf(int version, int actions,
 
															     ** it on non-x64 because the interpreter restores all callee-saved regs.
														
 
															     */
														
 
															     lj_err_throw(L, errcode);
														
 
															+#if LJ_TARGET_X64
														
 
															+#error "Broken build system -- only use the provided Makefiles!"
														
 
															+#endif
														
 
															 #endif
														
 
															   }
														
 
															   return _URC_CONTINUE_UNWIND;
														
 
															 }
														
 
															-#if LJ_UNWIND_EXT
														
 
															-static __thread _Unwind_Exception static_uex;
														
 
															+#if LJ_UNWIND_EXT && defined(LUA_USE_ASSERT)
														
 
															+struct dwarf_eh_bases { void *tbase, *dbase, *func; };
														
 
															+extern const void *_Unwind_Find_FDE(void *pc, struct dwarf_eh_bases *bases);
														
 
															-/* Raise DWARF2 exception. */
														
 
															-static void err_raise_ext(int errcode)
														
 
															+/* Verify that external error handling actually has a chance to work. */
														
 
															+void lj_err_verify(void)
														
 
															 {
														
 
															-  static_uex.exclass = LJ_UEXCLASS_MAKE(errcode);
														
 
															-  static_uex.excleanup = NULL;
														
 
															-  _Unwind_RaiseException(&static_uex);
														
 
															+  struct dwarf_eh_bases ehb;
														
 
															+  lj_assertX(_Unwind_Find_FDE((void *)lj_err_throw, &ehb), "broken build: external frame unwinding enabled, but missing -funwind-tables");
														
 
															+  /* Check disabled, because of broken Fedora/ARM64. See #722.
														
 
															+  lj_assertX(_Unwind_Find_FDE((void *)_Unwind_RaiseException, &ehb), "broken build: external frame unwinding enabled, but system libraries have no unwind tables");
														
 
															+  */
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															+#if LJ_UNWIND_JIT
														
 
															+/* DWARF2 personality handler for JIT-compiled code. */
														
 
															+static int err_unwind_jit(int version, int actions,
														
 
															+  uint64_t uexclass, _Unwind_Exception *uex, _Unwind_Context *ctx)
														
 
															+{
														
 
															+  /* NYI: FFI C++ exception interoperability. */
														
 
															+  if (version != 1 || !LJ_UEXCLASS_CHECK(uexclass))
														
 
															+    return _URC_FATAL_PHASE1_ERROR;
														
 
															+  if ((actions & _UA_SEARCH_PHASE)) {
														
 
															+    return _URC_HANDLER_FOUND;
														
 
															+  }
														
 
															+  if ((actions & _UA_CLEANUP_PHASE)) {
														
 
															+    global_State *g = *(global_State **)(uex+1);
														
 
															+    ExitNo exitno;
														
 
															+    uintptr_t addr = _Unwind_GetIP(ctx);  /* Return address _after_ call. */
														
 
															+    uintptr_t stub = lj_trace_unwind(G2J(g), addr - sizeof(MCode), &exitno);
														
 
															+    lj_assertG(tvref(g->jit_base), "unexpected throw across mcode frame");
														
 
															+    if (stub) {  /* Jump to side exit to unwind the trace. */
														
 
															+      G2J(g)->exitcode = LJ_UEXCLASS_ERRCODE(uexclass);
														
 
															+#ifdef LJ_TARGET_MIPS
														
 
															+      _Unwind_SetGR(ctx, 4, stub);
														
 
															+      _Unwind_SetGR(ctx, 5, exitno);
														
 
															+      _Unwind_SetIP(ctx, (uintptr_t)(void *)lj_vm_unwind_stub);
														
 
															+#else
														
 
															+      _Unwind_SetIP(ctx, stub);
														
 
															+#endif
														
 
															+      return _URC_INSTALL_CONTEXT;
														
 
															+    }
														
 
															+    return _URC_FATAL_PHASE2_ERROR;
														
 
															+  }
														
 
															+  return _URC_FATAL_PHASE1_ERROR;
														
 
															+}
														
 
															+
														
 
															+/* DWARF2 template frame info for JIT-compiled code.
														
 
															+**
														
 
															+** After copying the template to the start of the mcode segment,
														
 
															+** the frame handler function and the code size is patched.
														
 
															+** The frame handler always installs a new context to jump to the exit,
														
 
															+** so don't bother to add any unwind opcodes.
														
 
															+*/
														
 
															+static const uint8_t err_frame_jit_template[] = {
														
 
															+#if LJ_BE
														
 
															+  0,0,0,
														
 
															+#endif
														
 
															+  LJ_64 ? 0x1c : 0x14,  /* CIE length. */
														
 
															+#if LJ_LE
														
 
															+  0,0,0,
														
 
															+#endif
														
 
															+  0,0,0,0, 1, 'z','P','R',0,  /* CIE mark, CIE version, augmentation. */
														
 
															+  1, LJ_64 ? 0x78 : 0x7c, LJ_TARGET_EHRAREG,  /* Code/data align, RA. */
														
 
															+#if LJ_64
														
 
															+  10, 0, 0,0,0,0,0,0,0,0, 0x1b,  /* Aug. data ABS handler, PCREL|SDATA4 code. */
														
 
															+  0,0,0,0,0,  /* Alignment. */
														
 
															+#else
														
 
															+  6, 0, 0,0,0,0, 0x1b,  /* Aug. data ABS handler, PCREL|SDATA4 code. */
														
 
															+  0,  /* Alignment. */
														
 
															+#endif
														
 
															+#if LJ_BE
														
 
															+  0,0,0,
														
 
															+#endif
														
 
															+  LJ_64 ? 0x14 : 0x10,  /* FDE length. */
														
 
															+  0,0,0,
														
 
															+  LJ_64 ? 0x24 : 0x1c,  /* CIE offset. */
														
 
															+  0,0,0,
														
 
															+  LJ_64 ? 0x14 : 0x10,  /* Code offset. After Final FDE. */
														
 
															+#if LJ_LE
														
 
															+  0,0,0,
														
 
															+#endif
														
 
															+  0,0,0,0, 0, 0,0,0, /* Code size, augmentation length, alignment. */
														
 
															+#if LJ_64
														
 
															+  0,0,0,0,  /* Alignment. */
														
 
															+#endif
														
 
															+  0,0,0,0  /* Final FDE. */
														
 
															+};
														
 
															+
														
 
															+#define ERR_FRAME_JIT_OFS_HANDLER	0x12
														
 
															+#define ERR_FRAME_JIT_OFS_FDE		(LJ_64 ? 0x20 : 0x18)
														
 
															+#define ERR_FRAME_JIT_OFS_CODE_SIZE	(LJ_64 ? 0x2c : 0x24)
														
 
															+#if LJ_TARGET_OSX
														
 
															+#define ERR_FRAME_JIT_OFS_REGISTER	ERR_FRAME_JIT_OFS_FDE
														
 
															+#else
														
 
															+#define ERR_FRAME_JIT_OFS_REGISTER	0
														
 
															+#endif
														
 
															+
														
 
															+extern void __register_frame(const void *);
														
 
															+extern void __deregister_frame(const void *);
														
 
															+
														
 
															+uint8_t *lj_err_register_mcode(void *base, size_t sz, uint8_t *info)
														
 
															+{
														
 
															+  void **handler;
														
 
															+  memcpy(info, err_frame_jit_template, sizeof(err_frame_jit_template));
														
 
															+  handler = (void *)err_unwind_jit;
														
 
															+  memcpy(info + ERR_FRAME_JIT_OFS_HANDLER, &handler, sizeof(handler));
														
 
															+  *(uint32_t *)(info + ERR_FRAME_JIT_OFS_CODE_SIZE) =
														
 
															+    (uint32_t)(sz - sizeof(err_frame_jit_template) - (info - (uint8_t *)base));
														
 
															+  __register_frame(info + ERR_FRAME_JIT_OFS_REGISTER);
														
 
															+#ifdef LUA_USE_ASSERT
														
 
															+  {
														
 
															+    struct dwarf_eh_bases ehb;
														
 
															+    lj_assertX(_Unwind_Find_FDE(info + sizeof(err_frame_jit_template)+1, &ehb),
														
 
															+	       "bad JIT unwind table registration");
														
 
															+  }
														
 
															+#endif
														
 
															+  return info + sizeof(err_frame_jit_template);
														
 
															+}
														
 
															+
														
 
															+void lj_err_deregister_mcode(void *base, size_t sz, uint8_t *info)
														
 
															+{
														
 
															+  UNUSED(base); UNUSED(sz);
														
 
															+  __deregister_frame(info + ERR_FRAME_JIT_OFS_REGISTER);
														
 
															 }
														
 
															 #endif
														
@@ -306,6 +609,7 @@ static void err_raise_ext(int errcode)
 
															 #define _US_FORCE_UNWIND		8
														
 
															 typedef struct _Unwind_Control_Block _Unwind_Control_Block;
														
 
															+#define UNWIND_EXCEPTION_TYPE	_Unwind_Control_Block
														
 
															 struct _Unwind_Control_Block {
														
 
															   uint64_t exclass;
														
@@ -364,136 +668,63 @@ LJ_FUNCA int lj_err_unwind_arm(int state, _Unwind_Control_Block *ucb,
 
															   }
														
 
															   if (__gnu_unwind_frame(ucb, ctx) != _URC_OK)
														
 
															     return _URC_FAILURE;
														
 
															+#ifdef LUA_USE_ASSERT
														
 
															+  /* We should never get here unless this is a forced unwind aka backtrace. */
														
 
															+  if (_Unwind_GetGR(ctx, 0) == 0xff33aa77) {
														
 
															+    _Unwind_SetGR(ctx, 0, 0xff33aa88);
														
 
															+  }
														
 
															+#endif
														
 
															   return _URC_CONTINUE_UNWIND;
														
 
															 }
														
 
															-#if LJ_UNWIND_EXT
														
 
															-static __thread _Unwind_Control_Block static_uex;
														
 
															+#if LJ_UNWIND_EXT && defined(LUA_USE_ASSERT)
														
 
															+typedef int (*_Unwind_Trace_Fn)(_Unwind_Context *, void *);
														
 
															+extern int _Unwind_Backtrace(_Unwind_Trace_Fn, void *);
														
 
															-static void err_raise_ext(int errcode)
														
 
															+static int err_verify_bt(_Unwind_Context *ctx, int *got)
														
 
															 {
														
 
															-  memset(&static_uex, 0, sizeof(static_uex));
														
 
															-  static_uex.exclass = LJ_UEXCLASS_MAKE(errcode);
														
 
															-  _Unwind_RaiseException(&static_uex);
														
 
															+  if (_Unwind_GetGR(ctx, 0) == 0xff33aa88) { *got = 2; }
														
 
															+  else if (*got == 0) { *got = 1; _Unwind_SetGR(ctx, 0, 0xff33aa77); }
														
 
															+  return _URC_OK;
														
 
															 }
														
 
															-#endif
														
 
															-#endif /* LJ_TARGET_ARM */
														
 
															-
														
 
															-#elif LJ_ABI_WIN
														
 
															+/* Verify that external error handling actually has a chance to work. */
														
 
															+void lj_err_verify(void)
														
 
															+{
														
 
															+  int got = 0;
														
 
															+  _Unwind_Backtrace((_Unwind_Trace_Fn)err_verify_bt, &got);
														
 
															+  lj_assertX(got == 2, "broken build: external frame unwinding enabled, but missing -funwind-tables");
														
 
															+}
														
 
															+#endif
														
 
															 /*
														
 
															-** Someone in Redmond owes me several days of my life. A lot of this is
														
 
															-** undocumented or just plain wrong on MSDN. Some of it can be gathered
														
 
															-** from 3rd party docs or must be found by trial-and-error. They really
														
 
															-** don't want you to write your own language-specific exception handler
														
 
															-** or to interact gracefully with MSVC. :-(
														
 
															+** Note: LJ_UNWIND_JIT is not implemented for 32 bit ARM.
														
 
															 **
														
 
															-** Apparently MSVC doesn't call C++ destructors for foreign exceptions
														
 
															-** unless you compile your C++ code with /EHa. Unfortunately this means
														
 
															-** catch (...) also catches things like access violations. The use of
														
 
															-** _set_se_translator doesn't really help, because it requires /EHa, too.
														
 
															+** The quirky ARM unwind API doesn't have __register_frame().
														
 
															+** A potential workaround might involve _Unwind_Backtrace.
														
 
															+** But most 32 bit ARM targets don't qualify for LJ_UNWIND_EXT, anyway,
														
 
															+** since they are built without unwind tables by default.
														
 
															 */
														
 
															-#define WIN32_LEAN_AND_MEAN
														
 
															-#include <windows.h>
														
 
															-
														
 
															-#if LJ_TARGET_X64
														
 
															-/* Taken from: http://www.nynaeve.net/?p=99 */
														
 
															-typedef struct UndocumentedDispatcherContext {
														
 
															-  ULONG64 ControlPc;
														
 
															-  ULONG64 ImageBase;
														
 
															-  PRUNTIME_FUNCTION FunctionEntry;
														
 
															-  ULONG64 EstablisherFrame;
														
 
															-  ULONG64 TargetIp;
														
 
															-  PCONTEXT ContextRecord;
														
 
															-  void (*LanguageHandler)(void);
														
 
															-  PVOID HandlerData;
														
 
															-  PUNWIND_HISTORY_TABLE HistoryTable;
														
 
															-  ULONG ScopeIndex;
														
 
															-  ULONG Fill0;
														
 
															-} UndocumentedDispatcherContext;
														
 
															-#else
														
 
															-typedef void *UndocumentedDispatcherContext;
														
 
															-#endif
														
 
															-
														
 
															-/* Another wild guess. */
														
 
															-extern void __DestructExceptionObject(EXCEPTION_RECORD *rec, int nothrow);
														
 
															-
														
 
															-#if LJ_TARGET_X64 && defined(MINGW_SDK_INIT)
														
 
															-/* Workaround for broken MinGW64 declaration. */
														
 
															-VOID RtlUnwindEx_FIXED(PVOID,PVOID,PVOID,PVOID,PVOID,PVOID) asm("RtlUnwindEx");
														
 
															-#define RtlUnwindEx RtlUnwindEx_FIXED
														
 
															-#endif
														
 
															+#endif /* LJ_TARGET_ARM */
														
 
															-#define LJ_MSVC_EXCODE		((DWORD)0xe06d7363)
														
 
															-#define LJ_GCC_EXCODE		((DWORD)0x20474343)
														
 
															-#define LJ_EXCODE		((DWORD)0xe24c4a00)
														
 
															-#define LJ_EXCODE_MAKE(c)	(LJ_EXCODE | (DWORD)(c))
														
 
															-#define LJ_EXCODE_CHECK(cl)	(((cl) ^ LJ_EXCODE) <= 0xff)
														
 
															-#define LJ_EXCODE_ERRCODE(cl)	((int)((cl) & 0xff))
														
 
															+#if LJ_UNWIND_EXT
														
 
															+static __thread struct {
														
 
															+  UNWIND_EXCEPTION_TYPE ex;
														
 
															+  global_State *g;
														
 
															+} static_uex;
														
 
															-/* Windows exception handler for interpreter frame. */
														
 
															-LJ_FUNCA int lj_err_unwind_win(EXCEPTION_RECORD *rec,
														
 
															-  void *f, CONTEXT *ctx, UndocumentedDispatcherContext *dispatch)
														
 
															+/* Raise external exception. */
														
 
															+static void err_raise_ext(global_State *g, int errcode)
														
 
															 {
														
 
															-#if LJ_TARGET_X64
														
 
															-  void *cf = f;
														
 
															-#else
														
 
															-  void *cf = (char *)f - CFRAME_OFS_SEH;
														
 
															-#endif
														
 
															-  lua_State *L = cframe_L(cf);
														
 
															-  int errcode = LJ_EXCODE_CHECK(rec->ExceptionCode) ?
														
 
															-		LJ_EXCODE_ERRCODE(rec->ExceptionCode) : LUA_ERRRUN;
														
 
															-  if ((rec->ExceptionFlags & 6)) {  /* EH_UNWINDING|EH_EXIT_UNWIND */
														
 
															-    /* Unwind internal frames. */
														
 
															-    err_unwind(L, cf, errcode);
														
 
															-  } else {
														
 
															-    void *cf2 = err_unwind(L, cf, 0);
														
 
															-    if (cf2) {  /* We catch it, so start unwinding the upper frames. */
														
 
															-      if (rec->ExceptionCode == LJ_MSVC_EXCODE ||
														
 
															-	  rec->ExceptionCode == LJ_GCC_EXCODE) {
														
 
															-#if LJ_TARGET_WINDOWS
														
 
															-	__DestructExceptionObject(rec, 1);
														
 
															-#endif
														
 
															-	setstrV(L, L->top++, lj_err_str(L, LJ_ERR_ERRCPP));
														
 
															-      } else if (!LJ_EXCODE_CHECK(rec->ExceptionCode)) {
														
 
															-	/* Don't catch access violations etc. */
														
 
															-	return 1;  /* ExceptionContinueSearch */
														
 
															-      }
														
 
															-#if LJ_TARGET_X64
														
 
															-      /* Unwind the stack and call all handlers for all lower C frames
														
 
															-      ** (including ourselves) again with EH_UNWINDING set. Then set
														
 
															-      ** rsp = cf, rax = errcode and jump to the specified target.
														
 
															-      */
														
 
															-      RtlUnwindEx(cf, (void *)((cframe_unwind_ff(cf2) && errcode != LUA_YIELD) ?
														
 
															-			       lj_vm_unwind_ff_eh :
														
 
															-			       lj_vm_unwind_c_eh),
														
 
															-		  rec, (void *)(uintptr_t)errcode, ctx, dispatch->HistoryTable);
														
 
															-      /* RtlUnwindEx should never return. */
														
 
															-#else
														
 
															-      UNUSED(ctx);
														
 
															-      UNUSED(dispatch);
														
 
															-      /* Call all handlers for all lower C frames (including ourselves) again
														
 
															-      ** with EH_UNWINDING set. Then call the specified function, passing cf
														
 
															-      ** and errcode.
														
 
															-      */
														
 
															-      lj_vm_rtlunwind(cf, (void *)rec,
														
 
															-	(cframe_unwind_ff(cf2) && errcode != LUA_YIELD) ?
														
 
															-	(void *)lj_vm_unwind_ff : (void *)lj_vm_unwind_c, errcode);
														
 
															-      /* lj_vm_rtlunwind does not return. */
														
 
															-#endif
														
 
															-    }
														
 
															-  }
														
 
															-  return 1;  /* ExceptionContinueSearch */
														
 
															+  memset(&static_uex, 0, sizeof(static_uex));
														
 
															+  static_uex.ex.exclass = LJ_UEXCLASS_MAKE(errcode);
														
 
															+  static_uex.g = g;
														
 
															+  _Unwind_RaiseException(&static_uex.ex);
														
 
															 }
														
 
															-/* Raise Windows exception. */
														
 
															-static void err_raise_ext(int errcode)
														
 
															-{
														
 
															-  RaiseException(LJ_EXCODE_MAKE(errcode), 1 /* EH_NONCONTINUABLE */, 0, NULL);
														
 
															-}
														
 
															+#endif
														
 
															 #endif
														
@@ -504,22 +735,23 @@ LJ_NOINLINE void LJ_FASTCALL lj_err_throw(lua_State *L, int errcode)
 
															 {
														
 
															   global_State *g = G(L);
														
 
															   lj_trace_abort(g);
														
 
															-  setmref(g->jit_base, NULL);
														
 
															   L->status = LUA_OK;
														
 
															 #if LJ_UNWIND_EXT
														
 
															-  err_raise_ext(errcode);
														
 
															+  err_raise_ext(g, errcode);
														
 
															   /*
														
 
															   ** A return from this function signals a corrupt C stack that cannot be
														
 
															   ** unwound. We have no choice but to call the panic function and exit.
														
 
															   **
														
 
															   ** Usually this is caused by a C function without unwind information.
														
 
															-  ** This should never happen on x64, but may happen if you've manually
														
 
															-  ** enabled LUAJIT_UNWIND_EXTERNAL and forgot to recompile *every*
														
 
															-  ** non-C++ file with -funwind-tables.
														
 
															+  ** This may happen if you've manually enabled LUAJIT_UNWIND_EXTERNAL
														
 
															+  ** and forgot to recompile *every* non-C++ file with -funwind-tables.
														
 
															   */
														
 
															   if (G(L)->panic)
														
 
															     G(L)->panic(L);
														
 
															 #else
														
 
															+#if LJ_HASJIT
														
 
															+  setmref(g->jit_base, NULL);
														
 
															+#endif
														
 
															   {
														
 
															     void *cf = err_unwind(L, NULL, errcode);
														
 
															     if (cframe_unwind_ff(cf))
														
@@ -600,7 +832,7 @@ static ptrdiff_t finderrfunc(lua_State *L)
 
															 /* Runtime error. */
														
 
															 LJ_NOINLINE void LJ_FASTCALL lj_err_run(lua_State *L)
														
 
															 {
														
 
															-  ptrdiff_t ef = finderrfunc(L);
														
 
															+  ptrdiff_t ef = (LJ_HASJIT && tvref(G(L)->jit_base)) ? 0 : finderrfunc(L);
														
 
															   if (ef) {
														
 
															     TValue *errfunc = restorestack(L, ef);
														
 
															     TValue *top = L->top;
														
@@ -619,6 +851,16 @@ LJ_NOINLINE void LJ_FASTCALL lj_err_run(lua_State *L)
 
															   lj_err_throw(L, LUA_ERRRUN);
														
 
															 }
														
 
															+#if LJ_HASJIT
														
 
															+LJ_NOINLINE void LJ_FASTCALL lj_err_trace(lua_State *L, int errcode)
														
 
															+{
														
 
															+  if (errcode == LUA_ERRRUN)
														
 
															+    lj_err_run(L);
														
 
															+  else
														
 
															+    lj_err_throw(L, errcode);
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															 /* Formatted runtime error message. */
														
 
															 LJ_NORET LJ_NOINLINE static void err_msgv(lua_State *L, ErrMsg em, ...)
														
 
															 {
														
@@ -699,25 +941,27 @@ LJ_NOINLINE void lj_err_optype_call(lua_State *L, TValue *o)
 
															 /* Error in context of caller. */
														
 
															 LJ_NOINLINE void lj_err_callermsg(lua_State *L, const char *msg)
														
 
															 {
														
 
															-  TValue *frame = L->base-1;
														
 
															-  TValue *pframe = NULL;
														
 
															-  if (frame_islua(frame)) {
														
 
															-    pframe = frame_prevl(frame);
														
 
															-  } else if (frame_iscont(frame)) {
														
 
															-    if (frame_iscont_fficb(frame)) {
														
 
															-      pframe = frame;
														
 
															-      frame = NULL;
														
 
															-    } else {
														
 
															-      pframe = frame_prevd(frame);
														
 
															+  TValue *frame = NULL, *pframe = NULL;
														
 
															+  if (!(LJ_HASJIT && tvref(G(L)->jit_base))) {
														
 
															+    frame = L->base-1;
														
 
															+    if (frame_islua(frame)) {
														
 
															+      pframe = frame_prevl(frame);
														
 
															+    } else if (frame_iscont(frame)) {
														
 
															+      if (frame_iscont_fficb(frame)) {
														
 
															+	pframe = frame;
														
 
															+	frame = NULL;
														
 
															+      } else {
														
 
															+	pframe = frame_prevd(frame);
														
 
															 #if LJ_HASFFI
														
 
															-      /* Remove frame for FFI metamethods. */
														
 
															-      if (frame_func(frame)->c.ffid >= FF_ffi_meta___index &&
														
 
															-	  frame_func(frame)->c.ffid <= FF_ffi_meta___tostring) {
														
 
															-	L->base = pframe+1;
														
 
															-	L->top = frame;
														
 
															-	setcframe_pc(cframe_raw(L->cframe), frame_contpc(frame));
														
 
															-      }
														
 
															+	/* Remove frame for FFI metamethods. */
														
 
															+	if (frame_func(frame)->c.ffid >= FF_ffi_meta___index &&
														
 
															+	    frame_func(frame)->c.ffid <= FF_ffi_meta___tostring) {
														
 
															+	  L->base = pframe+1;
														
 
															+	  L->top = frame;
														
 
															+	  setcframe_pc(cframe_raw(L->cframe), frame_contpc(frame));
														
 
															+	}
														
 
															 #endif
														
 
															+      }
														
 
															     }
														
 
															   }
														
 
															   lj_debug_addloc(L, msg, pframe, frame);
														
--- a/libs/LuaJIT/src/lj_err.h
+++ b/libs/LuaJIT/src/lj_err.h
@@ -23,7 +23,10 @@ LJ_DATA const char *lj_err_allmsg;
 
															 LJ_FUNC GCstr *lj_err_str(lua_State *L, ErrMsg em);
														
 
															 LJ_FUNCA_NORET void LJ_FASTCALL lj_err_throw(lua_State *L, int errcode);
														
 
															 LJ_FUNC_NORET void lj_err_mem(lua_State *L);
														
 
															-LJ_FUNCA_NORET void LJ_FASTCALL lj_err_run(lua_State *L);
														
 
															+LJ_FUNC_NORET void LJ_FASTCALL lj_err_run(lua_State *L);
														
 
															+#if LJ_HASJIT
														
 
															+LJ_FUNCA_NORET void LJ_FASTCALL lj_err_trace(lua_State *L, int errcode);
														
 
															+#endif
														
 
															 LJ_FUNC_NORET void lj_err_msg(lua_State *L, ErrMsg em);
														
 
															 LJ_FUNC_NORET void lj_err_lex(lua_State *L, GCstr *src, const char *tok,
														
 
															 			      BCLine line, ErrMsg em, va_list argp);
														
@@ -38,4 +41,18 @@ LJ_FUNC_NORET void lj_err_argv(lua_State *L, int narg, ErrMsg em, ...);
 
															 LJ_FUNC_NORET void lj_err_argtype(lua_State *L, int narg, const char *xname);
														
 
															 LJ_FUNC_NORET void lj_err_argt(lua_State *L, int narg, int tt);
														
 
															+#if LJ_UNWIND_JIT && !LJ_ABI_WIN
														
 
															+LJ_FUNC uint8_t *lj_err_register_mcode(void *base, size_t sz, uint8_t *info);
														
 
															+LJ_FUNC void lj_err_deregister_mcode(void *base, size_t sz, uint8_t *info);
														
 
															+#else
														
 
															+#define lj_err_register_mcode(base, sz, info)	(info)
														
 
															+#define lj_err_deregister_mcode(base, sz, info)	UNUSED(base)
														
 
															+#endif
														
 
															+
														
 
															+#if LJ_UNWIND_EXT && !LJ_ABI_WIN && defined(LUA_USE_ASSERT)
														
 
															+LJ_FUNC void lj_err_verify(void);
														
 
															+#else
														
 
															+#define lj_err_verify()		((void)0)
														
 
															+#endif
														
 
															+
														
 
															 #endif
														
--- a/libs/LuaJIT/src/lj_errmsg.h
+++ b/libs/LuaJIT/src/lj_errmsg.h
@@ -67,6 +67,7 @@ ERRDEF(PROTMT,	"cannot change a protected metatable")
 
															 ERRDEF(UNPACK,	"too many results to unpack")
														
 
															 ERRDEF(RDRSTR,	"reader function must return a string")
														
 
															 ERRDEF(PRTOSTR,	LUA_QL("tostring") " must return a string to " LUA_QL("print"))
														
 
															+ERRDEF(NUMRNG,	"number out of range")
														
 
															 ERRDEF(IDXRNG,	"index out of range")
														
 
															 ERRDEF(BASERNG,	"base out of range")
														
 
															 ERRDEF(LVLRNG,	"level out of range")
														
@@ -179,6 +180,19 @@ ERRDEF(FFI_NYIPACKBIT,	"NYI: packed bit fields")
 
															 ERRDEF(FFI_NYICALL,	"NYI: cannot call this C function (yet)")
														
 
															 #endif
														
 
															+#if LJ_HASBUFFER
														
 
															+/* String buffer errors. */
														
 
															+ERRDEF(BUFFER_SELF,	"cannot put buffer into itself")
														
 
															+ERRDEF(BUFFER_BADOPT,	"bad options table")
														
 
															+ERRDEF(BUFFER_BADENC,	"cannot serialize " LUA_QS)
														
 
															+ERRDEF(BUFFER_BADDEC,	"cannot deserialize tag 0x%02x")
														
 
															+ERRDEF(BUFFER_BADDICTX,	"cannot deserialize dictionary index %d")
														
 
															+ERRDEF(BUFFER_DEPTH,	"too deep to serialize")
														
 
															+ERRDEF(BUFFER_DUPKEY,	"duplicate table key")
														
 
															+ERRDEF(BUFFER_EOB,	"unexpected end of buffer")
														
 
															+ERRDEF(BUFFER_LEFTOV,	"left-over data in buffer")
														
 
															+#endif
														
 
															+
														
 
															 #undef ERRDEF
														
 
															 /* Detecting unused error messages:
														
--- a/libs/LuaJIT/src/lj_ffrecord.c
+++ b/libs/LuaJIT/src/lj_ffrecord.c
@@ -11,6 +11,7 @@
 
															 #if LJ_HASJIT
														
 
															 #include "lj_err.h"
														
 
															+#include "lj_buf.h"
														
 
															 #include "lj_str.h"
														
 
															 #include "lj_tab.h"
														
 
															 #include "lj_frame.h"
														
@@ -28,6 +29,7 @@
 
															 #include "lj_vm.h"
														
 
															 #include "lj_strscan.h"
														
 
															 #include "lj_strfmt.h"
														
 
															+#include "lj_serialize.h"
														
 
															 /* Some local macros to save typing. Undef'd at the end. */
														
 
															 #define IR(ref)			(&J->cur.ir[(ref)])
														
@@ -107,6 +109,10 @@ static void recff_stitch(jit_State *J)
 
															   const BCIns *pc = frame_pc(base-1);
														
 
															   TValue *pframe = frame_prevl(base-1);
														
 
															+  /* Check for this now. Throwing in lj_record_stop messes up the stack. */
														
 
															+  if (J->cur.nsnap >= (MSize)J->param[JIT_P_maxsnap])
														
 
															+    lj_trace_err(J, LJ_TRERR_SNAPOV);
														
 
															+
														
 
															   /* Move func + args up in Lua stack and insert continuation. */
														
 
															   memmove(&base[1], &base[-1-LJ_FR2], sizeof(TValue)*nslot);
														
 
															   setframe_ftsz(nframe, ((char *)nframe - (char *)pframe) + FRAME_CONT);
														
@@ -182,6 +188,14 @@ static TRef recff_bufhdr(jit_State *J)
 
															 		lj_ir_kptr(J, &J2G(J)->tmpbuf), IRBUFHDR_RESET);
														
 
															 }
														
 
															+/* Emit TMPREF. */
														
 
															+static TRef recff_tmpref(jit_State *J, TRef tr, int mode)
														
 
															+{
														
 
															+  if (!LJ_DUALNUM && tref_isinteger(tr))
														
 
															+    tr = emitir(IRTN(IR_CONV), tr, IRCONV_NUM_INT);
														
 
															+  return emitir(IRT(IR_TMPREF, IRT_PGC), tr, mode);
														
 
															+}
														
 
															+
														
 
															 /* -- Base library fast functions ----------------------------------------- */
														
 
															 static void LJ_FASTCALL recff_assert(jit_State *J, RecordFFData *rd)
														
@@ -296,7 +310,7 @@ int32_t lj_ffrecord_select_mode(jit_State *J, TRef tr, TValue *tv)
 
															     } else {
														
 
															       TRef trptr = emitir(IRT(IR_STRREF, IRT_PGC), tr, lj_ir_kint(J, 0));
														
 
															       TRef trchar = emitir(IRT(IR_XLOAD, IRT_U8), trptr, IRXLOAD_READONLY);
														
 
															-      emitir(IRTG(IR_EQ, IRT_INT), trchar, lj_ir_kint(J, '#'));
														
 
															+      emitir(IRTGI(IR_EQ), trchar, lj_ir_kint(J, '#'));
														
 
															     }
														
 
															     return 0;
														
 
															   } else {  /* select(n, ...) */
														
@@ -317,9 +331,9 @@ static void LJ_FASTCALL recff_select(jit_State *J, RecordFFData *rd)
 
															       ptrdiff_t n = (ptrdiff_t)J->maxslot;
														
 
															       if (start < 0) start += n;
														
 
															       else if (start > n) start = n;
														
 
															-      rd->nres = n - start;
														
 
															       if (start >= 1) {
														
 
															 	ptrdiff_t i;
														
 
															+	rd->nres = n - start;
														
 
															 	for (i = 0; i < n - start; i++)
														
 
															 	  J->base[i] = J->base[start+i];
														
 
															       }  /* else: Interpreter will throw. */
														
@@ -455,6 +469,7 @@ static void LJ_FASTCALL recff_pcall(jit_State *J, RecordFFData *rd)
 
															 #endif
														
 
															     lj_record_call(J, 0, J->maxslot - 1);
														
 
															     rd->nres = -1;  /* Pending call. */
														
 
															+    J->needsnap = 1;  /* Start catching on-trace errors. */
														
 
															   }  /* else: Interpreter will throw. */
														
 
															 }
														
@@ -490,6 +505,7 @@ static void LJ_FASTCALL recff_xpcall(jit_State *J, RecordFFData *rd)
 
															     if (errcode)
														
 
															       lj_err_throw(J->L, errcode);  /* Propagate errors. */
														
 
															     rd->nres = -1;  /* Pending call. */
														
 
															+    J->needsnap = 1;  /* Start catching on-trace errors. */
														
 
															   }  /* else: Interpreter will throw. */
														
 
															 }
														
@@ -505,6 +521,40 @@ static void LJ_FASTCALL recff_getfenv(jit_State *J, RecordFFData *rd)
 
															   recff_nyiu(J, rd);
														
 
															 }
														
 
															+static void LJ_FASTCALL recff_next(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+#if LJ_BE
														
 
															+  /* YAGNI: Disabled on big-endian due to issues with lj_vm_next,
														
 
															+  ** IR_HIOP, RID_RETLO/RID_RETHI and ra_destpair.
														
 
															+  */
														
 
															+  recff_nyi(J, rd);
														
 
															+#else
														
 
															+  TRef tab = J->base[0];
														
 
															+  if (tref_istab(tab)) {
														
 
															+    RecordIndex ix;
														
 
															+    cTValue *keyv;
														
 
															+    ix.tab = tab;
														
 
															+    if (tref_isnil(J->base[1])) {  /* Shortcut for start of traversal. */
														
 
															+      ix.key = lj_ir_kint(J, 0);
														
 
															+      keyv = niltvg(J2G(J));
														
 
															+    } else {
														
 
															+      TRef tmp = recff_tmpref(J, J->base[1], IRTMPREF_IN1);
														
 
															+      ix.key = lj_ir_call(J, IRCALL_lj_tab_keyindex, tab, tmp);
														
 
															+      keyv = &rd->argv[1];
														
 
															+    }
														
 
															+    copyTV(J->L, &ix.tabv, &rd->argv[0]);
														
 
															+    ix.keyv.u32.lo = lj_tab_keyindex(tabV(&ix.tabv), keyv);
														
 
															+    /* Omit the value, if not used by the caller. */
														
 
															+    ix.idxchain = (J->framedepth && frame_islua(J->L->base-1) &&
														
 
															+		   bc_b(frame_pc(J->L->base-1)[-1])-1 < 2);
														
 
															+    ix.mobj = 0;  /* We don't need the next index. */
														
 
															+    rd->nres = lj_record_next(J, &ix);
														
 
															+    J->base[0] = ix.key;
														
 
															+    J->base[1] = ix.val;
														
 
															+  }  /* else: Interpreter will throw. */
														
 
															+#endif
														
 
															+}
														
 
															+
														
 
															 /* -- Math library fast functions ----------------------------------------- */
														
 
															 static void LJ_FASTCALL recff_math_abs(jit_State *J, RecordFFData *rd)
														
@@ -707,7 +757,7 @@ static void LJ_FASTCALL recff_bit_tohex(jit_State *J, RecordFFData *rd)
 
															 #if LJ_HASFFI
														
 
															   TRef hdr = recff_bufhdr(J);
														
 
															   TRef tr = recff_bit64_tohex(J, rd, hdr);
														
 
															-  J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
														
 
															+  J->base[0] = emitir(IRTG(IR_BUFSTR, IRT_STR), tr, hdr);
														
 
															 #else
														
 
															   recff_nyiu(J, rd);  /* Don't bother working around this NYI. */
														
 
															 #endif
														
@@ -833,8 +883,8 @@ static void LJ_FASTCALL recff_string_char(jit_State *J, RecordFFData *rd)
 
															   if (i > 1) {  /* Concatenate the strings, if there's more than one. */
														
 
															     TRef hdr = recff_bufhdr(J), tr = hdr;
														
 
															     for (i = 0; J->base[i] != 0; i++)
														
 
															-      tr = emitir(IRT(IR_BUFPUT, IRT_PGC), tr, J->base[i]);
														
 
															-    J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
														
 
															+      tr = emitir(IRTG(IR_BUFPUT, IRT_PGC), tr, J->base[i]);
														
 
															+    J->base[0] = emitir(IRTG(IR_BUFSTR, IRT_STR), tr, hdr);
														
 
															   } else if (i == 0) {
														
 
															     J->base[0] = lj_ir_kstr(J, &J2G(J)->strempty);
														
 
															   }
														
@@ -852,19 +902,19 @@ static void LJ_FASTCALL recff_string_rep(jit_State *J, RecordFFData *rd)
 
															     emitir(IRTGI(vrep > 1 ? IR_GT : IR_LE), rep, lj_ir_kint(J, 1));
														
 
															     if (vrep > 1) {
														
 
															       TRef hdr2 = recff_bufhdr(J);
														
 
															-      TRef tr2 = emitir(IRT(IR_BUFPUT, IRT_PGC), hdr2, sep);
														
 
															-      tr2 = emitir(IRT(IR_BUFPUT, IRT_PGC), tr2, str);
														
 
															-      str2 = emitir(IRT(IR_BUFSTR, IRT_STR), tr2, hdr2);
														
 
															+      TRef tr2 = emitir(IRTG(IR_BUFPUT, IRT_PGC), hdr2, sep);
														
 
															+      tr2 = emitir(IRTG(IR_BUFPUT, IRT_PGC), tr2, str);
														
 
															+      str2 = emitir(IRTG(IR_BUFSTR, IRT_STR), tr2, hdr2);
														
 
															     }
														
 
															   }
														
 
															   tr = hdr = recff_bufhdr(J);
														
 
															   if (str2) {
														
 
															-    tr = emitir(IRT(IR_BUFPUT, IRT_PGC), tr, str);
														
 
															+    tr = emitir(IRTG(IR_BUFPUT, IRT_PGC), tr, str);
														
 
															     str = str2;
														
 
															     rep = emitir(IRTI(IR_ADD), rep, lj_ir_kint(J, -1));
														
 
															   }
														
 
															   tr = lj_ir_call(J, IRCALL_lj_buf_putstr_rep, tr, str, rep);
														
 
															-  J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
														
 
															+  J->base[0] = emitir(IRTG(IR_BUFSTR, IRT_STR), tr, hdr);
														
 
															 }
														
 
															 static void LJ_FASTCALL recff_string_op(jit_State *J, RecordFFData *rd)
														
@@ -872,7 +922,7 @@ static void LJ_FASTCALL recff_string_op(jit_State *J, RecordFFData *rd)
 
															   TRef str = lj_ir_tostr(J, J->base[0]);
														
 
															   TRef hdr = recff_bufhdr(J);
														
 
															   TRef tr = lj_ir_call(J, rd->data, hdr, str);
														
 
															-  J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
														
 
															+  J->base[0] = emitir(IRTG(IR_BUFSTR, IRT_STR), tr, hdr);
														
 
															 }
														
 
															 static void LJ_FASTCALL recff_string_find(jit_State *J, RecordFFData *rd)
														
@@ -935,34 +985,40 @@ static void LJ_FASTCALL recff_string_find(jit_State *J, RecordFFData *rd)
 
															   }
														
 
															 }
														
 
															-static void LJ_FASTCALL recff_string_format(jit_State *J, RecordFFData *rd)
														
 
															+static void recff_format(jit_State *J, RecordFFData *rd, TRef hdr, int sbufx)
														
 
															 {
														
 
															-  TRef trfmt = lj_ir_tostr(J, J->base[0]);
														
 
															-  GCstr *fmt = argv2str(J, &rd->argv[0]);
														
 
															-  int arg = 1;
														
 
															-  TRef hdr, tr;
														
 
															+  ptrdiff_t arg = sbufx;
														
 
															+  TRef tr = hdr, trfmt = lj_ir_tostr(J, J->base[arg]);
														
 
															+  GCstr *fmt = argv2str(J, &rd->argv[arg]);
														
 
															   FormatState fs;
														
 
															   SFormat sf;
														
 
															   /* Specialize to the format string. */
														
 
															   emitir(IRTG(IR_EQ, IRT_STR), trfmt, lj_ir_kstr(J, fmt));
														
 
															-  tr = hdr = recff_bufhdr(J);
														
 
															   lj_strfmt_init(&fs, strdata(fmt), fmt->len);
														
 
															   while ((sf = lj_strfmt_parse(&fs)) != STRFMT_EOF) {  /* Parse format. */
														
 
															-    TRef tra = sf == STRFMT_LIT ? 0 : J->base[arg++];
														
 
															+    TRef tra = sf == STRFMT_LIT ? 0 : J->base[++arg];
														
 
															     TRef trsf = lj_ir_kint(J, (int32_t)sf);
														
 
															     IRCallID id;
														
 
															     switch (STRFMT_TYPE(sf)) {
														
 
															     case STRFMT_LIT:
														
 
															-      tr = emitir(IRT(IR_BUFPUT, IRT_PGC), tr,
														
 
															+      tr = emitir(IRTG(IR_BUFPUT, IRT_PGC), tr,
														
 
															 		  lj_ir_kstr(J, lj_str_new(J->L, fs.str, fs.len)));
														
 
															       break;
														
 
															     case STRFMT_INT:
														
 
															       id = IRCALL_lj_strfmt_putfnum_int;
														
 
															     handle_int:
														
 
															-      if (!tref_isinteger(tra))
														
 
															+      if (!tref_isinteger(tra)) {
														
 
															+#if LJ_HASFFI
														
 
															+	if (tref_iscdata(tra)) {
														
 
															+	  tra = lj_crecord_loadiu64(J, tra, &rd->argv[arg]);
														
 
															+	  tr = lj_ir_call(J, IRCALL_lj_strfmt_putfxint, tr, trsf, tra);
														
 
															+	  break;
														
 
															+	}
														
 
															+#endif
														
 
															 	goto handle_num;
														
 
															+      }
														
 
															       if (sf == STRFMT_INT) { /* Shortcut for plain %d. */
														
 
															-	tr = emitir(IRT(IR_BUFPUT, IRT_PGC), tr,
														
 
															+	tr = emitir(IRTG(IR_BUFPUT, IRT_PGC), tr,
														
 
															 		    emitir(IRT(IR_TOSTR, IRT_STR), tra, IRTOSTR_INT));
														
 
															       } else {
														
 
															 #if LJ_HASFFI
														
@@ -989,10 +1045,11 @@ static void LJ_FASTCALL recff_string_format(jit_State *J, RecordFFData *rd)
 
															     case STRFMT_STR:
														
 
															       if (!tref_isstr(tra)) {
														
 
															 	recff_nyiu(J, rd);  /* NYI: __tostring and non-string types for %s. */
														
 
															+	/* NYI: also buffers. */
														
 
															 	return;
														
 
															       }
														
 
															       if (sf == STRFMT_STR)  /* Shortcut for plain %s. */
														
 
															-	tr = emitir(IRT(IR_BUFPUT, IRT_PGC), tr, tra);
														
 
															+	tr = emitir(IRTG(IR_BUFPUT, IRT_PGC), tr, tra);
														
 
															       else if ((sf & STRFMT_T_QUOTED))
														
 
															 	tr = lj_ir_call(J, IRCALL_lj_strfmt_putquoted, tr, tra);
														
 
															       else
														
@@ -1001,7 +1058,7 @@ static void LJ_FASTCALL recff_string_format(jit_State *J, RecordFFData *rd)
 
															     case STRFMT_CHAR:
														
 
															       tra = lj_opt_narrow_toint(J, tra);
														
 
															       if (sf == STRFMT_CHAR)  /* Shortcut for plain %c. */
														
 
															-	tr = emitir(IRT(IR_BUFPUT, IRT_PGC), tr,
														
 
															+	tr = emitir(IRTG(IR_BUFPUT, IRT_PGC), tr,
														
 
															 		    emitir(IRT(IR_TOSTR, IRT_STR), tra, IRTOSTR_CHAR));
														
 
															       else
														
 
															 	tr = lj_ir_call(J, IRCALL_lj_strfmt_putfchar, tr, trsf, tra);
														
@@ -1013,9 +1070,326 @@ static void LJ_FASTCALL recff_string_format(jit_State *J, RecordFFData *rd)
 
															       return;
														
 
															     }
														
 
															   }
														
 
															-  J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
														
 
															+  if (sbufx) {
														
 
															+    emitir(IRT(IR_USE, IRT_NIL), tr, 0);
														
 
															+  } else {
														
 
															+    J->base[0] = emitir(IRTG(IR_BUFSTR, IRT_STR), tr, hdr);
														
 
															+  }
														
 
															 }
														
 
															+static void LJ_FASTCALL recff_string_format(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  recff_format(J, rd, recff_bufhdr(J), 0);
														
 
															+}
														
 
															+
														
 
															+/* -- Buffer library fast functions --------------------------------------- */
														
 
															+
														
 
															+#if LJ_HASBUFFER
														
 
															+
														
 
															+static LJ_AINLINE TRef recff_sbufx_get_L(jit_State *J, TRef ud)
														
 
															+{
														
 
															+  return emitir(IRT(IR_FLOAD, IRT_PGC), ud, IRFL_SBUF_L);
														
 
															+}
														
 
															+
														
 
															+static LJ_AINLINE void recff_sbufx_set_L(jit_State *J, TRef ud, TRef val)
														
 
															+{
														
 
															+  TRef fref = emitir(IRT(IR_FREF, IRT_PGC), ud, IRFL_SBUF_L);
														
 
															+  emitir(IRT(IR_FSTORE, IRT_PGC), fref, val);
														
 
															+}
														
 
															+
														
 
															+static LJ_AINLINE TRef recff_sbufx_get_ptr(jit_State *J, TRef ud, IRFieldID fl)
														
 
															+{
														
 
															+  return emitir(IRT(IR_FLOAD, IRT_PTR), ud, fl);
														
 
															+}
														
 
															+
														
 
															+static LJ_AINLINE void recff_sbufx_set_ptr(jit_State *J, TRef ud, IRFieldID fl, TRef val)
														
 
															+{
														
 
															+  TRef fref = emitir(IRT(IR_FREF, IRT_PTR), ud, fl);
														
 
															+  emitir(IRT(IR_FSTORE, IRT_PTR), fref, val);
														
 
															+}
														
 
															+
														
 
															+static LJ_AINLINE TRef recff_sbufx_len(jit_State *J, TRef trr, TRef trw)
														
 
															+{
														
 
															+  TRef len = emitir(IRT(IR_SUB, IRT_INTP), trw, trr);
														
 
															+  if (LJ_64)
														
 
															+    len = emitir(IRTI(IR_CONV), len, (IRT_INT<<5)|IRT_INTP|IRCONV_NONE);
														
 
															+  return len;
														
 
															+}
														
 
															+
														
 
															+/* Emit typecheck for string buffer. */
														
 
															+static TRef recff_sbufx_check(jit_State *J, RecordFFData *rd, int arg)
														
 
															+{
														
 
															+  TRef trtype, ud = J->base[arg];
														
 
															+  if (!tvisbuf(&rd->argv[arg])) lj_trace_err(J, LJ_TRERR_BADTYPE);
														
 
															+  trtype = emitir(IRT(IR_FLOAD, IRT_U8), ud, IRFL_UDATA_UDTYPE);
														
 
															+  emitir(IRTGI(IR_EQ), trtype, lj_ir_kint(J, UDTYPE_BUFFER));
														
 
															+  J->needsnap = 1;
														
 
															+  return ud;
														
 
															+}
														
 
															+
														
 
															+/* Emit BUFHDR for write to extended string buffer. */
														
 
															+static TRef recff_sbufx_write(jit_State *J, TRef ud)
														
 
															+{
														
 
															+  TRef trbuf = emitir(IRT(IR_ADD, IRT_PGC), ud, lj_ir_kint(J, sizeof(GCudata)));
														
 
															+  return emitir(IRT(IR_BUFHDR, IRT_PGC), trbuf, IRBUFHDR_WRITE);
														
 
															+}
														
 
															+
														
 
															+/* Check for integer in range for the buffer API. */
														
 
															+static TRef recff_sbufx_checkint(jit_State *J, RecordFFData *rd, int arg)
														
 
															+{
														
 
															+  TRef tr = J->base[arg];
														
 
															+  TRef trlim = lj_ir_kint(J, LJ_MAX_BUF);
														
 
															+  if (tref_isinteger(tr)) {
														
 
															+    emitir(IRTGI(IR_ULE), tr, trlim);
														
 
															+  } else if (tref_isnum(tr)) {
														
 
															+    tr = emitir(IRTI(IR_CONV), tr, IRCONV_INT_NUM|IRCONV_ANY);
														
 
															+    emitir(IRTGI(IR_ULE), tr, trlim);
														
 
															+#if LJ_HASFFI
														
 
															+  } else if (tref_iscdata(tr)) {
														
 
															+    tr = lj_crecord_loadiu64(J, tr, &rd->argv[arg]);
														
 
															+    emitir(IRTG(IR_ULE, IRT_U64), tr, lj_ir_kint64(J, LJ_MAX_BUF));
														
 
															+    tr = emitir(IRTI(IR_CONV), tr, (IRT_INT<<5)|IRT_I64|IRCONV_NONE);
														
 
															+#else
														
 
															+    UNUSED(rd);
														
 
															+#endif
														
 
															+  } else {
														
 
															+    lj_trace_err(J, LJ_TRERR_BADTYPE);
														
 
															+  }
														
 
															+  return tr;
														
 
															+}
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_method_reset(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef ud = recff_sbufx_check(J, rd, 0);
														
 
															+  SBufExt *sbx = bufV(&rd->argv[0]);
														
 
															+  int iscow = (int)sbufiscow(sbx);
														
 
															+  TRef trl = recff_sbufx_get_L(J, ud);
														
 
															+  TRef trcow = emitir(IRT(IR_BAND, IRT_IGC), trl, lj_ir_kint(J, SBUF_FLAG_COW));
														
 
															+  TRef zero = lj_ir_kint(J, 0);
														
 
															+  emitir(IRTG(iscow ? IR_NE : IR_EQ, IRT_IGC), trcow, zero);
														
 
															+  if (iscow) {
														
 
															+    trl = emitir(IRT(IR_BXOR, IRT_IGC), trl,
														
 
															+		 LJ_GC64 ? lj_ir_kint64(J, SBUF_FLAG_COW) :
														
 
															+			   lj_ir_kint(J, SBUF_FLAG_COW));
														
 
															+    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_W, zero);
														
 
															+    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_E, zero);
														
 
															+    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_B, zero);
														
 
															+    recff_sbufx_set_L(J, ud, trl);
														
 
															+    emitir(IRT(IR_FSTORE, IRT_PGC),
														
 
															+	   emitir(IRT(IR_FREF, IRT_PGC), ud, IRFL_SBUF_REF), zero);
														
 
															+    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_R, zero);
														
 
															+  } else {
														
 
															+    TRef trb = recff_sbufx_get_ptr(J, ud, IRFL_SBUF_B);
														
 
															+    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_W, trb);
														
 
															+    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_R, trb);
														
 
															+  }
														
 
															+}
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_method_skip(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef ud = recff_sbufx_check(J, rd, 0);
														
 
															+  TRef trr = recff_sbufx_get_ptr(J, ud, IRFL_SBUF_R);
														
 
															+  TRef trw = recff_sbufx_get_ptr(J, ud, IRFL_SBUF_W);
														
 
															+  TRef len = recff_sbufx_len(J, trr, trw);
														
 
															+  TRef trn = recff_sbufx_checkint(J, rd, 1);
														
 
															+  len = emitir(IRTI(IR_MIN), len, trn);
														
 
															+  trr = emitir(IRT(IR_ADD, IRT_PTR), trr, len);
														
 
															+  recff_sbufx_set_ptr(J, ud, IRFL_SBUF_R, trr);
														
 
															+}
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_method_set(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef ud = recff_sbufx_check(J, rd, 0);
														
 
															+  TRef trbuf = recff_sbufx_write(J, ud);
														
 
															+  TRef tr = J->base[1];
														
 
															+  if (tref_isstr(tr)) {
														
 
															+    TRef trp = emitir(IRT(IR_STRREF, IRT_PGC), tr, lj_ir_kint(J, 0));
														
 
															+    TRef len = emitir(IRTI(IR_FLOAD), tr, IRFL_STR_LEN);
														
 
															+    lj_ir_call(J, IRCALL_lj_bufx_set, trbuf, trp, len, tr);
														
 
															+#if LJ_HASFFI
														
 
															+  } else if (tref_iscdata(tr)) {
														
 
															+    TRef trp = lj_crecord_topcvoid(J, tr, &rd->argv[1]);
														
 
															+    TRef len = recff_sbufx_checkint(J, rd, 2);
														
 
															+    lj_ir_call(J, IRCALL_lj_bufx_set, trbuf, trp, len, tr);
														
 
															+#endif
														
 
															+  }  /* else: Interpreter will throw. */
														
 
															+}
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_method_put(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef ud = recff_sbufx_check(J, rd, 0);
														
 
															+  TRef trbuf = recff_sbufx_write(J, ud);
														
 
															+  TRef tr;
														
 
															+  ptrdiff_t arg;
														
 
															+  if (!J->base[1]) return;
														
 
															+  for (arg = 1; (tr = J->base[arg]); arg++) {
														
 
															+    if (tref_isstr(tr)) {
														
 
															+      trbuf = emitir(IRTG(IR_BUFPUT, IRT_PGC), trbuf, tr);
														
 
															+    } else if (tref_isnumber(tr)) {
														
 
															+      trbuf = emitir(IRTG(IR_BUFPUT, IRT_PGC), trbuf,
														
 
															+		     emitir(IRT(IR_TOSTR, IRT_STR), tr,
														
 
															+			    tref_isnum(tr) ? IRTOSTR_NUM : IRTOSTR_INT));
														
 
															+    } else if (tref_isudata(tr)) {
														
 
															+      TRef ud2 = recff_sbufx_check(J, rd, arg);
														
 
															+      TRef trr = recff_sbufx_get_ptr(J, ud2, IRFL_SBUF_R);
														
 
															+      TRef trw = recff_sbufx_get_ptr(J, ud2, IRFL_SBUF_W);
														
 
															+      TRef len = recff_sbufx_len(J, trr, trw);
														
 
															+      emitir(IRTG(IR_NE, IRT_PGC), ud, ud2);
														
 
															+      trbuf = lj_ir_call(J, IRCALL_lj_buf_putmem, trbuf, trr, len);
														
 
															+    } else {
														
 
															+      recff_nyiu(J, rd);
														
 
															+    }
														
 
															+  }
														
 
															+  emitir(IRT(IR_USE, IRT_NIL), trbuf, 0);
														
 
															+}
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_method_putf(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef ud = recff_sbufx_check(J, rd, 0);
														
 
															+  TRef trbuf = recff_sbufx_write(J, ud);
														
 
															+  recff_format(J, rd, trbuf, 1);
														
 
															+}
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_method_get(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef ud = recff_sbufx_check(J, rd, 0);
														
 
															+  TRef trr = recff_sbufx_get_ptr(J, ud, IRFL_SBUF_R);
														
 
															+  TRef trw = recff_sbufx_get_ptr(J, ud, IRFL_SBUF_W);
														
 
															+  TRef tr;
														
 
															+  ptrdiff_t arg;
														
 
															+  if (!J->base[1]) { J->base[1] = TREF_NIL; J->base[2] = 0; }
														
 
															+  for (arg = 0; (tr = J->base[arg+1]); arg++) {
														
 
															+    TRef len = recff_sbufx_len(J, trr, trw);
														
 
															+    if (tref_isnil(tr)) {
														
 
															+      J->base[arg] = emitir(IRT(IR_XSNEW, IRT_STR), trr, len);
														
 
															+      trr = trw;
														
 
															+    } else {
														
 
															+      TRef trn = recff_sbufx_checkint(J, rd, arg+1);
														
 
															+      TRef tru;
														
 
															+      len = emitir(IRTI(IR_MIN), len, trn);
														
 
															+      tru = emitir(IRT(IR_ADD, IRT_PTR), trr, len);
														
 
															+      J->base[arg] = emitir(IRT(IR_XSNEW, IRT_STR), trr, len);
														
 
															+      trr = tru;  /* Doing the ADD before the SNEW generates better code. */
														
 
															+    }
														
 
															+    recff_sbufx_set_ptr(J, ud, IRFL_SBUF_R, trr);
														
 
															+  }
														
 
															+  rd->nres = arg;
														
 
															+}
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_method___tostring(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef ud = recff_sbufx_check(J, rd, 0);
														
 
															+  TRef trr = recff_sbufx_get_ptr(J, ud, IRFL_SBUF_R);
														
 
															+  TRef trw = recff_sbufx_get_ptr(J, ud, IRFL_SBUF_W);
														
 
															+  J->base[0] = emitir(IRT(IR_XSNEW, IRT_STR), trr, recff_sbufx_len(J, trr, trw));
														
 
															+}
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_method___len(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef ud = recff_sbufx_check(J, rd, 0);
														
 
															+  TRef trr = recff_sbufx_get_ptr(J, ud, IRFL_SBUF_R);
														
 
															+  TRef trw = recff_sbufx_get_ptr(J, ud, IRFL_SBUF_W);
														
 
															+  J->base[0] = recff_sbufx_len(J, trr, trw);
														
 
															+}
														
 
															+
														
 
															+#if LJ_HASFFI
														
 
															+static void LJ_FASTCALL recff_buffer_method_putcdata(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef ud = recff_sbufx_check(J, rd, 0);
														
 
															+  TRef trbuf = recff_sbufx_write(J, ud);
														
 
															+  TRef tr = lj_crecord_topcvoid(J, J->base[1], &rd->argv[1]);
														
 
															+  TRef len = recff_sbufx_checkint(J, rd, 2);
														
 
															+  trbuf = lj_ir_call(J, IRCALL_lj_buf_putmem, trbuf, tr, len);
														
 
															+  emitir(IRT(IR_USE, IRT_NIL), trbuf, 0);
														
 
															+}
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_method_reserve(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef ud = recff_sbufx_check(J, rd, 0);
														
 
															+  TRef trbuf = recff_sbufx_write(J, ud);
														
 
															+  TRef trsz = recff_sbufx_checkint(J, rd, 1);
														
 
															+  J->base[1] = lj_ir_call(J, IRCALL_lj_bufx_more, trbuf, trsz);
														
 
															+  J->base[0] = lj_crecord_topuint8(J, recff_sbufx_get_ptr(J, ud, IRFL_SBUF_W));
														
 
															+  rd->nres = 2;
														
 
															+}
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_method_commit(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef ud = recff_sbufx_check(J, rd, 0);
														
 
															+  TRef len = recff_sbufx_checkint(J, rd, 1);
														
 
															+  TRef trw = recff_sbufx_get_ptr(J, ud, IRFL_SBUF_W);
														
 
															+  TRef tre = recff_sbufx_get_ptr(J, ud, IRFL_SBUF_E);
														
 
															+  TRef left = emitir(IRT(IR_SUB, IRT_INTP), tre, trw);
														
 
															+  if (LJ_64)
														
 
															+    left = emitir(IRTI(IR_CONV), left, (IRT_INT<<5)|IRT_INTP|IRCONV_NONE);
														
 
															+  emitir(IRTGI(IR_ULE), len, left);
														
 
															+  trw = emitir(IRT(IR_ADD, IRT_PTR), trw, len);
														
 
															+  recff_sbufx_set_ptr(J, ud, IRFL_SBUF_W, trw);
														
 
															+}
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_method_ref(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef ud = recff_sbufx_check(J, rd, 0);
														
 
															+  TRef trr = recff_sbufx_get_ptr(J, ud, IRFL_SBUF_R);
														
 
															+  TRef trw = recff_sbufx_get_ptr(J, ud, IRFL_SBUF_W);
														
 
															+  J->base[0] = lj_crecord_topuint8(J, trr);
														
 
															+  J->base[1] = recff_sbufx_len(J, trr, trw);
														
 
															+  rd->nres = 2;
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_method_encode(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef ud = recff_sbufx_check(J, rd, 0);
														
 
															+  TRef trbuf = recff_sbufx_write(J, ud);
														
 
															+  TRef tmp = recff_tmpref(J, J->base[1], IRTMPREF_IN1);
														
 
															+  lj_ir_call(J, IRCALL_lj_serialize_put, trbuf, tmp);
														
 
															+  /* No IR_USE needed, since the call is a store. */
														
 
															+}
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_method_decode(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef ud = recff_sbufx_check(J, rd, 0);
														
 
															+  TRef trbuf = recff_sbufx_write(J, ud);
														
 
															+  TRef tmp = recff_tmpref(J, TREF_NIL, IRTMPREF_OUT1);
														
 
															+  TRef trr = lj_ir_call(J, IRCALL_lj_serialize_get, trbuf, tmp);
														
 
															+  IRType t = (IRType)lj_serialize_peektype(bufV(&rd->argv[0]));
														
 
															+  /* No IR_USE needed, since the call is a store. */
														
 
															+  J->base[0] = lj_record_vload(J, tmp, 0, t);
														
 
															+  /* The sbx->r store must be after the VLOAD type check, in case it fails. */
														
 
															+  recff_sbufx_set_ptr(J, ud, IRFL_SBUF_R, trr);
														
 
															+}
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_encode(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  TRef tmp = recff_tmpref(J, J->base[0], IRTMPREF_IN1);
														
 
															+  J->base[0] = lj_ir_call(J, IRCALL_lj_serialize_encode, tmp);
														
 
															+  /* IR_USE needed for IR_CALLA, because the encoder may throw non-OOM. */
														
 
															+  emitir(IRT(IR_USE, IRT_NIL), J->base[0], 0);
														
 
															+  UNUSED(rd);
														
 
															+}
														
 
															+
														
 
															+static void LJ_FASTCALL recff_buffer_decode(jit_State *J, RecordFFData *rd)
														
 
															+{
														
 
															+  if (tvisstr(&rd->argv[0])) {
														
 
															+    GCstr *str = strV(&rd->argv[0]);
														
 
															+    SBufExt sbx;
														
 
															+    IRType t;
														
 
															+    TRef tmp = recff_tmpref(J, TREF_NIL, IRTMPREF_OUT1);
														
 
															+    TRef tr = lj_ir_call(J, IRCALL_lj_serialize_decode, tmp, J->base[0]);
														
 
															+    /* IR_USE needed for IR_CALLA, because the decoder may throw non-OOM.
														
 
															+    ** That's why IRCALL_lj_serialize_decode needs a fake INT result.
														
 
															+    */
														
 
															+    emitir(IRT(IR_USE, IRT_NIL), tr, 0);
														
 
															+    memset(&sbx, 0, sizeof(SBufExt));
														
 
															+    lj_bufx_set_cow(J->L, &sbx, strdata(str), str->len);
														
 
															+    t = (IRType)lj_serialize_peektype(&sbx);
														
 
															+    J->base[0] = lj_record_vload(J, tmp, 0, t);
														
 
															+  }  /* else: Interpreter will throw. */
														
 
															+}
														
 
															+
														
 
															+#endif
														
 
															+
														
 
															 /* -- Table library fast functions ---------------------------------------- */
														
 
															 static void LJ_FASTCALL recff_table_insert(jit_State *J, RecordFFData *rd)
														
@@ -1054,7 +1428,7 @@ static void LJ_FASTCALL recff_table_concat(jit_State *J, RecordFFData *rd)
 
															     TRef hdr = recff_bufhdr(J);
														
 
															     TRef tr = lj_ir_call(J, IRCALL_lj_buf_puttab, hdr, tab, sep, tri, tre);
														
 
															     emitir(IRTG(IR_NE, IRT_PTR), tr, lj_ir_kptr(J, NULL));
														
 
															-    J->base[0] = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
														
 
															+    J->base[0] = emitir(IRTG(IR_BUFSTR, IRT_STR), tr, hdr);
														
 
															   }  /* else: Interpreter will throw. */
														
 
															   UNUSED(rd);
														
 
															 }
														
--- a/libs/LuaJIT/src/lj_frame.h
+++ b/libs/LuaJIT/src/lj_frame.h
@@ -192,12 +192,12 @@ enum { LJ_CONT_TAILCALL, LJ_CONT_FFI_CALLBACK };  /* Special continuations. */
 
															 #endif
														
 
															 #define CFRAME_SHIFT_MULTRES	3
														
 
															 #elif LJ_TARGET_ARM64
														
 
															-#define CFRAME_OFS_ERRF		196
														
 
															-#define CFRAME_OFS_NRES		200
														
 
															-#define CFRAME_OFS_PREV		160
														
 
															-#define CFRAME_OFS_L		176
														
 
															-#define CFRAME_OFS_PC		168
														
 
															-#define CFRAME_OFS_MULTRES	192
														
 
															+#define CFRAME_OFS_ERRF		36
														
 
															+#define CFRAME_OFS_NRES		40
														
 
															+#define CFRAME_OFS_PREV		0
														
 
															+#define CFRAME_OFS_L		16
														
 
															+#define CFRAME_OFS_PC		8
														
 
															+#define CFRAME_OFS_MULTRES	32
														
 
															 #define CFRAME_SIZE		208
														
 
															 #define CFRAME_SHIFT_MULTRES	3
														
 
															 #elif LJ_TARGET_PPC
														
--- a/libs/LuaJIT/src/lj_gc.c
+++ b/libs/LuaJIT/src/lj_gc.c
@@ -65,6 +65,15 @@ static void gc_mark(global_State *g, GCobj *o)
 
															     gray2black(o);  /* Userdata are never gray. */
														
 
															     if (mt) gc_markobj(g, mt);
														
 
															     gc_markobj(g, tabref(gco2ud(o)->env));
														
 
															+    if (LJ_HASBUFFER && gco2ud(o)->udtype == UDTYPE_BUFFER) {
														
 
															+      SBufExt *sbx = (SBufExt *)uddata(gco2ud(o));
														
 
															+      if (sbufiscow(sbx) && gcref(sbx->cowref))
														
 
															+	gc_markobj(g, gcref(sbx->cowref));
														
 
															+      if (gcref(sbx->dict_str))
														
 
															+	gc_markobj(g, gcref(sbx->dict_str));
														
 
															+      if (gcref(sbx->dict_mt))
														
 
															+	gc_markobj(g, gcref(sbx->dict_mt));
														
 
															+    }
														
 
															   } else if (LJ_UNLIKELY(gct == ~LJ_TUPVAL)) {
														
 
															     GCupval *uv = gco2uv(o);
														
 
															     gc_marktv(g, uvval(uv));
														
--- a/libs/LuaJIT/src/lj_ir.c
+++ b/libs/LuaJIT/src/lj_ir.c
@@ -30,6 +30,7 @@
 
															 #endif
														
 
															 #include "lj_vm.h"
														
 
															 #include "lj_strscan.h"
														
 
															+#include "lj_serialize.h"
														
 
															 #include "lj_strfmt.h"
														
 
															 #include "lj_prng.h"
														
@@ -147,7 +148,7 @@ TRef lj_ir_call(jit_State *J, IRCallID id, ...)
 
															 }
														
 
															 /* Load field of type t from GG_State + offset. Must be 32 bit aligned. */
														
 
															-LJ_FUNC TRef lj_ir_ggfload(jit_State *J, IRType t, uintptr_t ofs)
														
 
															+TRef lj_ir_ggfload(jit_State *J, IRType t, uintptr_t ofs)
														
 
															 {
														
 
															   lj_assertJ((ofs & 3) == 0, "unaligned GG_State field offset");
														
 
															   ofs >>= 2;
														
--- a/libs/LuaJIT/src/lj_ir.h
+++ b/libs/LuaJIT/src/lj_ir.h
@@ -95,6 +95,7 @@
 
															   _(UREFO,	LW, ref, lit) \
														
 
															   _(UREFC,	LW, ref, lit) \
														
 
															   _(FREF,	R , ref, lit) \
														
 
															+  _(TMPREF,	S , ref, lit) \
														
 
															   _(STRREF,	N , ref, ref) \
														
 
															   _(LREF,	L , ___, ___) \
														
 
															   \
														
@@ -105,7 +106,7 @@
 
															   _(FLOAD,	L , ref, lit) \
														
 
															   _(XLOAD,	L , ref, lit) \
														
 
															   _(SLOAD,	L , lit, lit) \
														
 
															-  _(VLOAD,	L , ref, ___) \
														
 
															+  _(VLOAD,	L , ref, lit) \
														
 
															   _(ALEN,	L , ref, ref) \
														
 
															   \
														
 
															   _(ASTORE,	S , ref, ref) \
														
@@ -124,8 +125,8 @@
 
															   \
														
 
															   /* Buffer operations. */ \
														
 
															   _(BUFHDR,	L , ref, lit) \
														
 
															-  _(BUFPUT,	L , ref, ref) \
														
 
															-  _(BUFSTR,	A , ref, ref) \
														
 
															+  _(BUFPUT,	LW, ref, ref) \
														
 
															+  _(BUFSTR,	AW, ref, ref) \
														
 
															   \
														
 
															   /* Barriers. */ \
														
 
															   _(TBAR,	S , ref, ___) \
														
@@ -139,9 +140,9 @@
 
															   _(STRTO,	N , ref, ___) \
														
 
															   \
														
 
															   /* Calls. */ \
														
 
															-  _(CALLN,	N , ref, lit) \
														
 
															-  _(CALLA,	A , ref, lit) \
														
 
															-  _(CALLL,	L , ref, lit) \
														
 
															+  _(CALLN,	NW, ref, lit) \
														
 
															+  _(CALLA,	AW, ref, lit) \
														
 
															+  _(CALLL,	LW, ref, lit) \
														
 
															   _(CALLS,	S , ref, lit) \
														
 
															   _(CALLXS,	S , ref, ref) \
														
 
															   _(CARG,	N , ref, ref) \
														
@@ -204,9 +205,15 @@ IRFPMDEF(FPMENUM)
 
															   _(UDATA_META,	offsetof(GCudata, metatable)) \
														
 
															   _(UDATA_UDTYPE, offsetof(GCudata, udtype)) \
														
 
															   _(UDATA_FILE,	sizeof(GCudata)) \
														
 
															+  _(SBUF_W,	sizeof(GCudata) + offsetof(SBufExt, w)) \
														
 
															+  _(SBUF_E,	sizeof(GCudata) + offsetof(SBufExt, e)) \
														
 
															+  _(SBUF_B,	sizeof(GCudata) + offsetof(SBufExt, b)) \
														
 
															+  _(SBUF_L,	sizeof(GCudata) + offsetof(SBufExt, L)) \
														
 
															+  _(SBUF_REF,	sizeof(GCudata) + offsetof(SBufExt, cowref)) \
														
 
															+  _(SBUF_R,	sizeof(GCudata) + offsetof(SBufExt, r)) \
														
 
															   _(CDATA_CTYPEID, offsetof(GCcdata, ctypeid)) \
														
 
															   _(CDATA_PTR,	sizeof(GCcdata)) \
														
 
															-  _(CDATA_INT, sizeof(GCcdata)) \
														
 
															+  _(CDATA_INT,	sizeof(GCcdata)) \
														
 
															   _(CDATA_INT64, sizeof(GCcdata)) \
														
 
															   _(CDATA_INT64_4, sizeof(GCcdata) + 4)
														
@@ -217,6 +224,11 @@ IRFLDEF(FLENUM)
 
															   IRFL__MAX
														
 
															 } IRFieldID;
														
 
															+/* TMPREF mode bits, stored in op2. */
														
 
															+#define IRTMPREF_IN1		0x01	/* First input value. */
														
 
															+#define IRTMPREF_OUT1		0x02	/* First output value. */
														
 
															+#define IRTMPREF_OUT2		0x04	/* Second output value. */
														
 
															+
														
 
															 /* SLOAD mode bits, stored in op2. */
														
 
															 #define IRSLOAD_PARENT		0x01	/* Coalesce with parent trace. */
														
 
															 #define IRSLOAD_FRAME		0x02	/* Load 32 bits of ftsz. */
														
@@ -224,15 +236,17 @@ IRFLDEF(FLENUM)
 
															 #define IRSLOAD_CONVERT		0x08	/* Number to integer conversion. */
														
 
															 #define IRSLOAD_READONLY	0x10	/* Read-only, omit slot store. */
														
 
															 #define IRSLOAD_INHERIT		0x20	/* Inherited by exits/side traces. */
														
 
															+#define IRSLOAD_KEYINDEX	0x40	/* Table traversal key index. */
														
 
															-/* XLOAD mode, stored in op2. */
														
 
															-#define IRXLOAD_READONLY	1	/* Load from read-only data. */
														
 
															-#define IRXLOAD_VOLATILE	2	/* Load from volatile data. */
														
 
															-#define IRXLOAD_UNALIGNED	4	/* Unaligned load. */
														
 
															+/* XLOAD mode bits, stored in op2. */
														
 
															+#define IRXLOAD_READONLY	0x01	/* Load from read-only data. */
														
 
															+#define IRXLOAD_VOLATILE	0x02	/* Load from volatile data. */
														
 
															+#define IRXLOAD_UNALIGNED	0x04	/* Unaligned load. */
														
 
															 /* BUFHDR mode, stored in op2. */
														
 
															 #define IRBUFHDR_RESET		0	/* Reset buffer. */
														
 
															 #define IRBUFHDR_APPEND		1	/* Append to buffer. */
														
 
															+#define IRBUFHDR_WRITE		2	/* Write to string buffer. */
														
 
															 /* CONV mode, stored in op2. */
														
 
															 #define IRCONV_SRCMASK		0x001f	/* Source IRType. */
														
@@ -249,6 +263,7 @@ IRFLDEF(FLENUM)
 
															 #define IRCONV_ANY    (1<<IRCONV_CSH)	/* Any FP number is ok. */
														
 
															 #define IRCONV_INDEX  (2<<IRCONV_CSH)	/* Check + special backprop rules. */
														
 
															 #define IRCONV_CHECK  (3<<IRCONV_CSH)	/* Number checked for integerness. */
														
 
															+#define IRCONV_NONE   IRCONV_ANY	/* INT|*64 no conv, but change type. */
														
 
															 /* TOSTR mode, stored in op2. */
														
 
															 #define IRTOSTR_INT		0	/* Convert integer to string. */
														
@@ -481,6 +496,7 @@ typedef uint32_t TRef;
 
															 #define TREF_REFMASK		0x0000ffff
														
 
															 #define TREF_FRAME		0x00010000
														
 
															 #define TREF_CONT		0x00020000
														
 
															+#define TREF_KEYINDEX		0x00100000
														
 
															 #define TREF(ref, t)		((TRef)((ref) + ((t)<<24)))
														
--- a/libs/LuaJIT/src/lj_ircall.h
+++ b/libs/LuaJIT/src/lj_ircall.h
@@ -30,10 +30,12 @@ typedef struct CCallInfo {
 
															 #define CCI_CALL_L		(IR_CALLL << CCI_OPSHIFT)
														
 
															 #define CCI_CALL_S		(IR_CALLS << CCI_OPSHIFT)
														
 
															 #define CCI_CALL_FN		(CCI_CALL_N|CCI_CC_FASTCALL)
														
 
															+#define CCI_CALL_FA		(CCI_CALL_A|CCI_CC_FASTCALL)
														
 
															 #define CCI_CALL_FL		(CCI_CALL_L|CCI_CC_FASTCALL)
														
 
															 #define CCI_CALL_FS		(CCI_CALL_S|CCI_CC_FASTCALL)
														
 
															 /* C call info flags. */
														
 
															+#define CCI_T			(IRT_GUARD << CCI_OTSHIFT)  /* May throw. */
														
 
															 #define CCI_L			0x0100	/* Implicit L arg. */
														
 
															 #define CCI_CASTU64		0x0200	/* Cast u64 result to number. */
														
 
															 #define CCI_NOFPRCLOBBER	0x0400	/* Does not clobber any FPRs. */
														
@@ -111,6 +113,18 @@ typedef struct CCallInfo {
 
															 #define IRCALLCOND_FFI32(x)		NULL
														
 
															 #endif
														
 
															+#if LJ_HASBUFFER
														
 
															+#define IRCALLCOND_BUFFER(x)		x
														
 
															+#else
														
 
															+#define IRCALLCOND_BUFFER(x)		NULL
														
 
															+#endif
														
 
															+
														
 
															+#if LJ_HASBUFFER && LJ_HASFFI
														
 
															+#define IRCALLCOND_BUFFFI(x)		x
														
 
															+#else
														
 
															+#define IRCALLCOND_BUFFFI(x)		NULL
														
 
															+#endif
														
 
															+
														
 
															 #if LJ_SOFTFP
														
 
															 #define XA_FP		CCI_XA
														
 
															 #define XA2_FP		(CCI_XA+CCI_XA)
														
@@ -139,39 +153,47 @@ typedef struct CCallInfo {
 
															 #define IRCALLDEF(_) \
														
 
															   _(ANY,	lj_str_cmp,		2,  FN, INT, CCI_NOFPRCLOBBER) \
														
 
															   _(ANY,	lj_str_find,		4,   N, PGC, 0) \
														
 
															-  _(ANY,	lj_str_new,		3,   S, STR, CCI_L) \
														
 
															+  _(ANY,	lj_str_new,		3,   S, STR, CCI_L|CCI_T) \
														
 
															   _(ANY,	lj_strscan_num,		2,  FN, INT, 0) \
														
 
															-  _(ANY,	lj_strfmt_int,		2,  FN, STR, CCI_L) \
														
 
															-  _(ANY,	lj_strfmt_num,		2,  FN, STR, CCI_L) \
														
 
															-  _(ANY,	lj_strfmt_char,		2,  FN, STR, CCI_L) \
														
 
															-  _(ANY,	lj_strfmt_putint,	2,  FL, PGC, 0) \
														
 
															-  _(ANY,	lj_strfmt_putnum,	2,  FL, PGC, 0) \
														
 
															-  _(ANY,	lj_strfmt_putquoted,	2,  FL, PGC, 0) \
														
 
															-  _(ANY,	lj_strfmt_putfxint,	3,   L, PGC, XA_64) \
														
 
															-  _(ANY,	lj_strfmt_putfnum_int,	3,   L, PGC, XA_FP) \
														
 
															-  _(ANY,	lj_strfmt_putfnum_uint,	3,   L, PGC, XA_FP) \
														
 
															-  _(ANY,	lj_strfmt_putfnum,	3,   L, PGC, XA_FP) \
														
 
															-  _(ANY,	lj_strfmt_putfstr,	3,   L, PGC, 0) \
														
 
															-  _(ANY,	lj_strfmt_putfchar,	3,   L, PGC, 0) \
														
 
															-  _(ANY,	lj_buf_putmem,		3,   S, PGC, 0) \
														
 
															-  _(ANY,	lj_buf_putstr,		2,  FL, PGC, 0) \
														
 
															-  _(ANY,	lj_buf_putchar,		2,  FL, PGC, 0) \
														
 
															-  _(ANY,	lj_buf_putstr_reverse,	2,  FL, PGC, 0) \
														
 
															-  _(ANY,	lj_buf_putstr_lower,	2,  FL, PGC, 0) \
														
 
															-  _(ANY,	lj_buf_putstr_upper,	2,  FL, PGC, 0) \
														
 
															-  _(ANY,	lj_buf_putstr_rep,	3,   L, PGC, 0) \
														
 
															-  _(ANY,	lj_buf_puttab,		5,   L, PGC, 0) \
														
 
															-  _(ANY,	lj_buf_tostr,		1,  FL, STR, 0) \
														
 
															-  _(ANY,	lj_tab_new_ah,		3,   A, TAB, CCI_L) \
														
 
															-  _(ANY,	lj_tab_new1,		2,  FS, TAB, CCI_L) \
														
 
															-  _(ANY,	lj_tab_dup,		2,  FS, TAB, CCI_L) \
														
 
															+  _(ANY,	lj_strfmt_int,		2,  FN, STR, CCI_L|CCI_T) \
														
 
															+  _(ANY,	lj_strfmt_num,		2,  FN, STR, CCI_L|CCI_T) \
														
 
															+  _(ANY,	lj_strfmt_char,		2,  FN, STR, CCI_L|CCI_T) \
														
 
															+  _(ANY,	lj_strfmt_putint,	2,  FL, PGC, CCI_T) \
														
 
															+  _(ANY,	lj_strfmt_putnum,	2,  FL, PGC, CCI_T) \
														
 
															+  _(ANY,	lj_strfmt_putquoted,	2,  FL, PGC, CCI_T) \
														
 
															+  _(ANY,	lj_strfmt_putfxint,	3,   L, PGC, XA_64|CCI_T) \
														
 
															+  _(ANY,	lj_strfmt_putfnum_int,	3,   L, PGC, XA_FP|CCI_T) \
														
 
															+  _(ANY,	lj_strfmt_putfnum_uint,	3,   L, PGC, XA_FP|CCI_T) \
														
 
															+  _(ANY,	lj_strfmt_putfnum,	3,   L, PGC, XA_FP|CCI_T) \
														
 
															+  _(ANY,	lj_strfmt_putfstr,	3,   L, PGC, CCI_T) \
														
 
															+  _(ANY,	lj_strfmt_putfchar,	3,   L, PGC, CCI_T) \
														
 
															+  _(ANY,	lj_buf_putmem,		3,   S, PGC, CCI_T) \
														
 
															+  _(ANY,	lj_buf_putstr,		2,  FL, PGC, CCI_T) \
														
 
															+  _(ANY,	lj_buf_putchar,		2,  FL, PGC, CCI_T) \
														
 
															+  _(ANY,	lj_buf_putstr_reverse,	2,  FL, PGC, CCI_T) \
														
 
															+  _(ANY,	lj_buf_putstr_lower,	2,  FL, PGC, CCI_T) \
														
 
															+  _(ANY,	lj_buf_putstr_upper,	2,  FL, PGC, CCI_T) \
														
 
															+  _(ANY,	lj_buf_putstr_rep,	3,   L, PGC, CCI_T) \
														
 
															+  _(ANY,	lj_buf_puttab,		5,   L, PGC, CCI_T) \
														
 
															+  _(BUFFER,	lj_bufx_set,		4,   S, NIL, 0) \
														
 
															+  _(BUFFFI,	lj_bufx_more,		2,  FS, INT, CCI_T) \
														
 
															+  _(BUFFER,	lj_serialize_put,	2,  FS, PGC, CCI_T) \
														
 
															+  _(BUFFER,	lj_serialize_get,	2,  FS, PTR, CCI_T) \
														
 
															+  _(BUFFER,	lj_serialize_encode,	2,  FA, STR, CCI_L|CCI_T) \
														
 
															+  _(BUFFER,	lj_serialize_decode,	3,   A, INT, CCI_L|CCI_T) \
														
 
															+  _(ANY,	lj_buf_tostr,		1,  FL, STR, CCI_T) \
														
 
															+  _(ANY,	lj_tab_new_ah,		3,   A, TAB, CCI_L|CCI_T) \
														
 
															+  _(ANY,	lj_tab_new1,		2,  FA, TAB, CCI_L|CCI_T) \
														
 
															+  _(ANY,	lj_tab_dup,		2,  FA, TAB, CCI_L|CCI_T) \
														
 
															   _(ANY,	lj_tab_clear,		1,  FS, NIL, 0) \
														
 
															-  _(ANY,	lj_tab_newkey,		3,   S, PGC, CCI_L) \
														
 
															+  _(ANY,	lj_tab_newkey,		3,   S, PGC, CCI_L|CCI_T) \
														
 
															+  _(ANY,	lj_tab_keyindex,	2,  FL, INT, 0) \
														
 
															+  _(ANY,	lj_vm_next,		2,  FL, PTR, 0) \
														
 
															   _(ANY,	lj_tab_len,		1,  FL, INT, 0) \
														
 
															   _(ANY,	lj_tab_len_hint,	2,  FL, INT, 0) \
														
 
															   _(ANY,	lj_gc_step_jit,		2,  FS, NIL, CCI_L) \
														
 
															   _(ANY,	lj_gc_barrieruv,	2,  FS, NIL, 0) \
														
 
															-  _(ANY,	lj_mem_newgco,		2,  FS, PGC, CCI_L) \
														
 
															+  _(ANY,	lj_mem_newgco,		2,  FA, PGC, CCI_L|CCI_T) \
														
 
															   _(ANY,	lj_prng_u64d,		1,  FS, NUM, CCI_CASTU64) \
														
 
															   _(ANY,	lj_vm_modi,		2,  FN, INT, 0) \
														
 
															   _(ANY,	log10,			1,   N, NUM, XA_FP) \
														
--- a/libs/LuaJIT/src/lj_iropt.h
+++ b/libs/LuaJIT/src/lj_iropt.h
@@ -124,6 +124,7 @@ LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_alen(jit_State *J);
 
															 LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_hrefk(jit_State *J);
														
 
															 LJ_FUNC int LJ_FASTCALL lj_opt_fwd_href_nokey(jit_State *J);
														
 
															 LJ_FUNC int LJ_FASTCALL lj_opt_fwd_tptr(jit_State *J, IRRef lim);
														
 
															+LJ_FUNC int LJ_FASTCALL lj_opt_fwd_sbuf(jit_State *J, IRRef lim);
														
 
															 LJ_FUNC int lj_opt_fwd_wasnonnil(jit_State *J, IROpT loadop, IRRef xref);
														
 
															 /* Dead-store elimination. */
														
--- a/libs/LuaJIT/src/lj_jit.h
+++ b/libs/LuaJIT/src/lj_jit.h
@@ -150,6 +150,7 @@ typedef enum {
 
															   LJ_TRACE_IDLE,	/* Trace compiler idle. */
														
 
															   LJ_TRACE_ACTIVE = 0x10,
														
 
															   LJ_TRACE_RECORD,	/* Bytecode recording active. */
														
 
															+  LJ_TRACE_RECORD_1ST,	/* Record 1st instruction, too. */
														
 
															   LJ_TRACE_START,	/* New trace started. */
														
 
															   LJ_TRACE_END,		/* End of trace. */
														
 
															   LJ_TRACE_ASM,		/* Assemble trace. */
														
@@ -184,6 +185,7 @@ typedef struct MCLink {
 
															 typedef struct SnapShot {
														
 
															   uint32_t mapofs;	/* Offset into snapshot map. */
														
 
															   IRRef1 ref;		/* First IR ref for this snapshot. */
														
 
															+  uint16_t mcofs;	/* Offset into machine code in MCode units. */
														
 
															   uint8_t nslots;	/* Number of valid slots. */
														
 
															   uint8_t topslot;	/* Maximum frame extent. */
														
 
															   uint8_t nent;		/* Number of compressed entries. */
														
@@ -199,12 +201,15 @@ typedef uint32_t SnapEntry;
 
															 #define SNAP_CONT		0x020000	/* Continuation slot. */
														
 
															 #define SNAP_NORESTORE		0x040000	/* No need to restore slot. */
														
 
															 #define SNAP_SOFTFPNUM		0x080000	/* Soft-float number. */
														
 
															+#define SNAP_KEYINDEX		0x100000	/* Traversal key index. */
														
 
															 LJ_STATIC_ASSERT(SNAP_FRAME == TREF_FRAME);
														
 
															 LJ_STATIC_ASSERT(SNAP_CONT == TREF_CONT);
														
 
															+LJ_STATIC_ASSERT(SNAP_KEYINDEX == TREF_KEYINDEX);
														
 
															 #define SNAP(slot, flags, ref)	(((SnapEntry)(slot) << 24) + (flags) + (ref))
														
 
															 #define SNAP_TR(slot, tr) \
														
 
															-  (((SnapEntry)(slot) << 24) + ((tr) & (TREF_CONT|TREF_FRAME|TREF_REFMASK)))
														
 
															+  (((SnapEntry)(slot) << 24) + \
														
 
															+   ((tr) & (TREF_KEYINDEX|TREF_CONT|TREF_FRAME|TREF_REFMASK)))
														
 
															 #if !LJ_FR2
														
 
															 #define SNAP_MKPC(pc)		((SnapEntry)u32ptr(pc))
														
 
															 #endif
														
@@ -485,6 +490,7 @@ typedef struct jit_State {
 
															   const BCIns *startpc;	/* Bytecode PC of starting instruction. */
														
 
															   TraceNo parent;	/* Parent of current side trace (0 for root traces). */
														
 
															   ExitNo exitno;	/* Exit number in parent of current side trace. */
														
 
															+  int exitcode;		/* Exit code from unwound trace. */
														
 
															   BCIns *patchpc;	/* PC for pending re-patch. */
														
 
															   BCIns patchins;	/* Instruction for pending re-patch. */
														
--- a/libs/LuaJIT/src/lj_lex.c
+++ b/libs/LuaJIT/src/lj_lex.c
@@ -105,7 +105,7 @@ static void lex_number(LexState *ls, TValue *tv)
 
															     lex_savenext(ls);
														
 
															   }
														
 
															   lex_save(ls, '\0');
														
 
															-  fmt = lj_strscan_scan((const uint8_t *)sbufB(&ls->sb), sbuflen(&ls->sb)-1, tv,
														
 
															+  fmt = lj_strscan_scan((const uint8_t *)ls->sb.b, sbuflen(&ls->sb)-1, tv,
														
 
															 	  (LJ_DUALNUM ? STRSCAN_OPT_TOINT : STRSCAN_OPT_TONUM) |
														
 
															 	  (LJ_HASFFI ? (STRSCAN_OPT_LL|STRSCAN_OPT_IMAG) : 0));
														
 
															   if (LJ_DUALNUM && fmt == STRSCAN_INT) {
														
@@ -118,11 +118,7 @@ static void lex_number(LexState *ls, TValue *tv)
 
															     GCcdata *cd;
														
 
															     lj_assertLS(fmt == STRSCAN_I64 || fmt == STRSCAN_U64 || fmt == STRSCAN_IMAG,
														
 
															 		"unexpected number format %d", fmt);
														
 
															-    if (!ctype_ctsG(G(L))) {
														
 
															-      ptrdiff_t oldtop = savestack(L, L->top);
														
 
															-      luaopen_ffi(L);  /* Load FFI library on-demand. */
														
 
															-      L->top = restorestack(L, oldtop);
														
 
															-    }
														
 
															+    ctype_loadffi(L);
														
 
															     if (fmt == STRSCAN_IMAG) {
														
 
															       cd = lj_cdata_new_(L, CTID_COMPLEX_DOUBLE, 2*sizeof(double));
														
 
															       ((double *)cdataptr(cd))[0] = 0;
														
@@ -180,7 +176,7 @@ static void lex_longstring(LexState *ls, TValue *tv, int sep)
 
															     }
														
 
															   } endloop:
														
 
															   if (tv) {
														
 
															-    GCstr *str = lj_parse_keepstr(ls, sbufB(&ls->sb) + (2 + (MSize)sep),
														
 
															+    GCstr *str = lj_parse_keepstr(ls, ls->sb.b + (2 + (MSize)sep),
														
 
															 				      sbuflen(&ls->sb) - 2*(2 + (MSize)sep));
														
 
															     setstrV(ls->L, tv, str);
														
 
															   }
														
@@ -286,7 +282,7 @@ static void lex_string(LexState *ls, TValue *tv)
 
															   }
														
 
															   lex_savenext(ls);  /* Skip trailing delimiter. */
														
 
															   setstrV(ls->L, tv,
														
 
															-	  lj_parse_keepstr(ls, sbufB(&ls->sb)+1, sbuflen(&ls->sb)-2));
														
 
															+	  lj_parse_keepstr(ls, ls->sb.b+1, sbuflen(&ls->sb)-2));
														
 
															 }
														
 
															 /* -- Main lexical scanner ------------------------------------------------ */
														
@@ -306,7 +302,7 @@ static LexToken lex_scan(LexState *ls, TValue *tv)
 
															       do {
														
 
															 	lex_savenext(ls);
														
 
															       } while (lj_char_isident(ls->c));
														
 
															-      s = lj_parse_keepstr(ls, sbufB(&ls->sb), sbuflen(&ls->sb));
														
 
															+      s = lj_parse_keepstr(ls, ls->sb.b, sbuflen(&ls->sb));
														
 
															       setstrV(ls->L, tv, s);
														
 
															       if (s->reserved > 0)  /* Reserved word? */
														
 
															 	return TK_OFS + s->reserved;
														
@@ -496,7 +492,7 @@ void lj_lex_error(LexState *ls, LexToken tok, ErrMsg em, ...)
 
															     tokstr = NULL;
														
 
															   } else if (tok == TK_name || tok == TK_string || tok == TK_number) {
														
 
															     lex_save(ls, '\0');
														
 
															-    tokstr = sbufB(&ls->sb);
														
 
															+    tokstr = ls->sb.b;
														
 
															   } else {
														
 
															     tokstr = lj_lex_token2str(ls, tok);
														
 
															   }
														
--- a/libs/LuaJIT/src/lj_lib.c
+++ b/libs/LuaJIT/src/lj_lib.c
@@ -16,6 +16,9 @@
 
															 #include "lj_func.h"
														
 
															 #include "lj_bc.h"
														
 
															 #include "lj_dispatch.h"
														
 
															+#if LJ_HASFFI
														
 
															+#include "lj_ctype.h"
														
 
															+#endif
														
 
															 #include "lj_vm.h"
														
 
															 #include "lj_strscan.h"
														
 
															 #include "lj_strfmt.h"
														
@@ -301,3 +304,56 @@ int lj_lib_checkopt(lua_State *L, int narg, int def, const char *lst)
 
															   return def;
														
 
															 }
														
 
															+/* -- Strict type checks -------------------------------------------------- */
														
 
															+
														
 
															+/* The following type checks do not coerce between strings and numbers.
														
 
															+** And they handle plain int64_t/uint64_t FFI numbers, too.
														
 
															+*/
														
 
															+
														
 
															+#if LJ_HASBUFFER
														
 
															+GCstr *lj_lib_checkstrx(lua_State *L, int narg)
														
 
															+{
														
 
															+  TValue *o = L->base + narg-1;
														
 
															+  if (!(o < L->top && tvisstr(o))) lj_err_argt(L, narg, LUA_TSTRING);
														
 
															+  return strV(o);
														
 
															+}
														
 
															+
														
 
															+int32_t lj_lib_checkintrange(lua_State *L, int narg, int32_t a, int32_t b)
														
 
															+{
														
 
															+  TValue *o = L->base + narg-1;
														
 
															+  lj_assertL(b >= 0, "expected range must be non-negative");
														
 
															+  if (o < L->top) {
														
 
															+    if (LJ_LIKELY(tvisint(o))) {
														
 
															+      int32_t i = intV(o);
														
 
															+      if (i >= a && i <= b) return i;
														
 
															+    } else if (LJ_LIKELY(tvisnum(o))) {
														
 
															+      /* For performance reasons, this doesn't check for integerness or
														
 
															+      ** integer overflow. Overflow detection still works, since all FPUs
														
 
															+      ** return either MININT or MAXINT, which is then out of range.
														
 
															+      */
														
 
															+      int32_t i = (int32_t)numV(o);
														
 
															+      if (i >= a && i <= b) return i;
														
 
															+#if LJ_HASFFI
														
 
															+    } else if (tviscdata(o)) {
														
 
															+      GCcdata *cd = cdataV(o);
														
 
															+      if (cd->ctypeid == CTID_INT64) {
														
 
															+	int64_t i = *(int64_t *)cdataptr(cd);
														
 
															+	if (i >= (int64_t)a && i <= (int64_t)b) return (int32_t)i;
														
 
															+      } else if (cd->ctypeid == CTID_UINT64) {
														
 
															+	uint64_t i = *(uint64_t *)cdataptr(cd);
														
 
															+	if ((a < 0 || i >= (uint64_t)a) && i <= (uint64_t)b) return (int32_t)i;
														
 
															+      } else {
														
 
															+	goto badtype;
														
 
															+      }
														
 
															+#endif
														
 
															+    } else {
														
 
															+      goto badtype;
														
 
															+    }
														
 
															+    lj_err_arg(L, narg, LJ_ERR_NUMRNG);
														
 
															+  }
														
 
															+badtype:
														
 
															+  lj_err_argt(L, narg, LUA_TNUMBER);
														
 
															+  return 0;  /* unreachable */
														
 
															+}
														
 
															+#endif
														
 
															+
														
--- a/libs/LuaJIT/src/lj_lib.h
+++ b/libs/LuaJIT/src/lj_lib.h
@@ -46,6 +46,12 @@ LJ_FUNC GCtab *lj_lib_checktab(lua_State *L, int narg);
 
															 LJ_FUNC GCtab *lj_lib_checktabornil(lua_State *L, int narg);
														
 
															 LJ_FUNC int lj_lib_checkopt(lua_State *L, int narg, int def, const char *lst);
														
 
															+#if LJ_HASBUFFER
														
 
															+LJ_FUNC GCstr *lj_lib_checkstrx(lua_State *L, int narg);
														
 
															+LJ_FUNC int32_t lj_lib_checkintrange(lua_State *L, int narg,
														
 
															+				     int32_t a, int32_t b);
														
 
															+#endif
														
 
															+
														
 
															 /* Avoid including lj_frame.h. */
														
 
															 #if LJ_GC64
														
 
															 #define lj_lib_upvalue(L, n) \
														
--- a/libs/LuaJIT/src/lj_mcode.c
+++ b/libs/LuaJIT/src/lj_mcode.c
@@ -97,10 +97,15 @@ static int mcode_setprot(void *p, size_t sz, DWORD prot)
 
															 #define MCPROT_RW	(PROT_READ|PROT_WRITE)
														
 
															 #define MCPROT_RX	(PROT_READ|PROT_EXEC)
														
 
															 #define MCPROT_RWX	(PROT_READ|PROT_WRITE|PROT_EXEC)
														
 
															+#ifdef PROT_MPROTECT
														
 
															+#define MCPROT_CREATE	(PROT_MPROTECT(MCPROT_RWX))
														
 
															+#else
														
 
															+#define MCPROT_CREATE	0
														
 
															+#endif
														
 
															 static void *mcode_alloc_at(jit_State *J, uintptr_t hint, size_t sz, int prot)
														
 
															 {
														
 
															-  void *p = mmap((void *)hint, sz, prot, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
														
 
															+  void *p = mmap((void *)hint, sz, prot|MCPROT_CREATE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
														
 
															   if (p == MAP_FAILED) {
														
 
															     if (!hint) lj_trace_err(J, LJ_TRERR_MCODEAL);
														
 
															     p = NULL;
														
@@ -238,7 +243,7 @@ static void *mcode_alloc(jit_State *J, size_t sz)
 
															 /* All memory addresses are reachable by relative jumps. */
														
 
															 static void *mcode_alloc(jit_State *J, size_t sz)
														
 
															 {
														
 
															-#if defined(__OpenBSD__) || LJ_TARGET_UWP
														
 
															+#if defined(__OpenBSD__) || defined(__NetBSD__) || LJ_TARGET_UWP
														
 
															   /* Allow better executable memory allocation for OpenBSD W^X mode. */
														
 
															   void *p = mcode_alloc_at(J, 0, sz, MCPROT_RUN);
														
 
															   if (p && mcode_setprot(p, sz, MCPROT_GEN)) {
														
@@ -269,6 +274,7 @@ static void mcode_allocarea(jit_State *J)
 
															   ((MCLink *)J->mcarea)->next = oldarea;
														
 
															   ((MCLink *)J->mcarea)->size = sz;
														
 
															   J->szallmcarea += sz;
														
 
															+  J->mcbot = (MCode *)lj_err_register_mcode(J->mcarea, sz, (uint8_t *)J->mcbot);
														
 
															 }
														
 
															 /* Free all MCode areas. */
														
@@ -279,7 +285,9 @@ void lj_mcode_free(jit_State *J)
 
															   J->szallmcarea = 0;
														
 
															   while (mc) {
														
 
															     MCode *next = ((MCLink *)mc)->next;
														
 
															-    mcode_free(J, mc, ((MCLink *)mc)->size);
														
 
															+    size_t sz = ((MCLink *)mc)->size;
														
 
															+    lj_err_deregister_mcode(mc, sz, (uint8_t *)mc + sizeof(MCLink));
														
 
															+    mcode_free(J, mc, sz);
														
 
															     mc = next;
														
 
															   }
														
 
															 }
														
@@ -314,21 +322,21 @@ void lj_mcode_abort(jit_State *J)
 
															 /* Set/reset protection to allow patching of MCode areas. */
														
 
															 MCode *lj_mcode_patch(jit_State *J, MCode *ptr, int finish)
														
 
															 {
														
 
															-#if LUAJIT_SECURITY_MCODE == 0
														
 
															-  UNUSED(J); UNUSED(ptr); UNUSED(finish);
														
 
															-  return NULL;
														
 
															-#else
														
 
															   if (finish) {
														
 
															+#if LUAJIT_SECURITY_MCODE
														
 
															     if (J->mcarea == ptr)
														
 
															       mcode_protect(J, MCPROT_RUN);
														
 
															     else if (LJ_UNLIKELY(mcode_setprot(ptr, ((MCLink *)ptr)->size, MCPROT_RUN)))
														
 
															       mcode_protfail(J);
														
 
															+#endif
														
 
															     return NULL;
														
 
															   } else {
														
 
															     MCode *mc = J->mcarea;
														
 
															     /* Try current area first to use the protection cache. */
														
 
															     if (ptr >= mc && ptr < (MCode *)((char *)mc + J->szmcarea)) {
														
 
															+#if LUAJIT_SECURITY_MCODE
														
 
															       mcode_protect(J, MCPROT_GEN);
														
 
															+#endif
														
 
															       return mc;
														
 
															     }
														
 
															     /* Otherwise search through the list of MCode areas. */
														
@@ -336,13 +344,14 @@ MCode *lj_mcode_patch(jit_State *J, MCode *ptr, int finish)
 
															       mc = ((MCLink *)mc)->next;
														
 
															       lj_assertJ(mc != NULL, "broken MCode area chain");
														
 
															       if (ptr >= mc && ptr < (MCode *)((char *)mc + ((MCLink *)mc)->size)) {
														
 
															+#if LUAJIT_SECURITY_MCODE
														
 
															 	if (LJ_UNLIKELY(mcode_setprot(mc, ((MCLink *)mc)->size, MCPROT_GEN)))
														
 
															 	  mcode_protfail(J);
														
 
															+#endif
														
 
															 	return mc;
														
 
															       }
														
 
															     }
														
 
															   }
														
 
															-#endif
														
 
															 }
														
 
															 /* Limit of MCode reservation reached. */
														
--- a/libs/LuaJIT/src/lj_meta.c
+++ b/libs/LuaJIT/src/lj_meta.c
@@ -240,8 +240,8 @@ TValue *lj_meta_cat(lua_State *L, TValue *top, int left)
 
															   int fromc = 0;
														
 
															   if (left < 0) { left = -left; fromc = 1; }
														
 
															   do {
														
 
															-    if (!(tvisstr(top) || tvisnumber(top)) ||
														
 
															-	!(tvisstr(top-1) || tvisnumber(top-1))) {
														
 
															+    if (!(tvisstr(top) || tvisnumber(top) || tvisbuf(top)) ||
														
 
															+	!(tvisstr(top-1) || tvisnumber(top-1) || tvisbuf(top-1))) {
														
 
															       cTValue *mo = lj_meta_lookup(L, top-1, MM_concat);
														
 
															       if (tvisnil(mo)) {
														
 
															 	mo = lj_meta_lookup(L, top, MM_concat);
														
@@ -277,10 +277,12 @@ TValue *lj_meta_cat(lua_State *L, TValue *top, int left)
 
															       ** next step: [...][CAT stack ............]
														
 
															       */
														
 
															       TValue *e, *o = top;
														
 
															-      uint64_t tlen = tvisstr(o) ? strV(o)->len : STRFMT_MAXBUF_NUM;
														
 
															+      uint64_t tlen = tvisstr(o) ? strV(o)->len :
														
 
															+		      tvisbuf(o) ? sbufxlen(bufV(o)) : STRFMT_MAXBUF_NUM;
														
 
															       SBuf *sb;
														
 
															       do {
														
 
															-	o--; tlen += tvisstr(o) ? strV(o)->len : STRFMT_MAXBUF_NUM;
														
 
															+	o--; tlen += tvisstr(o) ? strV(o)->len :
														
 
															+		     tvisbuf(o) ? sbufxlen(bufV(o)) : STRFMT_MAXBUF_NUM;
														
 
															       } while (--left > 0 && (tvisstr(o-1) || tvisnumber(o-1)));
														
 
															       if (tlen >= LJ_MAX_STR) lj_err_msg(L, LJ_ERR_STROV);
														
 
															       sb = lj_buf_tmp_(L);
														
@@ -290,6 +292,9 @@ TValue *lj_meta_cat(lua_State *L, TValue *top, int left)
 
															 	  GCstr *s = strV(o);
														
 
															 	  MSize len = s->len;
														
 
															 	  lj_buf_putmem(sb, strdata(s), len);
														
 
															+	} else if (tvisbuf(o)) {
														
 
															+	  SBufExt *sbx = bufV(o);
														
 
															+	  lj_buf_putmem(sb, sbx->r, sbufxlen(sbx));
														
 
															 	} else if (tvisint(o)) {
														
 
															 	  lj_strfmt_putint(sb, intV(o));
														
 
															 	} else {
														
--- a/libs/LuaJIT/src/lj_obj.h
+++ b/libs/LuaJIT/src/lj_obj.h
@@ -34,13 +34,17 @@ typedef struct MRef {
 
															 #if LJ_GC64
														
 
															 #define mref(r, t)	((t *)(void *)(r).ptr64)
														
 
															+#define mrefu(r)	((r).ptr64)
														
 
															 #define setmref(r, p)	((r).ptr64 = (uint64_t)(void *)(p))
														
 
															+#define setmrefu(r, u)	((r).ptr64 = (uint64_t)(u))
														
 
															 #define setmrefr(r, v)	((r).ptr64 = (v).ptr64)
														
 
															 #else
														
 
															 #define mref(r, t)	((t *)(void *)(uintptr_t)(r).ptr32)
														
 
															+#define mrefu(r)	((r).ptr32)
														
 
															 #define setmref(r, p)	((r).ptr32 = (uint32_t)(uintptr_t)(void *)(p))
														
 
															+#define setmrefu(r, u)	((r).ptr32 = (uint32_t)(u))
														
 
															 #define setmrefr(r, v)	((r).ptr32 = (v).ptr32)
														
 
															 #endif
														
@@ -153,11 +157,9 @@ typedef int32_t BCLine;  /* Bytecode line number. */
 
															 typedef void (*ASMFunction)(void);
														
 
															 /* Resizable string buffer. Need this here, details in lj_buf.h. */
														
 
															+#define SBufHeader	char *w, *e, *b; MRef L
														
 
															 typedef struct SBuf {
														
 
															-  MRef p;		/* String buffer pointer. */
														
 
															-  MRef e;		/* String buffer end pointer. */
														
 
															-  MRef b;		/* String buffer base. */
														
 
															-  MRef L;		/* lua_State, used for buffer resizing. */
														
 
															+  SBufHeader;
														
 
															 } SBuf;
														
 
															 /* -- Tags and values ----------------------------------------------------- */
														
@@ -282,6 +284,9 @@ typedef const TValue cTValue;
 
															 #define LJ_TISGCV		(LJ_TSTR+1)
														
 
															 #define LJ_TISTABUD		LJ_TTAB
														
 
															+/* Type marker for slot holding a traversal index. Must be lightuserdata. */
														
 
															+#define LJ_KEYINDEX		0xfffe7fffu
														
 
															+
														
 
															 #if LJ_GC64
														
 
															 #define LJ_GCVMASK		(((uint64_t)1 << 47) - 1)
														
 
															 #endif
														
@@ -330,6 +335,7 @@ enum {
 
															   UDTYPE_USERDATA,	/* Regular userdata. */
														
 
															   UDTYPE_IO_FILE,	/* I/O library FILE. */
														
 
															   UDTYPE_FFI_CLIB,	/* FFI C library namespace. */
														
 
															+  UDTYPE_BUFFER,	/* String buffer. */
														
 
															   UDTYPE__MAX
														
 
															 };
														
@@ -920,7 +926,7 @@ static LJ_AINLINE void setgcV(lua_State *L, TValue *o, GCobj *v, uint32_t it)
 
															 }
														
 
															 #define define_setV(name, type, tag) \
														
 
															-static LJ_AINLINE void name(lua_State *L, TValue *o, type *v) \
														
 
															+static LJ_AINLINE void name(lua_State *L, TValue *o, const type *v) \
														
 
															 { \
														
 
															   setgcV(L, o, obj2gco(v), tag); \
														
 
															 }
														
--- a/libs/LuaJIT/src/lj_opt_fold.c
+++ b/libs/LuaJIT/src/lj_opt_fold.c
@@ -514,6 +514,7 @@ LJFOLDF(kfold_snew_kptr)
 
															 }
														
 
															 LJFOLD(SNEW any KINT)
														
 
															+LJFOLD(XSNEW any KINT)
														
 
															 LJFOLDF(kfold_snew_empty)
														
 
															 {
														
 
															   if (fright->i == 0)
														
@@ -577,22 +578,49 @@ LJFOLDF(kfold_strcmp)
 
															 ** The compromise is to declare them as loads, emit them like stores and
														
 
															 ** CSE whole chains manually when the BUFSTR is to be emitted. Any chain
														
 
															 ** fragments left over from CSE are eliminated by DCE.
														
 
															+**
														
 
															+** The string buffer methods emit a USE instead of a BUFSTR to keep the
														
 
															+** chain alive.
														
 
															 */
														
 
															-/* BUFHDR is emitted like a store, see below. */
														
 
															+LJFOLD(BUFHDR any any)
														
 
															+LJFOLDF(bufhdr_merge)
														
 
															+{
														
 
															+  return fins->op2 == IRBUFHDR_WRITE ? CSEFOLD : EMITFOLD;
														
 
															+}
														
 
															-LJFOLD(BUFPUT BUFHDR BUFSTR)
														
 
															-LJFOLDF(bufput_append)
														
 
															+LJFOLD(BUFPUT any BUFSTR)
														
 
															+LJFOLDF(bufput_bufstr)
														
 
															 {
														
 
															-  /* New buffer, no other buffer op inbetween and same buffer? */
														
 
															-  if ((J->flags & JIT_F_OPT_FWD) &&
														
 
															-      !(fleft->op2 & IRBUFHDR_APPEND) &&
														
 
															-      fleft->prev == fright->op2 &&
														
 
															-      fleft->op1 == IR(fright->op2)->op1) {
														
 
															-    IRRef ref = fins->op1;
														
 
															-    IR(ref)->op2 = (fleft->op2 | IRBUFHDR_APPEND);  /* Modify BUFHDR. */
														
 
															-    IR(ref)->op1 = fright->op1;
														
 
															-    return ref;
														
 
															+  if ((J->flags & JIT_F_OPT_FWD)) {
														
 
															+    IRRef hdr = fright->op2;
														
 
															+    /* New buffer, no other buffer op inbetween and same buffer? */
														
 
															+    if (fleft->o == IR_BUFHDR && fleft->op2 == IRBUFHDR_RESET &&
														
 
															+	fleft->prev == hdr &&
														
 
															+	fleft->op1 == IR(hdr)->op1) {
														
 
															+      IRRef ref = fins->op1;
														
 
															+      IR(ref)->op2 = IRBUFHDR_APPEND;  /* Modify BUFHDR. */
														
 
															+      IR(ref)->op1 = fright->op1;
														
 
															+      return ref;
														
 
															+    }
														
 
															+    /* Replay puts to global temporary buffer. */
														
 
															+    if (IR(hdr)->op2 == IRBUFHDR_RESET) {
														
 
															+      IRIns *ir = IR(fright->op1);
														
 
															+      /* For now only handle single string.reverse .lower .upper .rep. */
														
 
															+      if (ir->o == IR_CALLL &&
														
 
															+	  ir->op2 >= IRCALL_lj_buf_putstr_reverse &&
														
 
															+	  ir->op2 <= IRCALL_lj_buf_putstr_rep) {
														
 
															+	IRIns *carg1 = IR(ir->op1);
														
 
															+	if (ir->op2 == IRCALL_lj_buf_putstr_rep) {
														
 
															+	  IRIns *carg2 = IR(carg1->op1);
														
 
															+	  if (carg2->op1 == hdr) {
														
 
															+	    return lj_ir_call(J, ir->op2, fins->op1, carg2->op2, carg1->op2);
														
 
															+	  }
														
 
															+	} else if (carg1->op1 == hdr) {
														
 
															+	  return lj_ir_call(J, ir->op2, fins->op1, carg1->op2);
														
 
															+	}
														
 
															+      }
														
 
															+    }
														
 
															   }
														
 
															   return EMITFOLD;  /* Always emit, CSE later. */
														
 
															 }
														
@@ -626,14 +654,14 @@ LJFOLDF(bufstr_kfold_cse)
 
															 	     "bad buffer constructor IR op %d", fleft->o);
														
 
															   if (LJ_LIKELY(J->flags & JIT_F_OPT_FOLD)) {
														
 
															     if (fleft->o == IR_BUFHDR) {  /* No put operations? */
														
 
															-      if (!(fleft->op2 & IRBUFHDR_APPEND))  /* Empty buffer? */
														
 
															+      if (fleft->op2 == IRBUFHDR_RESET)  /* Empty buffer? */
														
 
															 	return lj_ir_kstr(J, &J2G(J)->strempty);
														
 
															       fins->op1 = fleft->op1;
														
 
															       fins->op2 = fleft->prev;  /* Relies on checks in bufput_append. */
														
 
															       return CSEFOLD;
														
 
															     } else if (fleft->o == IR_BUFPUT) {
														
 
															       IRIns *irb = IR(fleft->op1);
														
 
															-      if (irb->o == IR_BUFHDR && !(irb->op2 & IRBUFHDR_APPEND))
														
 
															+      if (irb->o == IR_BUFHDR && irb->op2 == IRBUFHDR_RESET)
														
 
															 	return fleft->op2;  /* Shortcut for a single put operation. */
														
 
															     }
														
 
															   }
														
@@ -646,7 +674,7 @@ LJFOLDF(bufstr_kfold_cse)
 
															 	lj_assertJ(ira->o == IR_BUFHDR || ira->o == IR_BUFPUT ||
														
 
															 		   ira->o == IR_CALLL || ira->o == IR_CARG,
														
 
															 		   "bad buffer constructor IR op %d", ira->o);
														
 
															-	if (ira->o == IR_BUFHDR && !(ira->op2 & IRBUFHDR_APPEND))
														
 
															+	if (ira->o == IR_BUFHDR && ira->op2 == IRBUFHDR_RESET)
														
 
															 	  return ref;  /* CSE succeeded. */
														
 
															 	if (ira->o == IR_CALLL && ira->op2 == IRCALL_lj_buf_puttab)
														
 
															 	  break;
														
@@ -1297,6 +1325,10 @@ LJFOLD(CONV SUB IRCONV_U32_U64)
 
															 LJFOLD(CONV MUL IRCONV_U32_U64)
														
 
															 LJFOLDF(simplify_conv_narrow)
														
 
															 {
														
 
															+#if LJ_64
														
 
															+  UNUSED(J);
														
 
															+  return NEXTFOLD;
														
 
															+#else
														
 
															   IROp op = (IROp)fleft->o;
														
 
															   IRType t = irt_type(fins->t);
														
 
															   IRRef op1 = fleft->op1, op2 = fleft->op2, mode = fins->op2;
														
@@ -1307,6 +1339,7 @@ LJFOLDF(simplify_conv_narrow)
 
															   fins->op1 = op1;
														
 
															   fins->op2 = op2;
														
 
															   return RETRYFOLD;
														
 
															+#endif
														
 
															 }
														
 
															 /* Special CSE rule for CONV. */
														
@@ -2275,6 +2308,27 @@ LJFOLDF(fload_str_len_tostr)
 
															   return NEXTFOLD;
														
 
															 }
														
 
															+LJFOLD(FLOAD any IRFL_SBUF_W)
														
 
															+LJFOLD(FLOAD any IRFL_SBUF_E)
														
 
															+LJFOLD(FLOAD any IRFL_SBUF_B)
														
 
															+LJFOLD(FLOAD any IRFL_SBUF_L)
														
 
															+LJFOLD(FLOAD any IRFL_SBUF_REF)
														
 
															+LJFOLD(FLOAD any IRFL_SBUF_R)
														
 
															+LJFOLDF(fload_sbuf)
														
 
															+{
														
 
															+  TRef tr = lj_opt_fwd_fload(J);
														
 
															+  return lj_opt_fwd_sbuf(J, tref_ref(tr)) ? tr : EMITFOLD;
														
 
															+}
														
 
															+
														
 
															+/* The fast function ID of function objects is immutable. */
														
 
															+LJFOLD(FLOAD KGC IRFL_FUNC_FFID)
														
 
															+LJFOLDF(fload_func_ffid_kgc)
														
 
															+{
														
 
															+  if (LJ_LIKELY(J->flags & JIT_F_OPT_FOLD))
														
 
															+    return INTFOLD((int32_t)ir_kfunc(fleft)->c.ffid);
														
 
															+  return NEXTFOLD;
														
 
															+}
														
 
															+
														
 
															 /* The C type ID of cdata objects is immutable. */
														
 
															 LJFOLD(FLOAD KGC IRFL_CDATA_CTYPEID)
														
 
															 LJFOLDF(fload_cdata_typeid_kgc)
														
@@ -2421,6 +2475,7 @@ LJFOLD(XSTORE any any)
 
															 LJFOLDX(lj_opt_dse_xstore)
														
 
															 LJFOLD(NEWREF any any)  /* Treated like a store. */
														
 
															+LJFOLD(TMPREF any any)
														
 
															 LJFOLD(CALLA any any)
														
 
															 LJFOLD(CALLL any any)  /* Safeguard fallback. */
														
 
															 LJFOLD(CALLS any any)
														
@@ -2431,7 +2486,6 @@ LJFOLD(TNEW any any)
 
															 LJFOLD(TDUP any)
														
 
															 LJFOLD(CNEW any any)
														
 
															 LJFOLD(XSNEW any any)
														
 
															-LJFOLD(BUFHDR any any)
														
 
															 LJFOLDX(lj_ir_emit)
														
 
															 /* ------------------------------------------------------------------------ */
														
--- a/libs/LuaJIT/src/lj_opt_loop.c
+++ b/libs/LuaJIT/src/lj_opt_loop.c
@@ -225,6 +225,7 @@ static void loop_subst_snap(jit_State *J, SnapShot *osnap,
 
															   /* Setup new snapshot. */
														
 
															   snap->mapofs = (uint32_t)nmapofs;
														
 
															   snap->ref = (IRRef1)J->cur.nins;
														
 
															+  snap->mcofs = 0;
														
 
															   snap->nslots = nslots;
														
 
															   snap->topslot = osnap->topslot;
														
 
															   snap->count = 0;
														
--- a/libs/LuaJIT/src/lj_opt_mem.c
+++ b/libs/LuaJIT/src/lj_opt_mem.c
@@ -364,7 +364,10 @@ TRef LJ_FASTCALL lj_opt_dse_ahstore(jit_State *J)
 
															       /* Different value: try to eliminate the redundant store. */
														
 
															       if (ref > J->chain[IR_LOOP]) {  /* Quick check to avoid crossing LOOP. */
														
 
															 	IRIns *ir;
														
 
															-	/* Check for any intervening guards (includes conflicting loads). */
														
 
															+	/* Check for any intervening guards (includes conflicting loads).
														
 
															+	** Note that lj_tab_keyindex and lj_vm_next don't need guards,
														
 
															+	** since they are followed by at least one guarded VLOAD.
														
 
															+	*/
														
 
															 	for (ir = IR(J->cur.nins-1); ir > store; ir--)
														
 
															 	  if (irt_isguard(ir->t) || ir->o == IR_ALEN)
														
 
															 	    goto doemit;  /* No elimination possible. */
														
@@ -620,8 +623,9 @@ TRef LJ_FASTCALL lj_opt_dse_fstore(jit_State *J)
 
															 	goto doemit;
														
 
															       break;  /* Otherwise continue searching. */
														
 
															     case ALIAS_MUST:
														
 
															-      if (store->op2 == val)  /* Same value: drop the new store. */
														
 
															-	return DROPFOLD;
														
 
															+      if (store->op2 == val &&
														
 
															+	  !(xr->op2 >= IRFL_SBUF_W && xr->op2 <= IRFL_SBUF_R))
														
 
															+	return DROPFOLD;  /* Same value: drop the new store. */
														
 
															       /* Different value: try to eliminate the redundant store. */
														
 
															       if (ref > J->chain[IR_LOOP]) {  /* Quick check to avoid crossing LOOP. */
														
 
															 	IRIns *ir;
														
@@ -642,6 +646,29 @@ doemit:
 
															   return EMITFOLD;  /* Otherwise we have a conflict or simply no match. */
														
 
															 }
														
 
															+/* Check whether there's no aliasing buffer op between IRFL_SBUF_*. */
														
 
															+int LJ_FASTCALL lj_opt_fwd_sbuf(jit_State *J, IRRef lim)
														
 
															+{
														
 
															+  IRRef ref;
														
 
															+  if (J->chain[IR_BUFPUT] > lim)
														
 
															+    return 0;  /* Conflict. */
														
 
															+  ref = J->chain[IR_CALLS];
														
 
															+  while (ref > lim) {
														
 
															+    IRIns *ir = IR(ref);
														
 
															+    if (ir->op2 >= IRCALL_lj_strfmt_putint && ir->op2 < IRCALL_lj_buf_tostr)
														
 
															+      return 0;  /* Conflict. */
														
 
															+    ref = ir->prev;
														
 
															+  }
														
 
															+  ref = J->chain[IR_CALLL];
														
 
															+  while (ref > lim) {
														
 
															+    IRIns *ir = IR(ref);
														
 
															+    if (ir->op2 >= IRCALL_lj_strfmt_putint && ir->op2 < IRCALL_lj_buf_tostr)
														
 
															+      return 0;  /* Conflict. */
														
 
															+    ref = ir->prev;
														
 
															+  }
														
 
															+  return 1;  /* No conflict. Can safely FOLD/CSE. */
														
 
															+}
														
 
															+
														
 
															 /* -- XLOAD forwarding and XSTORE elimination ----------------------------- */
														
 
															 /* Find cdata allocation for a reference (if any). */
														
--- a/libs/LuaJIT/src/lj_opt_split.c
+++ b/libs/LuaJIT/src/lj_opt_split.c
@@ -645,7 +645,7 @@ static void split_ir(jit_State *J)
 
															       tmp = split_emit(J, IRT(IR_CARG, IRT_NIL), hisubst[op1], oir[op1].prev);
														
 
															 #endif
														
 
															       ir->prev = split_emit(J, IRTI(IR_CALLN), tmp, IRCALL_lj_vm_tobit);
														
 
															-    } else if (ir->o == IR_TOSTR) {
														
 
															+    } else if (ir->o == IR_TOSTR || ir->o == IR_TMPREF) {
														
 
															       if (hisubst[ir->op1]) {
														
 
															 	if (irref_isk(ir->op1))
														
 
															 	  nir->op1 = ir->op1;
														
--- a/libs/LuaJIT/src/lj_parse.c
+++ b/libs/LuaJIT/src/lj_parse.c
@@ -1465,7 +1465,7 @@ static size_t fs_prep_var(LexState *ls, FuncState *fs, size_t *ofsvar)
 
															     MSize len = s->len+1;
														
 
															     char *p = lj_buf_more(&ls->sb, len);
														
 
															     p = lj_buf_wmem(p, strdata(s), len);
														
 
															-    setsbufP(&ls->sb, p);
														
 
															+    ls->sb.w = p;
														
 
															   }
														
 
															   *ofsvar = sbuflen(&ls->sb);
														
 
															   lastpc = 0;
														
@@ -1486,7 +1486,7 @@ static size_t fs_prep_var(LexState *ls, FuncState *fs, size_t *ofsvar)
 
															       startpc = vs->startpc;
														
 
															       p = lj_strfmt_wuleb128(p, startpc-lastpc);
														
 
															       p = lj_strfmt_wuleb128(p, vs->endpc-startpc);
														
 
															-      setsbufP(&ls->sb, p);
														
 
															+      ls->sb.w = p;
														
 
															       lastpc = startpc;
														
 
															     }
														
 
															   }
														
@@ -1499,7 +1499,7 @@ static void fs_fixup_var(LexState *ls, GCproto *pt, uint8_t *p, size_t ofsvar)
 
															 {
														
 
															   setmref(pt->uvinfo, p);
														
 
															   setmref(pt->varinfo, (char *)p + ofsvar);
														
 
															-  memcpy(p, sbufB(&ls->sb), sbuflen(&ls->sb));  /* Copy from temp. buffer. */
														
 
															+  memcpy(p, ls->sb.b, sbuflen(&ls->sb));  /* Copy from temp. buffer. */
														
 
															 }
														
 
															 #else
														
--- a/libs/LuaJIT/src/lj_prng.c
+++ b/libs/LuaJIT/src/lj_prng.c
@@ -109,13 +109,19 @@ static PRGR libfunc_rgr;
 
															 #include <sys/syscall.h>
														
 
															 #else
														
 
															-#if LJ_TARGET_OSX
														
 
															+#if LJ_TARGET_OSX && !LJ_TARGET_IOS
														
 
															+/*
														
 
															+** In their infinite wisdom Apple decided to disallow getentropy() in the
														
 
															+** iOS App Store. Even though the call is common to all BSD-ish OS, it's
														
 
															+** recommended by Apple in their own security-related docs, and, to top
														
 
															+** off the foolery, /dev/urandom is handled by the same kernel code,
														
 
															+** yet accessing it is actually permitted (but less efficient).
														
 
															+*/
														
 
															 #include <Availability.h>
														
 
															-#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200 || \
														
 
															-    __IPHONE_OS_VERSION_MIN_REQUIRED >= 100000
														
 
															+#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200
														
 
															 #define LJ_TARGET_HAS_GETENTROPY	1
														
 
															 #endif
														
 
															-#elif LJ_TARGET_BSD || LJ_TARGET_SOLARIS || LJ_TARGET_CYGWIN
														
 
															+#elif (LJ_TARGET_BSD && !defined(__NetBSD__)) || LJ_TARGET_SOLARIS || LJ_TARGET_CYGWIN
														
 
															 #define LJ_TARGET_HAS_GETENTROPY	1
														
 
															 #endif
														
@@ -167,7 +173,7 @@ int LJ_FASTCALL lj_prng_seed_secure(PRNGState *rs)
 
															 #elif LJ_TARGET_PS4 || LJ_TARGET_PSVITA
														
 
															-  if (sceRandomGetRandomNumber(rs->u, sizeof(rs->u) == 0)
														
 
															+  if (sceRandomGetRandomNumber(rs->u, sizeof(rs->u)) == 0)
														
 
															     goto ok;
														
 
															 #elif LJ_TARGET_UWP || LJ_TARGET_XBOXONE
														
--- a/libs/LuaJIT/src/lj_profile.c
+++ b/libs/LuaJIT/src/lj_profile.c
@@ -346,8 +346,7 @@ LUA_API void luaJIT_profile_stop(lua_State *L)
 
															     lj_trace_flushall(L);
														
 
															 #endif
														
 
															     lj_buf_free(g, &ps->sb);
														
 
															-    setmref(ps->sb.b, NULL);
														
 
															-    setmref(ps->sb.e, NULL);
														
 
															+    ps->sb.w = ps->sb.e = NULL;
														
 
															     ps->g = NULL;
														
 
															   }
														
 
															 }
														
@@ -362,7 +361,7 @@ LUA_API const char *luaJIT_profile_dumpstack(lua_State *L, const char *fmt,
 
															   lj_buf_reset(sb);
														
 
															   lj_debug_dumpstack(L, sb, fmt, depth);
														
 
															   *len = (size_t)sbuflen(sb);
														
 
															-  return sbufB(sb);
														
 
															+  return sb->b;
														
 
															 }
														
 
															 #endif
														
--- a/libs/LuaJIT/src/lj_record.c
+++ b/libs/LuaJIT/src/lj_record.c
@@ -156,6 +156,9 @@ static void rec_check_slots(jit_State *J)
 
															 	lj_assertJ((J->slot[s+1+LJ_FR2] & TREF_FRAME),
														
 
															 		   "cont slot %d not followed by frame", s);
														
 
															 	depth++;
														
 
															+      } else if ((tr & TREF_KEYINDEX)) {
														
 
															+	lj_assertJ(tref_isint(tr), "keyindex slot %d bad type %d",
														
 
															+				   s, tref_type(tr));
														
 
															       } else {
														
 
															 	/* Number repr. may differ, but other types must be the same. */
														
 
															 	lj_assertJ(tvisnumber(tv) ? tref_isnumber(tr) :
														
@@ -259,6 +262,14 @@ TRef lj_record_constify(jit_State *J, cTValue *o)
 
															     return 0;  /* Can't represent lightuserdata (pointless). */
														
 
															 }
														
 
															+/* Emit a VLOAD with the correct type. */
														
 
															+TRef lj_record_vload(jit_State *J, TRef ref, MSize idx, IRType t)
														
 
															+{
														
 
															+  TRef tr = emitir(IRTG(IR_VLOAD, t), ref, idx);
														
 
															+  if (irtype_ispri(t)) tr = TREF_PRI(t);  /* Canonicalize primitives. */
														
 
															+  return tr;
														
 
															+}
														
 
															+
														
 
															 /* -- Record loop ops ----------------------------------------------------- */
														
 
															 /* Loop event. */
														
@@ -275,9 +286,9 @@ static void canonicalize_slots(jit_State *J)
 
															   if (LJ_DUALNUM) return;
														
 
															   for (s = J->baseslot+J->maxslot-1; s >= 1; s--) {
														
 
															     TRef tr = J->slot[s];
														
 
															-    if (tref_isinteger(tr)) {
														
 
															+    if (tref_isinteger(tr) && !(tr & TREF_KEYINDEX)) {
														
 
															       IRIns *ir = IR(tref_ref(tr));
														
 
															-      if (!(ir->o == IR_SLOAD && (ir->op2 & IRSLOAD_READONLY)))
														
 
															+      if (!(ir->o == IR_SLOAD && (ir->op2 & (IRSLOAD_READONLY))))
														
 
															 	J->slot[s] = emitir(IRTN(IR_CONV), tr, IRCONV_NUM_INT);
														
 
															     }
														
 
															   }
														
@@ -598,6 +609,7 @@ static void rec_loop_interp(jit_State *J, const BCIns *pc, LoopEvent ev)
 
															 {
														
 
															   if (J->parent == 0 && J->exitno == 0) {
														
 
															     if (pc == J->startpc && J->framedepth + J->retdepth == 0) {
														
 
															+      if (bc_op(J->cur.startins) == BC_ITERN) return;  /* See rec_itern(). */
														
 
															       /* Same loop? */
														
 
															       if (ev == LOOPEV_LEAVE)  /* Must loop back to form a root trace. */
														
 
															 	lj_trace_err(J, LJ_TRERR_LLEAVE);
														
@@ -638,6 +650,70 @@ static void rec_loop_jit(jit_State *J, TraceNo lnk, LoopEvent ev)
 
															   }  /* Side trace continues across a loop that's left or not entered. */
														
 
															 }
														
 
															+/* Record ITERN. */
														
 
															+static LoopEvent rec_itern(jit_State *J, BCReg ra, BCReg rb)
														
 
															+{
														
 
															+#if LJ_BE
														
 
															+  /* YAGNI: Disabled on big-endian due to issues with lj_vm_next,
														
 
															+  ** IR_HIOP, RID_RETLO/RID_RETHI and ra_destpair.
														
 
															+  */
														
 
															+  UNUSED(ra); UNUSED(rb);
														
 
															+  setintV(&J->errinfo, (int32_t)BC_ITERN);
														
 
															+  lj_trace_err_info(J, LJ_TRERR_NYIBC);
														
 
															+#else
														
 
															+  RecordIndex ix;
														
 
															+  /* Since ITERN is recorded at the start, we need our own loop detection. */
														
 
															+  if (J->pc == J->startpc &&
														
 
															+      (J->cur.nins > REF_FIRST+1 ||
														
 
															+       (J->cur.nins == REF_FIRST+1 && J->cur.ir[REF_FIRST].o != IR_PROF)) &&
														
 
															+      J->framedepth + J->retdepth == 0 && J->parent == 0 && J->exitno == 0) {
														
 
															+    lj_record_stop(J, LJ_TRLINK_LOOP, J->cur.traceno);  /* Looping trace. */
														
 
															+    return LOOPEV_ENTER;
														
 
															+  }
														
 
															+  J->maxslot = ra;
														
 
															+  lj_snap_add(J);  /* Required to make JLOOP the first ins in a side-trace. */
														
 
															+  ix.tab = getslot(J, ra-2);
														
 
															+  ix.key = J->base[ra-1] ? J->base[ra-1] :
														
 
															+	   sloadt(J, (int32_t)(ra-1), IRT_INT, IRSLOAD_KEYINDEX);
														
 
															+  copyTV(J->L, &ix.tabv, &J->L->base[ra-2]);
														
 
															+  copyTV(J->L, &ix.keyv, &J->L->base[ra-1]);
														
 
															+  ix.idxchain = (rb < 3);  /* Omit value type check, if unused. */
														
 
															+  ix.mobj = 1;  /* We need the next index, too. */
														
 
															+  J->maxslot = ra + lj_record_next(J, &ix);
														
 
															+  J->needsnap = 1;
														
 
															+  if (!tref_isnil(ix.key)) {  /* Looping back? */
														
 
															+    J->base[ra-1] = ix.mobj | TREF_KEYINDEX;  /* Control var has next index. */
														
 
															+    J->base[ra] = ix.key;
														
 
															+    J->base[ra+1] = ix.val;
														
 
															+    J->pc += bc_j(J->pc[1])+2;
														
 
															+    return LOOPEV_ENTER;
														
 
															+  } else {
														
 
															+    J->maxslot = ra-3;
														
 
															+    J->pc += 2;
														
 
															+    return LOOPEV_LEAVE;
														
 
															+  }
														
 
															+#endif
														
 
															+}
														
 
															+
														
 
															+/* Record ISNEXT. */
														
 
															+static void rec_isnext(jit_State *J, BCReg ra)
														
 
															+{
														
 
															+  cTValue *b = &J->L->base[ra-3];
														
 
															+  if (tvisfunc(b) && funcV(b)->c.ffid == FF_next &&
														
 
															+      tvistab(b+1) && tvisnil(b+2)) {
														
 
															+    /* These checks are folded away for a compiled pairs(). */
														
 
															+    TRef func = getslot(J, ra-3);
														
 
															+    TRef trid = emitir(IRT(IR_FLOAD, IRT_U8), func, IRFL_FUNC_FFID);
														
 
															+    emitir(IRTGI(IR_EQ), trid, lj_ir_kint(J, FF_next));
														
 
															+    (void)getslot(J, ra-2); /* Type check for table. */
														
 
															+    (void)getslot(J, ra-1); /* Type check for nil key. */
														
 
															+    J->base[ra-1] = lj_ir_kint(J, 0) | TREF_KEYINDEX;
														
 
															+    J->maxslot = ra;
														
 
															+  } else {  /* Abort trace. Interpreter will despecialize bytecode. */
														
 
															+    lj_trace_err(J, LJ_TRERR_RECERR);
														
 
															+  }
														
 
															+}
														
 
															+
														
 
															 /* -- Record profiler hook checks ----------------------------------------- */
														
 
															 #if LJ_HASPROFILE
														
@@ -708,7 +784,7 @@ static TRef rec_call_specialize(jit_State *J, GCfunc *fn, TRef tr)
 
															       /* NYI: io_file_iter doesn't have an ffid, yet. */
														
 
															       {  /* Specialize to the ffid. */
														
 
															 	TRef trid = emitir(IRT(IR_FLOAD, IRT_U8), tr, IRFL_FUNC_FFID);
														
 
															-	emitir(IRTG(IR_EQ, IRT_INT), trid, lj_ir_kint(J, fn->c.ffid));
														
 
															+	emitir(IRTGI(IR_EQ), trid, lj_ir_kint(J, fn->c.ffid));
														
 
															       }
														
 
															       return tr;
														
 
															     default:
														
@@ -832,6 +908,7 @@ void lj_record_ret(jit_State *J, BCReg rbase, ptrdiff_t gotresults)
 
															     J->base -= cbase;
														
 
															     J->base[--rbase] = TREF_TRUE;  /* Prepend true to results. */
														
 
															     frame = frame_prevd(frame);
														
 
															+    J->needsnap = 1;  /* Stop catching on-trace errors. */
														
 
															   }
														
 
															   /* Return to lower frame via interpreter for unhandled cases. */
														
 
															   if (J->framedepth == 0 && J->pt && bc_isret(bc_op(*J->pc)) &&
														
@@ -918,6 +995,9 @@ void lj_record_ret(jit_State *J, BCReg rbase, ptrdiff_t gotresults)
 
															       TRef tr = gotresults ? J->base[cbase+rbase] : TREF_NIL;
														
 
															       if (bslot != J->maxslot) {  /* Concatenate the remainder. */
														
 
															 	TValue *b = J->L->base, save;  /* Simulate lower frame and result. */
														
 
															+	/* Can't handle MM_concat + CALLT + fast func side-effects. */
														
 
															+	if (J->postproc != LJ_POST_NONE)
														
 
															+	  lj_trace_err(J, LJ_TRERR_NYIRETL);
														
 
															 	J->base[J->maxslot] = tr;
														
 
															 	copyTV(J->L, &save, b-(2<<LJ_FR2));
														
 
															 	if (gotresults)
														
@@ -1433,6 +1513,16 @@ TRef lj_record_idx(jit_State *J, RecordIndex *ix)
 
															 	return 0;  /* No result yet. */
														
 
															       }
														
 
															     }
														
 
															+#if LJ_HASBUFFER
														
 
															+    /* The index table of buffer objects is treated as immutable. */
														
 
															+    if (ix->mt == TREF_NIL && !ix->val &&
														
 
															+	tref_isudata(ix->tab) && udataV(&ix->tabv)->udtype == UDTYPE_BUFFER &&
														
 
															+	tref_istab(ix->mobj) && tref_isstr(ix->key) && tref_isk(ix->key)) {
														
 
															+      cTValue *val = lj_tab_getstr(tabV(&ix->mobjv), strV(&ix->keyv));
														
 
															+      TRef tr = lj_record_constify(J, val);
														
 
															+      if (tr) return tr;  /* Specialize to the value, i.e. a method. */
														
 
															+    }
														
 
															+#endif
														
 
															     /* Otherwise retry lookup with metaobject. */
														
 
															     ix->tab = ix->mobj;
														
 
															     copyTV(J->L, &ix->tabv, &ix->mobjv);
														
@@ -1543,6 +1633,47 @@ TRef lj_record_idx(jit_State *J, RecordIndex *ix)
 
															   }
														
 
															 }
														
 
															+/* Determine result type of table traversal. */
														
 
															+static IRType rec_next_types(GCtab *t, uint32_t idx)
														
 
															+{
														
 
															+  for (; idx < t->asize; idx++) {
														
 
															+    cTValue *a = arrayslot(t, idx);
														
 
															+    if (LJ_LIKELY(!tvisnil(a)))
														
 
															+      return (LJ_DUALNUM ? IRT_INT : IRT_NUM) + (itype2irt(a) << 8);
														
 
															+  }
														
 
															+  idx -= t->asize;
														
 
															+  for (; idx <= t->hmask; idx++) {
														
 
															+    Node *n = &noderef(t->node)[idx];
														
 
															+    if (!tvisnil(&n->val))
														
 
															+      return itype2irt(&n->key) + (itype2irt(&n->val) << 8);
														
 
															+  }
														
 
															+  return IRT_NIL + (IRT_NIL << 8);
														
 
															+}
														
 
															+
														
 
															+/* Record a table traversal step aka next(). */
														
 
															+int lj_record_next(jit_State *J, RecordIndex *ix)
														
 
															+{
														
 
															+  IRType t, tkey, tval;
														
 
															+  TRef trvk;
														
 
															+  t = rec_next_types(tabV(&ix->tabv), ix->keyv.u32.lo);
														
 
															+  tkey = (t & 0xff); tval = (t >> 8);
														
 
															+  trvk = lj_ir_call(J, IRCALL_lj_vm_next, ix->tab, ix->key);
														
 
															+  if (ix->mobj || tkey == IRT_NIL) {
														
 
															+    TRef idx = emitir(IRTI(IR_HIOP), trvk, trvk);
														
 
															+    /* Always check for invalid key from next() for nil result. */
														
 
															+    if (!ix->mobj) emitir(IRTGI(IR_NE), idx, lj_ir_kint(J, -1));
														
 
															+    ix->mobj = idx;
														
 
															+  }
														
 
															+  ix->key = lj_record_vload(J, trvk, 1, tkey);
														
 
															+  if (tkey == IRT_NIL || ix->idxchain) {  /* Omit value type check. */
														
 
															+    ix->val = TREF_NIL;
														
 
															+    return 1;
														
 
															+  } else {  /* Need value. */
														
 
															+    ix->val = lj_record_vload(J, trvk, 0, tval);
														
 
															+    return 2;
														
 
															+  }
														
 
															+}
														
 
															+
														
 
															 static void rec_tsetm(jit_State *J, BCReg ra, BCReg rn, int32_t i)
														
 
															 {
														
 
															   RecordIndex ix;
														
@@ -1826,11 +1957,7 @@ static void rec_varg(jit_State *J, BCReg dst, ptrdiff_t nresults)
 
															 	vbase = emitir(IRT(IR_ADD, IRT_PGC), vbase, lj_ir_kint(J, frofs-8));
														
 
															 	for (i = 0; i < nload; i++) {
														
 
															 	  IRType t = itype2irt(&J->L->base[i-1-LJ_FR2-nvararg]);
														
 
															-	  TRef aref = emitir(IRT(IR_AREF, IRT_PGC),
														
 
															-			     vbase, lj_ir_kint(J, (int32_t)i));
														
 
															-	  TRef tr = emitir(IRTG(IR_VLOAD, t), aref, 0);
														
 
															-	  if (irtype_ispri(t)) tr = TREF_PRI(t);  /* Canonicalize primitives. */
														
 
															-	  J->base[dst+i] = tr;
														
 
															+	  J->base[dst+i] = lj_record_vload(J, vbase, i, t);
														
 
															 	}
														
 
															       } else {
														
 
															 	emitir(IRTGI(IR_LE), fr, lj_ir_kint(J, frofs));
														
@@ -1877,8 +2004,7 @@ static void rec_varg(jit_State *J, BCReg dst, ptrdiff_t nresults)
 
															 		       lj_ir_kint(J, frofs-(8<<LJ_FR2)));
														
 
															 	t = itype2irt(&J->L->base[idx-2-LJ_FR2-nvararg]);
														
 
															 	aref = emitir(IRT(IR_AREF, IRT_PGC), vbase, tridx);
														
 
															-	tr = emitir(IRTG(IR_VLOAD, t), aref, 0);
														
 
															-	if (irtype_ispri(t)) tr = TREF_PRI(t);  /* Canonicalize primitives. */
														
 
															+	tr = lj_record_vload(J, aref, 0, t);
														
 
															       }
														
 
															       J->base[dst-2-LJ_FR2] = tr;
														
 
															       J->maxslot = dst-1-LJ_FR2;
														
@@ -1935,9 +2061,9 @@ static TRef rec_cat(jit_State *J, BCReg baseslot, BCReg topslot)
 
															     tr = hdr = emitir(IRT(IR_BUFHDR, IRT_PGC),
														
 
															 		      lj_ir_kptr(J, &J2G(J)->tmpbuf), IRBUFHDR_RESET);
														
 
															     do {
														
 
															-      tr = emitir(IRT(IR_BUFPUT, IRT_PGC), tr, *trp++);
														
 
															+      tr = emitir(IRTG(IR_BUFPUT, IRT_PGC), tr, *trp++);
														
 
															     } while (trp <= top);
														
 
															-    tr = emitir(IRT(IR_BUFSTR, IRT_STR), tr, hdr);
														
 
															+    tr = emitir(IRTG(IR_BUFSTR, IRT_STR), tr, hdr);
														
 
															     J->maxslot = (BCReg)(xbase - J->base);
														
 
															     if (xbase == base) return tr;  /* Return simple concatenation result. */
														
 
															     /* Pass partial result. */
														
@@ -2050,7 +2176,7 @@ void lj_record_ins(jit_State *J)
 
															   /* Need snapshot before recording next bytecode (e.g. after a store). */
														
 
															   if (J->needsnap) {
														
 
															     J->needsnap = 0;
														
 
															-    lj_snap_purge(J);
														
 
															+    if (J->pt) lj_snap_purge(J);
														
 
															     lj_snap_add(J);
														
 
															     J->mergesnap = 1;
														
 
															   }
														
@@ -2423,6 +2549,9 @@ void lj_record_ins(jit_State *J)
 
															   case BC_ITERL:
														
 
															     rec_loop_interp(J, pc, rec_iterl(J, *pc));
														
 
															     break;
														
 
															+  case BC_ITERN:
														
 
															+    rec_loop_interp(J, pc, rec_itern(J, ra, rb));
														
 
															+    break;
														
 
															   case BC_LOOP:
														
 
															     rec_loop_interp(J, pc, rec_loop(J, ra, 1));
														
 
															     break;
														
@@ -2451,6 +2580,10 @@ void lj_record_ins(jit_State *J)
 
															       J->maxslot = ra;  /* Shrink used slots. */
														
 
															     break;
														
 
															+  case BC_ISNEXT:
														
 
															+    rec_isnext(J, ra);
														
 
															+    break;
														
 
															+
														
 
															   /* -- Function headers -------------------------------------------------- */
														
 
															   case BC_FUNCF:
														
@@ -2480,8 +2613,6 @@ void lj_record_ins(jit_State *J)
 
															       break;
														
 
															     }
														
 
															     /* fallthrough */
														
 
															-  case BC_ITERN:
														
 
															-  case BC_ISNEXT:
														
 
															   case BC_UCLO:
														
 
															   case BC_FNEW:
														
 
															     setintV(&J->errinfo, (int32_t)op);
														
@@ -2533,6 +2664,13 @@ static const BCIns *rec_setup_root(jit_State *J)
 
															     lj_assertJ(bc_op(pc[-1]) == BC_JMP, "ITERL does not point to JMP+1");
														
 
															     J->bc_min = pc;
														
 
															     break;
														
 
															+  case BC_ITERN:
														
 
															+    lj_assertJ(bc_op(pc[1]) == BC_ITERL, "no ITERL after ITERN");
														
 
															+    J->maxslot = ra;
														
 
															+    J->bc_extent = (MSize)(-bc_j(pc[1]))*sizeof(BCIns);
														
 
															+    J->bc_min = pc+2 + bc_j(pc[1]);
														
 
															+    J->state = LJ_TRACE_RECORD_1ST;  /* Record the first ITERN, too. */
														
 
															+    break;
														
 
															   case BC_LOOP:
														
 
															     /* Only check BC range for real loops, but not for "repeat until true". */
														
 
															     pcj = pc + bc_j(ins);
														
@@ -2629,9 +2767,14 @@ void lj_record_setup(jit_State *J)
 
															     }
														
 
															     lj_snap_replay(J, T);
														
 
															   sidecheck:
														
 
															-    if (traceref(J, J->cur.root)->nchild >= J->param[JIT_P_maxside] ||
														
 
															-	T->snap[J->exitno].count >= J->param[JIT_P_hotexit] +
														
 
															-				    J->param[JIT_P_tryside]) {
														
 
															+    if ((traceref(J, J->cur.root)->nchild >= J->param[JIT_P_maxside] ||
														
 
															+	 T->snap[J->exitno].count >= J->param[JIT_P_hotexit] +
														
 
															+				     J->param[JIT_P_tryside])) {
														
 
															+      if (bc_op(*J->pc) == BC_JLOOP) {
														
 
															+	BCIns startins = traceref(J, bc_d(*J->pc))->startins;
														
 
															+	if (bc_op(startins) == BC_ITERN)
														
 
															+	  rec_itern(J, bc_a(startins), bc_b(startins));
														
 
															+      }
														
 
															       lj_record_stop(J, LJ_TRLINK_INTERP, 0);
														
 
															     }
														
 
															   } else {  /* Root trace. */
														
@@ -2640,6 +2783,7 @@ void lj_record_setup(jit_State *J)
 
															     J->pc = rec_setup_root(J);
														
 
															     /* Note: the loop instruction itself is recorded at the end and not
														
 
															     ** at the start! So snapshot #0 needs to point to the *next* instruction.
														
 
															+    ** The one exception is BC_ITERN, which sets LJ_TRACE_RECORD_1ST.
														
 
															     */
														
 
															     lj_snap_add(J);
														
 
															     if (bc_op(J->cur.startins) == BC_FORL)
														
--- a/libs/LuaJIT/src/lj_record.h
+++ b/libs/LuaJIT/src/lj_record.h
@@ -30,6 +30,7 @@ LJ_FUNC int lj_record_objcmp(jit_State *J, TRef a, TRef b,
 
															 			     cTValue *av, cTValue *bv);
														
 
															 LJ_FUNC void lj_record_stop(jit_State *J, TraceLink linktype, TraceNo lnk);
														
 
															 LJ_FUNC TRef lj_record_constify(jit_State *J, cTValue *o);
														
 
															+LJ_FUNC TRef lj_record_vload(jit_State *J, TRef ref, MSize idx, IRType t);
														
 
															 LJ_FUNC void lj_record_call(jit_State *J, BCReg func, ptrdiff_t nargs);
														
 
															 LJ_FUNC void lj_record_tailcall(jit_State *J, BCReg func, ptrdiff_t nargs);
														
@@ -37,6 +38,7 @@ LJ_FUNC void lj_record_ret(jit_State *J, BCReg rbase, ptrdiff_t gotresults);
 
															 LJ_FUNC int lj_record_mm_lookup(jit_State *J, RecordIndex *ix, MMS mm);
														
 
															 LJ_FUNC TRef lj_record_idx(jit_State *J, RecordIndex *ix);
														
 
															+LJ_FUNC int lj_record_next(jit_State *J, RecordIndex *ix);
														
 
															 LJ_FUNC void lj_record_ins(jit_State *J);
														
 
															 LJ_FUNC void lj_record_setup(jit_State *J);
														
--- a/libs/LuaJIT/src/lj_serialize.c
+++ b/libs/LuaJIT/src/lj_serialize.c
@@ -0,0 +1,538 @@
 
															+/*
														
 
															+** Object de/serialization.
														
 
															+** Copyright (C) 2005-2021 Mike Pall. See Copyright Notice in luajit.h
														
 
															+*/
														
 
															+
														
 
															+#define lj_serialize_c
														
 
															+#define LUA_CORE
														
 
															+
														
 
															+#include "lj_obj.h"
														
 
															+
														
 
															+#if LJ_HASBUFFER
														
 
															+#include "lj_err.h"
														
 
															+#include "lj_buf.h"
														
 
															+#include "lj_str.h"
														
 
															+#include "lj_tab.h"
														
 
															+#include "lj_udata.h"
														
 
															+#if LJ_HASFFI
														
 
															+#include "lj_ctype.h"
														
 
															+#include "lj_cdata.h"
														
 
															+#endif
														
 
															+#if LJ_HASJIT
														
 
															+#include "lj_ir.h"
														
 
															+#endif
														
 
															+#include "lj_serialize.h"
														
 
															+
														
 
															+/* Tags for internal serialization format. */
														
 
															+enum {
														
 
															+  SER_TAG_NIL,		/* 0x00 */
														
 
															+  SER_TAG_FALSE,
														
 
															+  SER_TAG_TRUE,
														
 
															+  SER_TAG_NULL,
														
 
															+  SER_TAG_LIGHTUD32,
														
 
															+  SER_TAG_LIGHTUD64,
														
 
															+  SER_TAG_INT,
														
 
															+  SER_TAG_NUM,
														
 
															+  SER_TAG_TAB,		/* 0x08 */
														
 
															+  SER_TAG_DICT_MT = SER_TAG_TAB+6,
														
 
															+  SER_TAG_DICT_STR,
														
 
															+  SER_TAG_INT64,	/* 0x10 */
														
 
															+  SER_TAG_UINT64,
														
 
															+  SER_TAG_COMPLEX,
														
 
															+  SER_TAG_0x13,
														
 
															+  SER_TAG_0x14,
														
 
															+  SER_TAG_0x15,
														
 
															+  SER_TAG_0x16,
														
 
															+  SER_TAG_0x17,
														
 
															+  SER_TAG_0x18,		/* 0x18 */
														
 
															+  SER_TAG_0x19,
														
 
															+  SER_TAG_0x1a,
														
 
															+  SER_TAG_0x1b,
														
 
															+  SER_TAG_0x1c,
														
 
															+  SER_TAG_0x1d,
														
 
															+  SER_TAG_0x1e,
														
 
															+  SER_TAG_0x1f,
														
 
															+  SER_TAG_STR,		/* 0x20 + str->len */
														
 
															+};
														
 
															+LJ_STATIC_ASSERT((SER_TAG_TAB & 7) == 0);
														
 
															+
														
 
															+/* -- Helper functions ---------------------------------------------------- */
														
 
															+
														
 
															+static LJ_AINLINE char *serialize_more(char *w, SBufExt *sbx, MSize sz)
														
 
															+{
														
 
															+  if (LJ_UNLIKELY(sz > (MSize)(sbx->e - w))) {
														
 
															+    sbx->w = w;
														
 
															+    w = lj_buf_more2((SBuf *)sbx, sz);
														
 
															+  }
														
 
															+  return w;
														
 
															+}
														
 
															+
														
 
															+/* Write U124 to buffer. */
														
 
															+static LJ_NOINLINE char *serialize_wu124_(char *w, uint32_t v)
														
 
															+{
														
 
															+  if (v < 0x1fe0) {
														
 
															+    v -= 0xe0;
														
 
															+    *w++ = (char)(0xe0 | (v >> 8)); *w++ = (char)v;
														
 
															+  } else {
														
 
															+    *w++ = (char)0xff;
														
 
															+#if LJ_BE
														
 
															+    v = lj_bswap(v);
														
 
															+#endif
														
 
															+    memcpy(w, &v, 4); w += 4;
														
 
															+  }
														
 
															+  return w;
														
 
															+}
														
 
															+
														
 
															+static LJ_AINLINE char *serialize_wu124(char *w, uint32_t v)
														
 
															+{
														
 
															+  if (LJ_LIKELY(v < 0xe0)) {
														
 
															+    *w++ = (char)v;
														
 
															+    return w;
														
 
															+  } else {
														
 
															+    return serialize_wu124_(w, v);
														
 
															+  }
														
 
															+}
														
 
															+
														
 
															+static LJ_NOINLINE char *serialize_ru124_(char *r, char *w, uint32_t *pv)
														
 
															+{
														
 
															+  uint32_t v = *pv;
														
 
															+  if (v != 0xff) {
														
 
															+    if (r >= w) return NULL;
														
 
															+    v = ((v & 0x1f) << 8) + *(uint8_t *)r + 0xe0; r++;
														
 
															+  } else {
														
 
															+    if (r + 4 > w) return NULL;
														
 
															+    v = lj_getu32(r); r += 4;
														
 
															+#if LJ_BE
														
 
															+    v = lj_bswap(v);
														
 
															+#endif
														
 
															+  }
														
 
															+  *pv = v;
														
 
															+  return r;
														
 
															+}
														
 
															+
														
 
															+static LJ_AINLINE char *serialize_ru124(char *r, char *w, uint32_t *pv)
														
 
															+{
														
 
															+  if (LJ_LIKELY(r < w)) {
														
 
															+    uint32_t v = *(uint8_t *)r; r++;
														
 
															+    *pv = v;
														
 
															+    if (LJ_UNLIKELY(v >= 0xe0)) {
														
 
															+      r = serialize_ru124_(r, w, pv);
														
 
															+    }
														
 
															+    return r;
														
 
															+  }
														
 
															+  return NULL;
														
 
															+}
														
 
															+
														
 
															+/* Prepare string dictionary for use (once). */
														
 
															+void LJ_FASTCALL lj_serialize_dict_prep_str(lua_State *L, GCtab *dict)
														
 
															+{
														
 
															+  if (!dict->hmask) {  /* No hash part means not prepared, yet. */
														
 
															+    MSize i, len = lj_tab_len(dict);
														
 
															+    if (!len) return;
														
 
															+    lj_tab_resize(L, dict, dict->asize, hsize2hbits(len));
														
 
															+    for (i = 1; i <= len && i < dict->asize; i++) {
														
 
															+      cTValue *o = arrayslot(dict, i);
														
 
															+      if (tvisstr(o)) {
														
 
															+	if (!lj_tab_getstr(dict, strV(o))) {  /* Ignore dups. */
														
 
															+	  lj_tab_newkey(L, dict, o)->u64 = (uint64_t)(i-1);
														
 
															+	}
														
 
															+      } else if (!tvisfalse(o)) {
														
 
															+	lj_err_caller(L, LJ_ERR_BUFFER_BADOPT);
														
 
															+      }
														
 
															+    }
														
 
															+  }
														
 
															+}
														
 
															+
														
 
															+/* Prepare metatable dictionary for use (once). */
														
 
															+void LJ_FASTCALL lj_serialize_dict_prep_mt(lua_State *L, GCtab *dict)
														
 
															+{
														
 
															+  if (!dict->hmask) {  /* No hash part means not prepared, yet. */
														
 
															+    MSize i, len = lj_tab_len(dict);
														
 
															+    if (!len) return;
														
 
															+    lj_tab_resize(L, dict, dict->asize, hsize2hbits(len));
														
 
															+    for (i = 1; i <= len && i < dict->asize; i++) {
														
 
															+      cTValue *o = arrayslot(dict, i);
														
 
															+      if (tvistab(o)) {
														
 
															+	if (tvisnil(lj_tab_get(L, dict, o))) {  /* Ignore dups. */
														
 
															+	  lj_tab_newkey(L, dict, o)->u64 = (uint64_t)(i-1);
														
 
															+	}
														
 
															+      } else if (!tvisfalse(o)) {
														
 
															+	lj_err_caller(L, LJ_ERR_BUFFER_BADOPT);
														
 
															+      }
														
 
															+    }
														
 
															+  }
														
 
															+}
														
 
															+
														
 
															+/* -- Internal serializer ------------------------------------------------- */
														
 
															+
														
 
															+/* Put serialized object into buffer. */
														
 
															+static char *serialize_put(char *w, SBufExt *sbx, cTValue *o)
														
 
															+{
														
 
															+  if (LJ_LIKELY(tvisstr(o))) {
														
 
															+    const GCstr *str = strV(o);
														
 
															+    MSize len = str->len;
														
 
															+    w = serialize_more(w, sbx, 5+len);
														
 
															+    w = serialize_wu124(w, SER_TAG_STR + len);
														
 
															+    w = lj_buf_wmem(w, strdata(str), len);
														
 
															+  } else if (tvisint(o)) {
														
 
															+    uint32_t x = LJ_BE ? lj_bswap((uint32_t)intV(o)) : (uint32_t)intV(o);
														
 
															+    w = serialize_more(w, sbx, 1+4);
														
 
															+    *w++ = SER_TAG_INT; memcpy(w, &x, 4); w += 4;
														
 
															+  } else if (tvisnum(o)) {
														
 
															+    uint64_t x = LJ_BE ? lj_bswap64(o->u64) : o->u64;
														
 
															+    w = serialize_more(w, sbx, 1+sizeof(lua_Number));
														
 
															+    *w++ = SER_TAG_NUM; memcpy(w, &x, 8); w += 8;
														
 
															+  } else if (tvispri(o)) {
														
 
															+    w = serialize_more(w, sbx, 1);
														
 
															+    *w++ = (char)(SER_TAG_NIL + ~itype(o));
														
 
															+  } else if (tvistab(o)) {
														
 
															+    const GCtab *t = tabV(o);
														
 
															+    uint32_t narray = 0, nhash = 0, one = 2;
														
 
															+    if (sbx->depth <= 0) lj_err_caller(sbufL(sbx), LJ_ERR_BUFFER_DEPTH);
														
 
															+    sbx->depth--;
														
 
															+    if (t->asize > 0) {  /* Determine max. length of array part. */
														
 
															+      ptrdiff_t i;
														
 
															+      TValue *array = tvref(t->array);
														
 
															+      for (i = (ptrdiff_t)t->asize-1; i >= 0; i--)
														
 
															+	if (!tvisnil(&array[i]))
														
 
															+	  break;
														
 
															+      narray = (uint32_t)(i+1);
														
 
															+      if (narray && tvisnil(&array[0])) one = 4;
														
 
															+    }
														
 
															+    if (t->hmask > 0) {  /* Count number of used hash slots. */
														
 
															+      uint32_t i, hmask = t->hmask;
														
 
															+      Node *node = noderef(t->node);
														
 
															+      for (i = 0; i <= hmask; i++)
														
 
															+	nhash += !tvisnil(&node[i].val);
														
 
															+    }
														
 
															+    /* Write metatable index. */
														
 
															+    if (LJ_UNLIKELY(tabref(sbx->dict_mt)) && tabref(t->metatable)) {
														
 
															+      TValue mto;
														
 
															+      Node *n;
														
 
															+      settabV(sbufL(sbx), &mto, tabref(t->metatable));
														
 
															+      n = hashgcref(tabref(sbx->dict_mt), mto.gcr);
														
 
															+      do {
														
 
															+	if (n->key.u64 == mto.u64) {
														
 
															+	  uint32_t idx = n->val.u32.lo;
														
 
															+	  w = serialize_more(w, sbx, 1+5);
														
 
															+	  *w++ = SER_TAG_DICT_MT;
														
 
															+	  w = serialize_wu124(w, idx);
														
 
															+	  break;
														
 
															+	}
														
 
															+      } while ((n = nextnode(n)));
														
 
															+    }
														
 
															+    /* Write number of array slots and hash slots. */
														
 
															+    w = serialize_more(w, sbx, 1+2*5);
														
 
															+    *w++ = (char)(SER_TAG_TAB + (nhash ? 1 : 0) + (narray ? one : 0));
														
 
															+    if (narray) w = serialize_wu124(w, narray);
														
 
															+    if (nhash) w = serialize_wu124(w, nhash);
														
 
															+    if (narray) {  /* Write array entries. */
														
 
															+      cTValue *oa = tvref(t->array) + (one >> 2);
														
 
															+      cTValue *oe = tvref(t->array) + narray;
														
 
															+      while (oa < oe) w = serialize_put(w, sbx, oa++);
														
 
															+    }
														
 
															+    if (nhash) {  /* Write hash entries. */
														
 
															+      const Node *node = noderef(t->node) + t->hmask;
														
 
															+      GCtab *dict_str = tabref(sbx->dict_str);
														
 
															+      if (LJ_UNLIKELY(dict_str)) {
														
 
															+	for (;; node--)
														
 
															+	  if (!tvisnil(&node->val)) {
														
 
															+	    if (LJ_LIKELY(tvisstr(&node->key))) {
														
 
															+	      /* Inlined lj_tab_getstr is 30% faster. */
														
 
															+	      const GCstr *str = strV(&node->key);
														
 
															+	      Node *n = hashstr(dict_str, str);
														
 
															+	      do {
														
 
															+		if (tvisstr(&n->key) && strV(&n->key) == str) {
														
 
															+		  uint32_t idx = n->val.u32.lo;
														
 
															+		  w = serialize_more(w, sbx, 1+5);
														
 
															+		  *w++ = SER_TAG_DICT_STR;
														
 
															+		  w = serialize_wu124(w, idx);
														
 
															+		  break;
														
 
															+		}
														
 
															+		n = nextnode(n);
														
 
															+		if (!n) {
														
 
															+		  MSize len = str->len;
														
 
															+		  w = serialize_more(w, sbx, 5+len);
														
 
															+		  w = serialize_wu124(w, SER_TAG_STR + len);
														
 
															+		  w = lj_buf_wmem(w, strdata(str), len);
														
 
															+		  break;
														
 
															+		}
														
 
															+	      } while (1);
														
 
															+	    } else {
														
 
															+	      w = serialize_put(w, sbx, &node->key);
														
 
															+	    }
														
 
															+	    w = serialize_put(w, sbx, &node->val);
														
 
															+	    if (--nhash == 0) break;
														
 
															+	  }
														
 
															+      } else {
														
 
															+	for (;; node--)
														
 
															+	  if (!tvisnil(&node->val)) {
														
 
															+	    w = serialize_put(w, sbx, &node->key);
														
 
															+	    w = serialize_put(w, sbx, &node->val);
														
 
															+	    if (--nhash == 0) break;
														
 
															+	  }
														
 
															+      }
														
 
															+    }
														
 
															+    sbx->depth++;
														
 
															+#if LJ_HASFFI
														
 
															+  } else if (tviscdata(o)) {
														
 
															+    CTState *cts = ctype_cts(sbufL(sbx));
														
 
															+    CType *s = ctype_raw(cts, cdataV(o)->ctypeid);
														
 
															+    uint8_t *sp = cdataptr(cdataV(o));
														
 
															+    if (ctype_isinteger(s->info) && s->size == 8) {
														
 
															+      w = serialize_more(w, sbx, 1+8);
														
 
															+      *w++ = (s->info & CTF_UNSIGNED) ? SER_TAG_UINT64 : SER_TAG_INT64;
														
 
															+#if LJ_BE
														
 
															+      { uint64_t u = lj_bswap64(*(uint64_t *)sp); memcpy(w, &u, 8); }
														
 
															+#else
														
 
															+      memcpy(w, sp, 8);
														
 
															+#endif
														
 
															+      w += 8;
														
 
															+    } else if (ctype_iscomplex(s->info) && s->size == 16) {
														
 
															+      w = serialize_more(w, sbx, 1+16);
														
 
															+      *w++ = SER_TAG_COMPLEX;
														
 
															+#if LJ_BE
														
 
															+      {  /* Only swap the doubles. The re/im order stays the same. */
														
 
															+	uint64_t u = lj_bswap64(((uint64_t *)sp)[0]); memcpy(w, &u, 8);
														
 
															+	u = lj_bswap64(((uint64_t *)sp)[1]); memcpy(w+8, &u, 8);
														
 
															+      }
														
 
															+#else
														
 
															+      memcpy(w, sp, 16);
														
 
															+#endif
														
 
															+      w += 16;
														
 
															+    } else {
														
 
															+      goto badenc;  /* NYI other cdata */
														
 
															+    }
														
 
															+#endif
														
 
															+  } else if (tvislightud(o)) {
														
 
															+    uintptr_t ud = (uintptr_t)lightudV(G(sbufL(sbx)), o);
														
 
															+    w = serialize_more(w, sbx, 1+sizeof(ud));
														
 
															+    if (ud == 0) {
														
 
															+      *w++ = SER_TAG_NULL;
														
 
															+    } else if (LJ_32 || checku32(ud)) {
														
 
															+#if LJ_BE && LJ_64
														
 
															+      ud = lj_bswap64(ud);
														
 
															+#elif LJ_BE
														
 
															+      ud = lj_bswap(ud);
														
 
															+#endif
														
 
															+      *w++ = SER_TAG_LIGHTUD32; memcpy(w, &ud, 4); w += 4;
														
 
															+#if LJ_64
														
 
															+    } else {
														
 
															+#if LJ_BE
														
 
															+      ud = lj_bswap64(ud);
														
 
															+#endif
														
 
															+      *w++ = SER_TAG_LIGHTUD64; memcpy(w, &ud, 8); w += 8;
														
 
															+#endif
														
 
															+    }
														
 
															+  } else {
														
 
															+    /* NYI userdata */
														
 
															+#if LJ_HASFFI
														
 
															+  badenc:
														
 
															+#endif
														
 
															+    lj_err_callerv(sbufL(sbx), LJ_ERR_BUFFER_BADENC, lj_typename(o));
														
 
															+  }
														
 
															+  return w;
														
 
															+}
														
 
															+
														
 
															+/* Get serialized object from buffer. */
														
 
															+static char *serialize_get(char *r, SBufExt *sbx, TValue *o)
														
 
															+{
														
 
															+  char *w = sbx->w;
														
 
															+  uint32_t tp;
														
 
															+  r = serialize_ru124(r, w, &tp); if (LJ_UNLIKELY(!r)) goto eob;
														
 
															+  if (LJ_LIKELY(tp >= SER_TAG_STR)) {
														
 
															+    uint32_t len = tp - SER_TAG_STR;
														
 
															+    if (LJ_UNLIKELY(len > (uint32_t)(w - r))) goto eob;
														
 
															+    setstrV(sbufL(sbx), o, lj_str_new(sbufL(sbx), r, len));
														
 
															+    r += len;
														
 
															+  } else if (tp == SER_TAG_INT) {
														
 
															+    if (LJ_UNLIKELY(r + 4 > w)) goto eob;
														
 
															+    setintV(o, (int32_t)(LJ_BE ? lj_bswap(lj_getu32(r)) : lj_getu32(r)));
														
 
															+    r += 4;
														
 
															+  } else if (tp == SER_TAG_NUM) {
														
 
															+    if (LJ_UNLIKELY(r + 8 > w)) goto eob;
														
 
															+    memcpy(o, r, 8); r += 8;
														
 
															+#if LJ_BE
														
 
															+    o->u64 = lj_bswap64(o->u64);
														
 
															+#endif
														
 
															+    if (!tvisnum(o)) setnanV(o);  /* Fix non-canonical NaNs. */
														
 
															+  } else if (tp <= SER_TAG_TRUE) {
														
 
															+    setpriV(o, ~tp);
														
 
															+  } else if (tp == SER_TAG_DICT_STR) {
														
 
															+    GCtab *dict_str;
														
 
															+    uint32_t idx;
														
 
															+    r = serialize_ru124(r, w, &idx); if (LJ_UNLIKELY(!r)) goto eob;
														
 
															+    idx++;
														
 
															+    dict_str = tabref(sbx->dict_str);
														
 
															+    if (dict_str && idx < dict_str->asize && tvisstr(arrayslot(dict_str, idx)))
														
 
															+      copyTV(sbufL(sbx), o, arrayslot(dict_str, idx));
														
 
															+    else
														
 
															+      lj_err_callerv(sbufL(sbx), LJ_ERR_BUFFER_BADDICTX, idx);
														
 
															+  } else if (tp >= SER_TAG_TAB && tp <= SER_TAG_DICT_MT) {
														
 
															+    uint32_t narray = 0, nhash = 0;
														
 
															+    GCtab *t, *mt = NULL;
														
 
															+    if (sbx->depth <= 0) lj_err_caller(sbufL(sbx), LJ_ERR_BUFFER_DEPTH);
														
 
															+    sbx->depth--;
														
 
															+    if (tp == SER_TAG_DICT_MT) {
														
 
															+      GCtab *dict_mt;
														
 
															+      uint32_t idx;
														
 
															+      r = serialize_ru124(r, w, &idx); if (LJ_UNLIKELY(!r)) goto eob;
														
 
															+      idx++;
														
 
															+      dict_mt = tabref(sbx->dict_mt);
														
 
															+      if (dict_mt && idx < dict_mt->asize && tvistab(arrayslot(dict_mt, idx)))
														
 
															+	mt = tabV(arrayslot(dict_mt, idx));
														
 
															+      else
														
 
															+	lj_err_callerv(sbufL(sbx), LJ_ERR_BUFFER_BADDICTX, idx);
														
 
															+      r = serialize_ru124(r, w, &tp); if (LJ_UNLIKELY(!r)) goto eob;
														
 
															+      if (!(tp >= SER_TAG_TAB && tp < SER_TAG_DICT_MT)) goto badtag;
														
 
															+    }
														
 
															+    if (tp >= SER_TAG_TAB+2) {
														
 
															+      r = serialize_ru124(r, w, &narray); if (LJ_UNLIKELY(!r)) goto eob;
														
 
															+    }
														
 
															+    if ((tp & 1)) {
														
 
															+      r = serialize_ru124(r, w, &nhash); if (LJ_UNLIKELY(!r)) goto eob;
														
 
															+    }
														
 
															+    t = lj_tab_new(sbufL(sbx), narray, hsize2hbits(nhash));
														
 
															+    /* NOBARRIER: The table is new (marked white). */
														
 
															+    setgcref(t->metatable, obj2gco(mt));
														
 
															+    settabV(sbufL(sbx), o, t);
														
 
															+    if (narray) {
														
 
															+      TValue *oa = tvref(t->array) + (tp >= SER_TAG_TAB+4);
														
 
															+      TValue *oe = tvref(t->array) + narray;
														
 
															+      while (oa < oe) r = serialize_get(r, sbx, oa++);
														
 
															+    }
														
 
															+    if (nhash) {
														
 
															+      do {
														
 
															+	TValue k, *v;
														
 
															+	r = serialize_get(r, sbx, &k);
														
 
															+	v = lj_tab_set(sbufL(sbx), t, &k);
														
 
															+	if (LJ_UNLIKELY(!tvisnil(v)))
														
 
															+	  lj_err_caller(sbufL(sbx), LJ_ERR_BUFFER_DUPKEY);
														
 
															+	r = serialize_get(r, sbx, v);
														
 
															+      } while (--nhash);
														
 
															+    }
														
 
															+    sbx->depth++;
														
 
															+#if LJ_HASFFI
														
 
															+  } else if (tp >= SER_TAG_INT64 &&  tp <= SER_TAG_COMPLEX) {
														
 
															+    uint32_t sz = tp == SER_TAG_COMPLEX ? 16 : 8;
														
 
															+    GCcdata *cd;
														
 
															+    if (LJ_UNLIKELY(r + sz > w)) goto eob;
														
 
															+    cd = lj_cdata_new_(sbufL(sbx),
														
 
															+	   tp == SER_TAG_INT64 ? CTID_INT64 :
														
 
															+	   tp == SER_TAG_UINT64 ? CTID_UINT64 : CTID_COMPLEX_DOUBLE,
														
 
															+	   sz);
														
 
															+    memcpy(cdataptr(cd), r, sz); r += sz;
														
 
															+#if LJ_BE
														
 
															+    *(uint64_t *)cdataptr(cd) = lj_bswap64(*(uint64_t *)cdataptr(cd));
														
 
															+    if (sz == 16)
														
 
															+      ((uint64_t *)cdataptr(cd))[1] = lj_bswap64(((uint64_t *)cdataptr(cd))[1]);
														
 
															+#endif
														
 
															+    if (sz == 16) {  /* Fix non-canonical NaNs. */
														
 
															+      TValue *cdo = (TValue *)cdataptr(cd);
														
 
															+      if (!tvisnum(&cdo[0])) setnanV(&cdo[0]);
														
 
															+      if (!tvisnum(&cdo[1])) setnanV(&cdo[1]);
														
 
															+    }
														
 
															+    setcdataV(sbufL(sbx), o, cd);
														
 
															+#endif
														
 
															+  } else if (tp <= (LJ_64 ? SER_TAG_LIGHTUD64 : SER_TAG_LIGHTUD32)) {
														
 
															+    uintptr_t ud = 0;
														
 
															+    if (tp == SER_TAG_LIGHTUD32) {
														
 
															+      if (LJ_UNLIKELY(r + 4 > w)) goto eob;
														
 
															+      ud = (uintptr_t)(LJ_BE ? lj_bswap(lj_getu32(r)) : lj_getu32(r));
														
 
															+      r += 4;
														
 
															+    }
														
 
															+#if LJ_64
														
 
															+    else if (tp == SER_TAG_LIGHTUD64) {
														
 
															+      if (LJ_UNLIKELY(r + 8 > w)) goto eob;
														
 
															+      memcpy(&ud, r, 8); r += 8;
														
 
															+#if LJ_BE
														
 
															+      ud = lj_bswap64(ud);
														
 
															+#endif
														
 
															+    }
														
 
															+    setrawlightudV(o, lj_lightud_intern(sbufL(sbx), (void *)ud));
														
 
															+#else
														
 
															+    setrawlightudV(o, (void *)ud);
														
 
															+#endif
														
 
															+  } else {
														
 
															+badtag:
														
 
															+    lj_err_callerv(sbufL(sbx), LJ_ERR_BUFFER_BADDEC, tp);
														
 
															+  }
														
 
															+  return r;
														
 
															+eob:
														
 
															+  lj_err_caller(sbufL(sbx), LJ_ERR_BUFFER_EOB);
														
 
															+  return NULL;
														
 
															+}
														
 
															+
														
 
															+/* -- External serialization API ------------------------------------------ */
														
 
															+
														
 
															+/* Encode to buffer. */
														
 
															+SBufExt * LJ_FASTCALL lj_serialize_put(SBufExt *sbx, cTValue *o)
														
 
															+{
														
 
															+  sbx->depth = LJ_SERIALIZE_DEPTH;
														
 
															+  sbx->w = serialize_put(sbx->w, sbx, o);
														
 
															+  return sbx;
														
 
															+}
														
 
															+
														
 
															+/* Decode from buffer. */
														
 
															+char * LJ_FASTCALL lj_serialize_get(SBufExt *sbx, TValue *o)
														
 
															+{
														
 
															+  sbx->depth = LJ_SERIALIZE_DEPTH;
														
 
															+  return serialize_get(sbx->r, sbx, o);
														
 
															+}
														
 
															+
														
 
															+/* Stand-alone encoding, borrowing from global temporary buffer. */
														
 
															+GCstr * LJ_FASTCALL lj_serialize_encode(lua_State *L, cTValue *o)
														
 
															+{
														
 
															+  SBufExt sbx;
														
 
															+  char *w;
														
 
															+  memset(&sbx, 0, sizeof(SBufExt));
														
 
															+  lj_bufx_set_borrow(L, &sbx, &G(L)->tmpbuf);
														
 
															+  sbx.depth = LJ_SERIALIZE_DEPTH;
														
 
															+  w = serialize_put(sbx.w, &sbx, o);
														
 
															+  return lj_str_new(L, sbx.b, (size_t)(w - sbx.b));
														
 
															+}
														
 
															+
														
 
															+/* Stand-alone decoding, copy-on-write from string. */
														
 
															+void lj_serialize_decode(lua_State *L, TValue *o, GCstr *str)
														
 
															+{
														
 
															+  SBufExt sbx;
														
 
															+  char *r;
														
 
															+  memset(&sbx, 0, sizeof(SBufExt));
														
 
															+  lj_bufx_set_cow(L, &sbx, strdata(str), str->len);
														
 
															+  /* No need to set sbx.cowref here. */
														
 
															+  sbx.depth = LJ_SERIALIZE_DEPTH;
														
 
															+  r = serialize_get(sbx.r, &sbx, o);
														
 
															+  if (r != sbx.w) lj_err_caller(L, LJ_ERR_BUFFER_LEFTOV);
														
 
															+}
														
 
															+
														
 
															+#if LJ_HASJIT
														
 
															+/* Peek into buffer to find the result IRType for specialization purposes. */
														
 
															+LJ_FUNC MSize LJ_FASTCALL lj_serialize_peektype(SBufExt *sbx)
														
 
															+{
														
 
															+  uint32_t tp;
														
 
															+  if (serialize_ru124(sbx->r, sbx->w, &tp)) {
														
 
															+    /* This must match the handling of all tags in the decoder above. */
														
 
															+    switch (tp) {
														
 
															+    case SER_TAG_NIL: return IRT_NIL;
														
 
															+    case SER_TAG_FALSE: return IRT_FALSE;
														
 
															+    case SER_TAG_TRUE: return IRT_TRUE;
														
 
															+    case SER_TAG_NULL: case SER_TAG_LIGHTUD32: case SER_TAG_LIGHTUD64:
														
 
															+      return IRT_LIGHTUD;
														
 
															+    case SER_TAG_INT: return LJ_DUALNUM ? IRT_INT : IRT_NUM;
														
 
															+    case SER_TAG_NUM: return IRT_NUM;
														
 
															+    case SER_TAG_TAB: case SER_TAG_TAB+1: case SER_TAG_TAB+2:
														
 
															+    case SER_TAG_TAB+3: case SER_TAG_TAB+4: case SER_TAG_TAB+5:
														
 
															+    case SER_TAG_DICT_MT:
														
 
															+      return IRT_TAB;
														
 
															+    case SER_TAG_INT64: case SER_TAG_UINT64: case SER_TAG_COMPLEX:
														
 
															+      return IRT_CDATA;
														
 
															+    case SER_TAG_DICT_STR:
														
 
															+    default:
														
 
															+      return IRT_STR;
														
 
															+    }
														
 
															+  }
														
 
															+  return IRT_NIL;  /* Will fail on actual decode. */
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															+#endif
														
--- a/libs/LuaJIT/src/lj_serialize.h
+++ b/libs/LuaJIT/src/lj_serialize.h
@@ -0,0 +1,28 @@
 
															+/*
														
 
															+** Object de/serialization.
														
 
															+** Copyright (C) 2005-2021 Mike Pall. See Copyright Notice in luajit.h
														
 
															+*/
														
 
															+
														
 
															+#ifndef _LJ_SERIALIZE_H
														
 
															+#define _LJ_SERIALIZE_H
														
 
															+
														
 
															+#include "lj_obj.h"
														
 
															+#include "lj_buf.h"
														
 
															+
														
 
															+#if LJ_HASBUFFER
														
 
															+
														
 
															+#define LJ_SERIALIZE_DEPTH	100	/* Default depth. */
														
 
															+
														
 
															+LJ_FUNC void LJ_FASTCALL lj_serialize_dict_prep_str(lua_State *L, GCtab *dict);
														
 
															+LJ_FUNC void LJ_FASTCALL lj_serialize_dict_prep_mt(lua_State *L, GCtab *dict);
														
 
															+LJ_FUNC SBufExt * LJ_FASTCALL lj_serialize_put(SBufExt *sbx, cTValue *o);
														
 
															+LJ_FUNC char * LJ_FASTCALL lj_serialize_get(SBufExt *sbx, TValue *o);
														
 
															+LJ_FUNC GCstr * LJ_FASTCALL lj_serialize_encode(lua_State *L, cTValue *o);
														
 
															+LJ_FUNC void lj_serialize_decode(lua_State *L, TValue *o, GCstr *str);
														
 
															+#if LJ_HASJIT
														
 
															+LJ_FUNC MSize LJ_FASTCALL lj_serialize_peektype(SBufExt *sbx);
														
 
															+#endif
														
 
															+
														
 
															+#endif
														
 
															+
														
 
															+#endif
														
--- a/libs/LuaJIT/src/lj_snap.c
+++ b/libs/LuaJIT/src/lj_snap.c
@@ -171,6 +171,7 @@ static void snapshot_stack(jit_State *J, SnapShot *snap, MSize nsnapmap)
 
															   nent += snapshot_framelinks(J, p + nent, &snap->topslot);
														
 
															   snap->mapofs = (uint32_t)nsnapmap;
														
 
															   snap->ref = (IRRef1)J->cur.nins;
														
 
															+  snap->mcofs = 0;
														
 
															   snap->nslots = (uint8_t)nslots;
														
 
															   snap->count = 0;
														
 
															   J->cur.nsnapmap = (uint32_t)(nsnapmap + nent);
														
@@ -251,7 +252,12 @@ static BCReg snap_usedef(jit_State *J, uint8_t *udf,
 
															       BCReg minslot = bc_a(ins);
														
 
															       if (op >= BC_FORI && op <= BC_JFORL) minslot += FORL_EXT;
														
 
															       else if (op >= BC_ITERL && op <= BC_JITERL) minslot += bc_b(pc[-2])-1;
														
 
															-      else if (op == BC_UCLO) { pc += bc_j(ins); break; }
														
 
															+      else if (op == BC_UCLO) {
														
 
															+	ptrdiff_t delta = bc_j(ins);
														
 
															+	if (delta < 0) return maxslot;  /* Prevent loop. */
														
 
															+	pc += delta;
														
 
															+	break;
														
 
															+      }
														
 
															       for (s = minslot; s < maxslot; s++) DEF_SLOT(s);
														
 
															       return minslot < maxslot ? minslot : maxslot;
														
 
															       }
														
@@ -275,7 +281,7 @@ static BCReg snap_usedef(jit_State *J, uint8_t *udf,
 
															        if (!(op == BC_ISTC || op == BC_ISFC)) DEF_SLOT(bc_a(ins));
														
 
															        break;
														
 
															     case BCMbase:
														
 
															-      if (op >= BC_CALLM && op <= BC_VARG) {
														
 
															+      if (op >= BC_CALLM && op <= BC_ITERN) {
														
 
															 	BCReg top = (op == BC_CALLM || op == BC_CALLMT || bc_c(ins) == 0) ?
														
 
															 		    maxslot : (bc_a(ins) + bc_c(ins)+LJ_FR2);
														
 
															 	if (LJ_FR2) DEF_SLOT(bc_a(ins)+1);
														
@@ -286,6 +292,8 @@ static BCReg snap_usedef(jit_State *J, uint8_t *udf,
 
															 	  for (s = 0; s < bc_a(ins); s++) DEF_SLOT(s);
														
 
															 	  return 0;
														
 
															 	}
														
 
															+      } else if (op == BC_VARG) {
														
 
															+	return maxslot;  /* NYI: punt. */
														
 
															       } else if (op == BC_KNIL) {
														
 
															 	for (s = bc_a(ins); s <= bc_d(ins); s++) DEF_SLOT(s);
														
 
															       } else if (op == BC_TSETM) {
														
@@ -304,15 +312,45 @@ static BCReg snap_usedef(jit_State *J, uint8_t *udf,
 
															   return 0;  /* unreachable */
														
 
															 }
														
 
															+/* Mark slots used by upvalues of child prototypes as used. */
														
 
															+void snap_useuv(GCproto *pt, uint8_t *udf)
														
 
															+{
														
 
															+  /* This is a coarse check, because it's difficult to correlate the lifetime
														
 
															+  ** of slots and closures. But the number of false positives is quite low.
														
 
															+  ** A false positive may cause a slot not to be purged, which is just
														
 
															+  ** a missed optimization.
														
 
															+  */
														
 
															+  if ((pt->flags & PROTO_CHILD)) {
														
 
															+    ptrdiff_t i, j, n = pt->sizekgc;
														
 
															+    GCRef *kr = mref(pt->k, GCRef) - 1;
														
 
															+    for (i = 0; i < n; i++, kr--) {
														
 
															+      GCobj *o = gcref(*kr);
														
 
															+      if (o->gch.gct == ~LJ_TPROTO) {
														
 
															+	for (j = 0; j < gco2pt(o)->sizeuv; j++) {
														
 
															+	  uint32_t v = proto_uv(gco2pt(o))[j];
														
 
															+	  if ((v & PROTO_UV_LOCAL)) {
														
 
															+	    udf[(v & 0xff)] = 0;
														
 
															+	  }
														
 
															+	}
														
 
															+      }
														
 
															+    }
														
 
															+  }
														
 
															+}
														
 
															+
														
 
															 /* Purge dead slots before the next snapshot. */
														
 
															 void lj_snap_purge(jit_State *J)
														
 
															 {
														
 
															   uint8_t udf[SNAP_USEDEF_SLOTS];
														
 
															-  BCReg maxslot = J->maxslot;
														
 
															-  BCReg s = snap_usedef(J, udf, J->pc, maxslot);
														
 
															-  for (; s < maxslot; s++)
														
 
															-    if (udf[s] != 0)
														
 
															-      J->base[s] = 0;  /* Purge dead slots. */
														
 
															+  BCReg s, maxslot = J->maxslot;
														
 
															+  if (bc_op(*J->pc) == BC_FUNCV && maxslot > J->pt->numparams)
														
 
															+    maxslot = J->pt->numparams;
														
 
															+  s = snap_usedef(J, udf, J->pc, maxslot);
														
 
															+  if (s < maxslot) {
														
 
															+    snap_useuv(J->pt, udf);
														
 
															+    for (; s < maxslot; s++)
														
 
															+      if (udf[s] != 0)
														
 
															+	J->base[s] = 0;  /* Purge dead slots. */
														
 
															+  }
														
 
															 }
														
 
															 /* Shrink last snapshot. */
														
@@ -325,6 +363,7 @@ void lj_snap_shrink(jit_State *J)
 
															   BCReg maxslot = J->maxslot;
														
 
															   BCReg baseslot = J->baseslot;
														
 
															   BCReg minslot = snap_usedef(J, udf, snap_pc(&map[nent]), maxslot);
														
 
															+  if (minslot < maxslot) snap_useuv(J->pt, udf);
														
 
															   maxslot += baseslot;
														
 
															   minslot += baseslot;
														
 
															   snap->nslots = (uint8_t)maxslot;
														
@@ -424,7 +463,7 @@ static TRef snap_dedup(jit_State *J, SnapEntry *map, MSize nmax, IRRef ref)
 
															   MSize j;
														
 
															   for (j = 0; j < nmax; j++)
														
 
															     if (snap_ref(map[j]) == ref)
														
 
															-      return J->slot[snap_slot(map[j])] & ~(SNAP_CONT|SNAP_FRAME);
														
 
															+      return J->slot[snap_slot(map[j])] & ~(SNAP_KEYINDEX|SNAP_CONT|SNAP_FRAME);
														
 
															   return 0;
														
 
															 }
														
@@ -499,10 +538,12 @@ void lj_snap_replay(jit_State *J, GCtrace *T)
 
															       uint32_t mode = IRSLOAD_INHERIT|IRSLOAD_PARENT;
														
 
															       if (LJ_SOFTFP32 && (sn & SNAP_SOFTFPNUM)) t = IRT_NUM;
														
 
															       if (ir->o == IR_SLOAD) mode |= (ir->op2 & IRSLOAD_READONLY);
														
 
															+      if ((sn & SNAP_KEYINDEX)) mode |= IRSLOAD_KEYINDEX;
														
 
															       tr = emitir_raw(IRT(IR_SLOAD, t), s, mode);
														
 
															     }
														
 
															   setslot:
														
 
															-    J->slot[s] = tr | (sn&(SNAP_CONT|SNAP_FRAME));  /* Same as TREF_* flags. */
														
 
															+    /* Same as TREF_* flags. */
														
 
															+    J->slot[s] = tr | (sn&(SNAP_KEYINDEX|SNAP_CONT|SNAP_FRAME));
														
 
															     J->framedepth += ((sn & (SNAP_CONT|SNAP_FRAME)) && (s != LJ_FR2));
														
 
															     if ((sn & SNAP_FRAME))
														
 
															       J->baseslot = s+1;
														
@@ -922,6 +963,10 @@ const BCIns *lj_snap_restore(jit_State *J, void *exptr)
 
															 	setframe_ftsz(o, snap_slot(sn) != 0 ? (int32_t)*flinks-- : ftsz0);
														
 
															 	L->base = o+1;
														
 
															 #endif
														
 
															+      } else if ((sn & SNAP_KEYINDEX)) {
														
 
															+	/* A IRT_INT key index slot is restored as a number. Undo this. */
														
 
															+	o->u32.lo = (uint32_t)(LJ_DUALNUM ? intV(o) : lj_num2int(numV(o)));
														
 
															+	o->u32.hi = LJ_KEYINDEX;
														
 
															       }
														
 
															     }
														
 
															   }
														
--- a/libs/LuaJIT/src/lj_state.c
+++ b/libs/LuaJIT/src/lj_state.c
@@ -156,6 +156,7 @@ static TValue *cpluaopen(lua_State *L, lua_CFunction dummy, void *ud)
 
															   fixstring(lj_err_str(L, LJ_ERR_ERRMEM));  /* Preallocate memory error msg. */
														
 
															   g->gc.threshold = 4*g->gc.total;
														
 
															   lj_trace_initstate(g);
														
 
															+  lj_err_verify();
														
 
															   return NULL;
														
 
															 }
														
--- a/libs/LuaJIT/src/lj_strfmt.c
+++ b/libs/LuaJIT/src/lj_strfmt.c
@@ -9,11 +9,17 @@
 
															 #define LUA_CORE
														
 
															 #include "lj_obj.h"
														
 
															+#include "lj_err.h"
														
 
															 #include "lj_buf.h"
														
 
															 #include "lj_str.h"
														
 
															+#include "lj_meta.h"
														
 
															 #include "lj_state.h"
														
 
															 #include "lj_char.h"
														
 
															 #include "lj_strfmt.h"
														
 
															+#if LJ_HASFFI
														
 
															+#include "lj_ctype.h"
														
 
															+#endif
														
 
															+#include "lj_lib.h"
														
 
															 /* -- Format parser ------------------------------------------------------- */
														
@@ -161,6 +167,10 @@ const char *lj_strfmt_wstrnum(lua_State *L, cTValue *o, MSize *lenp)
 
															   if (tvisstr(o)) {
														
 
															     *lenp = strV(o)->len;
														
 
															     return strVdata(o);
														
 
															+  } else if (tvisbuf(o)) {
														
 
															+    SBufExt *sbx = bufV(o);
														
 
															+    *lenp = sbufxlen(sbx);
														
 
															+    return sbx->r;
														
 
															   } else if (tvisint(o)) {
														
 
															     sb = lj_strfmt_putint(lj_buf_tmp_(L), intV(o));
														
 
															   } else if (tvisnum(o)) {
														
@@ -169,7 +179,7 @@ const char *lj_strfmt_wstrnum(lua_State *L, cTValue *o, MSize *lenp)
 
															     return NULL;
														
 
															   }
														
 
															   *lenp = sbuflen(sb);
														
 
															-  return sbufB(sb);
														
 
															+  return sb->b;
														
 
															 }
														
 
															 /* -- Unformatted conversions to buffer ----------------------------------- */
														
@@ -177,7 +187,7 @@ const char *lj_strfmt_wstrnum(lua_State *L, cTValue *o, MSize *lenp)
 
															 /* Add integer to buffer. */
														
 
															 SBuf * LJ_FASTCALL lj_strfmt_putint(SBuf *sb, int32_t k)
														
 
															 {
														
 
															-  setsbufP(sb, lj_strfmt_wint(lj_buf_more(sb, STRFMT_MAXBUF_INT), k));
														
 
															+  sb->w = lj_strfmt_wint(lj_buf_more(sb, STRFMT_MAXBUF_INT), k);
														
 
															   return sb;
														
 
															 }
														
@@ -191,73 +201,86 @@ SBuf * LJ_FASTCALL lj_strfmt_putnum(SBuf *sb, cTValue *o)
 
															 SBuf * LJ_FASTCALL lj_strfmt_putptr(SBuf *sb, const void *v)
														
 
															 {
														
 
															-  setsbufP(sb, lj_strfmt_wptr(lj_buf_more(sb, STRFMT_MAXBUF_PTR), v));
														
 
															+  sb->w = lj_strfmt_wptr(lj_buf_more(sb, STRFMT_MAXBUF_PTR), v);
														
 
															   return sb;
														
 
															 }
														
 
															 /* Add quoted string to buffer. */
														
 
															-SBuf * LJ_FASTCALL lj_strfmt_putquoted(SBuf *sb, GCstr *str)
														
 
															+static SBuf *strfmt_putquotedlen(SBuf *sb, const char *s, MSize len)
														
 
															 {
														
 
															-  const char *s = strdata(str);
														
 
															-  MSize len = str->len;
														
 
															   lj_buf_putb(sb, '"');
														
 
															   while (len--) {
														
 
															     uint32_t c = (uint32_t)(uint8_t)*s++;
														
 
															-    char *p = lj_buf_more(sb, 4);
														
 
															+    char *w = lj_buf_more(sb, 4);
														
 
															     if (c == '"' || c == '\\' || c == '\n') {
														
 
															-      *p++ = '\\';
														
 
															+      *w++ = '\\';
														
 
															     } else if (lj_char_iscntrl(c)) {  /* This can only be 0-31 or 127. */
														
 
															       uint32_t d;
														
 
															-      *p++ = '\\';
														
 
															+      *w++ = '\\';
														
 
															       if (c >= 100 || lj_char_isdigit((uint8_t)*s)) {
														
 
															-	*p++ = (char)('0'+(c >= 100)); if (c >= 100) c -= 100;
														
 
															+	*w++ = (char)('0'+(c >= 100)); if (c >= 100) c -= 100;
														
 
															 	goto tens;
														
 
															       } else if (c >= 10) {
														
 
															       tens:
														
 
															-	d = (c * 205) >> 11; c -= d * 10; *p++ = (char)('0'+d);
														
 
															+	d = (c * 205) >> 11; c -= d * 10; *w++ = (char)('0'+d);
														
 
															       }
														
 
															       c += '0';
														
 
															     }
														
 
															-    *p++ = (char)c;
														
 
															-    setsbufP(sb, p);
														
 
															+    *w++ = (char)c;
														
 
															+    sb->w = w;
														
 
															   }
														
 
															   lj_buf_putb(sb, '"');
														
 
															   return sb;
														
 
															 }
														
 
															+#if LJ_HASJIT
														
 
															+SBuf * LJ_FASTCALL lj_strfmt_putquoted(SBuf *sb, GCstr *str)
														
 
															+{
														
 
															+  return strfmt_putquotedlen(sb, strdata(str), str->len);
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															 /* -- Formatted conversions to buffer ------------------------------------- */
														
 
															 /* Add formatted char to buffer. */
														
 
															 SBuf *lj_strfmt_putfchar(SBuf *sb, SFormat sf, int32_t c)
														
 
															 {
														
 
															   MSize width = STRFMT_WIDTH(sf);
														
 
															-  char *p = lj_buf_more(sb, width > 1 ? width : 1);
														
 
															-  if ((sf & STRFMT_F_LEFT)) *p++ = (char)c;
														
 
															-  while (width-- > 1) *p++ = ' ';
														
 
															-  if (!(sf & STRFMT_F_LEFT)) *p++ = (char)c;
														
 
															-  setsbufP(sb, p);
														
 
															+  char *w = lj_buf_more(sb, width > 1 ? width : 1);
														
 
															+  if ((sf & STRFMT_F_LEFT)) *w++ = (char)c;
														
 
															+  while (width-- > 1) *w++ = ' ';
														
 
															+  if (!(sf & STRFMT_F_LEFT)) *w++ = (char)c;
														
 
															+  sb->w = w;
														
 
															   return sb;
														
 
															 }
														
 
															 /* Add formatted string to buffer. */
														
 
															-SBuf *lj_strfmt_putfstr(SBuf *sb, SFormat sf, GCstr *str)
														
 
															+static SBuf *strfmt_putfstrlen(SBuf *sb, SFormat sf, const char *s, MSize len)
														
 
															 {
														
 
															-  MSize len = str->len <= STRFMT_PREC(sf) ? str->len : STRFMT_PREC(sf);
														
 
															   MSize width = STRFMT_WIDTH(sf);
														
 
															-  char *p = lj_buf_more(sb, width > len ? width : len);
														
 
															-  if ((sf & STRFMT_F_LEFT)) p = lj_buf_wmem(p, strdata(str), len);
														
 
															-  while (width-- > len) *p++ = ' ';
														
 
															-  if (!(sf & STRFMT_F_LEFT)) p = lj_buf_wmem(p, strdata(str), len);
														
 
															-  setsbufP(sb, p);
														
 
															+  char *w;
														
 
															+  if (len > STRFMT_PREC(sf)) len = STRFMT_PREC(sf);
														
 
															+  w = lj_buf_more(sb, width > len ? width : len);
														
 
															+  if ((sf & STRFMT_F_LEFT)) w = lj_buf_wmem(w, s, len);
														
 
															+  while (width-- > len) *w++ = ' ';
														
 
															+  if (!(sf & STRFMT_F_LEFT)) w = lj_buf_wmem(w, s, len);
														
 
															+  sb->w = w;
														
 
															   return sb;
														
 
															 }
														
 
															+#if LJ_HASJIT
														
 
															+SBuf *lj_strfmt_putfstr(SBuf *sb, SFormat sf, GCstr *str)
														
 
															+{
														
 
															+  return strfmt_putfstrlen(sb, sf, strdata(str), str->len);
														
 
															+}
														
 
															+#endif
														
 
															+
														
 
															 /* Add formatted signed/unsigned integer to buffer. */
														
 
															 SBuf *lj_strfmt_putfxint(SBuf *sb, SFormat sf, uint64_t k)
														
 
															 {
														
 
															-  char buf[STRFMT_MAXBUF_XINT], *q = buf + sizeof(buf), *p;
														
 
															+  char buf[STRFMT_MAXBUF_XINT], *q = buf + sizeof(buf), *w;
														
 
															 #ifdef LUA_USE_ASSERT
														
 
															-  char *ps;
														
 
															+  char *ws;
														
 
															 #endif
														
 
															   MSize prefix = 0, len, prec, pprec, width, need;
														
@@ -301,27 +324,27 @@ SBuf *lj_strfmt_putfxint(SBuf *sb, SFormat sf, uint64_t k)
 
															   width = STRFMT_WIDTH(sf);
														
 
															   pprec = prec + (prefix >> 8);
														
 
															   need = width > pprec ? width : pprec;
														
 
															-  p = lj_buf_more(sb, need);
														
 
															+  w = lj_buf_more(sb, need);
														
 
															 #ifdef LUA_USE_ASSERT
														
 
															-  ps = p;
														
 
															+  ws = w;
														
 
															 #endif
														
 
															   /* Format number with leading/trailing whitespace and zeros. */
														
 
															   if ((sf & (STRFMT_F_LEFT|STRFMT_F_ZERO)) == 0)
														
 
															-    while (width-- > pprec) *p++ = ' ';
														
 
															+    while (width-- > pprec) *w++ = ' ';
														
 
															   if (prefix) {
														
 
															-    if ((char)prefix >= 'X') *p++ = '0';
														
 
															-    *p++ = (char)prefix;
														
 
															+    if ((char)prefix >= 'X') *w++ = '0';
														
 
															+    *w++ = (char)prefix;
														
 
															   }
														
 
															   if ((sf & (STRFMT_F_LEFT|STRFMT_F_ZERO)) == STRFMT_F_ZERO)
														
 
															-    while (width-- > pprec) *p++ = '0';
														
 
															-  while (prec-- > len) *p++ = '0';
														
 
															-  while (q < buf + sizeof(buf)) *p++ = *q++;  /* Add number itself. */
														
 
															+    while (width-- > pprec) *w++ = '0';
														
 
															+  while (prec-- > len) *w++ = '0';
														
 
															+  while (q < buf + sizeof(buf)) *w++ = *q++;  /* Add number itself. */
														
 
															   if ((sf & STRFMT_F_LEFT))
														
 
															-    while (width-- > pprec) *p++ = ' ';
														
 
															+    while (width-- > pprec) *w++ = ' ';
														
 
															-  lj_assertX(need == (MSize)(p - ps), "miscalculated format size");
														
 
															-  setsbufP(sb, p);
														
 
															+  lj_assertX(need == (MSize)(w - ws), "miscalculated format size");
														
 
															+  sb->w = w;
														
 
															   return sb;
														
 
															 }
														
@@ -346,6 +369,117 @@ SBuf *lj_strfmt_putfnum_uint(SBuf *sb, SFormat sf, lua_Number n)
 
															   return lj_strfmt_putfxint(sb, sf, (uint64_t)k);
														
 
															 }
														
 
															+/* Format stack arguments to buffer. */
														
 
															+int lj_strfmt_putarg(lua_State *L, SBuf *sb, int arg, int retry)
														
 
															+{
														
 
															+  int narg = (int)(L->top - L->base);
														
 
															+  GCstr *fmt = lj_lib_checkstr(L, arg);
														
 
															+  FormatState fs;
														
 
															+  SFormat sf;
														
 
															+  lj_strfmt_init(&fs, strdata(fmt), fmt->len);
														
 
															+  while ((sf = lj_strfmt_parse(&fs)) != STRFMT_EOF) {
														
 
															+    if (sf == STRFMT_LIT) {
														
 
															+      lj_buf_putmem(sb, fs.str, fs.len);
														
 
															+    } else if (sf == STRFMT_ERR) {
														
 
															+      lj_err_callerv(L, LJ_ERR_STRFMT,
														
 
															+		     strdata(lj_str_new(L, fs.str, fs.len)));
														
 
															+    } else {
														
 
															+      TValue *o = &L->base[arg++];
														
 
															+      if (arg > narg)
														
 
															+	lj_err_arg(L, arg, LJ_ERR_NOVAL);
														
 
															+      switch (STRFMT_TYPE(sf)) {
														
 
															+      case STRFMT_INT:
														
 
															+	if (tvisint(o)) {
														
 
															+	  int32_t k = intV(o);
														
 
															+	  if (sf == STRFMT_INT)
														
 
															+	    lj_strfmt_putint(sb, k);  /* Shortcut for plain %d. */
														
 
															+	  else
														
 
															+	    lj_strfmt_putfxint(sb, sf, k);
														
 
															+	  break;
														
 
															+	}
														
 
															+#if LJ_HASFFI
														
 
															+	if (tviscdata(o)) {
														
 
															+	  GCcdata *cd = cdataV(o);
														
 
															+	  if (cd->ctypeid == CTID_INT64 || cd->ctypeid == CTID_UINT64) {
														
 
															+	    lj_strfmt_putfxint(sb, sf, *(uint64_t *)cdataptr(cd));
														
 
															+	    break;
														
 
															+	  }
														
 
															+	}
														
 
															+#endif
														
 
															+	lj_strfmt_putfnum_int(sb, sf, lj_lib_checknum(L, arg));
														
 
															+	break;
														
 
															+      case STRFMT_UINT:
														
 
															+	if (tvisint(o)) {
														
 
															+	  lj_strfmt_putfxint(sb, sf, intV(o));
														
 
															+	  break;
														
 
															+	}
														
 
															+#if LJ_HASFFI
														
 
															+	if (tviscdata(o)) {
														
 
															+	  GCcdata *cd = cdataV(o);
														
 
															+	  if (cd->ctypeid == CTID_INT64 || cd->ctypeid == CTID_UINT64) {
														
 
															+	    lj_strfmt_putfxint(sb, sf, *(uint64_t *)cdataptr(cd));
														
 
															+	    break;
														
 
															+	  }
														
 
															+	}
														
 
															+#endif
														
 
															+	lj_strfmt_putfnum_uint(sb, sf, lj_lib_checknum(L, arg));
														
 
															+	break;
														
 
															+      case STRFMT_NUM:
														
 
															+	lj_strfmt_putfnum(sb, sf, lj_lib_checknum(L, arg));
														
 
															+	break;
														
 
															+      case STRFMT_STR: {
														
 
															+	MSize len;
														
 
															+	const char *s;
														
 
															+	cTValue *mo;
														
 
															+	if (LJ_UNLIKELY(!tvisstr(o) && !tvisbuf(o)) && retry >= 0 &&
														
 
															+	    !tvisnil(mo = lj_meta_lookup(L, o, MM_tostring))) {
														
 
															+	  /* Call __tostring metamethod once. */
														
 
															+	  copyTV(L, L->top++, mo);
														
 
															+	  copyTV(L, L->top++, o);
														
 
															+	  lua_call(L, 1, 1);
														
 
															+	  o = &L->base[arg-1];  /* Stack may have been reallocated. */
														
 
															+	  copyTV(L, o, --L->top);  /* Replace inline for retry. */
														
 
															+	  if (retry < 2) {  /* Global buffer may have been overwritten. */
														
 
															+	    retry = 1;
														
 
															+	    break;
														
 
															+	  }
														
 
															+	}
														
 
															+	if (LJ_LIKELY(tvisstr(o))) {
														
 
															+	  len = strV(o)->len;
														
 
															+	  s = strVdata(o);
														
 
															+#if LJ_HASBUFFER
														
 
															+	} else if (tvisbuf(o)) {
														
 
															+	  SBufExt *sbx = bufV(o);
														
 
															+	  if (sbx == (SBufExt *)sb) lj_err_arg(L, arg+1, LJ_ERR_BUFFER_SELF);
														
 
															+	  len = sbufxlen(sbx);
														
 
															+	  s = sbx->r;
														
 
															+#endif
														
 
															+	} else {
														
 
															+	  GCstr *str = lj_strfmt_obj(L, o);
														
 
															+	  len = str->len;
														
 
															+	  s = strdata(str);
														
 
															+	}
														
 
															+	if ((sf & STRFMT_T_QUOTED))
														
 
															+	  strfmt_putquotedlen(sb, s, len);  /* No formatting. */
														
 
															+	else
														
 
															+	  strfmt_putfstrlen(sb, sf, s, len);
														
 
															+	break;
														
 
															+	}
														
 
															+      case STRFMT_CHAR:
														
 
															+	lj_strfmt_putfchar(sb, sf, lj_lib_checkint(L, arg));
														
 
															+	break;
														
 
															+      case STRFMT_PTR:  /* No formatting. */
														
 
															+	lj_strfmt_putptr(sb, lj_obj_ptr(G(L), o));
														
 
															+	break;
														
 
															+      default:
														
 
															+	lj_assertL(0, "bad string format type");
														
 
															+	break;
														
 
															+      }
														
 
															+    }
														
 
															+  }
														
 
															+  return retry;
														
 
															+}
														
 
															+
														
 
															 /* -- Conversions to strings ---------------------------------------------- */
														
 
															 /* Convert integer to string. */
														
--- a/libs/LuaJIT/src/lj_strfmt.h
+++ b/libs/LuaJIT/src/lj_strfmt.h
@@ -95,7 +95,9 @@ LJ_FUNC SBuf * LJ_FASTCALL lj_strfmt_putint(SBuf *sb, int32_t k);
 
															 LJ_FUNC SBuf * LJ_FASTCALL lj_strfmt_putnum(SBuf *sb, cTValue *o);
														
 
															 #endif
														
 
															 LJ_FUNC SBuf * LJ_FASTCALL lj_strfmt_putptr(SBuf *sb, const void *v);
														
 
															+#if LJ_HASJIT
														
 
															 LJ_FUNC SBuf * LJ_FASTCALL lj_strfmt_putquoted(SBuf *sb, GCstr *str);
														
 
															+#endif
														
 
															 /* Formatted conversions to buffer. */
														
 
															 LJ_FUNC SBuf *lj_strfmt_putfxint(SBuf *sb, SFormat sf, uint64_t k);
														
@@ -103,7 +105,10 @@ LJ_FUNC SBuf *lj_strfmt_putfnum_int(SBuf *sb, SFormat sf, lua_Number n);
 
															 LJ_FUNC SBuf *lj_strfmt_putfnum_uint(SBuf *sb, SFormat sf, lua_Number n);
														
 
															 LJ_FUNC SBuf *lj_strfmt_putfnum(SBuf *sb, SFormat, lua_Number n);
														
 
															 LJ_FUNC SBuf *lj_strfmt_putfchar(SBuf *sb, SFormat, int32_t c);
														
 
															+#if LJ_HASJIT
														
 
															 LJ_FUNC SBuf *lj_strfmt_putfstr(SBuf *sb, SFormat, GCstr *str);
														
 
															+#endif
														
 
															+LJ_FUNC int lj_strfmt_putarg(lua_State *L, SBuf *sb, int arg, int retry);
														
 
															 /* Conversions to strings. */
														
 
															 LJ_FUNC GCstr * LJ_FASTCALL lj_strfmt_int(lua_State *L, int32_t k);