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