doc/install.html

   1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
   2 <html>
   3 <head>
   4 <title>Installation</title>
   5 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
   6 <meta name="Author" content="Mike Pall">
   7 <meta name="Copyright" content="Copyright (C) 2005-2012, Mike Pall">
   8 <meta name="Language" content="en">
   9 <link rel="stylesheet" type="text/css" href="bluequad.css" media="screen">
  10 <link rel="stylesheet" type="text/css" href="bluequad-print.css" media="print">
  11 <style type="text/css">
  12 table.compat {
  13   line-height: 1.2;
  14   width: 600px;
  15 }
  16 table.compat td {
  17   border: 1px solid #bfcfff;
  18   font-size: 90%;
  19   height: 2.5em;
  20 }
  21 table.compat tr.compathead td {
  22   font-weight: bold;
  23   border-bottom: 2px solid #bfcfff;
  24 }
  25 tr.compathead td.compatos {
  26   vertical-align: top;
  27 }
  28 table.compat td.compatcpu {
  29   width: 16%;
  30   border-right: 2px solid #bfcfff;
  31 }
  32 td.compatos {
  33   width: 21%;
  34   vertical-align: middle;
  35 }
  36 td.compatno {
  37   background-color: #d0d0d0;
  38 }
  39 </style>
  40 </head>
  41 <body>
  42 <div id="site">
  43 <a href="http://luajit.org"><span>Lua<span id="logo">JIT</span></span></a>
  44 </div>
  45 <div id="head">
  46 <h1>Installation</h1>
  47 </div>
  48 <div id="nav">
  49 <ul><li>
  50 <a href="luajit.html">LuaJIT</a>
  51 <ul><li>
  52 <a class="current" href="install.html">Installation</a>
  53 </li><li>
  54 <a href="running.html">Running</a>
  55 </li></ul>
  56 </li><li>
  57 <a href="extensions.html">Extensions</a>
  58 <ul><li>
  59 <a href="ext_ffi.html">FFI Library</a>
  60 <ul><li>
  61 <a href="ext_ffi_tutorial.html">FFI Tutorial</a>
  62 </li><li>
  63 <a href="ext_ffi_api.html">ffi.* API</a>
  64 </li><li>
  65 <a href="ext_ffi_semantics.html">FFI Semantics</a>
  66 </li></ul>
  67 </li><li>
  68 <a href="ext_jit.html">jit.* Library</a>
  69 </li><li>
  70 <a href="ext_c_api.html">Lua/C API</a>
  71 </li></ul>
  72 </li><li>
  73 <a href="status.html">Status</a>
  74 <ul><li>
  75 <a href="changes.html">Changes</a>
  76 </li></ul>
  77 </li><li>
  78 <a href="faq.html">FAQ</a>
  79 </li><li>
  80 <a href="http://luajit.org/performance.html">Performance <span class="ext">&raquo;</span></a>
  81 </li><li>
  82 <a href="http://luajit.org/download.html">Download <span class="ext">&raquo;</span></a>
  83 </li><li>
  84 <a href="http://luajit.org/list.html">Mailing List <span class="ext">&raquo;</span></a>
  85 </li></ul>
  86 </div>
  87 <div id="main">
  88 <p>
  89 LuaJIT is only distributed as a source package. This page explains
  90 how to build and install LuaJIT with different operating systems
  91 and C&nbsp;compilers.
  92 </p>
  93 <p>
  94 For the impatient (on POSIX systems):
  95 </p>
  96 <pre class="code">
  97 make &amp;&amp; sudo make install
  98 </pre>
  99 <p>
 100 LuaJIT currently builds out-of-the box on most systems.
 101 Here's the compatibility matrix for the supported combinations of
 102 operating systems, CPUs and compilers:
 103 </p>
 104 <table class="compat">
 105 <tr class="compathead">
 106 <td class="compatcpu">CPU / OS</td>
 107 <td class="compatos"><a href="#posix">Linux</a> or<br><a href="#android">Android</a></td>
 108 <td class="compatos"><a href="#posix">*BSD, Other</a></td>
 109 <td class="compatos"><a href="#posix">OSX 10.4+</a> or<br><a href="#ios">iOS 3.0+</a></td>
 110 <td class="compatos"><a href="#windows">Windows<br>XP/Vista/7</a></td>
 111 </tr>
 112 <tr class="odd separate">
 113 <td class="compatcpu">x86 (32 bit)</td>
 114 <td class="compatos">GCC 4.x<br>GCC 3.4</td>
 115 <td class="compatos">GCC 4.x<br>GCC 3.4</td>
 116 <td class="compatos">GCC 4.x<br>GCC 3.4</td>
 117 <td class="compatos">MSVC, MSVC/EE<br>WinSDK<br>MinGW, Cygwin</td>
 118 </tr>
 119 <tr class="even">
 120 <td class="compatcpu">x64 (64 bit)</td>
 121 <td class="compatos">GCC 4.x</td>
 122 <td class="compatos compatno">&nbsp;</td>
 123 <td class="compatos">GCC 4.x</td>
 124 <td class="compatos">MSVC + SDK v7.0<br>WinSDK v7.0</td>
 125 </tr>
 126 <tr class="odd">
 127 <td class="compatcpu"><a href="#android">ARMv5+<br>ARM9E+</a></td>
 128 <td class="compatos">GCC 4.2+</td>
 129 <td class="compatos">GCC 4.2+</td>
 130 <td class="compatos">GCC 4.2+</td>
 131 <td class="compatos compatno">&nbsp;</td>
 132 </tr>
 133 <tr class="even">
 134 <td class="compatcpu"><a href="#ppc">PPC</a></td>
 135 <td class="compatos">GCC 4.3+</td>
 136 <td class="compatos">GCC 4.3+</td>
 137 <td class="compatos compatno">&nbsp;</td>
 138 <td class="compatos compatno">&nbsp;</td>
 139 </tr>
 140 <tr class="odd">
 141 <td class="compatcpu"><a href="#ppc">PPC/e500v2</a></td>
 142 <td class="compatos">GCC 4.3+</td>
 143 <td class="compatos">GCC 4.3+</td>
 144 <td class="compatos compatno">&nbsp;</td>
 145 <td class="compatos compatno">&nbsp;</td>
 146 </tr>
 147 <tr class="even">
 148 <td class="compatcpu"><a href="#mips">MIPS</a></td>
 149 <td class="compatos">GCC 4.3+</td>
 150 <td class="compatos">GCC 4.3+</td>
 151 <td class="compatos compatno">&nbsp;</td>
 152 <td class="compatos compatno">&nbsp;</td>
 153 </tr>
 154 </table>
 155
 156 <h2>Configuring LuaJIT</h2>
 157 <p>
 158 The standard configuration should work fine for most installations.
 159 Usually there is no need to tweak the settings. The following files
 160 hold all user-configurable settings:
 161 </p>
 162 <ul>
 163 <li><tt>src/luaconf.h</tt> sets some configuration variables.</li>
 164 <li><tt>Makefile</tt> has settings for <b>installing</b> LuaJIT (POSIX
 165 only).</li>
 166 <li><tt>src/Makefile</tt> has settings for <b>compiling</b> LuaJIT
 167 under POSIX, MinGW or Cygwin.</li>
 168 <li><tt>src/msvcbuild.bat</tt> has settings for compiling LuaJIT with
 169 MSVC or WinSDK.</li>
 170 </ul>
 171 <p>
 172 Please read the instructions given in these files, before changing
 173 any settings.
 174 </p>
 175
 176 <h2 id="posix">POSIX Systems (Linux, OSX, *BSD etc.)</h2>
 177 <h3>Prerequisites</h3>
 178 <p>
 179 Depending on your distribution, you may need to install a package for
 180 GCC, the development headers and/or a complete SDK. E.g. on a current
 181 Debian/Ubuntu, install <tt>libc6-dev</tt> with the package manager.
 182 </p>
 183 <p>
 184 Download the current source package of LuaJIT (pick the .tar.gz),
 185 if you haven't already done so. Move it to a directory of your choice,
 186 open a terminal window and change to this directory. Now unpack the archive
 187 and change to the newly created directory:
 188 </p>
 189 <pre class="code">
 190 tar zxf LuaJIT-2.0.0-beta10.tar.gz
 191 cd LuaJIT-2.0.0-beta10</pre>
 192 <h3>Building LuaJIT</h3>
 193 <p>
 194 The supplied Makefiles try to auto-detect the settings needed for your
 195 operating system and your compiler. They need to be run with GNU Make,
 196 which is probably the default on your system, anyway. Simply run:
 197 </p>
 198 <pre class="code">
 199 make
 200 </pre>
 201 <p>
 202 This always builds a native x86, x64 or PPC binary, depending on the host OS
 203 you're running this command on. Check the section on
 204 <a href="#cross">cross-compilation</a> for more options.
 205 </p>
 206 <p>
 207 By default, modules are only searched under the prefix <tt>/usr/local</tt>.
 208 You can add an extra prefix to the search paths by appending the
 209 <tt>PREFIX</tt> option, e.g.:
 210 </p>
 211 <pre class="code">
 212 make PREFIX=/home/myself/lj2
 213 </pre>
 214 <p>
 215 Note for OSX: if the <tt>MACOSX_DEPLOYMENT_TARGET</tt> environment
 216 variable is not set, then it's forced to <tt>10.4</tt>.
 217 </p>
 218 <h3>Installing LuaJIT</h3>
 219 <p>
 220 The top-level Makefile installs LuaJIT by default under
 221 <tt>/usr/local</tt>, i.e. the executable ends up in
 222 <tt>/usr/local/bin</tt> and so on. You need root privileges
 223 to write to this path. So, assuming sudo is installed on your system,
 224 run the following command and enter your sudo password:
 225 </p>
 226 <pre class="code">
 227 sudo make install
 228 </pre>
 229 <p>
 230 Otherwise specify the directory prefix as an absolute path, e.g.:
 231 </p>
 232 <pre class="code">
 233 make install PREFIX=/home/myself/lj2
 234 </pre>
 235 <p>
 236 Obviously the prefixes given during build and installation need to be the same.
 237 </p>
 238 <p style="color: #c00000;">
 239 Note: to avoid overwriting a previous version, the beta test releases
 240 only install the LuaJIT executable under the versioned name (i.e.
 241 <tt>luajit-2.0.0-beta10</tt>). You probably want to create a symlink
 242 for convenience, with a command like this:
 243 </p>
 244 <pre class="code" style="color: #c00000;">
 245 sudo ln -sf luajit-2.0.0-beta10&nbsp;/usr/local/bin/luajit
 246 </pre>
 247
 248 <h2 id="windows">Windows Systems</h2>
 249 <h3>Prerequisites</h3>
 250 <p>
 251 Either install one of the open source SDKs
 252 (<a href="http://mingw.org/"><span class="ext">&raquo;</span>&nbsp;MinGW</a> or
 253 <a href="http://www.cygwin.com/"><span class="ext">&raquo;</span>&nbsp;Cygwin</a>), which come with a modified
 254 GCC plus the required development headers.
 255 </p>
 256 <p>
 257 Or install Microsoft's Visual C++ (MSVC). The freely downloadable
 258 <a href="http://www.microsoft.com/Express/VC/"><span class="ext">&raquo;</span>&nbsp;Express Edition</a>
 259 works just fine, but only contains an x86 compiler.
 260 </p>
 261 <p>
 262 The freely downloadable
 263 <a href="http://msdn.microsoft.com/en-us/windowsserver/bb980924.aspx"><span class="ext">&raquo;</span>&nbsp;Windows SDK</a>
 264 only comes with command line tools, but this is all you need to build LuaJIT.
 265 It contains x86 and x64 compilers.
 266 </p>
 267 <p>
 268 Next, download the source package and unpack it using an archive manager
 269 (e.g. the Windows Explorer) to a directory of your choice.
 270 </p>
 271 <h3>Building with MSVC</h3>
 272 <p>
 273 Open a "Visual Studio .NET Command Prompt", <tt>cd</tt> to the
 274 directory where you've unpacked the sources and run these commands:
 275 </p>
 276 <pre class="code">
 277 cd src
 278 msvcbuild
 279 </pre>
 280 <p>
 281 Then follow the installation instructions below.
 282 </p>
 283 <h3>Building with the Windows SDK</h3>
 284 <p>
 285 Open a "Windows SDK Command Shell" and select the x86 compiler:
 286 </p>
 287 <pre class="code">
 288 setenv /release /x86
 289 </pre>
 290 <p>
 291 Or select the x64 compiler:
 292 </p>
 293 <pre class="code">
 294 setenv /release /x64
 295 </pre>
 296 <p>
 297 Then <tt>cd</tt> to the directory where you've unpacked the sources
 298 and run these commands:
 299 </p>
 300 <pre class="code">
 301 cd src
 302 msvcbuild
 303 </pre>
 304 <p>
 305 Then follow the installation instructions below.
 306 </p>
 307 <h3>Building with MinGW or Cygwin</h3>
 308 <p>
 309 Open a command prompt window and make sure the MinGW or Cygwin programs
 310 are in your path. Then <tt>cd</tt> to the directory where
 311 you've unpacked the sources and run this command for MinGW:
 312 </p>
 313 <pre class="code">
 314 mingw32-make
 315 </pre>
 316 <p>
 317 Or this command for Cygwin:
 318 </p>
 319 <pre class="code">
 320 make
 321 </pre>
 322 <p>
 323 Then follow the installation instructions below.
 324 </p>
 325 <h3>Installing LuaJIT</h3>
 326 <p>
 327 Copy <tt>luajit.exe</tt> and <tt>lua51.dll</tt> (built in the <tt>src</tt>
 328 directory) to a newly created directory (any location is ok).
 329 Add <tt>lua</tt> and <tt>lua\jit</tt> directories below it and copy
 330 all Lua files from the <tt>lib</tt> directory of the distribution
 331 to the latter directory.
 332 </p>
 333 <p>
 334 There are no hardcoded
 335 absolute path names &mdash; all modules are loaded relative to the
 336 directory where <tt>luajit.exe</tt> is installed
 337 (see <tt>src/luaconf.h</tt>).
 338 </p>
 339
 340 <h2 id="cross">Cross-compiling LuaJIT</h2>
 341 <p>
 342 The build system has limited support for cross-compilation. For details
 343 check the comments in <tt>src/Makefile</tt>. Here are some popular examples:
 344 </p>
 345 <p>
 346 You can cross-compile to a <b>32 bit binary on a multilib x64 OS</b> by
 347 installing the multilib development packages (e.g. <tt>libc6-dev-i386</tt>
 348 on Debian/Ubuntu) and running:
 349 </p>
 350 <pre class="code">
 351 make CC="gcc -m32"
 352 </pre>
 353 <p>
 354 You can cross-compile for a <b>Windows target on Debian/Ubuntu</b> by
 355 installing the <tt>mingw32</tt> package and running:
 356 </p>
 357 <pre class="code">
 358 make HOST_CC="gcc -m32" CROSS=i586-mingw32msvc- TARGET_SYS=Windows
 359 </pre>
 360 <p>
 361 You can cross-compile for an <b>ARM target</b> on an x86 or x64 host
 362 system using a standard GNU cross-compile toolchain (Binutils, GCC,
 363 EGLIBC). The <tt>CROSS</tt> prefix may vary depending on the
 364 <tt>--target</tt> of the toolchain:
 365 </p>
 366 <pre class="code">
 367 make HOST_CC="gcc -m32" CROSS=arm-linux-gnueabi-
 368 </pre>
 369 <p>
 370 You can cross-compile for <b id="android">Android (ARM)</b> using the <a href="http://developer.android.com/sdk/ndk/index.html"><span class="ext">&raquo;</span>&nbsp;Android NDK</a>.
 371 The environment variables need to match the install locations and the
 372 desired target platform. E.g. Android&nbsp;2.2 corresponds to ABI level&nbsp;8:
 373 </p>
 374 <pre class="code">
 375 NDK=/opt/android/ndk
 376 NDKABI=8
 377 NDKVER=$NDK/toolchains/arm-linux-androideabi-4.4.3
 378 NDKP=$NDKVER/prebuilt/linux-x86/bin/arm-linux-androideabi-
 379 NDKF="--sysroot $NDK/platforms/android-$NDKABI/arch-arm"
 380 make HOST_CC="gcc -m32" CROSS=$NDKP TARGET_FLAGS="$NDKF"
 381 </pre>
 382 <p>
 383 You can cross-compile for <b id="ios">iOS 3.0+</b> (iPhone/iPad) using the <a href="http://developer.apple.com/devcenter/ios/index.action"><span class="ext">&raquo;</span>&nbsp;iOS SDK</a>.
 384 The environment variables need to match the iOS SDK version:
 385 </p>
 386 <p style="font-size: 8pt;">
 387 Note: <b>the JIT compiler is disabled for iOS</b>, because regular iOS Apps
 388 are not allowed to generate code at runtime. You'll only get the performance
 389 of the LuaJIT interpreter on iOS. This is still faster than plain Lua, but
 390 much slower than the JIT compiler. Please complain to Apple, not me.
 391 Or use Android. :-p
 392 </p>
 393 <pre class="code">
 394 ISDK=/Developer/Platforms/iPhoneOS.platform/Developer
 395 ISDKVER=iPhoneOS4.3.sdk
 396 ISDKP=$ISDK/usr/bin/
 397 ISDKF="-arch armv6 -isysroot $ISDK/SDKs/$ISDKVER"
 398 make HOST_CC="gcc -m32 -arch i386" CROSS=$ISDKP TARGET_FLAGS="$ISDKF" \
 399      TARGET_SYS=iOS
 400 </pre>
 401 <p>
 402 You can cross-compile for a <b id="ppc">PPC target</b> or a
 403 <b>PPC/e500v2 target</b> on x86 or x64 host systems using a standard
 404 GNU cross-compile toolchain (Binutils, GCC, EGLIBC).
 405 The <tt>CROSS</tt> prefix may vary depending on the <tt>--target</tt>
 406 of the toolchain:
 407 </p>
 408 <pre class="code">
 409 # PPC
 410 make HOST_CC="gcc -m32" CROSS=powerpc-linux-gnu-
 411 </pre>
 412 <pre class="code">
 413 # PPC/e500v2
 414 make HOST_CC="gcc -m32" CROSS=powerpc-e500v2-linux-gnuspe-
 415 </pre>
 416 <p>
 417 You can cross-compile for a big-endian or little-endian
 418 <b id="mips">MIPS target</b> on x86 or x64 host systems using a standard
 419 GNU cross-compile toolchain (Binutils, GCC, EGLIBC).
 420 The <tt>CROSS</tt> prefix may vary depending on the <tt>--target</tt>
 421 of the toolchain:
 422 </p>
 423 <pre class="code">
 424 # MIPS big-endian
 425 make HOST_CC="gcc -m32" CROSS=mips-linux-
 426 </pre>
 427 <pre class="code">
 428 # MIPS little-endian
 429 make HOST_CC="gcc -m32" CROSS=mipsel-linux-
 430 </pre>
 431 <p>
 432 Whenever the <b>host OS and the target OS differ</b>, you need to specify
 433 <tt>TARGET_SYS</tt> or you'll get assembler or linker errors. E.g. if
 434 you're compiling on a Windows or OSX host for embedded Linux or Android,
 435 you need to add <tt>TARGET_SYS=Linux</tt> to the examples above. For a
 436 minimal target OS, you may need to disable the built-in allocator in
 437 <tt>src/Makefile</tt> and use <tt>TARGET_SYS=Other</tt>.
 438 </p>
 439
 440 <h2 id="embed">Embedding LuaJIT</h2>
 441 <p>
 442 LuaJIT is API-compatible with Lua 5.1. If you've already embedded Lua
 443 into your application, you probably don't need to do anything to switch
 444 to LuaJIT, except link with a different library:
 445 </p>
 446 <ul>
 447 <li>It's strongly suggested to build LuaJIT separately using the supplied
 448 build system. Please do <em>not</em> attempt to integrate the individual
 449 source files into your build tree. You'll most likely get the internal build
 450 dependencies wrong or mess up the compiler flags. Treat LuaJIT like any
 451 other external library and link your application with either the dynamic
 452 or static library, depending on your needs.</li>
 453 <li>If you want to load C modules compiled for plain Lua
 454 with <tt>require()</tt>, you need to make sure the public symbols
 455 (e.g. <tt>lua_pushnumber</tt>) are exported, too:
 456 <ul><li>On POSIX systems you can either link to the shared library
 457 or link the static library into your application. In the latter case
 458 you'll need to export all public symbols from your main executable
 459 (e.g. <tt>-Wl,-E</tt> on Linux) and add the external dependencies
 460 (e.g. <tt>-lm -ldl</tt> on Linux).</li>
 461 <li>Since Windows symbols are bound to a specific DLL name, you need to
 462 link to the <tt>lua51.dll</tt> created by the LuaJIT build (do not rename
 463 the DLL). You may link LuaJIT statically on Windows only if you don't
 464 intend to load Lua/C modules at runtime.
 465 </li></ul>
 466 </li>
 467 <li>
 468 If you're building a 64 bit application on OSX which links directly or
 469 indirectly against LuaJIT, you need to link your main executable
 470 with these flags:
 471 <pre class="code">
 472 -pagezero_size 10000 -image_base 100000000
 473 </pre>
 474 Also, it's recommended to <tt>rebase</tt> all (self-compiled) shared libraries
 475 which are loaded at runtime on OSX/x64 (e.g. C extension modules for Lua).
 476 See: <tt>man rebase</tt>
 477 </li>
 478 </ul>
 479 <p>Additional hints for initializing LuaJIT using the C API functions:</p>
 480 <ul>
 481 <li>Here's a
 482 <a href="http://lua-users.org/wiki/SimpleLuaApiExample"><span class="ext">&raquo;</span>&nbsp;simple example</a>
 483 for embedding Lua or LuaJIT into your application.</li>
 484 <li>Make sure you use <tt>luaL_newstate</tt>. Avoid using
 485 <tt>lua_newstate</tt>, since this uses the (slower) default memory
 486 allocator from your system (no support for this on x64).</li>
 487 <li>Make sure you use <tt>luaL_openlibs</tt> and not the old Lua 5.0 style
 488 of calling <tt>luaopen_base</tt> etc. directly.</li>
 489 <li>To change or extend the list of standard libraries to load, copy
 490 <tt>src/lib_init.c</tt> to your project and modify it accordingly.
 491 Make sure the <tt>jit</tt> library is loaded or the JIT compiler
 492 will not be activated.</li>
 493 <li>The <tt>bit.*</tt> module for bitwise operations
 494 is already built-in. There's no need to statically link
 495 <a href="http://bitop.luajit.org/"><span class="ext">&raquo;</span>&nbsp;Lua BitOp</a> to your application.</li>
 496 </ul>
 497
 498 <h2 id="distro">Hints for Distribution Maintainers</h2>
 499 <p>
 500 The LuaJIT build system has extra provisions for the needs of most
 501 POSIX-based distributions. If you're a package maintainer for
 502 a distribution, <em>please</em> make use of these features and
 503 avoid patching, subverting, autotoolizing or messing up the build system
 504 in unspeakable ways.
 505 </p>
 506 <p>
 507 There should be absolutely no need to patch <tt>luaconf.h</tt> or any
 508 of the Makefiles. And please do not hand-pick files for your packages &mdash;
 509 simply use whatever <tt>make install</tt> creates. There's a reason
 510 for all of the files <em>and</em> directories it creates.
 511 </p>
 512 <p>
 513 The build system uses GNU make and auto-detects most settings based on
 514 the host you're building it on. This should work fine for native builds,
 515 even when sandboxed. You may need to pass some of the following flags to
 516 <em>both</em> the <tt>make</tt> and the <tt>make install</tt> command lines
 517 for a regular distribution build:
 518 </p>
 519 <ul>
 520 <li><tt>PREFIX</tt> overrides the installation path and should usually
 521 be set to <tt>/usr</tt>. Setting this also changes the module paths and
 522 the <tt>-rpath</tt> of the shared library.</li>
 523 <li><tt>DESTDIR</tt> is an absolute path which allows you to install
 524 to a shadow tree instead of the root tree of the build system.</li>
 525 <li>Have a look at the top-level <tt>Makefile</tt> and <tt>src/Makefile</tt>
 526 for additional variables to tweak. The following variables <em>may</em> be
 527 overridden, but it's <em>not</em> recommended, except for special needs
 528 like cross-builds:
 529 <tt>BUILDMODE, CC, HOST_CC, STATIC_CC, DYNAMIC_CC, CFLAGS, HOST_CFLAGS,
 530 TARGET_CFLAGS, LDFLAGS, HOST_LDFLAGS, TARGET_LDFLAGS, TARGET_SHLDFLAGS,
 531 TARGET_FLAGS, LIBS, HOST_LIBS, TARGET_LIBS, CROSS, HOST_SYS, TARGET_SYS
 532 </tt></li>
 533 </ul>
 534 <p>
 535 The build system has a special target for an amalgamated build, i.e.
 536 <tt>make amalg</tt>. This compiles the LuaJIT core as one huge C file
 537 and allows GCC to generate faster and shorter code. Alas, this requires
 538 lots of memory during the build. This may be a problem for some users,
 539 that's why it's not enabled by default. But it shouldn't be a problem for
 540 most build farms. It's recommended that binary distributions use this
 541 target for their LuaJIT builds.
 542 </p>
 543 <p>
 544 The tl;dr version of the above:
 545 </p>
 546 <pre class="code">
 547 make amalg PREFIX=/usr && \
 548 make install PREFIX=/usr DESTDIR=/tmp/buildroot
 549 </pre>
 550 <p>
 551 Finally, if you encounter any difficulties, please
 552 <a href="contact.html">contact me</a> first, instead of releasing a broken
 553 package onto unsuspecting users. Because they'll usually gonna complain
 554 to me (the upstream) and not you (the package maintainer), anyway.
 555 </p>
 556 <br class="flush">
 557 </div>
 558 <div id="foot">
 559 <hr class="hide">
 560 Copyright &copy; 2005-2012 Mike Pall
 561 <span class="noprint">
 562 &middot;
 563 <a href="contact.html">Contact</a>
 564 </span>
 565 </div>
 566 </body>
 567 </html>