Mercurial

comparison third_party/luajit/doc/install.html @ 186:8cf4ec5e2191 hg-web

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fixed merge conflict.
author MrJuneJune <me@mrjunejune.com>
date Fri, 23 Jan 2026 22:38:59 -0800
parents 94705b5986b3
children
comparison
equal deleted inserted replaced
176:fed99fc04e12 186:8cf4ec5e2191
1 <!DOCTYPE html>
2 <html>
3 <head>
4 <title>Installation</title>
5 <meta charset="utf-8">
6 <meta name="Copyright" content="Copyright (C) 2005-2023">
7 <meta name="Language" content="en">
8 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
9 <link rel="stylesheet" type="text/css" href="bluequad-print.css" media="print">
10 <style type="text/css">
11 table.compat {
12 line-height: 1.2;
13 font-size: 80%;
14 }
15 table.compat td {
16 border: 1px solid #bfcfff;
17 height: 1.5em;
18 }
19 table.compat tr.compathead td {
20 font-weight: bold;
21 border-bottom: 2px solid #bfcfff;
22 }
23 td.compatname {
24 width: 10%;
25 }
26 td.compatbits {
27 width: 5%;
28 }
29 td.compatx {
30 width: 21%;
31 }
32 </style>
33 </head>
34 <body>
35 <div id="site">
36 <a href="https://luajit.org"><span>Lua<span id="logo">JIT</span></span></a>
37 </div>
38 <div id="head">
39 <h1>Installation</h1>
40 </div>
41 <div id="nav">
42 <ul><li>
43 <a href="luajit.html">LuaJIT</a>
44 <ul><li>
45 <a href="https://luajit.org/download.html">Download <span class="ext">&raquo;</span></a>
46 </li><li>
47 <a class="current" href="install.html">Installation</a>
48 </li><li>
49 <a href="running.html">Running</a>
50 </li></ul>
51 </li><li>
52 <a href="extensions.html">Extensions</a>
53 <ul><li>
54 <a href="ext_ffi.html">FFI Library</a>
55 <ul><li>
56 <a href="ext_ffi_tutorial.html">FFI Tutorial</a>
57 </li><li>
58 <a href="ext_ffi_api.html">ffi.* API</a>
59 </li><li>
60 <a href="ext_ffi_semantics.html">FFI Semantics</a>
61 </li></ul>
62 </li><li>
63 <a href="ext_buffer.html">String Buffers</a>
64 </li><li>
65 <a href="ext_jit.html">jit.* Library</a>
66 </li><li>
67 <a href="ext_c_api.html">Lua/C API</a>
68 </li><li>
69 <a href="ext_profiler.html">Profiler</a>
70 </li></ul>
71 </li><li>
72 <a href="https://luajit.org/status.html">Status <span class="ext">&raquo;</span></a>
73 </li><li>
74 <a href="https://luajit.org/faq.html">FAQ <span class="ext">&raquo;</span></a>
75 </li><li>
76 <a href="https://luajit.org/list.html">Mailing List <span class="ext">&raquo;</span></a>
77 </li></ul>
78 </div>
79 <div id="main">
80 <p>
81 LuaJIT is only distributed as source code &mdash; get it from the
82 <a href="https://luajit.org/download.html"><span class="ext">&raquo;</span>&nbsp;git repository</a>. This page explains how to build
83 and install the LuaJIT binary and library for different operating systems.
84 </p>
85 <p>
86 For the impatient (on POSIX systems):
87 </p>
88 <pre class="code">
89 make &amp;&amp; sudo make install
90 </pre>
91
92 <h2 id="req">Requirements</h2>
93 <p>
94 LuaJIT currently builds out-of-the box on most systems. Please check the
95 supported operating systems and CPU architectures on the
96 <a href="https://luajit.org/status.html"><span class="ext">&raquo;</span>&nbsp;status page</a>.
97 </p>
98 <p>
99 Building LuaJIT requires a recent toolchain based on GCC, Clang/LLVM or
100 MSVC++.
101 </p>
102 <p>
103 The Makefile-based build system requires GNU Make and supports
104 cross-builds.
105 </p>
106 <p>
107 Batch files are provided for MSVC++ builds and console cross-builds.
108 </p>
109
110 <h2>Configuring LuaJIT</h2>
111 <p>
112 The standard configuration should work fine for most installations.
113 Usually there is no need to tweak the settings. The following files
114 hold all user-configurable settings:
115 </p>
116 <ul>
117 <li><tt>Makefile</tt> has settings for <b>installing</b> LuaJIT (POSIX
118 only).</li>
119 <li><tt>src/Makefile</tt> has settings for <b>compiling</b> LuaJIT
120 under POSIX, MinGW or Cygwin.</li>
121 <li><tt>src/msvcbuild.bat</tt> has settings for compiling LuaJIT with
122 MSVC (Visual Studio).</li>
123 </ul>
124 <p>
125 Please read the instructions given in these files, before changing
126 any settings.
127 </p>
128 <p>
129 All LuaJIT 64 bit ports use 64 bit GC objects by default (<tt>LJ_GC64</tt>).
130 For x64, you can select the old 32-on-64 bit mode by adding
131 <tt>XCFLAGS=-DLUAJIT_DISABLE_GC64</tt> to the make command.
132 Please check the note about the
133 <a href="extensions.html#string_dump">bytecode format</a> differences, too.
134 </p>
135
136 <h2 id="posix">POSIX Systems (Linux, macOS, *BSD etc.)</h2>
137 <h3>Prerequisites</h3>
138 <p>
139 Depending on your distribution, you may need to install a package for a
140 compiler (GCC or Clang/LLVM), the development headers and/or a complete SDK.
141 E.g. on a current Debian/Ubuntu, install <tt>build-essential</tt> with the
142 package manager.
143 </p>
144 </pre>
145 <h3>Building LuaJIT</h3>
146 <p>
147 The supplied Makefiles try to auto-detect the settings needed for your
148 operating system and your compiler. They need to be run with GNU Make,
149 which is probably the default on your system, anyway. Simply run:
150 </p>
151 <pre class="code">
152 make
153 </pre>
154 <p>
155 This always builds a native binary, depending on the host OS
156 you're running this command on. Check the section on
157 <a href="#cross">cross-compilation</a> for more options.
158 </p>
159 <p>
160 By default, modules are only searched under the prefix <tt>/usr/local</tt>.
161 You can add an extra prefix to the search paths by appending the
162 <tt>PREFIX</tt> option, e.g.:
163 </p>
164 <pre class="code">
165 make PREFIX=/home/myself/lj2
166 </pre>
167 <p>
168 Note for macOS: you <b>must</b> set the <tt>MACOSX_DEPLOYMENT_TARGET</tt>
169 environment variable to a value supported by your toolchain:
170 </p>
171 <pre class="code">
172 MACOSX_DEPLOYMENT_TARGET=XX.YY make
173 </pre>
174 <h3>Installing LuaJIT</h3>
175 <p>
176 The top-level Makefile installs LuaJIT by default under
177 <tt>/usr/local</tt>, i.e. the executable ends up in
178 <tt>/usr/local/bin</tt> and so on. You need root privileges
179 to write to this path. So, assuming sudo is installed on your system,
180 run the following command and enter your sudo password:
181 </p>
182 <pre class="code">
183 sudo make install
184 </pre>
185 <p>
186 Otherwise specify the directory prefix as an absolute path, e.g.:
187 </p>
188 <pre class="code">
189 make install PREFIX=/home/myself/lj2
190 </pre>
191 <p>
192 Obviously the prefixes given during build and installation need to be the same.
193 </p>
194
195 <h2 id="windows">Windows Systems</h2>
196 <h3>Prerequisites</h3>
197 <p>
198 Either install one of the open source SDKs
199 (<a href="http://mingw.org/"><span class="ext">&raquo;</span>&nbsp;MinGW</a> or
200 <a href="https://www.cygwin.com/"><span class="ext">&raquo;</span>&nbsp;Cygwin</a>), which come with a modified
201 GCC plus the required development headers.
202 Or install Microsoft's Visual Studio (MSVC).
203 </p>
204 <h3>Building with MSVC</h3>
205 <p>
206 Open a "Visual Studio Command Prompt" (either x86 or x64), <tt>cd</tt> to the
207 directory with the source code and run these commands:
208 </p>
209 <pre class="code">
210 cd src
211 msvcbuild
212 </pre>
213 <p>
214 Check the <tt>msvcbuild.bat</tt> file for more options.
215 Then follow the installation instructions below.
216 </p>
217 <h3>Building with MinGW or Cygwin</h3>
218 <p>
219 Open a command prompt window and make sure the MinGW or Cygwin programs
220 are in your path. Then <tt>cd</tt> to the directory of the git repository.
221 Then run this command for MinGW:
222 </p>
223 <pre class="code">
224 mingw32-make
225 </pre>
226 <p>
227 Or this command for Cygwin:
228 </p>
229 <pre class="code">
230 make
231 </pre>
232 <p>
233 Then follow the installation instructions below.
234 </p>
235 <h3>Installing LuaJIT</h3>
236 <p>
237 Copy <tt>luajit.exe</tt> and <tt>lua51.dll</tt> (built in the <tt>src</tt>
238 directory) to a newly created directory (any location is ok).
239 Add <tt>lua</tt> and <tt>lua\jit</tt> directories below it and copy
240 all Lua files from the <tt>src\jit</tt> directory of the distribution
241 to the latter directory.
242 </p>
243 <p>
244 There are no hardcoded
245 absolute path names &mdash; all modules are loaded relative to the
246 directory where <tt>luajit.exe</tt> is installed
247 (see <tt>src/luaconf.h</tt>).
248 </p>
249
250 <h2 id="cross">Cross-compiling LuaJIT</h2>
251 <p>
252 First, let's clear up some terminology:
253 </p>
254 <ul>
255 <li>Host: This is your development system, usually based on a x64 or x86 CPU.</li>
256 <li>Target: This is the target system you want LuaJIT to run on, e.g. Android/ARM.</li>
257 <li>Toolchain: This comprises a C compiler, linker, assembler and a matching C library.</li>
258 <li>Host (or system) toolchain: This is the toolchain used to build native binaries for your host system.</li>
259 <li>Cross-compile toolchain: This is the toolchain used to build binaries for the target system. They can only be run on the target system.</li>
260 </ul>
261 <p>
262 The GNU Makefile-based build system allows cross-compiling on any host
263 for any supported target:
264 </p>
265 <ul>
266 <li>Yes, you need a toolchain for both your host <em>and</em> your target!</li>
267 <li>Both host and target architectures must have the same pointer size.</li>
268 <li>E.g. if you want to cross-compile to a 32 bit target on a 64 bit host, you need to install the multilib development package (e.g. <tt>libc6-dev-i386</tt> on Debian/Ubuntu) and build a 32 bit host part (<tt>HOST_CC="gcc -m32"</tt>).</li>
269 <li>64 bit targets always require compilation on a 64 bit host.</li>
270 </ul>
271 <p>
272 You need to specify <tt>TARGET_SYS</tt> whenever the host OS and the
273 target OS differ, or you'll get assembler or linker errors:
274 </p>
275 <ul>
276 <li>E.g. if you're compiling on a Windows or macOS host for embedded Linux or Android, you need to add <tt>TARGET_SYS=Linux</tt> to the examples below.</li>
277 <li>For a minimal target OS, you may need to disable the built-in allocator in <tt>src/Makefile</tt> and use <tt>TARGET_SYS=Other</tt>.</li>
278 <li>Don't forget to specify the same <tt>TARGET_SYS</tt> for the install step, too.</li>
279 </ul>
280 <p>
281 Here are some examples where host and target have the same CPU:
282 </p>
283 <pre class="code">
284 # Cross-compile to a 32 bit binary on a multilib x64 OS
285 make CC="gcc -m32"
286
287 # Cross-compile on Debian/Ubuntu for Windows (mingw32 package)
288 make HOST_CC="gcc -m32" CROSS=i586-mingw32msvc- TARGET_SYS=Windows
289 </pre>
290 <p id="cross2">
291 The <tt>CROSS</tt> prefix allows specifying a standard GNU cross-compile
292 toolchain (Binutils, GCC and a matching libc). The prefix may vary
293 depending on the <tt>--target</tt> the toolchain was built for (note the
294 <tt>CROSS</tt> prefix has a trailing <tt>"-"</tt>). The examples below
295 use the canonical toolchain triplets for Linux.
296 </p>
297 <p>
298 Since there's often no easy way to detect CPU features at runtime, it's
299 important to compile with the proper CPU or architecture settings:
300 </o>
301 <ul>
302 <li>The best way to get consistent results is to specify the correct settings when building the toolchain yourself.</li>
303 <li>For a pre-built, generic toolchain add <tt>-mcpu=...</tt> or <tt>-march=...</tt> and other necessary flags to <tt>TARGET_CFLAGS</tt>.</li>
304 <li>For ARM it's important to have the correct <tt>-mfloat-abi=...</tt> setting, too. Otherwise LuaJIT may not run at the full performance of your target CPU.</li>
305 <li>For MIPS it's important to select a supported ABI (o32 on MIPS32, n64 on MIPS64) and consistently compile your project either with hard-float or soft-float compiler settings.</li>
306 </ul>
307 <p>
308 Here are some examples for targets with a different CPU than the host:
309 </p>
310 <pre class="code">
311 # ARM soft-float
312 make HOST_CC="gcc -m32" CROSS=arm-linux-gnueabi- \
313 TARGET_CFLAGS="-mfloat-abi=soft"
314
315 # ARM soft-float ABI with VFP (example for Cortex-A9)
316 make HOST_CC="gcc -m32" CROSS=arm-linux-gnueabi- \
317 TARGET_CFLAGS="-mcpu=cortex-a9 -mfloat-abi=softfp"
318
319 # ARM hard-float ABI with VFP (armhf, most modern toolchains)
320 make HOST_CC="gcc -m32" CROSS=arm-linux-gnueabihf-
321
322 # ARM64
323 make CROSS=aarch64-linux-gnu-
324
325 # PPC
326 make HOST_CC="gcc -m32" CROSS=powerpc-linux-gnu-
327
328 # MIPS32 big-endian
329 make HOST_CC="gcc -m32" CROSS=mips-linux-gnu-
330 # MIPS32 little-endian
331 make HOST_CC="gcc -m32" CROSS=mipsel-linux-gnu-
332
333 # MIPS64 big-endian
334 make CROSS=mips-linux- TARGET_CFLAGS="-mips64r2 -mabi=64"
335 # MIPS64 little-endian
336 make CROSS=mipsel-linux- TARGET_CFLAGS="-mips64r2 -mabi=64"
337 </pre>
338 <p>
339 You can cross-compile for <b id="android">Android</b> using the <a href="https://developer.android.com/ndk/"><span class="ext">&raquo;</span>&nbsp;Android NDK</a>.
340 Please adapt the environment variables to match the install locations and the
341 desired target platform. E.g. Android&nbsp;4.1 corresponds to ABI level&nbsp;16.
342 </p>
343 <pre class="code">
344 # Android/ARM64, aarch64, Android 5.0+ (L)
345 NDKDIR=/opt/android/ndk
346 NDKBIN=$NDKDIR/toolchains/llvm/prebuilt/linux-x86_64/bin
347 NDKCROSS=$NDKBIN/aarch64-linux-android-
348 NDKCC=$NDKBIN/aarch64-linux-android21-clang
349 make CROSS=$NDKCROSS \
350 STATIC_CC=$NDKCC DYNAMIC_CC="$NDKCC -fPIC" \
351 TARGET_LD=$NDKCC TARGET_AR="$NDKBIN/llvm-ar rcus" \
352 TARGET_STRIP=$NDKBIN/llvm-strip
353
354 # Android/ARM, armeabi-v7a (ARMv7 VFP), Android 4.1+ (JB)
355 NDKDIR=/opt/android/ndk
356 NDKBIN=$NDKDIR/toolchains/llvm/prebuilt/linux-x86_64/bin
357 NDKCROSS=$NDKBIN/arm-linux-androideabi-
358 NDKCC=$NDKBIN/armv7a-linux-androideabi16-clang
359 make HOST_CC="gcc -m32" CROSS=$NDKCROSS \
360 STATIC_CC=$NDKCC DYNAMIC_CC="$NDKCC -fPIC" \
361 TARGET_LD=$NDKCC TARGET_AR="$NDKBIN/llvm-ar rcus" \
362 TARGET_STRIP=$NDKBIN/llvm-strip
363 </pre>
364 <p>
365 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>:
366 </p>
367 <p style="font-size: 8pt;">
368 Note: <b>the JIT compiler is disabled for iOS</b>, because regular iOS Apps
369 are not allowed to generate code at runtime. You'll only get the performance
370 of the LuaJIT interpreter on iOS. This is still faster than plain Lua, but
371 much slower than the JIT compiler. Please complain to Apple, not me.
372 Or use Android. :-p
373 </p>
374 <pre class="code">
375 # iOS/ARM64
376 ISDKP=$(xcrun --sdk iphoneos --show-sdk-path)
377 ICC=$(xcrun --sdk iphoneos --find clang)
378 ISDKF="-arch arm64 -isysroot $ISDKP"
379 make DEFAULT_CC=clang CROSS="$(dirname $ICC)/" \
380 TARGET_FLAGS="$ISDKF" TARGET_SYS=iOS
381 </pre>
382
383 <h3 id="consoles">Cross-compiling for consoles</h3>
384 <p>
385 Building LuaJIT for consoles requires both a supported host compiler
386 (x86 or x64) and a cross-compiler from the official console SDK.
387 </p>
388 <p>
389 Due to restrictions on consoles, the JIT compiler is disabled and only
390 the fast interpreter is built. This is still faster than plain Lua,
391 but much slower than the JIT compiler. The FFI is disabled, too, since
392 it's not very useful in such an environment.
393 </p>
394 <p>
395 The following commands build a static library <tt>libluajit.a</tt>,
396 which can be linked against your game, just like the Lua library.
397 </p>
398 <p>
399 To cross-compile for <b id="ps3">PS3</b> from a Linux host (requires
400 32&nbsp;bit GCC, i.e. multilib Linux/x64) or a Windows host (requires
401 32&nbsp;bit MinGW), run this command:
402 </p>
403 <pre class="code">
404 make HOST_CC="gcc -m32" CROSS=ppu-lv2-
405 </pre>
406 <p>
407 To cross-compile for the other consoles from a Windows host, open a
408 "Native Tools Command Prompt for VS". You need to choose either the 32
409 or the 64&nbsp;bit version of the host compiler to match the target.
410 Then <tt>cd</tt> to the <tt>src</tt> directory below the source code
411 and run the build command given in the table:
412 </p>
413 <table class="compat">
414 <tr class="compathead">
415 <td class="compatname">Console</td>
416 <td class="compatbits">Bits</td>
417 <td class="compatx">Build Command</td>
418 </tr>
419 <tr class="odd separate">
420 <td class="compatname"><b id="ps4">PS4</b></td>
421 <td class="compatbits">64</td>
422 <td class="compatx"><tt>ps4build</tt></td>
423 </tr>
424 <tr class="even">
425 <td class="compatname"><b id="ps5">PS5</b></td>
426 <td class="compatbits">64</td>
427 <td class="compatx"><tt>ps5build</tt></td>
428 </tr>
429 <tr class="odd">
430 <td class="compatname"><b id="psvita">PS Vita</b></td>
431 <td class="compatbits">32</td>
432 <td class="compatx"><tt>psvitabuild</tt></td>
433 </tr>
434 <tr class="even">
435 <td class="compatname"><b id="xbox360">Xbox 360</b></td>
436 <td class="compatbits">32</td>
437 <td class="compatx"><tt>xedkbuild</tt></td>
438 </tr>
439 <tr class="odd">
440 <td class="compatname"><b id="xboxone">Xbox One</b></td>
441 <td class="compatbits">64</td>
442 <td class="compatx"><tt>xb1build</tt></td>
443 </tr>
444 <tr class="even">
445 <td class="compatname"><b id="nx32">Nintendo Switch NX32</b></td>
446 <td class="compatbits">32</td>
447 <td class="compatx"><tt>nxbuild</tt></td>
448 </tr>
449 <tr class="odd">
450 <td class="compatname"><b id="nx64">Nintendo Switch NX64</b></td>
451 <td class="compatbits">64</td>
452 <td class="compatx"><tt>nxbuild</tt></td>
453 </tr>
454 </table>
455 <p>
456 Please check out the comments in the corresponding <tt>*.bat</tt>
457 file for more options.
458 </p>
459
460 <h2 id="embed">Embedding LuaJIT</h2>
461 <p>
462 LuaJIT is API-compatible with Lua 5.1. If you've already embedded Lua
463 into your application, you probably don't need to do anything to switch
464 to LuaJIT, except link with a different library:
465 </p>
466 <ul>
467 <li>It's strongly suggested to build LuaJIT separately using the supplied
468 build system. Please do <em>not</em> attempt to integrate the individual
469 source files into your build tree. You'll most likely get the internal build
470 dependencies wrong or mess up the compiler flags. Treat LuaJIT like any
471 other external library and link your application with either the dynamic
472 or static library, depending on your needs.</li>
473 <li>If you want to load C modules compiled for plain Lua
474 with <tt>require()</tt>, you need to make sure the public symbols
475 (e.g. <tt>lua_pushnumber</tt>) are exported, too:
476 <ul><li>On POSIX systems you can either link to the shared library
477 or link the static library into your application. In the latter case
478 you'll need to export all public symbols from your main executable
479 (e.g. <tt>-Wl,-E</tt> on Linux) and add the external dependencies
480 (e.g. <tt>-lm -ldl</tt> on Linux).</li>
481 <li>Since Windows symbols are bound to a specific DLL name, you need to
482 link to the <tt>lua51.dll</tt> created by the LuaJIT build (do not rename
483 the DLL). You may link LuaJIT statically on Windows only if you don't
484 intend to load Lua/C modules at runtime.
485 </li></ul>
486 </li>
487 </ul>
488 <p>Additional hints for initializing LuaJIT using the C API functions:</p>
489 <ul>
490 <li>Here's a
491 <a href="http://lua-users.org/wiki/SimpleLuaApiExample"><span class="ext">&raquo;</span>&nbsp;simple example</a>
492 for embedding Lua or LuaJIT into your application.</li>
493 <li>Make sure you use <tt>luaL_newstate</tt>. Avoid using
494 <tt>lua_newstate</tt>, since this uses the (slower) default memory
495 allocator from your system (no support for this on 64&nbsp;bit architectures).</li>
496 <li>Make sure you use <tt>luaL_openlibs</tt> and not the old Lua 5.0 style
497 of calling <tt>luaopen_base</tt> etc. directly.</li>
498 <li>To change or extend the list of standard libraries to load, copy
499 <tt>src/lib_init.c</tt> to your project and modify it accordingly.
500 Make sure the <tt>jit</tt> library is loaded, or the JIT compiler
501 will not be activated.</li>
502 <li>The <tt>bit.*</tt> module for bitwise operations
503 is already built-in. There's no need to statically link
504 <a href="https://bitop.luajit.org/"><span class="ext">&raquo;</span>&nbsp;Lua BitOp</a> to your application.</li>
505 </ul>
506
507 <h2 id="distro">Hints for Distribution Maintainers</h2>
508 <p>
509 The LuaJIT build system has extra provisions for the needs of most
510 POSIX-based distributions. If you're a package maintainer for
511 a distribution, <em>please</em> make use of these features and
512 avoid patching, subverting, autotoolizing or messing up the build system
513 in unspeakable ways.
514 </p>
515 <p>
516 There should be absolutely no need to patch <tt>luaconf.h</tt> or any
517 of the Makefiles. And please do not hand-pick files for your packages &mdash;
518 simply use whatever <tt>make install</tt> creates. There's a reason
519 for all the files <em>and</em> directories it creates.
520 </p>
521 <p>
522 The build system uses GNU make and auto-detects most settings based on
523 the host you're building it on. This should work fine for native builds,
524 even when sandboxed. You may need to pass some of the following flags to
525 <em>both</em> the <tt>make</tt> and the <tt>make install</tt> command lines
526 for a regular distribution build:
527 </p>
528 <ul>
529 <li><tt>PREFIX</tt> overrides the installation path and should usually
530 be set to <tt>/usr</tt>. Setting this also changes the module paths and
531 the paths needed to locate the shared library.</li>
532 <li><tt>DESTDIR</tt> is an absolute path which allows you to install
533 to a shadow tree instead of the root tree of the build system.</li>
534 <li><tt>MULTILIB</tt> sets the architecture-specific library path component
535 for multilib systems. The default is <tt>lib</tt>.</li>
536 <li>Have a look at the top-level <tt>Makefile</tt> and <tt>src/Makefile</tt>
537 for additional variables to tweak. The following variables <em>may</em> be
538 overridden, but it's <em>not</em> recommended, except for special needs
539 like cross-builds:
540 <tt>BUILDMODE, CC, HOST_CC, STATIC_CC, DYNAMIC_CC, CFLAGS, HOST_CFLAGS,
541 TARGET_CFLAGS, LDFLAGS, HOST_LDFLAGS, TARGET_LDFLAGS, TARGET_SHLDFLAGS,
542 TARGET_FLAGS, LIBS, HOST_LIBS, TARGET_LIBS, CROSS, HOST_SYS, TARGET_SYS
543 </tt></li>
544 </ul>
545 <p>
546 The build system has a special target for an amalgamated build, i.e.
547 <tt>make amalg</tt>. This compiles the LuaJIT core as one huge C file
548 and allows GCC to generate faster and shorter code. Alas, this requires
549 lots of memory during the build. This may be a problem for some users,
550 that's why it's not enabled by default. But it shouldn't be a problem for
551 most build farms. It's recommended that binary distributions use this
552 target for their LuaJIT builds.
553 </p>
554 <p>
555 The tl;dr version of the above:
556 </p>
557 <pre class="code">
558 make amalg PREFIX=/usr && \
559 make install PREFIX=/usr DESTDIR=/tmp/buildroot
560 </pre>
561 <p>
562 Finally, if you encounter any difficulties, please
563 <a href="contact.html">contact me</a> first, instead of releasing a broken
564 package onto unsuspecting users. Because they'll usually gonna complain
565 to me (the upstream) and not you (the package maintainer), anyway.
566 </p>
567 <br class="flush">
568 </div>
569 <div id="foot">
570 <hr class="hide">
571 Copyright &copy; 2005-2023
572 <span class="noprint">
573 &middot;
574 <a href="contact.html">Contact</a>
575 </span>
576 </div>
577 </body>
578 </html>