Merge pull request #630 from peastman/jit

JIT compilation for custom forces in CPU platform

CMakeLists.txt

@@ -269,6 +269,16 @@ IF (ANDROID OR PNACL)
 ELSE (ANDROID OR PNACL)
     SET_SOURCE_FILES_PROPERTIES(${CMAKE_SOURCE_DIR}/libraries/sfmt/src/SFMT.cpp PROPERTIES COMPILE_FLAGS "-DHAVE_SSE2=1")
 ENDIF(ANDROID OR PNACL)
+IF (NOT (ANDROID OR PNACL))
+    IF (CMAKE_SIZEOF_VOID_P EQUAL 8)
+        FILE(GLOB src_files ${CMAKE_CURRENT_SOURCE_DIR}/libraries/asmjit/*/*.cpp)
+        FILE(GLOB incl_files ${CMAKE_CURRENT_SOURCE_DIR}/libraries/asmjit/*.h)
+        SET(SOURCE_FILES ${SOURCE_FILES} ${src_files})
+        SET(SOURCE_INCLUDE_FILES ${SOURCE_INCLUDE_FILES} ${incl_files})
+        INCLUDE_DIRECTORIES(BEFORE "${CMAKE_CURRENT_SOURCE_DIR}/libraries/asmjit")
+        SET(EXTRA_COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DLEPTON_USE_JIT")
+    ENDIF (CMAKE_SIZEOF_VOID_P EQUAL 8)
+ENDIF (NOT (ANDROID OR PNACL))
 
 # If API wrappers are being generated, and add them to the build.
 SET(OPENMM_BUILD_C_AND_FORTRAN_WRAPPERS ON CACHE BOOL "Build wrappers for C and Fortran")
@@ -282,9 +292,14 @@ INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/src)
 
 SET(OPENMM_BUILD_SHARED_LIB ON CACHE BOOL "Whether to build shared OpenMM libraries")
 
+SET(EXTRA_LINK_FLAGS ${EXTRA_COMPILE_FLAGS})
+IF (CMAKE_SYSTEM_NAME MATCHES "Linux")
+    SET(EXTRA_LINK_FLAGS "${EXTRA_LINK_FLAGS} -Wl,--no-as-needed -lrt")
+ENDIF (CMAKE_SYSTEM_NAME MATCHES "Linux")
+
 IF(OPENMM_BUILD_SHARED_LIB)
     ADD_LIBRARY(${SHARED_TARGET} SHARED ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
-    SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_COMPILE_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_BUILDING_SHARED_LIBRARY -DLEPTON_BUILDING_SHARED_LIBRARY -DOPENMM_VALIDATE_BUILDING_SHARED_LIBRARY")
+    SET_TARGET_PROPERTIES(${SHARED_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_LINK_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_BUILDING_SHARED_LIBRARY -DLEPTON_BUILDING_SHARED_LIBRARY -DOPENMM_VALIDATE_BUILDING_SHARED_LIBRARY")
     IF(WIN32)
         ADD_DEPENDENCIES(${SHARED_TARGET} PthreadsLibraries)
     ENDIF(WIN32)
@@ -294,7 +309,7 @@ SET(OPENMM_BUILD_STATIC_LIB OFF CACHE BOOL "Whether to build static OpenMM libra
 IF(OPENMM_BUILD_STATIC_LIB)
     ADD_LIBRARY(${STATIC_TARGET} STATIC ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
     SET(EXTRA_COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_USE_STATIC_LIBRARIES -DLEPTON_USE_STATIC_LIBRARIES -DPTW32_STATIC_LIB")
-    SET_TARGET_PROPERTIES(${STATIC_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_COMPILE_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_BUILDING_STATIC_LIBRARY -DLEPTON_BUILDING_STATIC_LIBRARY -DOPENMMM_VALIDATE_BUILDING_STATIC_LIBRARY -DOPENMM_VALIDATE_BUILDING_STATIC_LIBRARY")
+    SET_TARGET_PROPERTIES(${STATIC_TARGET} PROPERTIES LINK_FLAGS "${EXTRA_LINK_FLAGS}" COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -DOPENMM_BUILDING_STATIC_LIBRARY -DLEPTON_BUILDING_STATIC_LIBRARY -DOPENMMM_VALIDATE_BUILDING_STATIC_LIBRARY -DOPENMM_VALIDATE_BUILDING_STATIC_LIBRARY")
 ENDIF(OPENMM_BUILD_STATIC_LIB)
 
 IF(OPENMM_BUILD_C_AND_FORTRAN_WRAPPERS)

docs-source/licenses/Licenses.txt

@@ -2,16 +2,16 @@ OpenMM was developed by Simbios, the NIH National Center for Physics-Based
 Simulation of Biological Structures at Stanford, funded under the NIH Roadmap
 for Medical Research, grant U54 GM072970. See https://simtk.org.
 
-Portions copyright © 2008-2009 Stanford University and the Authors.
+Portions copyright © 2008-2014 Stanford University and the Authors.
 
 There are several licenses which cover different parts of OpenMM as described
 below.
 
 
-1. API and Reference Platform
+1. API, Reference Platform, CPU Platform
 
-The OpenMM API and the Reference Platform may be used under the terms of the
-MIT License:
+The OpenMM API, the Reference Platform, and the CPU platform may be used under
+the terms of the MIT License:
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -99,10 +99,23 @@ name of the person performing the modification, the date of modification,
 and the reason for such modification.
 
 
-5. GPU-BBSort
+5. AsmJit
 
-The CUDA platform uses the GPU-BBSort library written by Chen Shifu.  It
-includes the following license statement:
+OpenMM uses the AsmJit library which is copyright 2008-2014 by Petr Kobalicek.
+It may be used under the following terms:
 
-The code is distributed under BSD license, you are allowed to use, modify
-or sell this code, but a statement is required if you used this code any where.
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
\ No newline at end of file
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.

libraries/asmjit/LICENSE.md

+AsmJit - Complete x86/x64 JIT and Remote Assembler for C++  
+Copyright (c) 2008-2014, Petr Kobalicek <kobalicek.petr@gmail.com>
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.

libraries/asmjit/apibegin.h

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+#if !defined(_ASMJIT_BUILD_H)
+#include "build.h"
+#endif // !_ASMJIT_BUILD_H
+
+// ============================================================================
+// [MSVC]
+// ============================================================================
+
+#if defined(_MSC_VER)
+// Disable some warnings we know about
+# pragma warning(push)
+# pragma warning(disable: 4127) // conditional expression is constant
+# pragma warning(disable: 4201) // nameless struct/union
+# pragma warning(disable: 4244) // '+=' : conversion from 'int' to 'x', possible
+                                // loss of data
+# pragma warning(disable: 4251) // struct needs to have dll-interface to be used
+                                // by clients of struct ...
+# pragma warning(disable: 4275) // non dll-interface struct ... used as base for
+                                // dll-interface struct
+# pragma warning(disable: 4355) // this used in base member initializer list
+# pragma warning(disable: 4480) // specifying underlying type for enum
+# pragma warning(disable: 4800) // forcing value to bool 'true' or 'false'
+
+// Rename symbols.
+# if !defined(vsnprintf)
+#  define ASMJIT_DEFINED_VSNPRINTF
+#  define vsnprintf _vsnprintf
+# endif // !vsnprintf
+# if !defined(snprintf)
+#  define ASMJIT_DEFINED_SNPRINTF
+#  define snprintf _snprintf
+# endif // !snprintf
+#endif // _MSC_VER
+
+// ============================================================================
+// [GNUC]
+// ============================================================================
+
+#if defined(__GNUC__) && !defined(__clang__)
+# if __GNUC__ >= 4 && !defined(__MINGW32__)
+#  pragma GCC visibility push(hidden)
+# endif // __GNUC__ >= 4
+#endif // __GNUC__

libraries/asmjit/apiend.h

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// ============================================================================
+// [MSVC]
+// ============================================================================
+
+#if defined(_MSC_VER)
+// Pop disabled warnings by ApiBegin.h
+# pragma warning(pop)
+// Rename symbols back.
+# if defined(ASMJIT_DEFINED_VSNPRINTF)
+#  undef ASMJIT_DEFINED_VSNPRINTF
+#  undef vsnprintf
+# endif // ASMJIT_DEFINED_VSNPRINTF
+# if defined(ASMJIT_DEFINED_SNPRINTF)
+#  undef ASMJIT_DEFINED_SNPRINTF
+#  undef snprintf
+# endif // ASMJIT_DEFINED_SNPRINTF
+#endif // _MSC_VER
+
+// ============================================================================
+// [GNUC]
+// ============================================================================
+
+#if defined(__GNUC__) && !defined(__clang__)
+# if __GNUC__ >= 4 && !defined(__MINGW32__)
+#  pragma GCC visibility pop
+# endif // __GNUC__ >= 4
+#endif // __GNUC__

libraries/asmjit/asmjit.h

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Guard]
+#ifndef _ASMJIT_ASMJIT_H
+#define _ASMJIT_ASMJIT_H
+
+// ============================================================================
+// [asmjit_mainpage]
+// ============================================================================
+
+//! @mainpage
+//!
+//! AsmJit - Complete x86/x64 JIT and Remote Assembler for C++.
+//!
+//! AsmJit is a complete JIT and remote assembler for C++ language. It can
+//! generate native code for x86 and x64 architectures having support for
+//! a full instruction set, from legacy MMX to the newest AVX2. It has a
+//! type-safe API that allows C++ compiler to do a semantic checks at
+//! compile-time even before the assembled code is generated or run.
+//!
+//! AsmJit is not a virtual machine (VM). It doesn't have functionality to
+//! implement VM out of the box; however, it can be be used as a JIT backend
+//! for your own VM. The usage of AsmJit is not limited at all; it's suitable
+//! for multimedia, VM backends or remote code generation.
+//!
+//! @section AsmJit_Concepts Code Generation Concepts
+//!
+//! AsmJit has two completely different code generation concepts. The difference
+//! is in how the code is generated. The first concept, also referred as the low
+//! level concept, is called 'Assembler' and it's the same as writing RAW
+//! assembly by using physical registers directly. In this case AsmJit does only
+//! instruction encoding, verification and relocation.
+//!
+//! The second concept, also referred as the high level concept, is called
+//! 'Compiler'. Compiler lets you use virtually unlimited number of registers
+//! (called variables) significantly simplifying the code generation process.
+//! Compiler allocates these virtual registers to physical registers after the
+//! code generation is done. This requires some extra effort - Compiler has to
+//! generate information for each node (instruction, function declaration,
+//! function call) in the code, perform a variable liveness analysis and
+//! translate the code having variables into code having only registers.
+//!
+//! In addition, Compiler understands functions and function calling conventions.
+//! It has been designed in a way that the code generated is always a function
+//! having prototype like in a programming language. By having a function
+//! prototype the Compiler is able to insert prolog and epilog to a function
+//! being generated and it is able to call a function inside a generated one.
+//!
+//! There is no conclusion on which concept is better. Assembler brings full
+//! control on how the code is generated, while Compiler makes the generation
+//! more portable.
+//!
+//! @section AsmJit_Main_CodeGeneration Code Generation
+//!
+//! - \ref asmjit_base_general "Assembler core" - Operands, intrinsics and low-level assembler.
+//! - \ref asmjit_compiler "Compiler" - High level code generation.
+//! - \ref asmjit_cpuinfo "Cpu Information" - Get information about host processor.
+//! - \ref asmjit_logging "Logging" - Logging and error handling.
+//! - \ref AsmJit_MemoryManagement "Memory Management" - Virtual memory management.
+//!
+//! @section AsmJit_Main_HomePage AsmJit Homepage
+//!
+//! - https://github.com/kobalicek/asmjit
+
+// ============================================================================
+// [asmjit_base]
+// ============================================================================
+
+//! \defgroup asmjit_base AsmJit
+//!
+//! \brief AsmJit.
+
+// ============================================================================
+// [asmjit_base_general]
+// ============================================================================
+
+//! \defgroup asmjit_base_general AsmJit General API
+//! \ingroup asmjit_base
+//!
+//! \brief AsmJit general API.
+//!
+//! Contains all `asmjit` classes and helper functions that are architecture
+//! independent or abstract. Abstract classes are implemented by the backend,
+//! for example `Assembler` is implemented by `X86Assembler`.
+//!
+//! - See `Assembler` for low level code generation documentation.
+//! - See `Compiler` for high level code generation documentation.
+//! - See `Operand` for operand's overview.
+//!
+//! Logging and Error Handling
+//! --------------------------
+//!
+//! AsmJit contains robust interface that can be used to log the generated code
+//! and to handle possible errors. Base logging interface is defined in `Logger`
+//! class that is abstract and can be overridden. AsmJit contains two loggers
+//! that can be used out of the box - `FileLogger` that logs into a pure C
+//! `FILE*` stream and `StringLogger` that just concatenates all log messages
+//! by using a `StringBuilder` class.
+//!
+//! The following snippet shows how to setup a logger that logs to `stderr`:
+//!
+//! ~~~
+//! // `FileLogger` instance.
+//! FileLogger logger(stderr);
+//!
+//! // `Compiler` or any other `CodeGen` interface.
+//! host::Compiler c;
+//!
+//! // use `setLogger` to replace the `CodeGen` logger.
+//! c.setLogger(&logger);
+//! ~~~
+//!
+//! \sa \ref Logger, \ref FileLogger, \ref StringLogger.
+
+// ============================================================================
+// [asmjit_base_compiler]
+// ============================================================================
+
+//! \defgroup asmjit_base_compiler AsmJit Compiler
+//! \ingroup asmjit_base
+//!
+//! \brief AsmJit code-tree used by Compiler.
+//!
+//! AsmJit intermediate code-tree is a double-linked list that is made of nodes
+//! that represent assembler instructions, directives, labels and high-level
+//! constructs compiler is using to represent functions and function calls. The
+//! node list can only be used together with \ref Compiler.
+//!
+//! TODO
+
+// ============================================================================
+// [asmjit_base_util]
+// ============================================================================
+
+//! \defgroup asmjit_base_util AsmJit Utilities
+//! \ingroup asmjit_base
+//!
+//! \brief AsmJit utility classes.
+//!
+//! AsmJit contains numerous utility classes that are needed by the library
+//! itself. The most useful ones have been made public and are now exported.
+//!
+//! POD Containers
+//! --------------
+//!
+//! POD containers are used by AsmJit to manage its own data structures. The
+//! following classes can be used by AsmJit consumers:
+//!
+//!   - \ref PodVector - Simple growing array-like container for POD data.
+//!   - \ref StringBuilder - Simple string builder that can append string
+//!     and integers.
+//!
+//! Zone Memory Allocator
+//! ---------------------
+//!
+//! Zone memory allocator is an incremental memory allocator that can be used
+//! to allocate data of short life-time. It has much better performance
+//! characteristics than all other allocators, because the only thing it can do
+//! is to increment a pointer and return its previous address. See \ref Zone
+//! for more details.
+//!
+//! CPU Ticks
+//! ---------
+//!
+//! CPU Ticks is a simple helper that can be used to do basic benchmarks. See
+//! \ref CpuTicks class for more details.
+//!
+//! Integer Utilities
+//! -----------------
+//!
+//! Integer utilities are all implemented by a static class \ref IntUtil.
+//! There are utilities for bit manipulation and bit counting, utilities to get
+//! an integer minimum / maximum and various other helpers required to perform
+//! alignment checks and binary casting from float to integer and vica versa.
+//!
+//! Vector Utilities
+//! ----------------
+//!
+//! SIMD code generation often requires to embed constants after each function
+//! or a block of functions generated. AsmJit contains classes `Vec64`,
+//! `Vec128` and `Vec256` that can be used to prepare data useful when
+//! generating SIMD code.
+//!
+//! X86/X64 code generator contains member functions `dmm`, `dxmm` and `dymm`
+//! which can be used to embed 64-bit, 128-bit and 256-bit data structures into
+//! machine code (both assembler and compiler are supported).
+//!
+//! \note Compiler contains a constant pool, which should be used instead of
+//! embedding constants manually after the function body.
+
+// ============================================================================
+// [asmjit_x86]
+// ============================================================================
+
+//! \defgroup asmjit_x86 X86/X64
+//!
+//! \brief X86/X64 module
+
+// ============================================================================
+// [asmjit_x86_general]
+// ============================================================================
+
+//! \defgroup asmjit_x86_general X86/X64 General API
+//! \ingroup asmjit_x86
+//!
+//! \brief X86/X64 general API.
+//!
+//! X86/X64 Registers
+//! -----------------
+//!
+//! There are static objects that represents X86 and X64 registers. They can
+//! be used directly (like `eax`, `mm`, `xmm`, ...) or created through
+//! these functions:
+//!
+//! - `asmjit::gpb_lo()` - Get Gpb-lo register.
+//! - `asmjit::gpb_hi()` - Get Gpb-hi register.
+//! - `asmjit::gpw()` - Get Gpw register.
+//! - `asmjit::gpd()` - Get Gpd register.
+//! - `asmjit::gpq()` - Get Gpq Gp register.
+//! - `asmjit::gpz()` - Get Gpd/Gpq register.
+//! - `asmjit::fp()`  - Get Fp register.
+//! - `asmjit::mm()`  - Get Mm register.
+//! - `asmjit::xmm()` - Get Xmm register.
+//! - `asmjit::ymm()` - Get Ymm register.
+//!
+//! X86/X64 Addressing
+//! ------------------
+//!
+//! X86 and x64 architectures contains several addressing modes and most ones
+//! are possible with AsmJit library. Memory represents are represented by
+//! `BaseMem` class. These functions are used to make operands that represents
+//! memory addresses:
+//!
+//! - `asmjit::ptr()`
+//! - `asmjit::byte_ptr()`
+//! - `asmjit::word_ptr()`
+//! - `asmjit::dword_ptr()`
+//! - `asmjit::qword_ptr()`
+//! - `asmjit::tword_ptr()`
+//! - `asmjit::oword_ptr()`
+//! - `asmjit::yword_ptr()`
+//! - `asmjit::zword_ptr()`
+//!
+//! Most useful function to make pointer should be `asmjit::ptr()`. It creates
+//! pointer to the target with unspecified size. Unspecified size works in all
+//! intrinsics where are used registers (this means that size is specified by
+//! register operand or by instruction itself). For example `asmjit::ptr()`
+//! can't be used with `Assembler::inc()` instruction. In this case size must
+//! be specified and it's also reason to make difference between pointer sizes.
+//!
+//! Supported are simple address forms `[base + displacement]` and complex
+//! address forms `[base + index * scale + displacement]`.
+//!
+//! X86/X64 Immediates
+//! ------------------
+//!
+//! Immediate values are constants thats passed directly after instruction
+//! opcode. To create such value use `imm()` or `imm_u()` methods to create
+//! signed or unsigned immediate value.
+//!
+//! X86/X64 CPU Information
+//! -----------------------
+//!
+//! The CPUID instruction can be used to get an exhaustive information about
+//! the host X86/X64 processor. AsmJit contains utilities that can get the most
+//! important information related to the features supported by the CPU and the
+//! host operating system, in addition to host processor name and number of
+//! cores. Class `X86CpuInfo` extends `CpuInfo` and provides functionality
+//! specific to X86 and X64.
+//!
+//! By default AsmJit queries the CPU information after the library is loaded
+//! and the queried information is reused by all instances of `JitRuntime`.
+//! The global instance of `X86CpuInfo` can't be changed, because it will affect
+//! the code generation of all `Runtime`s. If there is a need to have a
+//! specific CPU information which contains modified features or processor
+//! vendor it's possible by creating a new instance of `X86CpuInfo` and setting
+//! up its members. `X86CpuUtil::detect` can be used to detect CPU features into
+//! an existing `X86CpuInfo` instance - it may become handly if only one property
+//! has to be turned on/off.
+//!
+//! If the high-level interface `X86CpuInfo` offers is not enough there is also
+//! `X86CpuUtil::callCpuId` helper that can be used to call CPUID instruction
+//! with a given parameters and to consume the output.
+//!
+//! Cpu detection is important when generating a JIT code that may or may not
+//! use certain CPU features. For example there used to be a SSE/SSE2 detection
+//! in the past and today there is often AVX/AVX2 detection.
+//!
+//! The example below shows how to detect SSE2:
+//!
+//! ~~~
+//! using namespace asmjit;
+//!
+//! // Get `X86CpuInfo` global instance.
+//! const X86CpuInfo* cpuInfo = X86CpuInfo::getHost();
+//!
+//! if (cpuInfo->hasFeature(kX86CpuFeatureSse2)) {
+//!   // Processor has SSE2.
+//! }
+//! else if (cpuInfo->hasFeature(kX86CpuFeatureMmx)) {
+//!   // Processor doesn't have SSE2, but has MMX.
+//! }
+//! else {
+//!   // Processor is archaic; it's a wonder AsmJit works here!
+//! }
+//! ~~~
+//!
+//! The next example shows how to call `CPUID` directly:
+//!
+//! ~~~
+//! using namespace asmjit;
+//!
+//! // Call cpuid, first two arguments are passed in Eax/Ecx.
+//! X86CpuId out;
+//! X86CpuUtil::callCpuId(0, 0, &out);
+//!
+//! // If Eax argument is 0, Ebx, Ecx and Edx registers are filled with a cpu vendor.
+//! char cpuVendor[13];
+//! ::memcpy(cpuVendor, &out.ebx, 4);
+//! ::memcpy(cpuVendor + 4, &out.edx, 4);
+//! ::memcpy(cpuVendor + 8, &out.ecx, 4);
+//! vendor[12] = '\0';
+//!
+//! // Print a CPU vendor retrieved from CPUID.
+//! ::printf("%s", cpuVendor);
+//! ~~~
+
+// ============================================================================
+// [asmjit_x86_compiler]
+// ============================================================================
+
+//! \defgroup asmjit_x86_compiler X86/X64 Code-Tree
+//! \ingroup asmjit_x86
+//!
+//! \brief X86/X64 code-tree and helpers.
+
+// ============================================================================
+// [asmjit_x86_inst]
+// ============================================================================
+
+//! \defgroup asmjit_x86_inst X86/X64 Instructions
+//! \ingroup asmjit_x86
+//!
+//! \brief X86/X64 low-level instruction definitions.
+
+// ============================================================================
+// [asmjit_x86_util]
+// ============================================================================
+
+//! \defgroup asmjit_x86_util X86/X64 Utilities
+//! \ingroup asmjit_x86
+//!
+//! \brief X86/X64 utility classes.
+
+// ============================================================================
+// [asmjit_contrib]
+// ============================================================================
+
+//! \defgroup asmjit_contrib Contributions
+//!
+//! \brief Contributions.
+
+// [Dependencies - Base]
+#include "base.h"
+
+// [Dependencies - X86/X64]
+#if defined(ASMJIT_BUILD_X86) || defined(ASMJIT_BUILD_X64)
+#include "x86.h"
+#endif // ASMJIT_BUILD_X86 || ASMJIT_BUILD_X64
+
+// [Dependencies - Host]
+#include "host.h"
+
+// [Guard]
+#endif // _ASMJIT_ASMJIT_H

libraries/asmjit/base.h

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Guard]
+#ifndef _ASMJIT_BASE_H
+#define _ASMJIT_BASE_H
+
+// [Dependencies - AsmJit]
+#include "build.h"
+
+#include "base/assembler.h"
+#include "base/codegen.h"
+#include "base/compiler.h"
+#include "base/constpool.h"
+#include "base/containers.h"
+#include "base/cpuinfo.h"
+#include "base/cputicks.h"
+#include "base/error.h"
+#include "base/globals.h"
+#include "base/intutil.h"
+#include "base/lock.h"
+#include "base/logger.h"
+#include "base/operand.h"
+#include "base/runtime.h"
+#include "base/string.h"
+#include "base/vectypes.h"
+#include "base/vmem.h"
+#include "base/zone.h"
+
+// [Guard]
+#endif // _ASMJIT_BASE_H

libraries/asmjit/base/assembler.cpp

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Export]
+#define ASMJIT_EXPORTS
+
+// [Dependencies - AsmJit]
+#include "../base/assembler.h"
+#include "../base/intutil.h"
+#include "../base/vmem.h"
+
+// [Dependenceis - C]
+#include <stdarg.h>
+
+// [Api-Begin]
+#include "../apibegin.h"
+
+namespace asmjit {
+
+// ============================================================================
+// [asmjit::Assembler - Construction / Destruction]
+// ============================================================================
+
+Assembler::Assembler(Runtime* runtime) :
+  CodeGen(runtime),
+  _buffer(NULL),
+  _end(NULL),
+  _cursor(NULL),
+  _trampolineSize(0),
+  _comment(NULL),
+  _unusedLinks(NULL) {}
+
+Assembler::~Assembler() {
+  reset(true);
+}
+
+// ============================================================================
+// [asmjit::Assembler - Clear / Reset]
+// ============================================================================
+
+void Assembler::reset(bool releaseMemory) {
+  // CodeGen members.
+  _baseAddress = kNoBaseAddress;
+  _instOptions = 0;
+  _error = kErrorOk;
+
+  _baseZone.reset(releaseMemory);
+
+  // Assembler members.
+  if (releaseMemory && _buffer != NULL) {
+    ASMJIT_FREE(_buffer);
+    _buffer = NULL;
+    _end = NULL;
+  }
+
+  _cursor = _buffer;
+  _trampolineSize = 0;
+
+  _comment = NULL;
+  _unusedLinks = NULL;
+
+  _labelList.reset(releaseMemory);
+  _relocList.reset(releaseMemory);
+}
+
+// ============================================================================
+// [asmjit::Assembler - Buffer]
+// ============================================================================
+
+Error Assembler::_grow(size_t n) {
+  size_t capacity = getCapacity();
+  size_t after = getOffset() + n;
+
+  // Overflow.
+  if (n > IntUtil::maxUInt<uintptr_t>() - capacity)
+    return setError(kErrorNoHeapMemory);
+
+  // Grow is called when allocation is needed, so it shouldn't happen, but on
+  // the other hand it is simple to catch and it's not an error.
+  if (after <= capacity)
+    return kErrorOk;
+
+  if (capacity < kMemAllocOverhead)
+    capacity = kMemAllocOverhead;
+  else
+    capacity += kMemAllocOverhead;
+
+  do {
+    size_t oldCapacity = capacity;
+
+    if (capacity < kMemAllocGrowMax)
+      capacity *= 2;
+    else
+      capacity += kMemAllocGrowMax;
+
+    // Overflow.
+    if (oldCapacity > capacity)
+      return setError(kErrorNoHeapMemory);
+  } while (capacity - kMemAllocOverhead < after);
+
+  capacity -= kMemAllocOverhead;
+  return _reserve(capacity);
+}
+
+Error Assembler::_reserve(size_t n) {
+  size_t capacity = getCapacity();
+  if (n <= capacity)
+    return kErrorOk;
+
+  uint8_t* newBuffer;
+  if (_buffer == NULL)
+    newBuffer = static_cast<uint8_t*>(ASMJIT_ALLOC(n));
+  else
+    newBuffer = static_cast<uint8_t*>(ASMJIT_REALLOC(_buffer, n));
+
+  if (newBuffer == NULL)
+    return setError(kErrorNoHeapMemory);
+
+  size_t offset = getOffset();
+
+  _buffer = newBuffer;
+  _end = _buffer + n;
+  _cursor = newBuffer + offset;
+
+  return kErrorOk;
+}
+
+// ============================================================================
+// [asmjit::Assembler - Label]
+// ============================================================================
+
+Error Assembler::_registerIndexedLabels(size_t index) {
+  size_t i = _labelList.getLength();
+  if (index < i)
+    return kErrorOk;
+
+  if (_labelList._grow(index - i) != kErrorOk)
+    return setError(kErrorNoHeapMemory);
+
+  LabelData data;
+  data.offset = -1;
+  data.links = NULL;
+
+  do {
+    _labelList.append(data);
+  } while (++i < index);
+
+  return kErrorOk;
+}
+
+Error Assembler::_newLabel(Label* dst) {
+  dst->_label.op = kOperandTypeLabel;
+  dst->_label.size = 0;
+  dst->_label.id = OperandUtil::makeLabelId(static_cast<uint32_t>(_labelList.getLength()));
+
+  LabelData data;
+  data.offset = -1;
+  data.links = NULL;
+
+  if (_labelList.append(data) != kErrorOk)
+    goto _NoMemory;
+  return kErrorOk;
+
+_NoMemory:
+  dst->_label.id = kInvalidValue;
+  return setError(kErrorNoHeapMemory);
+}
+
+LabelLink* Assembler::_newLabelLink() {
+  LabelLink* link = _unusedLinks;
+
+  if (link) {
+    _unusedLinks = link->prev;
+  }
+  else {
+    link = _baseZone.allocT<LabelLink>();
+    if (link == NULL)
+      return NULL;
+  }
+
+  link->prev = NULL;
+  link->offset = 0;
+  link->displacement = 0;
+  link->relocId = -1;
+
+  return link;
+}
+
+Error Assembler::bind(const Label& label) {
+  // Get label data based on label id.
+  uint32_t index = label.getId();
+  LabelData* data = getLabelData(index);
+
+  // Label can be bound only once.
+  if (data->offset != -1)
+    return setError(kErrorLabelAlreadyBound);
+
+#if !defined(ASMJIT_DISABLE_LOGGER)
+  if (_logger)
+    _logger->logFormat(kLoggerStyleLabel, "L%u:\n", index);
+#endif // !ASMJIT_DISABLE_LOGGER
+
+  Error error = kErrorOk;
+  size_t pos = getOffset();
+
+  LabelLink* link = data->links;
+  LabelLink* prev = NULL;
+
+  while (link) {
+    intptr_t offset = link->offset;
+
+    if (link->relocId != -1) {
+      // Handle RelocData - We have to update RelocData information instead of
+      // patching the displacement in LabelData.
+      _relocList[link->relocId].data += static_cast<Ptr>(pos);
+    }
+    else {
+      // Not using relocId, this means that we are overwriting a real
+      // displacement in the binary stream.
+      int32_t patchedValue = static_cast<int32_t>(
+        static_cast<intptr_t>(pos) - offset + link->displacement);
+
+      // Size of the value we are going to patch. Only BYTE/DWORD is allowed.
+      uint32_t size = getByteAt(offset);
+      ASMJIT_ASSERT(size == 1 || size == 4);
+
+      if (size == 4) {
+        setInt32At(offset, patchedValue);
+      }
+      else {
+        ASMJIT_ASSERT(size == 1);
+        if (IntUtil::isInt8(patchedValue))
+          setByteAt(offset, static_cast<uint8_t>(patchedValue & 0xFF));
+        else
+          error = kErrorIllegalDisplacement;
+      }
+    }
+
+    prev = link->prev;
+    link = prev;
+  }
+
+  // Chain unused links.
+  link = data->links;
+  if (link) {
+    if (prev == NULL)
+      prev = link;
+
+    prev->prev = _unusedLinks;
+    _unusedLinks = link;
+  }
+
+  // Set as bound (offset is zero or greater and no links).
+  data->offset = pos;
+  data->links = NULL;
+
+  if (error != kErrorOk)
+    return setError(error);
+
+  return error;
+}
+
+// ============================================================================
+// [asmjit::Assembler - Embed]
+// ============================================================================
+
+Error Assembler::embed(const void* data, uint32_t size) {
+  if (getRemainingSpace() < size) {
+    Error error = _grow(size);
+    if (error != kErrorOk)
+      return setError(error);
+  }
+
+  uint8_t* cursor = getCursor();
+  ::memcpy(cursor, data, size);
+  setCursor(cursor + size);
+
+#if !defined(ASMJIT_DISABLE_LOGGER)
+  if (_logger)
+    _logger->logBinary(kLoggerStyleData, data, size);
+#endif // !ASMJIT_DISABLE_LOGGER
+
+  return kErrorOk;
+}
+
+// ============================================================================
+// [asmjit::Assembler - Reloc]
+// ============================================================================
+
+size_t Assembler::relocCode(void* dst, Ptr baseAddress) const {
+  if (baseAddress == kNoBaseAddress)
+    baseAddress = hasBaseAddress() ? getBaseAddress() : static_cast<Ptr>((uintptr_t)dst);
+  else if (getBaseAddress() != baseAddress)
+    return 0;
+
+  return _relocCode(dst, baseAddress);
+}
+
+// ============================================================================
+// [asmjit::Assembler - Make]
+// ============================================================================
+
+void* Assembler::make() {
+  // Do nothing on error condition or if no instruction has been emitted.
+  if (_error != kErrorOk || getCodeSize() == 0)
+    return NULL;
+
+  void* p;
+  Error error = _runtime->add(&p, this);
+
+  if (error != kErrorOk)
+    setError(error);
+
+  return p;
+}
+
+// ============================================================================
+// [asmjit::Assembler - Emit (Helpers)]
+// ============================================================================
+
+#define NA noOperand
+
+Error Assembler::emit(uint32_t code) {
+  return _emit(code, NA, NA, NA, NA);
+}
+
+Error Assembler::emit(uint32_t code, const Operand& o0) {
+  return _emit(code, o0, NA, NA, NA);
+}
+
+Error Assembler::emit(uint32_t code, const Operand& o0, const Operand& o1) {
+  return _emit(code, o0, o1, NA, NA);
+}
+
+Error Assembler::emit(uint32_t code, const Operand& o0, const Operand& o1, const Operand& o2) {
+  return _emit(code, o0, o1, o2, NA);
+}
+
+Error Assembler::emit(uint32_t code, int o0) {
+  Imm imm(o0);
+  return _emit(code, imm, NA, NA, NA);
+}
+
+Error Assembler::emit(uint32_t code, uint64_t o0) {
+  Imm imm(o0);
+  return _emit(code, imm, NA, NA, NA);
+}
+
+Error Assembler::emit(uint32_t code, const Operand& o0, int o1) {
+  Imm imm(o1);
+  return _emit(code, o0, imm, NA, NA);
+}
+
+Error Assembler::emit(uint32_t code, const Operand& o0, uint64_t o1) {
+  Imm imm(o1);
+  return _emit(code, o0, imm, NA, NA);
+}
+
+Error Assembler::emit(uint32_t code, const Operand& o0, const Operand& o1, int o2) {
+  Imm imm(o2);
+  return _emit(code, o0, o1, imm, NA);
+}
+
+Error Assembler::emit(uint32_t code, const Operand& o0, const Operand& o1, uint64_t o2) {
+  Imm imm(o2);
+  return _emit(code, o0, o1, imm, NA);
+}
+
+Error Assembler::emit(uint32_t code, const Operand& o0, const Operand& o1, const Operand& o2, int o3) {
+  Imm imm(o3);
+  return _emit(code, o0, o1, o2, imm);
+}
+
+Error Assembler::emit(uint32_t code, const Operand& o0, const Operand& o1, const Operand& o2, uint64_t o3) {
+  Imm imm(o3);
+  return _emit(code, o0, o1, o2, imm);
+}
+
+#undef NA
+
+} // asmjit namespace
+
+// [Api-End]
+#include "../apiend.h"

libraries/asmjit/base/assembler.h

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Guard]
+#ifndef _ASMJIT_BASE_ASSEMBLER_H
+#define _ASMJIT_BASE_ASSEMBLER_H
+
+// [Dependencies - AsmJit]
+#include "../base/codegen.h"
+#include "../base/containers.h"
+#include "../base/error.h"
+#include "../base/logger.h"
+#include "../base/operand.h"
+#include "../base/runtime.h"
+#include "../base/zone.h"
+
+// [Api-Begin]
+#include "../apibegin.h"
+
+namespace asmjit {
+
+//! \addtogroup asmjit_base_general
+//! \{
+
+// ============================================================================
+// [asmjit::kInstId]
+// ============================================================================
+
+//! Instruction codes (stub).
+ASMJIT_ENUM(kInstId) {
+  //! No instruction.
+  kInstIdNone = 0
+};
+
+// ============================================================================
+// [asmjit::kInstOptions]
+// ============================================================================
+
+//! Instruction options (stub).
+ASMJIT_ENUM(kInstOptions) {
+  //! No instruction options.
+  kInstOptionNone = 0x00,
+
+  //! Emit short form of the instruction.
+  //!
+  //! X86/X64:
+  //!
+  //! Short form is mostly related to jmp and jcc instructions, but can be used
+  //! by other instructions supporting 8-bit or 32-bit immediates. This option
+  //! can be dangerous if the short jmp/jcc is required, but not encodable due
+  //! to large displacement, in such case an error happens and the whole
+  //! assembler/compiler stream is unusable.
+  kInstOptionShortForm = 0x01,
+  //! Emit long form of the instruction.
+  //!
+  //! X86/X64:
+  //!
+  //! Long form is mosrlt related to jmp and jcc instructions, but like the
+  //! `kInstOptionShortForm` option it can be used by other instructions
+  //! supporting both 8-bit and 32-bit immediates.
+  kInstOptionLongForm = 0x02,
+
+  //! Condition is likely to be taken.
+  kInstOptionTaken = 0x04,
+  //! Condition is unlikely to be taken.
+  kInstOptionNotTaken = 0x08
+};
+
+// ============================================================================
+// [asmjit::LabelLink]
+// ============================================================================
+
+//! \internal
+//!
+//! Data structure used to link linked-labels.
+struct LabelLink {
+  //! Previous link.
+  LabelLink* prev;
+  //! Offset.
+  intptr_t offset;
+  //! Inlined displacement.
+  intptr_t displacement;
+  //! RelocId if link must be absolute when relocated.
+  intptr_t relocId;
+};
+
+// ============================================================================
+// [asmjit::LabelData]
+// ============================================================================
+
+//! \internal
+//!
+//! Label data.
+struct LabelData {
+  //! Label offset.
+  intptr_t offset;
+  //! Label links chain.
+  LabelLink* links;
+};
+
+// ============================================================================
+// [asmjit::RelocData]
+// ============================================================================
+
+//! \internal
+//!
+//! Code relocation data (relative vs absolute addresses).
+//!
+//! X86/X64:
+//!
+//! X86 architecture uses 32-bit absolute addressing model by memory operands,
+//! but 64-bit mode uses relative addressing model (RIP + displacement). In
+//! code we are always using relative addressing model for referencing labels
+//! and embedded data. In 32-bit mode we must patch all references to absolute
+//! address before we can call generated function.
+struct RelocData {
+  //! Type of relocation.
+  uint32_t type;
+  //! Size of relocation (4 or 8 bytes).
+  uint32_t size;
+
+  //! Offset from code begin address.
+  Ptr from;
+
+  //! Relative displacement from code begin address (not to `offset`) or
+  //! absolute address.
+  Ptr data;
+};
+
+// ============================================================================
+// [asmjit::Assembler]
+// ============================================================================
+
+//! Base assembler.
+//!
+//! This class implements the base interface to an assembler. The architecture
+//! specific API is implemented by backends.
+//!
+//! \sa Compiler.
+struct ASMJIT_VCLASS Assembler : public CodeGen {
+  ASMJIT_NO_COPY(Assembler)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `Assembler` instance.
+  ASMJIT_API Assembler(Runtime* runtime);
+  //! Destroy the `Assembler` instance.
+  ASMJIT_API virtual ~Assembler();
+
+  // --------------------------------------------------------------------------
+  // [Reset]
+  // --------------------------------------------------------------------------
+
+  //! Reset the assembler.
+  //!
+  //! If `releaseMemory` is true all buffers will be released to the system.
+  ASMJIT_API void reset(bool releaseMemory = false);
+
+  // --------------------------------------------------------------------------
+  // [Buffer]
+  // --------------------------------------------------------------------------
+
+  //! Get capacity of the code buffer.
+  ASMJIT_INLINE size_t getCapacity() const {
+    return (size_t)(_end - _buffer);
+  }
+
+  //! Get the number of remaining bytes (space between cursor and the end of
+  //! the buffer).
+  ASMJIT_INLINE size_t getRemainingSpace() const {
+    return (size_t)(_end - _cursor);
+  }
+
+  //! Get buffer.
+  ASMJIT_INLINE uint8_t* getBuffer() const {
+    return _buffer;
+  }
+
+  //! Get the end of the buffer (points to the first byte that is outside).
+  ASMJIT_INLINE uint8_t* getEnd() const {
+    return _end;
+  }
+
+  //! Get the current position in the buffer.
+  ASMJIT_INLINE uint8_t* getCursor() const {
+    return _cursor;
+  }
+
+  //! Set the current position in the buffer.
+  ASMJIT_INLINE void setCursor(uint8_t* cursor) {
+    ASMJIT_ASSERT(cursor >= _buffer && cursor <= _end);
+    _cursor = cursor;
+  }
+
+  //! Get the current offset in the buffer.
+  ASMJIT_INLINE size_t getOffset() const {
+    return (size_t)(_cursor - _buffer);
+  }
+
+  //! Set the current offset in the buffer to `offset` and get the previous
+  //! offset value.
+  ASMJIT_INLINE size_t setOffset(size_t offset) {
+    ASMJIT_ASSERT(offset < getCapacity());
+
+    size_t oldOffset = (size_t)(_cursor - _buffer);
+    _cursor = _buffer + offset;
+    return oldOffset;
+  }
+
+  //! Grow the internal buffer.
+  //!
+  //! The internal buffer will grow at least by `n` bytes so `n` bytes can be
+  //! added to it. If `n` is zero or `getOffset() + n` is not greater than the
+  //! current capacity of the buffer this function does nothing.
+  ASMJIT_API Error _grow(size_t n);
+
+  //! Reserve the internal buffer to at least `n` bytes.
+  ASMJIT_API Error _reserve(size_t n);
+
+  //! Get BYTE at position `pos`.
+  ASMJIT_INLINE uint8_t getByteAt(size_t pos) const {
+    ASMJIT_ASSERT(pos + 1 <= (size_t)(_end - _buffer));
+    return *reinterpret_cast<const uint8_t*>(_buffer + pos);
+  }
+
+  //! Get WORD at position `pos`.
+  ASMJIT_INLINE uint16_t getWordAt(size_t pos) const {
+    ASMJIT_ASSERT(pos + 2 <= (size_t)(_end - _buffer));
+    return *reinterpret_cast<const uint16_t*>(_buffer + pos);
+  }
+
+  //! Get DWORD at position `pos`.
+  ASMJIT_INLINE uint32_t getDWordAt(size_t pos) const {
+    ASMJIT_ASSERT(pos + 4 <= (size_t)(_end - _buffer));
+    return *reinterpret_cast<const uint32_t*>(_buffer + pos);
+  }
+
+  //! Get QWORD at position `pos`.
+  ASMJIT_INLINE uint64_t getQWordAt(size_t pos) const {
+    ASMJIT_ASSERT(pos + 8 <= (size_t)(_end - _buffer));
+    return *reinterpret_cast<const uint64_t*>(_buffer + pos);
+  }
+
+  //! Get int32_t at position `pos`.
+  ASMJIT_INLINE int32_t getInt32At(size_t pos) const {
+    ASMJIT_ASSERT(pos + 4 <= (size_t)(_end - _buffer));
+    return *reinterpret_cast<const int32_t*>(_buffer + pos);
+  }
+
+  //! Get uint32_t at position `pos`.
+  ASMJIT_INLINE uint32_t getUInt32At(size_t pos) const {
+    ASMJIT_ASSERT(pos + 4 <= (size_t)(_end - _buffer));
+    return *reinterpret_cast<const uint32_t*>(_buffer + pos);
+  }
+
+  //! Set BYTE at position `pos`.
+  ASMJIT_INLINE void setByteAt(size_t pos, uint8_t x) {
+    ASMJIT_ASSERT(pos + 1 <= (size_t)(_end - _buffer));
+    *reinterpret_cast<uint8_t*>(_buffer + pos) = x;
+  }
+
+  //! Set WORD at position `pos`.
+  ASMJIT_INLINE void setWordAt(size_t pos, uint16_t x) {
+    ASMJIT_ASSERT(pos + 2 <= (size_t)(_end - _buffer));
+    *reinterpret_cast<uint16_t*>(_buffer + pos) = x;
+  }
+
+  //! Set DWORD at position `pos`.
+  ASMJIT_INLINE void setDWordAt(size_t pos, uint32_t x) {
+    ASMJIT_ASSERT(pos + 4 <= (size_t)(_end - _buffer));
+    *reinterpret_cast<uint32_t*>(_buffer + pos) = x;
+  }
+
+  //! Set QWORD at position `pos`.
+  ASMJIT_INLINE void setQWordAt(size_t pos, uint64_t x) {
+    ASMJIT_ASSERT(pos + 8 <= (size_t)(_end - _buffer));
+    *reinterpret_cast<uint64_t*>(_buffer + pos) = x;
+  }
+
+  //! Set int32_t at position `pos`.
+  ASMJIT_INLINE void setInt32At(size_t pos, int32_t x) {
+    ASMJIT_ASSERT(pos + 4 <= (size_t)(_end - _buffer));
+    *reinterpret_cast<int32_t*>(_buffer + pos) = x;
+  }
+
+  //! Set uint32_t at position `pos`.
+  ASMJIT_INLINE void setUInt32At(size_t pos, uint32_t x) {
+    ASMJIT_ASSERT(pos + 4 <= (size_t)(_end - _buffer));
+    *reinterpret_cast<uint32_t*>(_buffer + pos) = x;
+  }
+
+  // --------------------------------------------------------------------------
+  // [GetCodeSize]
+  // --------------------------------------------------------------------------
+
+  //! Get current offset in buffer, same as `getOffset() + getTramplineSize()`.
+  ASMJIT_INLINE size_t getCodeSize() const {
+    return getOffset() + getTrampolineSize();
+  }
+
+  // --------------------------------------------------------------------------
+  // [GetTrampolineSize]
+  // --------------------------------------------------------------------------
+
+  //! Get size of all possible trampolines.
+  //!
+  //! Trampolines are needed to successfuly generate relative jumps to absolute
+  //! addresses. This value is only non-zero if jmp of call instructions were
+  //! used with immediate operand (this means jumping or calling an absolute
+  //! address directly).
+  ASMJIT_INLINE size_t getTrampolineSize() const {
+    return _trampolineSize;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Label]
+  // --------------------------------------------------------------------------
+
+  //! Get number of labels created.
+  ASMJIT_INLINE size_t getLabelsCount() const {
+    return _labelList.getLength();
+  }
+
+  //! Get whether the `label` is valid (created by the assembler).
+  ASMJIT_INLINE bool isLabelValid(const Label& label) const {
+    return isLabelValid(label.getId());
+  }
+
+  //! \overload
+  ASMJIT_INLINE bool isLabelValid(uint32_t id) const {
+    return static_cast<size_t>(id) < _labelList.getLength();
+  }
+
+  //! Get whether the `label` is bound.
+  //!
+  //! \note It's an error to pass label that is not valid. Check the validity
+  //! of the label by using `isLabelValid()` method before the bound check if
+  //! you are not sure about its validity, otherwise you may hit an assertion
+  //! failure in debug mode, and undefined behavior in release mode.
+  ASMJIT_INLINE bool isLabelBound(const Label& label) const {
+    return isLabelBound(label.getId());
+  }
+
+  //! \overload
+  ASMJIT_INLINE bool isLabelBound(uint32_t id) const {
+    ASMJIT_ASSERT(isLabelValid(id));
+
+    return _labelList[id].offset != -1;
+  }
+
+  //! Get `label` offset or -1 if the label is not yet bound.
+  ASMJIT_INLINE intptr_t getLabelOffset(const Label& label) const {
+    return getLabelOffset(label.getId());
+  }
+
+  //! \overload
+  ASMJIT_INLINE intptr_t getLabelOffset(uint32_t id) const {
+    ASMJIT_ASSERT(isLabelValid(id));
+    return _labelList[id].offset;
+  }
+
+  //! Get `LabelData` by `label`.
+  ASMJIT_INLINE LabelData* getLabelData(const Label& label) const {
+    return getLabelData(label.getId());
+  }
+
+  //! \overload
+  ASMJIT_INLINE LabelData* getLabelData(uint32_t id) const {
+    ASMJIT_ASSERT(isLabelValid(id));
+    return const_cast<LabelData*>(&_labelList[id]);
+  }
+
+  //! \internal
+  //!
+  //! Register labels for other code generator, i.e. `Compiler`.
+  ASMJIT_API Error _registerIndexedLabels(size_t index);
+
+  //! \internal
+  //!
+  //! Create and initialize a new `Label`.
+  ASMJIT_API Error _newLabel(Label* dst);
+
+  //! \internal
+  //!
+  //! New LabelLink instance.
+  ASMJIT_API LabelLink* _newLabelLink();
+
+  //! Create and return a new `Label`.
+  ASMJIT_INLINE Label newLabel() {
+    Label result(NoInit);
+    _newLabel(&result);
+    return result;
+  }
+
+  //! Bind label to the current offset.
+  //!
+  //! \note Label can be bound only once!
+  ASMJIT_API virtual Error bind(const Label& label);
+
+  // --------------------------------------------------------------------------
+  // [Embed]
+  // --------------------------------------------------------------------------
+
+  //! Embed data into the code buffer.
+  ASMJIT_API virtual Error embed(const void* data, uint32_t size);
+
+  // --------------------------------------------------------------------------
+  // [Align]
+  // --------------------------------------------------------------------------
+
+  //! Align target buffer to `m` bytes.
+  //!
+  //! Typical usage of this is to align labels at start of the inner loops.
+  //!
+  //! Inserts `nop()` instructions or CPU optimized NOPs.
+  virtual Error align(uint32_t mode, uint32_t offset) = 0;
+
+  // --------------------------------------------------------------------------
+  // [Reloc]
+  // --------------------------------------------------------------------------
+
+  //! Relocate the code to `baseAddress` and copy to `dst`.
+  //!
+  //! \param dst Contains the location where the relocated code should be
+  //! copied. The pointer can be address returned by virtual memory allocator
+  //! or any other address that has sufficient space.
+  //!
+  //! \param base Base address used for relocation. The `JitRuntime` always
+  //! sets the `base` address to be the same as `dst`, but other runtimes, for
+  //! example `StaticRuntime`, do not have to follow this rule.
+  //!
+  //! \retval The number bytes actually used. If the code generator reserved
+  //! space for possible trampolines, but didn't use it, the number of bytes
+  //! used can actually be less than the expected worst case. Virtual memory
+  //! allocator can shrink the memory allocated first time.
+  //!
+  //! A given buffer will be overwritten, to get the number of bytes required,
+  //! use `getCodeSize()`.
+  ASMJIT_API size_t relocCode(void* dst, Ptr baseAddress = kNoBaseAddress) const;
+
+  //! \internal
+  //!
+  //! Reloc code.
+  virtual size_t _relocCode(void* dst, Ptr baseAddress) const = 0;
+
+  // --------------------------------------------------------------------------
+  // [Make]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_API virtual void* make();
+
+  // --------------------------------------------------------------------------
+  // [Emit]
+  // --------------------------------------------------------------------------
+
+  //! Emit an instruction.
+  ASMJIT_API Error emit(uint32_t code);
+  //! \overload
+  ASMJIT_API Error emit(uint32_t code, const Operand& o0);
+  //! \overload
+  ASMJIT_API Error emit(uint32_t code, const Operand& o0, const Operand& o1);
+  //! \overload
+  ASMJIT_API Error emit(uint32_t code, const Operand& o0, const Operand& o1, const Operand& o2);
+  //! \overload
+  ASMJIT_INLINE Error emit(uint32_t code, const Operand& o0, const Operand& o1, const Operand& o2, const Operand& o3) {
+    return _emit(code, o0, o1, o2, o3);
+  }
+
+  //! Emit an instruction with integer immediate operand.
+  ASMJIT_API Error emit(uint32_t code, int o0);
+  //! \overload
+  ASMJIT_API Error emit(uint32_t code, uint64_t o0);
+  //! \overload
+  ASMJIT_API Error emit(uint32_t code, const Operand& o0, int o1);
+  //! \overload
+  ASMJIT_API Error emit(uint32_t code, const Operand& o0, uint64_t o1);
+  //! \overload
+  ASMJIT_API Error emit(uint32_t code, const Operand& o0, const Operand& o1, int o2);
+  //! \overload
+  ASMJIT_API Error emit(uint32_t code, const Operand& o0, const Operand& o1, uint64_t o2);
+  //! \overload
+  ASMJIT_API Error emit(uint32_t code, const Operand& o0, const Operand& o1, const Operand& o2, int o3);
+  //! \overload
+  ASMJIT_API Error emit(uint32_t code, const Operand& o0, const Operand& o1, const Operand& o2, uint64_t o3);
+
+  //! Emit an instruction (virtual).
+  virtual Error _emit(uint32_t code, const Operand& o0, const Operand& o1, const Operand& o2, const Operand& o3) = 0;
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Buffer where the code is emitted (either live or temporary).
+  //!
+  //! This is actually the base pointer of the buffer, to get the current
+  //! position (cursor) look at the `_cursor` member.
+  uint8_t* _buffer;
+  //! The end of the buffer (points to the first invalid byte).
+  //!
+  //! The end of the buffer is calculated as <code>_buffer + size</code>.
+  uint8_t* _end;
+  //! The current position in code `_buffer`.
+  uint8_t* _cursor;
+
+  //! Size of possible trampolines.
+  uint32_t _trampolineSize;
+
+  //! Inline comment that will be logged by the next instruction and set to NULL.
+  const char* _comment;
+  //! Unused `LabelLink` structures pool.
+  LabelLink* _unusedLinks;
+
+  //! LabelData list.
+  PodVector<LabelData> _labelList;
+  //! RelocData list.
+  PodVector<RelocData> _relocList;
+};
+
+//! \}
+
+// ============================================================================
+// [Defined-Later]
+// ============================================================================
+
+ASMJIT_INLINE Label::Label(Assembler& a) : Operand(NoInit) {
+  a._newLabel(this);
+}
+
+} // asmjit namespace
+
+// [Api-End]
+#include "../apiend.h"
+
+// [Guard]
+#endif // _ASMJIT_BASE_ASSEMBLER_H

libraries/asmjit/base/codegen.cpp

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Export]
+#define ASMJIT_EXPORTS
+
+// [Dependencies - AsmJit]
+#include "../base/codegen.h"
+#include "../base/intutil.h"
+
+// [Api-Begin]
+#include "../apibegin.h"
+
+namespace asmjit {
+
+// ============================================================================
+// [asmjit::CodeGen - Construction / Destruction]
+// ============================================================================
+
+CodeGen::CodeGen(Runtime* runtime) :
+  _runtime(runtime),
+  _logger(NULL),
+  _errorHandler(NULL),
+  _baseAddress(runtime->getBaseAddress()),
+  _arch(kArchNone),
+  _regSize(0),
+  _reserved(0),
+  _features(IntUtil::mask(kCodeGenOptimizedAlign)),
+  _instOptions(0),
+  _error(kErrorOk),
+  _baseZone(16384 - kZoneOverhead) {}
+
+CodeGen::~CodeGen() {
+  if (_errorHandler != NULL)
+    _errorHandler->release();
+}
+
+// ============================================================================
+// [asmjit::CodeGen - Logging]
+// ============================================================================
+
+#if !defined(ASMJIT_DISABLE_LOGGER)
+Error CodeGen::setLogger(Logger* logger) {
+  _logger = logger;
+  return kErrorOk;
+}
+#endif // !ASMJIT_DISABLE_LOGGER
+
+// ============================================================================
+// [asmjit::CodeGen - Error]
+// ============================================================================
+
+Error CodeGen::setError(Error error, const char* message) {
+  if (error == kErrorOk)  {
+    _error = kErrorOk;
+    return kErrorOk;
+  }
+
+  if (message == NULL) {
+#if !defined(ASMJIT_DISABLE_NAMES)
+    message = ErrorUtil::asString(error);
+#else
+    static const char noMessage[] = "";
+    message = noMessage;
+#endif // ASMJIT_DISABLE_NAMES
+  }
+
+  // Error handler is called before logger so logging can be skipped if error
+  // has been handled.
+  ErrorHandler* handler = _errorHandler;
+  ASMJIT_TLOG("[ERROR] %s %s\n", message, !handler ? "(Possibly unhandled?)" : "");
+
+  if (handler != NULL && handler->handleError(error, message))
+    return error;
+
+#if !defined(ASMJIT_DISABLE_LOGGER)
+  Logger* logger = _logger;
+  if (logger != NULL) {
+    logger->logFormat(kLoggerStyleComment,
+      "*** ERROR: %s (%u).\n", message, static_cast<unsigned int>(error));
+  }
+#endif // !ASMJIT_DISABLE_LOGGER
+
+  // The handler->handleError() function may throw an exception or longjmp()
+  // to terminate the execution of setError(). This is the reason why we have
+  // delayed changing the _error member until now.
+  _error = error;
+
+  return error;
+}
+
+Error CodeGen::setErrorHandler(ErrorHandler* handler) {
+  ErrorHandler* oldHandler = _errorHandler;
+
+  if (oldHandler != NULL)
+    oldHandler->release();
+
+  if (handler != NULL)
+    handler = handler->addRef();
+
+  _errorHandler = handler;
+  return kErrorOk;
+}
+
+} // asmjit namespace
+
+// [Api-End]
+#include "../apiend.h"

libraries/asmjit/base/codegen.h

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Guard]
+#ifndef _ASMJIT_BASE_CODEGEN_H
+#define _ASMJIT_BASE_CODEGEN_H
+
+// [Dependencies - AsmJit]
+#include "../base/error.h"
+#include "../base/logger.h"
+#include "../base/runtime.h"
+#include "../base/zone.h"
+
+// [Api-Begin]
+#include "../apibegin.h"
+
+namespace asmjit {
+
+//! \addtogroup asmjit_base_general
+//! \{
+
+// ============================================================================
+// [asmjit::kCodeGen]
+// ============================================================================
+
+//! Features of \ref CodeGen.
+ASMJIT_ENUM(kCodeGen) {
+  //! Emit optimized code-alignment sequences (`Assembler` and `Compiler`).
+  //!
+  //! Default `true`.
+  //!
+  //! X86/X64
+  //! -------
+  //!
+  //! Default align sequence used by X86/X64 architecture is one-byte 0x90
+  //! opcode that is mostly shown by disassemblers as nop. However there are
+  //! more optimized align sequences for 2-11 bytes that may execute faster.
+  //! If this feature is enabled asmjit will generate specialized sequences
+  //! for alignment between 1 to 11 bytes. Also when `X86Compiler` is used,
+  //! it can add REX prefixes into the code to make some instructions greater
+  //! so no alignment sequence is needed.
+  kCodeGenOptimizedAlign = 0,
+
+  //! Emit jump-prediction hints (`Assembler` and `Compiler`).
+  //!
+  //! Default `false`.
+  //!
+  //! X86/X64
+  //! -------
+  //!
+  //! Jump prediction is usually based on the direction of the jump. If the
+  //! jump is backward it is usually predicted as taken; and if the jump is
+  //! forward it is usually predicted as not-taken. The reason is that loops
+  //! generally use backward jumps and conditions usually use forward jumps.
+  //! However this behavior can be overridden by using instruction prefixes.
+  //! If this option is enabled these hints will be emitted.
+  //!
+  //! This feature is disabled by default, because the only processor that
+  //! used to take into consideration prediction hints was P4. Newer processors
+  //! implement heuristics for branch prediction that ignores any static hints.
+  kCodeGenPredictedJumps = 1,
+
+  //! Schedule instructions so they can be executed faster (`Compiler` only).
+  //!
+  //! Default `false` - has to be explicitly enabled as the scheduler needs
+  //! some time to run.
+  //!
+  //! X86/X64
+  //! -------
+  //!
+  //! If scheduling is enabled AsmJit will try to reorder instructions to
+  //! minimize dependency chain. Scheduler always runs after the registers are
+  //! allocated so it doesn't change count of register allocs/spills.
+  //!
+  //! This feature is highly experimental and untested.
+  kCodeGenEnableScheduler = 2
+};
+
+// ============================================================================
+// [asmjit::kAlignMode]
+// ============================================================================
+
+//! Code aligning mode.
+ASMJIT_ENUM(kAlignMode) {
+  //! Align by emitting a sequence that can be executed (code).
+  kAlignCode = 0,
+  //! Align by emitting sequence that shouldn't be executed (data).
+  kAlignData = 1
+};
+
+// ============================================================================
+// [asmjit::kRelocMode]
+// ============================================================================
+
+//! Relocation mode.
+ASMJIT_ENUM(kRelocMode) {
+  //! Relocate an absolute address to an absolute address.
+  kRelocAbsToAbs = 0,
+  //! Relocate a relative address to an absolute address.
+  kRelocRelToAbs = 1,
+  //! Relocate an absolute address to a relative address.
+  kRelocAbsToRel = 2,
+  //! Relocate an absolute address to a relative address or use trampoline.
+  kRelocTrampoline = 3
+};
+
+// ============================================================================
+// [asmjit::CodeGen]
+// ============================================================================
+
+//! Abstract class defining basics of \ref Assembler and \ref Compiler.
+struct ASMJIT_VCLASS CodeGen {
+  ASMJIT_NO_COPY(CodeGen)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `CodeGen` instance.
+  ASMJIT_API CodeGen(Runtime* runtime);
+  //! Destroy the `CodeGen` instance.
+  ASMJIT_API virtual ~CodeGen();
+
+  // --------------------------------------------------------------------------
+  // [Runtime]
+  // --------------------------------------------------------------------------
+
+  //! Get runtime.
+  ASMJIT_INLINE Runtime* getRuntime() const {
+    return _runtime;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Logger]
+  // --------------------------------------------------------------------------
+
+#if !defined(ASMJIT_DISABLE_LOGGER)
+  //! Get whether the code generator has a logger.
+  ASMJIT_INLINE bool hasLogger() const {
+    return _logger != NULL;
+  }
+
+  //! Get logger.
+  ASMJIT_INLINE Logger* getLogger() const {
+    return _logger;
+  }
+
+  //! Set logger to `logger`.
+  ASMJIT_API Error setLogger(Logger* logger);
+#endif // !ASMJIT_DISABLE_LOGGER
+
+  // --------------------------------------------------------------------------
+  // [Arch]
+  // --------------------------------------------------------------------------
+
+  //! Get target architecture.
+  ASMJIT_INLINE uint32_t getArch() const {
+    return _arch;
+  }
+
+  //! Get default register size (4 or 8 bytes).
+  ASMJIT_INLINE uint32_t getRegSize() const {
+    return _regSize;
+  }
+
+  // --------------------------------------------------------------------------
+  // [BaseAddress]
+  // --------------------------------------------------------------------------
+
+  //! Get whether the code-generator has a base address.
+  //!
+  //! \sa \ref getBaseAddress()
+  ASMJIT_INLINE bool hasBaseAddress() const {
+    return _baseAddress != kNoBaseAddress;
+  }
+
+  //! Get the base address.
+  ASMJIT_INLINE Ptr getBaseAddress() const {
+    return _baseAddress;
+  }
+
+  //! Set the base address to `baseAddress`.
+  ASMJIT_INLINE void setBaseAddress(Ptr baseAddress) {
+    _baseAddress = baseAddress;
+  }
+
+  //! Reset the base address.
+  ASMJIT_INLINE void resetBaseAddress() {
+    setBaseAddress(kNoBaseAddress);
+  }
+
+  // --------------------------------------------------------------------------
+  // [LastError / ErrorHandler]
+  // --------------------------------------------------------------------------
+
+  //! Get last error code.
+  ASMJIT_INLINE Error getError() const {
+    return _error;
+  }
+
+  //! Set last error code and propagate it through the error handler.
+  ASMJIT_API Error setError(Error error, const char* message = NULL);
+
+  //! Clear the last error code.
+  ASMJIT_INLINE void resetError() {
+    _error = kErrorOk;
+  }
+
+  //! Get error handler.
+  ASMJIT_INLINE ErrorHandler* getErrorHandler() const {
+    return _errorHandler;
+  }
+
+  //! Set error handler.
+  ASMJIT_API Error setErrorHandler(ErrorHandler* handler);
+
+  //! Clear error handler.
+  ASMJIT_INLINE Error resetErrorHandler() {
+    return setErrorHandler(NULL);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Code-Generation Features]
+  // --------------------------------------------------------------------------
+
+  //! Get code-generator `feature`.
+  ASMJIT_INLINE bool hasFeature(uint32_t feature) const {
+    ASMJIT_ASSERT(feature < 32);
+
+    return (_features & (1 << feature)) != 0;
+  }
+
+  //! Set code-generator `feature` to `value`.
+  ASMJIT_INLINE void setFeature(uint32_t feature, bool value) {
+    ASMJIT_ASSERT(feature < 32);
+
+    feature = static_cast<uint32_t>(value) << feature;
+    _features = (_features & ~feature) | feature;
+  }
+
+  //! Get code-generator features.
+  ASMJIT_INLINE uint32_t getFeatures() const {
+    return _features;
+  }
+
+  //! Set code-generator features.
+  ASMJIT_INLINE void setFeatures(uint32_t features) {
+    _features = features;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Instruction Options]
+  // --------------------------------------------------------------------------
+
+  //! Get options of the next instruction.
+  ASMJIT_INLINE uint32_t getInstOptions() const {
+    return _instOptions;
+  }
+
+  //! Get options of the next instruction and reset them.
+  ASMJIT_INLINE uint32_t getInstOptionsAndReset() {
+    uint32_t instOptions = _instOptions;
+    _instOptions = 0;
+    return instOptions;
+  };
+
+  //! Set options of the next instruction.
+  ASMJIT_INLINE void setInstOptions(uint32_t instOptions) {
+    _instOptions = instOptions;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Make]
+  // --------------------------------------------------------------------------
+
+  //! Make is a convenience method to make and relocate the current code and
+  //! add it to the associated `Runtime`.
+  //!
+  //! What is needed is only to cast the returned pointer to your function type
+  //! and then use it. If there was an error during `make()` `NULL` is returned
+  //! and the last error code can be obtained by calling `getError()`.
+  virtual void* make() = 0;
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Target runtime.
+  Runtime* _runtime;
+
+#if !defined(ASMJIT_DISABLE_LOGGER)
+  //! Logger.
+  Logger* _logger;
+#else
+  //! \internal
+  //!
+  //! Makes libraries built with or without logging support binary compatible.
+  void* _logger;
+#endif // ASMJIT_DISABLE_LOGGER
+
+  //! Error handler, called by \ref setError().
+  ErrorHandler* _errorHandler;
+
+  //! Base address (-1 if unknown/not used).
+  Ptr _baseAddress;
+
+  //! Target architecture ID.
+  uint8_t _arch;
+  //! Target architecture GP register size in bytes (4 or 8).
+  uint8_t _regSize;
+  //! \internal
+  uint16_t _reserved;
+
+  //! Code-Generation features, used by \ref hasFeature() and \ref setFeature().
+  uint32_t _features;
+  //! Options affecting the next instruction.
+  uint32_t _instOptions;
+
+  //! Last error code.
+  uint32_t _error;
+
+  //! Base zone.
+  Zone _baseZone;
+};
+
+//! \}
+
+} // asmjit namespace
+
+// [Api-End]
+#include "../apiend.h"
+
+// [Guard]
+#endif // _ASMJIT_BASE_CODEGEN_H

libraries/asmjit/base/compiler.cpp

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Export]
+#define ASMJIT_EXPORTS
+
+// [Guard]
+#include "../build.h"
+#if !defined(ASMJIT_DISABLE_COMPILER)
+
+// [Dependencies - AsmJit]
+#include "../base/assembler.h"
+#include "../base/compiler.h"
+#include "../base/context_p.h"
+#include "../base/cpuinfo.h"
+#include "../base/intutil.h"
+#include "../base/logger.h"
+
+// [Dependencies - C]
+#include <stdarg.h>
+
+// [Api-Begin]
+#include "../apibegin.h"
+
+namespace asmjit {
+
+// ============================================================================
+// [Constants]
+// ============================================================================
+
+static const char noName[1] = { '\0' };
+enum { kBaseCompilerDefaultLookAhead = 64 };
+
+// ============================================================================
+// [asmjit::Compiler - Construction / Destruction]
+// ============================================================================
+
+Compiler::Compiler(Runtime* runtime) :
+  CodeGen(runtime),
+  _nodeFlowId(0),
+  _nodeFlags(0),
+  _maxLookAhead(kBaseCompilerDefaultLookAhead),
+  _targetVarMapping(NULL),
+  _assembler(NULL),
+  _firstNode(NULL),
+  _lastNode(NULL),
+  _cursor(NULL),
+  _func(NULL),
+  _varZone(4096 - kZoneOverhead),
+  _stringZone(4096 - kZoneOverhead),
+  _localConstZone(4096 - kZoneOverhead),
+  _localConstPool(&_localConstZone),
+  _globalConstPool(&_baseZone) {}
+
+Compiler::~Compiler() {
+  reset(true);
+
+  if (_assembler != NULL)
+    delete _assembler;
+}
+
+// ============================================================================
+// [asmjit::Compiler - Clear / Reset]
+// ============================================================================
+
+void Compiler::reset(bool releaseMemory) {
+  // CodeGen members.
+  _baseAddress = kNoBaseAddress;
+  _instOptions = 0;
+  _error = kErrorOk;
+
+  _baseZone.reset(releaseMemory);
+
+  // Compiler members.
+  _nodeFlowId = 0;
+  _nodeFlags = 0;
+
+  if (_assembler != NULL)
+    _assembler->reset(releaseMemory);
+
+  _firstNode = NULL;
+  _lastNode = NULL;
+
+  _cursor = NULL;
+  _func = NULL;
+
+  _localConstPool.reset();
+  _globalConstPool.reset();
+
+  _localConstPoolLabel.reset();
+  _globalConstPoolLabel.reset();
+
+  _varZone.reset(releaseMemory);
+  _stringZone.reset(releaseMemory);
+  _localConstZone.reset(releaseMemory);
+
+  _targetList.reset(releaseMemory);
+  _varList.reset(releaseMemory);
+}
+
+// ============================================================================
+// [asmjit::Compiler - Node Management]
+// ============================================================================
+
+Node* Compiler::setCursor(Node* node) {
+  Node* old = _cursor;
+  _cursor = node;
+  return old;
+}
+
+Node* Compiler::addNode(Node* node) {
+  ASMJIT_ASSERT(node != NULL);
+  ASMJIT_ASSERT(node->_prev == NULL);
+  ASMJIT_ASSERT(node->_next == NULL);
+
+  if (_cursor == NULL) {
+    if (_firstNode == NULL) {
+      _firstNode = node;
+      _lastNode = node;
+    }
+    else {
+      node->_next = _firstNode;
+      _firstNode->_prev = node;
+      _firstNode = node;
+    }
+  }
+  else {
+    Node* prev = _cursor;
+    Node* next = _cursor->_next;
+
+    node->_prev = prev;
+    node->_next = next;
+
+    prev->_next = node;
+    if (next)
+      next->_prev = node;
+    else
+      _lastNode = node;
+  }
+
+  _cursor = node;
+  return node;
+}
+
+Node* Compiler::addNodeBefore(Node* node, Node* ref) {
+  ASMJIT_ASSERT(node != NULL);
+  ASMJIT_ASSERT(node->_prev == NULL);
+  ASMJIT_ASSERT(node->_next == NULL);
+  ASMJIT_ASSERT(ref != NULL);
+
+  Node* prev = ref->_prev;
+  Node* next = ref;
+
+  node->_prev = prev;
+  node->_next = next;
+
+  next->_prev = node;
+  if (prev)
+    prev->_next = node;
+  else
+    _firstNode = node;
+
+  return node;
+}
+
+Node* Compiler::addNodeAfter(Node* node, Node* ref) {
+  ASMJIT_ASSERT(node != NULL);
+  ASMJIT_ASSERT(node->_prev == NULL);
+  ASMJIT_ASSERT(node->_next == NULL);
+  ASMJIT_ASSERT(ref != NULL);
+
+  Node* prev = ref;
+  Node* next = ref->_next;
+
+  node->_prev = prev;
+  node->_next = next;
+
+  prev->_next = node;
+  if (next)
+    next->_prev = node;
+  else
+    _lastNode = node;
+
+  return node;
+}
+
+static ASMJIT_INLINE void BaseCompiler_nodeRemoved(Compiler* self, Node* node_) {
+  if (node_->isJmpOrJcc()) {
+    JumpNode* node = static_cast<JumpNode*>(node_);
+    TargetNode* target = node->getTarget();
+
+    // Disconnect.
+    JumpNode** pPrev = &target->_from;
+    for (;;) {
+      ASMJIT_ASSERT(*pPrev != NULL);
+      JumpNode* current = *pPrev;
+
+      if (current == NULL)
+        break;
+
+      if (current == node) {
+        *pPrev = node->_jumpNext;
+        break;
+      }
+
+      pPrev = &current->_jumpNext;
+    }
+
+    target->subNumRefs();
+  }
+}
+
+Node* Compiler::removeNode(Node* node) {
+  Node* prev = node->_prev;
+  Node* next = node->_next;
+
+  if (_firstNode == node)
+    _firstNode = next;
+  else
+    prev->_next = next;
+
+  if (_lastNode == node)
+    _lastNode  = prev;
+  else
+    next->_prev = prev;
+
+  node->_prev = NULL;
+  node->_next = NULL;
+
+  if (_cursor == node)
+    _cursor = prev;
+  BaseCompiler_nodeRemoved(this, node);
+
+  return node;
+}
+
+void Compiler::removeNodes(Node* first, Node* last) {
+  if (first == last) {
+    removeNode(first);
+    return;
+  }
+
+  Node* prev = first->_prev;
+  Node* next = last->_next;
+
+  if (_firstNode == first)
+    _firstNode = next;
+  else
+    prev->_next = next;
+
+  if (_lastNode == last)
+    _lastNode  = prev;
+  else
+    next->_prev = prev;
+
+  Node* node = first;
+  for (;;) {
+    Node* next = node->getNext();
+    ASMJIT_ASSERT(next != NULL);
+
+    node->_prev = NULL;
+    node->_next = NULL;
+
+    if (_cursor == node)
+      _cursor = prev;
+    BaseCompiler_nodeRemoved(this, node);
+
+    if (node == last)
+      break;
+    node = next;
+  }
+}
+
+// ============================================================================
+// [asmjit::Compiler - Align]
+// ============================================================================
+
+AlignNode* Compiler::newAlign(uint32_t mode, uint32_t offset) {
+  AlignNode* node = newNode<AlignNode>(mode, offset);
+  if (node == NULL)
+    goto _NoMemory;
+  return node;
+
+_NoMemory:
+  setError(kErrorNoHeapMemory);
+  return NULL;
+}
+
+AlignNode* Compiler::addAlign(uint32_t mode, uint32_t offset) {
+  AlignNode* node = newAlign(mode, offset);
+  if (node == NULL)
+    return NULL;
+  return static_cast<AlignNode*>(addNode(node));
+}
+
+// ============================================================================
+// [asmjit::Compiler - Target]
+// ============================================================================
+
+TargetNode* Compiler::newTarget() {
+  TargetNode* node = newNode<TargetNode>(
+    OperandUtil::makeLabelId(static_cast<uint32_t>(_targetList.getLength())));
+
+  if (node == NULL || _targetList.append(node) != kErrorOk)
+    goto _NoMemory;
+  return node;
+
+_NoMemory:
+  setError(kErrorNoHeapMemory);
+  return NULL;
+}
+
+TargetNode* Compiler::addTarget() {
+  TargetNode* node = newTarget();
+  if (node == NULL)
+    return NULL;
+  return static_cast<TargetNode*>(addNode(node));
+}
+
+// ============================================================================
+// [asmjit::Compiler - Label]
+// ============================================================================
+
+Error Compiler::_newLabel(Label* dst) {
+  dst->_init_packed_op_sz_b0_b1_id(kOperandTypeLabel, 0, 0, 0, kInvalidValue);
+  dst->_init_packed_d2_d3(0, 0);
+
+  TargetNode* node = newTarget();
+  if (node == NULL)
+    goto _NoMemory;
+
+  dst->_label.id = node->getLabelId();
+  return kErrorOk;
+
+_NoMemory:
+  return setError(kErrorNoHeapMemory);
+}
+
+Error Compiler::bind(const Label& label) {
+  uint32_t index = label.getId();
+  ASMJIT_ASSERT(index < _targetList.getLength());
+
+  addNode(_targetList[index]);
+  return kErrorOk;
+}
+
+// ============================================================================
+// [asmjit::Compiler - Embed]
+// ============================================================================
+
+EmbedNode* Compiler::newEmbed(const void* data, uint32_t size) {
+  EmbedNode* node;
+
+  if (size > EmbedNode::kInlineBufferSize) {
+    void* clonedData = _stringZone.alloc(size);
+    if (clonedData == NULL)
+      goto _NoMemory;
+
+    if (data != NULL)
+      ::memcpy(clonedData, data, size);
+    data = clonedData;
+  }
+
+  node = newNode<EmbedNode>(const_cast<void*>(data), size);
+  if (node == NULL)
+    goto _NoMemory;
+  return node;
+
+_NoMemory:
+  setError(kErrorNoHeapMemory);
+  return NULL;
+}
+
+EmbedNode* Compiler::addEmbed(const void* data, uint32_t size) {
+  EmbedNode* node = newEmbed(data, size);
+  if (node == NULL)
+    return node;
+  return static_cast<EmbedNode*>(addNode(node));
+}
+
+// ============================================================================
+// [asmjit::Compiler - Comment]
+// ============================================================================
+
+CommentNode* Compiler::newComment(const char* str) {
+  CommentNode* node;
+
+  if (str != NULL && str[0]) {
+    str = _stringZone.sdup(str);
+    if (str == NULL)
+      goto _NoMemory;
+  }
+
+  node = newNode<CommentNode>(str);
+  if (node == NULL)
+    goto _NoMemory;
+  return node;
+
+_NoMemory:
+  setError(kErrorNoHeapMemory);
+  return NULL;
+}
+
+CommentNode* Compiler::addComment(const char* str) {
+  CommentNode* node = newComment(str);
+  if (node == NULL)
+    return NULL;
+  return static_cast<CommentNode*>(addNode(node));
+}
+
+CommentNode* Compiler::comment(const char* fmt, ...) {
+  char buf[256];
+  char* p = buf;
+
+  if (fmt) {
+    *p++ = ';';
+    *p++ = ' ';
+
+    va_list ap;
+    va_start(ap, fmt);
+    p += vsnprintf(p, 254, fmt, ap);
+    va_end(ap);
+  }
+
+  p[0] = '\n';
+  p[1] = '\0';
+
+  return addComment(fmt);
+}
+
+// ============================================================================
+// [asmjit::Compiler - Hint]
+// ============================================================================
+
+HintNode* Compiler::newHint(Var& var, uint32_t hint, uint32_t value) {
+  if (var.getId() == kInvalidValue)
+    return NULL;
+  VarData* vd = getVd(var);
+
+  HintNode* node = newNode<HintNode>(vd, hint, value);
+  if (node == NULL)
+    goto _NoMemory;
+  return node;
+
+_NoMemory:
+  setError(kErrorNoHeapMemory);
+  return NULL;
+}
+
+HintNode* Compiler::addHint(Var& var, uint32_t hint, uint32_t value) {
+  if (var.getId() == kInvalidValue)
+    return NULL;
+
+  HintNode* node = newHint(var, hint, value);
+  if (node == NULL)
+    return NULL;
+  return static_cast<HintNode*>(addNode(node));
+}
+
+// ============================================================================
+// [asmjit::Compiler - Vars]
+// ============================================================================
+
+VarData* Compiler::_newVd(uint32_t type, uint32_t size, uint32_t c, const char* name) {
+  VarData* vd = reinterpret_cast<VarData*>(_varZone.alloc(sizeof(VarData)));
+  if (vd == NULL)
+    goto _NoMemory;
+
+  vd->_name = noName;
+  vd->_id = OperandUtil::makeVarId(static_cast<uint32_t>(_varList.getLength()));
+  vd->_contextId = kInvalidValue;
+
+  if (name != NULL && name[0] != '\0') {
+    vd->_name = _stringZone.sdup(name);
+  }
+
+  vd->_type = static_cast<uint8_t>(type);
+  vd->_class = static_cast<uint8_t>(c);
+  vd->_flags = 0;
+  vd->_priority = 10;
+
+  vd->_state = kVarStateUnused;
+  vd->_regIndex = kInvalidReg;
+  vd->_isStack = false;
+  vd->_isMemArg = false;
+  vd->_isCalculated = false;
+  vd->_saveOnUnuse = false;
+  vd->_modified = false;
+  vd->_reserved0 = 0;
+  vd->_alignment = static_cast<uint8_t>(IntUtil::iMin<uint32_t>(size, 64));
+
+  vd->_size = size;
+  vd->_homeMask = 0;
+
+  vd->_memOffset = 0;
+  vd->_memCell = NULL;
+
+  vd->rReadCount = 0;
+  vd->rWriteCount = 0;
+  vd->mReadCount = 0;
+  vd->mWriteCount = 0;
+
+  vd->_va = NULL;
+
+  if (_varList.append(vd) != kErrorOk)
+    goto _NoMemory;
+  return vd;
+
+_NoMemory:
+  setError(kErrorNoHeapMemory);
+  return NULL;
+}
+
+void Compiler::alloc(Var& var) {
+  addHint(var, kVarHintAlloc, kInvalidValue);
+}
+
+void Compiler::alloc(Var& var, uint32_t regIndex) {
+  addHint(var, kVarHintAlloc, regIndex);
+}
+
+void Compiler::alloc(Var& var, const Reg& reg) {
+  addHint(var, kVarHintAlloc, reg.getRegIndex());
+}
+
+void Compiler::save(Var& var) {
+  addHint(var, kVarHintSave, kInvalidValue);
+}
+
+void Compiler::spill(Var& var) {
+  addHint(var, kVarHintSpill, kInvalidValue);
+}
+
+void Compiler::unuse(Var& var) {
+  addHint(var, kVarHintUnuse, kInvalidValue);
+}
+
+uint32_t Compiler::getPriority(Var& var) const {
+  if (var.getId() == kInvalidValue)
+    return kInvalidValue;
+
+  VarData* vd = getVdById(var.getId());
+  return vd->getPriority();
+}
+
+void Compiler::setPriority(Var& var, uint32_t priority) {
+  if (var.getId() == kInvalidValue)
+    return;
+
+  if (priority > 255)
+    priority = 255;
+
+  VarData* vd = getVdById(var.getId());
+  vd->_priority = static_cast<uint8_t>(priority);
+}
+
+bool Compiler::getSaveOnUnuse(Var& var) const {
+  if (var.getId() == kInvalidValue)
+    return false;
+
+  VarData* vd = getVdById(var.getId());
+  return static_cast<bool>(vd->_saveOnUnuse);
+}
+
+void Compiler::setSaveOnUnuse(Var& var, bool value) {
+  if (var.getId() == kInvalidValue)
+    return;
+
+  VarData* vd = getVdById(var.getId());
+  vd->_saveOnUnuse = value;
+}
+
+void Compiler::rename(Var& var, const char* name) {
+  if (var.getId() == kInvalidValue)
+    return;
+
+  VarData* vd = getVdById(var.getId());
+  vd->_name = noName;
+
+  if (name != NULL && name[0] != '\0') {
+    vd->_name = _stringZone.sdup(name);
+  }
+}
+
+// ============================================================================
+// [asmjit::Compiler - Assembler]
+// ============================================================================
+
+Assembler* Compiler::getAssembler() {
+  Assembler* a = _assembler;
+
+  if (a != NULL) {
+    a->reset(false);
+  }
+  else {
+    a = _newAssembler();
+    _assembler = a;
+  }
+
+#if !defined(ASMJIT_DISABLE_LOGGER)
+  Logger* logger = _logger;
+  if (logger != NULL)
+    a->setLogger(logger);
+#endif // !ASMJIT_DISABLE_LOGGER
+
+  a->setBaseAddress(_baseAddress);
+  a->setFeatures(_features);
+
+  return a;
+}
+
+} // asmjit namespace
+
+// [Api-End]
+#include "../apiend.h"
+
+// [Guard]
+#endif // !ASMJIT_DISABLE_COMPILER

libraries/asmjit/base/compiler.h

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Guard]
+#ifndef _ASMJIT_BASE_COMPILER_H
+#define _ASMJIT_BASE_COMPILER_H
+
+#include "../build.h"
+#if !defined(ASMJIT_DISABLE_COMPILER)
+
+// [Dependencies - AsmJit]
+#include "../base/assembler.h"
+#include "../base/codegen.h"
+#include "../base/constpool.h"
+#include "../base/containers.h"
+#include "../base/error.h"
+#include "../base/intutil.h"
+#include "../base/operand.h"
+#include "../base/zone.h"
+
+// [Api-Begin]
+#include "../apibegin.h"
+
+namespace asmjit {
+
+// ============================================================================
+// [Forward Declarations]
+// ============================================================================
+
+struct Compiler;
+
+struct VarAttr;
+struct VarData;
+struct VarMap;
+struct VarState;
+
+struct Node;
+struct EndNode;
+struct InstNode;
+struct JumpNode;
+
+// ============================================================================
+// [asmjit::kConstScope]
+// ============================================================================
+
+//! \addtogroup asmjit_base_compiler
+//! \{
+
+//! Scope of the constant.
+ASMJIT_ENUM(kConstScope) {
+  //! Local constant, always embedded right after the current function.
+  kConstScopeLocal = 0,
+  //! Global constant, embedded at the end of the currently compiled code.
+  kConstScopeGlobal = 1
+};
+
+// ============================================================================
+// [asmjit::kVarType]
+// ============================================================================
+
+ASMJIT_ENUM(kVarType) {
+  //! Variable is 8-bit signed integer.
+  kVarTypeInt8 = 0,
+  //! Variable is 8-bit unsigned integer.
+  kVarTypeUInt8 = 1,
+  //! Variable is 16-bit signed integer.
+  kVarTypeInt16 = 2,
+  //! Variable is 16-bit unsigned integer.
+  kVarTypeUInt16 = 3,
+  //! Variable is 32-bit signed integer.
+  kVarTypeInt32 = 4,
+  //! Variable is 32-bit unsigned integer.
+  kVarTypeUInt32 = 5,
+  //! Variable is 64-bit signed integer.
+  kVarTypeInt64 = 6,
+  //! Variable is 64-bit unsigned integer.
+  kVarTypeUInt64 = 7,
+
+  //! Variable is target `intptr_t`, not compatible with host `intptr_t`.
+  kVarTypeIntPtr = 8,
+  //! Variable is target `uintptr_t`, not compatible with host `uintptr_t`.
+  kVarTypeUIntPtr = 9,
+
+  //! Variable is 32-bit floating point (single precision).
+  kVarTypeFp32 = 10,
+  //! Variable is 64-bit floating point (double precision).
+  kVarTypeFp64 = 11,
+
+  //! \internal
+  _kVarTypeIntStart = kVarTypeInt8,
+  //! \internal
+  _kVarTypeIntEnd = kVarTypeUIntPtr,
+
+  //! \internal
+  _kVarTypeFpStart = kVarTypeFp32,
+  //! \internal
+  _kVarTypeFpEnd = kVarTypeFp64
+};
+
+// ============================================================================
+// [asmjit::kVarFlags]
+// ============================================================================
+
+//! \internal
+//!
+//! X86/X64 variable flags.
+ASMJIT_ENUM(kVarFlags) {
+  //! Variable contains single-precision floating-point(s).
+  kVarFlagSp = 0x10,
+  //! Variable contains double-precision floating-point(s).
+  kVarFlagDp = 0x20,
+  //! Variable is packed, i.e. packed floats, doubles, ...
+  kVarFlagPacked = 0x40
+};
+
+// ============================================================================
+// [asmjit::kVarAttrFlags]
+// ============================================================================
+
+//! Variable attribute flags.
+ASMJIT_ENUM(kVarAttrFlags) {
+  //! Variable is accessed through register on input.
+  kVarAttrInReg = 0x00000001,
+  //! Variable is accessed through register on output.
+  kVarAttrOutReg = 0x00000002,
+  //! Variable is accessed through register on input & output.
+  kVarAttrInOutReg = 0x00000003,
+
+  //! Variable is accessed through memory on input.
+  kVarAttrInMem = 0x00000004,
+  //! Variable is accessed through memory on output.
+  kVarAttrOutMem = 0x00000008,
+  //! Variable is accessed through memory on input & output.
+  kVarAttrInOutMem = 0x0000000C,
+
+  //! Register allocator can decide if input will be in register or memory.
+  kVarAttrInDecide = 0x00000010,
+  //! Register allocator can decide if output will be in register or memory.
+  kVarAttrOutDecide = 0x00000020,
+  //! Register allocator can decide if in/out will be in register or memory.
+  kVarAttrInOutDecide = 0x00000030,
+
+  //! Variable is converted to other type/class on the input.
+  kVarAttrInConv = 0x00000040,
+  //! Variable is converted from other type/class on the output.
+  kVarAttrOutConv = 0x00000080,
+  //! Combination of `kVarAttrInConv` and `kVarAttrOutConv`.
+  kVarAttrInOutConv = 0x000000C0,
+
+  //! Variable is a function call operand.
+  kVarAttrInCall = 0x00000100,
+  //! Variable is a function argument passed in register.
+  kVarAttrInArg = 0x00000200,
+
+  //! Variable is a function return value passed in register.
+  kVarAttrOutRet = 0x00000400,
+  //! Variable should be spilled.
+  kVarAttrSpill = 0x00000800,
+  //! Variable should be unused at the end of the instruction/node.
+  kVarAttrUnuse = 0x00001000,
+
+  //! \internal
+  //!
+  //! All in-flags.
+  kVarAttrInAll =
+    kVarAttrInReg     |
+    kVarAttrInMem     |
+    kVarAttrInDecide  |
+    kVarAttrInCall    |
+    kVarAttrInArg,
+
+  //! \internal
+  //!
+  //! All out-flags.
+  kVarAttrOutAll =
+    kVarAttrOutReg    |
+    kVarAttrOutMem    |
+    kVarAttrOutDecide |
+    kVarAttrOutRet,
+
+  //! Variable is already allocated on the input.
+  kVarAttrAllocInDone = 0x00400000,
+  //! Variable is already allocated on the output.
+  kVarAttrAllocOutDone = 0x00800000
+};
+
+// ============================================================================
+// [asmjit::kVarHint]
+// ============================================================================
+
+//! Variable hint (used by `Compiler)`.
+//!
+//! \sa Compiler.
+ASMJIT_ENUM(kVarHint) {
+  //! Alloc variable.
+  kVarHintAlloc = 0,
+  //! Spill variable.
+  kVarHintSpill = 1,
+  //! Save variable if modified.
+  kVarHintSave = 2,
+  //! Save variable if modified and mark it as unused.
+  kVarHintSaveAndUnuse = 3,
+  //! Mark variable as unused.
+  kVarHintUnuse = 4
+};
+
+// ============================================================================
+// [asmjit::kVarState]
+// ============================================================================
+
+//! State of variable.
+//!
+//! \note State of variable is used only during make process and it's not
+//! visible to the developer.
+ASMJIT_ENUM(kVarState) {
+  //! Variable is currently not used.
+  kVarStateUnused = 0,
+
+  //! Variable is in register.
+  //!
+  //! Variable is currently allocated in register.
+  kVarStateReg = 1,
+
+  //! Variable is in memory location or spilled.
+  //!
+  //! Variable was spilled from register to memory or variable is used for
+  //! memory only storage.
+  kVarStateMem = 2
+};
+
+// ============================================================================
+// [asmjit::kFuncConv]
+// ============================================================================
+
+//! Function calling convention.
+//!
+//! For a platform specific calling conventions, see:
+//!   - `kX86FuncConv` - X86/X64 calling conventions.
+ASMJIT_ENUM(kFuncConv) {
+  //! Calling convention is invalid (can't be used).
+  kFuncConvNone = 0,
+
+#if defined(ASMJIT_DOCGEN)
+  //! Default calling convention for current platform / operating system.
+  kFuncConvHost = DependsOnHost,
+
+  //! Default C calling convention based on current compiler's settings.
+  kFuncConvHostCDecl = DependsOnHost,
+
+  //! Compatibility for `__stdcall` calling convention.
+  //!
+  //! \note This enumeration is always set to a value which is compatible with
+  //! current compilers __stdcall calling convention. In 64-bit mode the value
+  //! is compatible with `kX86FuncConvW64` or `kX86FuncConvU64`.
+  kFuncConvHostStdCall = DependsOnHost,
+
+  //! Compatibility for `__fastcall` calling convention.
+  //!
+  //! \note This enumeration is always set to a value which is compatible with
+  //! current compilers `__fastcall` calling convention. In 64-bit mode the value
+  //! is compatible with `kX86FuncConvW64` or `kX86FuncConvU64`.
+  kFuncConvHostFastCall = DependsOnHost
+#endif // ASMJIT_DOCGEN
+};
+
+// ============================================================================
+// [asmjit::kFuncHint]
+// ============================================================================
+
+//! Function hints.
+//!
+//! For a platform specific calling conventions, see:
+//!   - `kX86FuncHint` - X86/X64 function hints.
+ASMJIT_ENUM(kFuncHint) {
+  //! Make a naked function (default true).
+  //!
+  //! Naked function is function without using standard prolog/epilog sequence).
+  //!
+  //! X86/X64 Specific
+  //! ----------------
+  //!
+  //! Standard prolog sequence is:
+  //!
+  //! ~~~
+  //! push zbp
+  //! mov zsp, zbp
+  //! sub zsp, StackAdjustment
+  //! ~~~
+  //!
+  //! which is an equivalent to:
+  //!
+  //! ~~~
+  //! enter StackAdjustment, 0
+  //! ~~~
+  //!
+  //! Standard epilog sequence is:
+  //!
+  //! ~~~
+  //! mov zsp, zbp
+  //! pop zbp
+  //! ~~~
+  //!
+  //! which is an equavalent to:
+  //!
+  //! ~~~
+  //! leave
+  //! ~~~
+  //!
+  //! Naked functions can omit the prolog/epilog sequence. The advantage of
+  //! doing such modification is that EBP/RBP register can be used by the
+  //! register allocator which can result in less spills/allocs.
+  kFuncHintNaked = 0,
+
+  //! Generate compact function prolog/epilog if possible.
+  //!
+  //! X86/X64 Specific
+  //! ----------------
+  //!
+  //! Use shorter, but possible slower prolog/epilog sequence to save/restore
+  //! registers.
+  kFuncHintCompact = 1
+};
+
+// ============================================================================
+// [asmjit::kFuncFlags]
+// ============================================================================
+
+//! Function flags.
+//!
+//! For a platform specific calling conventions, see:
+//!   - `kX86FuncFlags` - X86/X64 function flags.
+ASMJIT_ENUM(kFuncFlags) {
+  //! Whether the function is using naked (minimal) prolog / epilog.
+  kFuncFlagIsNaked = 0x00000001,
+
+  //! Whether an another function is called from this function.
+  kFuncFlagIsCaller = 0x00000002,
+
+  //! Whether the stack is not aligned to the required stack alignment,
+  //! thus it has to be aligned manually.
+  kFuncFlagIsStackMisaligned = 0x00000004,
+
+  //! Whether the stack pointer is adjusted by the stack size needed
+  //! to save registers and function variables.
+  //!
+  //! X86/X64 Specific
+  //! ----------------
+  //!
+  //! Stack pointer (ESP/RSP) is adjusted by 'sub' instruction in prolog and by
+  //! 'add' instruction in epilog (only if function is not naked). If function
+  //! needs to perform manual stack alignment more instructions are used to
+  //! adjust the stack (like "and zsp, -Alignment").
+  kFuncFlagIsStackAdjusted = 0x00000008,
+
+  //! Whether the function is finished using `Compiler::endFunc()`.
+  kFuncFlagIsFinished = 0x80000000
+};
+
+// ============================================================================
+// [asmjit::kFuncDir]
+// ============================================================================
+
+//! Function arguments direction.
+ASMJIT_ENUM(kFuncDir) {
+  //! Arguments are passed left to right.
+  //!
+  //! This arguments direction is unusual in C, however it's used in Pascal.
+  kFuncDirLtr = 0,
+
+  //! Arguments are passed right ro left
+  //!
+  //! This is the default argument direction in C.
+  kFuncDirRtl = 1
+};
+
+// ============================================================================
+// [asmjit::kFuncArg]
+// ============================================================================
+
+//! Function argument (lo/hi) specification.
+ASMJIT_ENUM(kFuncArg) {
+  //! Maxumum number of function arguments supported by AsmJit.
+  kFuncArgCount = 16,
+  //! Extended maximum number of arguments (used internally).
+  kFuncArgCountLoHi = kFuncArgCount * 2,
+
+  //! Index to the LO part of function argument (default).
+  //!
+  //! This value is typically omitted and added only if there is HI argument
+  //! accessed.
+  kFuncArgLo = 0,
+  //! Index to the HI part of function argument.
+  //!
+  //! HI part of function argument depends on target architecture. On x86 it's
+  //! typically used to transfer 64-bit integers (they form a pair of 32-bit
+  //! integers).
+  kFuncArgHi = kFuncArgCount
+};
+
+// ============================================================================
+// [asmjit::kFuncRet]
+// ============================================================================
+
+//! Function return value (lo/hi) specification.
+ASMJIT_ENUM(kFuncRet) {
+  //! Index to the LO part of function return value.
+  kFuncRetLo = 0,
+  //! Index to the HI part of function return value.
+  kFuncRetHi = 1
+};
+
+// ============================================================================
+// [asmjit::kFuncStackInvalid]
+// ============================================================================
+
+enum kFuncMisc {
+  //! Invalid stack offset in function or function parameter.
+  kFuncStackInvalid = -1
+};
+
+// ============================================================================
+// [asmjit::kNodeType]
+// ============================================================================
+
+//! Type of node, see \ref Node.
+ASMJIT_ENUM(kNodeType) {
+  //! Invalid node (internal, can't be used).
+  kNodeTypeNone = 0,
+  //! Node is an .align directive, see \ref AlignNode.
+  kNodeTypeAlign,
+  //! Node is an embedded data, see \ref EmbedNode.
+  kNodeTypeEmbed,
+  //! Node is a comment, see \ref CommentNode.
+  kNodeTypeComment,
+  //! Node is a variable hint (alloc, spill, use, unuse), see \ref HintNode.
+  kNodeTypeHint,
+  //! Node is a label, see \ref TargetNode.
+  kNodeTypeTarget,
+  //! Node is an instruction, see \ref InstNode.
+  kNodeTypeInst,
+  //! Node is a function declaration, see \ref FuncNode.
+  kNodeTypeFunc,
+  //! Node is an end of the function, see \ref EndNode.
+  kNodeTypeEnd,
+  //! Node is a return, see \ref RetNode.
+  kNodeTypeRet,
+  //! Node is a function call, see \ref CallNode.
+  kNodeTypeCall,
+  //! Node is a function call argument moved on stack, see \ref SArgNode.
+  kNodeTypeSArg
+};
+
+// ============================================================================
+// [asmjit::kNodeFlags]
+// ============================================================================
+
+ASMJIT_ENUM(kNodeFlags) {
+  //! Whether the node has been translated, thus contains only registers.
+  kNodeFlagIsTranslated = 0x0001,
+
+  //! Whether the node was scheduled - possibly reordered, but basically this
+  //! is a mark that is set by scheduler after the node has been visited.
+  kNodeFlagIsScheduled = 0x0002,
+
+  //! Whether the node is informative only and can be safely removed.
+  kNodeFlagIsInformative = 0x0004,
+
+  //! Whether the `InstNode` is a jump.
+  kNodeFlagIsJmp = 0x0008,
+  //! Whether the `InstNode` is a conditional jump.
+  kNodeFlagIsJcc = 0x0010,
+
+  //! Whether the `InstNode` is an unconditinal jump or conditional
+  //! jump that is likely to be taken.
+  kNodeFlagIsTaken = 0x0020,
+
+  //! Whether the `Node` will return from a function.
+  //!
+  //! This flag is used by both `EndNode` and `RetNode`.
+  kNodeFlagIsRet = 0x0040,
+
+  //! Whether the instruction is special.
+  kNodeFlagIsSpecial = 0x0080,
+
+  //! Whether the instruction is an FPU instruction.
+  kNodeFlagIsFp = 0x0100
+};
+
+// ============================================================================
+// [asmjit::MemCell]
+// ============================================================================
+
+struct MemCell {
+  ASMJIT_NO_COPY(MemCell)
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get cell offset.
+  ASMJIT_INLINE int32_t getOffset() const { return _offset; }
+  //! Set cell offset.
+  ASMJIT_INLINE void setOffset(int32_t offset) { _offset = offset; }
+
+  //! Get cell size.
+  ASMJIT_INLINE uint32_t getSize() const { return _size; }
+  //! Set cell size.
+  ASMJIT_INLINE void setSize(uint32_t size) { _size = size; }
+
+  //! Get cell alignment.
+  ASMJIT_INLINE uint32_t getAlignment() const { return _alignment; }
+  //! Set cell alignment.
+  ASMJIT_INLINE void setAlignment(uint32_t alignment) { _alignment = alignment; }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Next active cell.
+  MemCell* _next;
+
+  //! Offset, relative to base-offset.
+  int32_t _offset;
+  //! Size.
+  uint32_t _size;
+  //! Alignment.
+  uint32_t _alignment;
+};
+
+// ============================================================================
+// [asmjit::Var]
+// ============================================================================
+
+//! Base class for all variables.
+struct Var : public Operand {
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE Var() : Operand(NoInit) {
+    _init_packed_op_sz_b0_b1_id(kOperandTypeVar, 0, 0, 0, kInvalidValue);
+    _init_packed_d2_d3(kInvalidValue, kInvalidValue);
+  }
+
+  ASMJIT_INLINE Var(const Var& other) : Operand(other) {}
+
+  explicit ASMJIT_INLINE Var(const _NoInit&) : Operand(NoInit) {}
+
+  // --------------------------------------------------------------------------
+  // [Var Specific]
+  // --------------------------------------------------------------------------
+
+  //! Clone `Var` operand.
+  ASMJIT_INLINE Var clone() const {
+    return Var(*this);
+  }
+
+  //! Get whether the variable has been initialized by `Compiler`.
+  ASMJIT_INLINE bool isInitialized() const {
+    return _vreg.id != kInvalidValue;
+  }
+
+  //! Get variable type.
+  ASMJIT_INLINE uint32_t getVarType() const {
+    return _vreg.vType;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Operator Overload]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE Var& operator=(const Var& other) { _copy(other); return *this; }
+
+  ASMJIT_INLINE bool operator==(const Var& other) const { return _packed[0] == other._packed[0]; }
+  ASMJIT_INLINE bool operator!=(const Var& other) const { return !operator==(other); }
+};
+
+// ============================================================================
+// [asmjit::VarBits]
+// ============================================================================
+
+//! Bit-array used by variable-liveness analysis.
+struct VarBits {
+  // --------------------------------------------------------------------------
+  // [Enums]
+  // --------------------------------------------------------------------------
+
+  enum {
+    kEntitySize = static_cast<int>(sizeof(uintptr_t)),
+    kEntityBits = kEntitySize * 8
+  };
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE uintptr_t getBit(uint32_t index) const {
+    return (data[index / kEntityBits] >> (index % kEntityBits)) & 1;
+  }
+
+  ASMJIT_INLINE void setBit(uint32_t index) {
+    data[index / kEntityBits] |= static_cast<uintptr_t>(1) << (index % kEntityBits);
+  }
+
+  ASMJIT_INLINE void delBit(uint32_t index) {
+    data[index / kEntityBits] &= ~(static_cast<uintptr_t>(1) << (index % kEntityBits));
+  }
+
+  // --------------------------------------------------------------------------
+  // [Ops]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE bool copyBits(const VarBits* s0, uint32_t len) {
+    uintptr_t r = 0;
+    for (uint32_t i = 0; i < len; i++) {
+      uintptr_t t = s0->data[i];
+      data[i] = t;
+      r |= t;
+    }
+    return r != 0;
+  }
+
+  ASMJIT_INLINE bool addBits(const VarBits* s0, uint32_t len) {
+    return addBits(this, s0, len);
+  }
+
+  ASMJIT_INLINE bool addBits(const VarBits* s0, const VarBits* s1, uint32_t len) {
+    uintptr_t r = 0;
+    for (uint32_t i = 0; i < len; i++) {
+      uintptr_t t = s0->data[i] | s1->data[i];
+      data[i] = t;
+      r |= t;
+    }
+    return r != 0;
+  }
+
+  ASMJIT_INLINE bool andBits(const VarBits* s1, uint32_t len) {
+    return andBits(this, s1, len);
+  }
+
+  ASMJIT_INLINE bool andBits(const VarBits* s0, const VarBits* s1, uint32_t len) {
+    uintptr_t r = 0;
+    for (uint32_t i = 0; i < len; i++) {
+      uintptr_t t = s0->data[i] & s1->data[i];
+      data[i] = t;
+      r |= t;
+    }
+    return r != 0;
+  }
+
+  ASMJIT_INLINE bool delBits(const VarBits* s1, uint32_t len) {
+    return delBits(this, s1, len);
+  }
+
+  ASMJIT_INLINE bool delBits(const VarBits* s0, const VarBits* s1, uint32_t len) {
+    uintptr_t r = 0;
+    for (uint32_t i = 0; i < len; i++) {
+      uintptr_t t = s0->data[i] & ~s1->data[i];
+      data[i] = t;
+      r |= t;
+    }
+    return r != 0;
+  }
+
+  ASMJIT_INLINE bool _addBitsDelSource(VarBits* s1, uint32_t len) {
+    return _addBitsDelSource(this, s1, len);
+  }
+
+  ASMJIT_INLINE bool _addBitsDelSource(const VarBits* s0, VarBits* s1, uint32_t len) {
+    uintptr_t r = 0;
+    for (uint32_t i = 0; i < len; i++) {
+      uintptr_t a = s0->data[i];
+      uintptr_t b = s1->data[i];
+
+      this->data[i] = a | b;
+      b &= ~a;
+
+      s1->data[i] = b;
+      r |= b;
+    }
+    return r != 0;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  uintptr_t data[1];
+};
+
+// ============================================================================
+// [asmjit::VarData]
+// ============================================================================
+
+//! Base variable data.
+struct VarData {
+  // --------------------------------------------------------------------------
+  // [Accessors - Base]
+  // --------------------------------------------------------------------------
+
+  //! Get variable name.
+  ASMJIT_INLINE const char* getName() const {
+    return _name;
+  }
+
+  //! Get variable id.
+  ASMJIT_INLINE uint32_t getId() const {
+    return _id;
+  }
+
+  //! Get variable type.
+  ASMJIT_INLINE uint32_t getType() const {
+    return _type;
+  }
+
+  //! Get variable class.
+  ASMJIT_INLINE uint32_t getClass() const {
+    return _class;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Accessors - ContextId]
+  // --------------------------------------------------------------------------
+
+  //! Get whether the variable has context id.
+  ASMJIT_INLINE bool hasContextId() const {
+    return _contextId != kInvalidValue;
+  }
+
+  //! Get context variable id (used only by `Context)`.
+  ASMJIT_INLINE uint32_t getContextId() const {
+    return _contextId;
+  }
+
+  //! Set context variable id (used only by `Context)`.
+  ASMJIT_INLINE void setContextId(uint32_t contextId) {
+    _contextId = contextId;
+  }
+
+  //! Reset context variable id (used only by `Context)`.
+  ASMJIT_INLINE void resetContextId() {
+    _contextId = kInvalidValue;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Accessors - Priority]
+  // --------------------------------------------------------------------------
+
+  //! Get variable priority, used by compiler to decide which variable to spill.
+  ASMJIT_INLINE uint32_t getPriority() const {
+    return _priority;
+  }
+
+  //! Set variable priority.
+  ASMJIT_INLINE void setPriority(uint32_t priority) {
+    ASMJIT_ASSERT(priority <= 0xFF);
+    _priority = static_cast<uint8_t>(priority);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Accessors - State]
+  // --------------------------------------------------------------------------
+
+  //! Get variable state, only used by `Context`.
+  ASMJIT_INLINE uint32_t getState() const {
+    return _state;
+  }
+
+  //! Set variable state, only used by `Context`.
+  ASMJIT_INLINE void setState(uint32_t state) {
+    ASMJIT_ASSERT(state <= 0xFF);
+    _state = static_cast<uint8_t>(state);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Accessors - RegIndex]
+  // --------------------------------------------------------------------------
+
+  //! Get register index.
+  ASMJIT_INLINE uint32_t getRegIndex() const {
+    return _regIndex;
+  }
+
+  //! Set register index.
+  ASMJIT_INLINE void setRegIndex(uint32_t regIndex) {
+    ASMJIT_ASSERT(regIndex <= 0xFF);
+    _regIndex = static_cast<uint8_t>(regIndex);
+  }
+
+  //! Reset register index.
+  ASMJIT_INLINE void resetRegIndex() {
+    _regIndex = static_cast<uint8_t>(kInvalidReg);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Accessors - HomeIndex/Mask]
+  // --------------------------------------------------------------------------
+
+  //! Get home registers mask.
+  ASMJIT_INLINE uint32_t getHomeMask() const {
+    return _homeMask;
+  }
+
+  //! Add a home register index to the home registers mask.
+  ASMJIT_INLINE void addHomeIndex(uint32_t regIndex) {
+    _homeMask |= IntUtil::mask(regIndex);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Accessors - Flags]
+  // --------------------------------------------------------------------------
+
+  //! Get variable flags.
+  ASMJIT_INLINE uint32_t getFlags() const {
+    return _flags;
+  }
+
+  //! Get whether the VarData is only memory allocated on the stack.
+  ASMJIT_INLINE bool isStack() const { return static_cast<bool>(_isStack); }
+
+  //! Get whether the variable is a function argument passed through memory.
+  ASMJIT_INLINE bool isMemArg() const { return static_cast<bool>(_isMemArg); }
+
+  //! Get variable content can be calculated by a simple instruction.
+  ASMJIT_INLINE bool isCalculated() const { return static_cast<bool>(_isCalculated); }
+  //! Get whether to save variable when it's unused (spill).
+  ASMJIT_INLINE bool saveOnUnuse() const { return static_cast<bool>(_saveOnUnuse); }
+
+  //! Get whether the variable was changed.
+  ASMJIT_INLINE bool isModified() const { return static_cast<bool>(_modified); }
+  //! Set whether the variable was changed.
+  ASMJIT_INLINE void setModified(bool modified) { _modified = modified; }
+
+  //! Get variable alignment.
+  ASMJIT_INLINE uint32_t getAlignment() const { return _alignment; }
+  //! Get variable size.
+  ASMJIT_INLINE uint32_t getSize() const { return _size; }
+
+  //! Get home memory offset.
+  ASMJIT_INLINE int32_t getMemOffset() const { return _memOffset; }
+  //! Set home memory offset.
+  ASMJIT_INLINE void setMemOffset(int32_t offset) { _memOffset = offset; }
+
+  //! Get home memory cell.
+  ASMJIT_INLINE MemCell* getMemCell() const { return _memCell; }
+  //! Set home memory cell.
+  ASMJIT_INLINE void setMemCell(MemCell* cell) { _memCell = cell; }
+
+  // --------------------------------------------------------------------------
+  // [Accessors - Temporary Usage]
+  // --------------------------------------------------------------------------
+
+  //! Get temporary VarAttr.
+  ASMJIT_INLINE VarAttr* getVa() const { return _va; }
+  //! Set temporary VarAttr.
+  ASMJIT_INLINE void setVa(VarAttr* va) { _va = va; }
+  //! Reset temporary VarAttr.
+  ASMJIT_INLINE void resetVa() { _va = NULL; }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Variable name.
+  const char* _name;
+
+  //! Variable id.
+  uint32_t _id;
+  //! Context variable id, used by `Context` only, initially `kInvalidValue`.
+  uint32_t _contextId;
+
+  //! Variable type.
+  uint8_t _type;
+  //! Variable class.
+  uint8_t _class;
+  //! Variable flags.
+  uint8_t _flags;
+  //! Variable priority.
+  uint8_t _priority;
+
+  //! Variable state (connected with actual `VarState)`.
+  uint8_t _state;
+  //! Actual register index (only used by `Context)`, during translate.
+  uint8_t _regIndex;
+
+  //! Whether the variable is only used as memory allocated on the stack.
+  uint8_t _isStack : 1;
+  //! Whether the variable is a function argument passed through memory.
+  uint8_t _isMemArg : 1;
+  //! Whether variable content can be calculated by a simple instruction.
+  //!
+  //! This is used mainly by MMX and SSE2 code. This flag indicates that
+  //! register allocator should never reserve memory for this variable, because
+  //! the content can be generated by a single instruction (for example PXOR).
+  uint8_t _isCalculated : 1;
+  //! Save on unuse (at end of the variable scope).
+  uint8_t _saveOnUnuse : 1;
+  //! Whether variable was changed (connected with actual `VarState)`.
+  uint8_t _modified : 1;
+  //! \internal
+  uint8_t _reserved0 : 3;
+  //! Variable natural alignment.
+  uint8_t _alignment;
+
+  //! Variable size.
+  uint32_t _size;
+
+  //! Mask of all registers variable has been allocated to.
+  uint32_t _homeMask;
+
+  //! Home memory offset.
+  int32_t _memOffset;
+  //! Home memory cell, used by `Context` (initially NULL).
+  MemCell* _memCell;
+
+  //! Register read access statistics.
+  uint32_t rReadCount;
+  //! Register write access statistics.
+  uint32_t rWriteCount;
+
+  //! Memory read statistics.
+  uint32_t mReadCount;
+  //! Memory write statistics.
+  uint32_t mWriteCount;
+
+  // --------------------------------------------------------------------------
+  // [Members - Temporary Usage]
+  // --------------------------------------------------------------------------
+
+  // These variables are only used during register allocation. They are
+  // initialized by init() phase and reset by cleanup() phase.
+
+  union {
+    //! Temporary link to VarAttr* used by the `Context` used in
+    //! various phases, but always set back to NULL when finished.
+    //!
+    //! This temporary data is designed to be used by algorithms that need to
+    //! store some data into variables themselves during compilation. But it's
+    //! expected that after variable is compiled & translated the data is set
+    //! back to zero/null. Initial value is NULL.
+    VarAttr* _va;
+
+    //! \internal
+    //!
+    //! Same as `_va` just provided as `uintptr_t`.
+    uintptr_t _vaUInt;
+  };
+};
+
+// ============================================================================
+// [asmjit::VarAttr]
+// ============================================================================
+
+struct VarAttr {
+  // --------------------------------------------------------------------------
+  // [Setup]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE void setup(VarData* vd, uint32_t flags = 0, uint32_t inRegs = 0, uint32_t allocableRegs = 0) {
+    _vd = vd;
+    _flags = flags;
+    _varCount = 0;
+    _inRegIndex = kInvalidReg;
+    _outRegIndex = kInvalidReg;
+    _reserved = 0;
+    _inRegs = inRegs;
+    _allocableRegs = allocableRegs;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get VarData.
+  ASMJIT_INLINE VarData* getVd() const { return _vd; }
+  //! Set VarData.
+  ASMJIT_INLINE void setVd(VarData* vd) { _vd = vd; }
+
+  //! Get flags.
+  ASMJIT_INLINE uint32_t getFlags() const { return _flags; }
+  //! Set flags.
+  ASMJIT_INLINE void setFlags(uint32_t flags) { _flags = flags; }
+
+  //! Get whether `flag` is on.
+  ASMJIT_INLINE bool hasFlag(uint32_t flag) { return (_flags & flag) != 0; }
+  //! Add `flags`.
+  ASMJIT_INLINE void addFlags(uint32_t flags) { _flags |= flags; }
+  //! Mask `flags`.
+  ASMJIT_INLINE void andFlags(uint32_t flags) { _flags &= flags; }
+  //! Clear `flags`.
+  ASMJIT_INLINE void delFlags(uint32_t flags) { _flags &= ~flags; }
+
+  //! Get how many times the variable is used by the instruction/node.
+  ASMJIT_INLINE uint32_t getVarCount() const { return _varCount; }
+  //! Set how many times the variable is used by the instruction/node.
+  ASMJIT_INLINE void setVarCount(uint32_t count) { _varCount = static_cast<uint8_t>(count); }
+  //! Add how many times the variable is used by the instruction/node.
+  ASMJIT_INLINE void addVarCount(uint32_t count = 1) { _varCount += static_cast<uint8_t>(count); }
+
+  //! Get whether the variable has to be allocated in a specific input register.
+  ASMJIT_INLINE uint32_t hasInRegIndex() const { return _inRegIndex != kInvalidReg; }
+  //! Get the input register index or `kInvalidReg`.
+  ASMJIT_INLINE uint32_t getInRegIndex() const { return _inRegIndex; }
+  //! Set the input register index.
+  ASMJIT_INLINE void setInRegIndex(uint32_t index) { _inRegIndex = static_cast<uint8_t>(index); }
+  //! Reset the input register index.
+  ASMJIT_INLINE void resetInRegIndex() { _inRegIndex = kInvalidReg; }
+
+  //! Get whether the variable has to be allocated in a specific output register.
+  ASMJIT_INLINE uint32_t hasOutRegIndex() const { return _outRegIndex != kInvalidReg; }
+  //! Get the output register index or `kInvalidReg`.
+  ASMJIT_INLINE uint32_t getOutRegIndex() const { return _outRegIndex; }
+  //! Set the output register index.
+  ASMJIT_INLINE void setOutRegIndex(uint32_t index) { _outRegIndex = static_cast<uint8_t>(index); }
+  //! Reset the output register index.
+  ASMJIT_INLINE void resetOutRegIndex() { _outRegIndex = kInvalidReg; }
+
+  //! Get whether the mandatory input registers are in used.
+  ASMJIT_INLINE bool hasInRegs() const { return _inRegs != 0; }
+  //! Get mandatory input registers (mask).
+  ASMJIT_INLINE uint32_t getInRegs() const { return _inRegs; }
+  //! Set mandatory input registers (mask).
+  ASMJIT_INLINE void setInRegs(uint32_t mask) { _inRegs = mask; }
+  //! Add mandatory input registers (mask).
+  ASMJIT_INLINE void addInRegs(uint32_t mask) { _inRegs |= mask; }
+  //! And mandatory input registers (mask).
+  ASMJIT_INLINE void andInRegs(uint32_t mask) { _inRegs &= mask; }
+  //! Clear mandatory input registers (mask).
+  ASMJIT_INLINE void delInRegs(uint32_t mask) { _inRegs &= ~mask; }
+
+  //! Get allocable input registers (mask).
+  ASMJIT_INLINE uint32_t getAllocableRegs() const { return _allocableRegs; }
+  //! Set allocable input registers (mask).
+  ASMJIT_INLINE void setAllocableRegs(uint32_t mask) { _allocableRegs = mask; }
+  //! Add allocable input registers (mask).
+  ASMJIT_INLINE void addAllocableRegs(uint32_t mask) { _allocableRegs |= mask; }
+  //! And allocable input registers (mask).
+  ASMJIT_INLINE void andAllocableRegs(uint32_t mask) { _allocableRegs &= mask; }
+  //! Clear allocable input registers (mask).
+  ASMJIT_INLINE void delAllocableRegs(uint32_t mask) { _allocableRegs &= ~mask; }
+
+  // --------------------------------------------------------------------------
+  // [Operator Overload]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE VarAttr& operator=(const VarAttr& other) {
+    ::memcpy(this, &other, sizeof(VarAttr));
+    return *this;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  VarData* _vd;
+  //! Flags.
+  uint32_t _flags;
+
+  union {
+    struct {
+      //! How many times the variable is used by the instruction/node.
+      uint8_t _varCount;
+      //! Input register index or `kInvalidReg` if it's not given.
+      //!
+      //! Even if the input register index is not given (i.e. it may by any
+      //! register), register allocator should assign an index that will be
+      //! used to persist a variable into this specific index. It's helpful
+      //! in situations where one variable has to be allocated in multiple
+      //! registers to determine the register which will be persistent.
+      uint8_t _inRegIndex;
+      //! Output register index or `kInvalidReg` if it's not given.
+      //!
+      //! Typically `kInvalidReg` if variable is only used on input.
+      uint8_t _outRegIndex;
+      //! \internal
+      uint8_t _reserved;
+    };
+
+    //! \internal
+    //!
+    //! Packed data #0.
+    uint32_t _packed;
+  };
+
+  //! Mandatory input registers.
+  //!
+  //! Mandatory input registers are required by the instruction even if
+  //! there are duplicates. This schema allows us to allocate one variable
+  //! in one or more register when needed. Required mostly by instructions
+  //! that have implicit register operands (imul, cpuid, ...) and function
+  //! call.
+  uint32_t _inRegs;
+
+  //! Allocable input registers.
+  //!
+  //! Optional input registers is a mask of all allocable registers for a given
+  //! variable where we have to pick one of them. This mask is usually not used
+  //! when _inRegs is set. If both masks are used then the register
+  //! allocator tries first to find an intersection between these and allocates
+  //! an extra slot if not found.
+  uint32_t _allocableRegs;
+};
+
+// ============================================================================
+// [asmjit::VarMap]
+// ============================================================================
+
+//! Variables' map related to a single node (instruction / other node).
+struct VarMap {
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get count of variables (all).
+  ASMJIT_INLINE uint32_t getVaCount() const {
+    return _vaCount;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Variables count.
+  uint32_t _vaCount;
+};
+
+// ============================================================================
+// [asmjit::VarState]
+// ============================================================================
+
+//! Variables' state.
+struct VarState {};
+
+// ============================================================================
+// [asmjit::TypeId / VarMapping]
+// ============================================================================
+
+//! Function builder 'void' type.
+struct Void {};
+
+//! Function builder 'int8_t' type.
+struct Int8Type {};
+//! Function builder 'uint8_t' type.
+struct UInt8Type {};
+
+//! Function builder 'int16_t' type.
+struct Int16Type {};
+//! Function builder 'uint16_t' type.
+struct UInt16Type {};
+
+//! Function builder 'int32_t' type.
+struct Int32Type {};
+//! Function builder 'uint32_t' type.
+struct UInt32Type {};
+
+//! Function builder 'int64_t' type.
+struct Int64Type {};
+//! Function builder 'uint64_t' type.
+struct UInt64Type {};
+
+//! Function builder 'intptr_t' type.
+struct IntPtrType {};
+//! Function builder 'uintptr_t' type.
+struct UIntPtrType {};
+
+//! Function builder 'float' type.
+struct FloatType {};
+//! Function builder 'double' type.
+struct DoubleType {};
+
+#if !defined(ASMJIT_DOCGEN)
+template<typename T>
+struct TypeId {
+  enum { kId = static_cast<int>(::asmjit::kInvalidVar) };
+};
+
+template<typename T>
+struct TypeId<T*> {
+  enum { kId = kVarTypeIntPtr };
+};
+
+#define ASMJIT_TYPE_ID(_T_, _Id_) \
+  template<> \
+  struct TypeId<_T_> { enum { kId = _Id_ }; }
+
+ASMJIT_TYPE_ID(void, kInvalidVar);
+ASMJIT_TYPE_ID(Void, kInvalidVar);
+
+ASMJIT_TYPE_ID(int8_t, kVarTypeInt8);
+ASMJIT_TYPE_ID(Int8Type, kVarTypeInt8);
+
+ASMJIT_TYPE_ID(uint8_t, kVarTypeUInt8);
+ASMJIT_TYPE_ID(UInt8Type, kVarTypeUInt8);
+
+ASMJIT_TYPE_ID(int16_t, kVarTypeInt16);
+ASMJIT_TYPE_ID(Int16Type, kVarTypeInt16);
+
+ASMJIT_TYPE_ID(uint16_t, kVarTypeUInt8);
+ASMJIT_TYPE_ID(UInt16Type, kVarTypeUInt8);
+
+ASMJIT_TYPE_ID(int32_t, kVarTypeInt32);
+ASMJIT_TYPE_ID(Int32Type, kVarTypeUInt8);
+
+ASMJIT_TYPE_ID(uint32_t, kVarTypeUInt32);
+ASMJIT_TYPE_ID(UInt32Type, kVarTypeUInt8);
+
+ASMJIT_TYPE_ID(int64_t, kVarTypeInt64);
+ASMJIT_TYPE_ID(Int64Type, kVarTypeUInt8);
+
+ASMJIT_TYPE_ID(uint64_t, kVarTypeUInt64);
+ASMJIT_TYPE_ID(UInt64Type, kVarTypeUInt8);
+
+ASMJIT_TYPE_ID(float, kVarTypeFp32);
+ASMJIT_TYPE_ID(FloatType, kVarTypeFp32);
+
+ASMJIT_TYPE_ID(double, kVarTypeFp64);
+ASMJIT_TYPE_ID(DoubleType, kVarTypeFp64);
+#endif // !ASMJIT_DOCGEN
+
+// ============================================================================
+// [asmjit::FuncInOut]
+// ============================================================================
+
+//! Function in/out - argument or return value translated from `FuncPrototype`.
+struct FuncInOut {
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE uint32_t getVarType() const { return _varType; }
+
+  ASMJIT_INLINE bool hasRegIndex() const { return _regIndex != kInvalidReg; }
+  ASMJIT_INLINE uint32_t getRegIndex() const { return _regIndex; }
+
+  ASMJIT_INLINE bool hasStackOffset() const { return _stackOffset != kFuncStackInvalid; }
+  ASMJIT_INLINE int32_t getStackOffset() const { return static_cast<int32_t>(_stackOffset); }
+
+  //! Get whether the argument / return value is assigned.
+  ASMJIT_INLINE bool isSet() const {
+    return (_regIndex != kInvalidReg) | (_stackOffset != kFuncStackInvalid);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Reset]
+  // --------------------------------------------------------------------------
+
+  //! Reset the function argument to "unassigned state".
+  ASMJIT_INLINE void reset() { _packed = 0xFFFFFFFF; }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  union {
+    struct {
+      //! Variable type, see `kVarType`.
+      uint8_t _varType;
+      //! Register index if argument / return value is a register.
+      uint8_t _regIndex;
+      //! Stack offset if argument / return value is on the stack.
+      int16_t _stackOffset;
+    };
+
+    //! All members packed into single 32-bit integer.
+    uint32_t _packed;
+  };
+};
+
+// ============================================================================
+// [asmjit::FuncPrototype]
+// ============================================================================
+
+//! Function prototype.
+//!
+//! Function prototype contains information about function return type, count
+//! of arguments and their types. Function prototype is a low level structure
+//! which doesn't contain platform specific or calling convention specific
+//! information. Function prototype is used to create a `FuncDecl`.
+struct FuncPrototype {
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get function return value.
+  ASMJIT_INLINE uint32_t getRet() const { return _ret; }
+
+  //! Get function arguments' IDs.
+  ASMJIT_INLINE const uint32_t* getArgList() const { return _argList; }
+  //! Get count of function arguments.
+  ASMJIT_INLINE uint32_t getArgCount() const { return _argCount; }
+
+  //! Get argument at index `id`.
+  ASMJIT_INLINE uint32_t getArg(uint32_t id) const {
+    ASMJIT_ASSERT(id < _argCount);
+    return _argList[id];
+  }
+
+  //! Set function definition - return type and arguments.
+  ASMJIT_INLINE void _setPrototype(uint32_t ret, const uint32_t* argList, uint32_t argCount) {
+    _ret = ret;
+    _argList = argList;
+    _argCount = argCount;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  uint32_t _ret;
+  uint32_t _argCount;
+  const uint32_t* _argList;
+};
+
+// ============================================================================
+// [asmjit::FuncBuilderX]
+// ============================================================================
+
+//! Custom function builder for up to 32 function arguments.
+struct FuncBuilderX : public FuncPrototype {
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE FuncBuilderX() {
+    _setPrototype(kInvalidVar, _builderArgList, 0);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Set return type to `retType`.
+  ASMJIT_INLINE void setRet(uint32_t retType) {
+    _ret = retType;
+  }
+
+  ASMJIT_INLINE void setArg(uint32_t id, uint32_t type) {
+    ASMJIT_ASSERT(id < _argCount);
+    _builderArgList[id] = type;
+  }
+
+  ASMJIT_INLINE void addArg(uint32_t type) {
+    ASMJIT_ASSERT(_argCount < kFuncArgCount);
+    _builderArgList[_argCount++] = type;
+  }
+
+  template<typename T>
+  ASMJIT_INLINE void setRetT() {
+    setRet(TypeId<T>::kId);
+  }
+
+  template<typename T>
+  ASMJIT_INLINE void setArgT(uint32_t id) {
+    setArg(id, TypeId<T>::kId);
+  }
+
+  template<typename T>
+  ASMJIT_INLINE void addArgT() {
+    addArg(TypeId<T>::kId);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  uint32_t _builderArgList[kFuncArgCount];
+};
+
+//! \internal
+#define T(_Type_) TypeId<_Type_>::kId
+
+//! Function prototype (no args).
+template<typename RET>
+struct FuncBuilder0 : public FuncPrototype {
+  ASMJIT_INLINE FuncBuilder0() {
+    _setPrototype(T(RET), NULL, 0);
+  }
+};
+
+//! Function prototype (1 argument).
+template<typename RET, typename P0>
+struct FuncBuilder1 : public FuncPrototype {
+  ASMJIT_INLINE FuncBuilder1() {
+    static const uint32_t args[] = { T(P0) };
+    _setPrototype(T(RET), args, ASMJIT_ARRAY_SIZE(args));
+  }
+};
+
+//! Function prototype (2 arguments).
+template<typename RET, typename P0, typename P1>
+struct FuncBuilder2 : public FuncPrototype {
+  ASMJIT_INLINE FuncBuilder2() {
+    static const uint32_t args[] = { T(P0), T(P1) };
+    _setPrototype(T(RET), args, ASMJIT_ARRAY_SIZE(args));
+  }
+};
+
+//! Function prototype (3 arguments).
+template<typename RET, typename P0, typename P1, typename P2>
+struct FuncBuilder3 : public FuncPrototype {
+  ASMJIT_INLINE FuncBuilder3() {
+    static const uint32_t args[] = { T(P0), T(P1), T(P2) };
+    _setPrototype(T(RET), args, ASMJIT_ARRAY_SIZE(args));
+  }
+};
+
+//! Function prototype (4 arguments).
+template<typename RET, typename P0, typename P1, typename P2, typename P3>
+struct FuncBuilder4 : public FuncPrototype {
+  ASMJIT_INLINE FuncBuilder4() {
+    static const uint32_t args[] = { T(P0), T(P1), T(P2), T(P3) };
+    _setPrototype(T(RET), args, ASMJIT_ARRAY_SIZE(args));
+  }
+};
+
+//! Function prototype (5 arguments).
+template<typename RET, typename P0, typename P1, typename P2, typename P3, typename P4>
+struct FuncBuilder5 : public FuncPrototype {
+  ASMJIT_INLINE FuncBuilder5() {
+    static const uint32_t args[] = { T(P0), T(P1), T(P2), T(P3), T(P4) };
+    _setPrototype(T(RET), args, ASMJIT_ARRAY_SIZE(args));
+  }
+};
+
+//! Function prototype (6 arguments).
+template<typename RET, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5>
+struct FuncBuilder6 : public FuncPrototype {
+  ASMJIT_INLINE FuncBuilder6() {
+    static const uint32_t args[] = { T(P0), T(P1), T(P2), T(P3), T(P4), T(P5) };
+    _setPrototype(T(RET), args, ASMJIT_ARRAY_SIZE(args));
+  }
+};
+
+//! Function prototype (7 arguments).
+template<typename RET, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
+struct FuncBuilder7 : public FuncPrototype {
+  ASMJIT_INLINE FuncBuilder7() {
+    static const uint32_t args[] = { T(P0), T(P1), T(P2), T(P3), T(P4), T(P5), T(P6) };
+    _setPrototype(T(RET), args, ASMJIT_ARRAY_SIZE(args));
+  }
+};
+
+//! Function prototype (8 arguments).
+template<typename RET, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
+struct FuncBuilder8 : public FuncPrototype {
+  ASMJIT_INLINE FuncBuilder8() {
+    static const uint32_t args[] = { T(P0), T(P1), T(P2), T(P3), T(P4), T(P5), T(P6), T(P7) };
+    _setPrototype(T(RET), args, ASMJIT_ARRAY_SIZE(args));
+  }
+};
+
+//! Function prototype (9 arguments).
+template<typename RET, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
+struct FuncBuilder9 : public FuncPrototype {
+  ASMJIT_INLINE FuncBuilder9() {
+    static const uint32_t args[] = { T(P0), T(P1), T(P2), T(P3), T(P4), T(P5), T(P6), T(P7), T(P8) };
+    _setPrototype(T(RET), args, ASMJIT_ARRAY_SIZE(args));
+  }
+};
+
+//! Function prototype (10 arguments).
+template<typename RET, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
+struct FuncBuilder10 : public FuncPrototype {
+  ASMJIT_INLINE FuncBuilder10() {
+    static const uint32_t args[] = { T(P0), T(P1), T(P2), T(P3), T(P4), T(P5), T(P6), T(P7), T(P8), T(P9) };
+    _setPrototype(T(RET), args, ASMJIT_ARRAY_SIZE(args));
+  }
+};
+
+#undef T
+
+// ============================================================================
+// [asmjit::FuncDecl]
+// ============================================================================
+
+//! Function declaration.
+struct FuncDecl {
+  // --------------------------------------------------------------------------
+  // [Accessors - Calling Convention]
+  // --------------------------------------------------------------------------
+
+  //! Get function calling convention, see `kFuncConv`.
+  ASMJIT_INLINE uint32_t getConvention() const { return _convention; }
+
+  //! Get whether the callee pops the stack.
+  ASMJIT_INLINE uint32_t getCalleePopsStack() const { return _calleePopsStack; }
+
+  //! Get direction of arguments passed on the stack.
+  //!
+  //! Direction should be always `kFuncDirRtl`.
+  //!
+  //! \note This is related to used calling convention, it's not affected by
+  //! number of function arguments or their types.
+  ASMJIT_INLINE uint32_t getDirection() const { return _direction; }
+
+  //! Get stack size needed for function arguments passed on the stack.
+  ASMJIT_INLINE uint32_t getArgStackSize() const { return _argStackSize; }
+  //! Get size of "Red Zone".
+  ASMJIT_INLINE uint32_t getRedZoneSize() const { return _redZoneSize; }
+  //! Get size of "Spill Zone".
+  ASMJIT_INLINE uint32_t getSpillZoneSize() const { return _spillZoneSize; }
+
+  // --------------------------------------------------------------------------
+  // [Accessors - Arguments and Return]
+  // --------------------------------------------------------------------------
+
+  //! Get whether the function has a return value.
+  ASMJIT_INLINE bool hasRet() const { return _retCount != 0; }
+  //! Get count of function return values.
+  ASMJIT_INLINE uint32_t getRetCount() const { return _retCount; }
+
+  //! Get function return value.
+  ASMJIT_INLINE FuncInOut& getRet(uint32_t index = kFuncRetLo) { return _retList[index]; }
+  //! Get function return value.
+  ASMJIT_INLINE const FuncInOut& getRet(uint32_t index = kFuncRetLo) const { return _retList[index]; }
+
+  //! Get count of function arguments.
+  ASMJIT_INLINE uint32_t getArgCount() const { return _argCount; }
+
+  //! Get function arguments array.
+  ASMJIT_INLINE FuncInOut* getArgList() { return _argList; }
+  //! Get function arguments array (const).
+  ASMJIT_INLINE const FuncInOut* getArgList() const { return _argList; }
+
+  //! Get function argument at index `index`.
+  ASMJIT_INLINE FuncInOut& getArg(size_t index) {
+    ASMJIT_ASSERT(index < kFuncArgCountLoHi);
+    return _argList[index];
+  }
+
+  //! Get function argument at index `index`.
+  ASMJIT_INLINE const FuncInOut& getArg(size_t index) const {
+    ASMJIT_ASSERT(index < kFuncArgCountLoHi);
+    return _argList[index];
+  }
+
+  ASMJIT_INLINE void resetArg(size_t index) {
+    ASMJIT_ASSERT(index < kFuncArgCountLoHi);
+    _argList[index].reset();
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Calling convention.
+  uint8_t _convention;
+  //! Whether a callee pops stack.
+  uint8_t _calleePopsStack : 1;
+  //! Direction for arguments passed on the stack, see `kFuncDir`.
+  uint8_t _direction : 1;
+  //! Reserved #0 (alignment).
+  uint8_t _reserved0 : 6;
+
+  //! Count of arguments in `_argList`.
+  uint8_t _argCount;
+  //! Count of return value(s).
+  uint8_t _retCount;
+
+  //! Count of bytes consumed by arguments on the stack (aligned).
+  uint32_t _argStackSize;
+
+  //! Size of "Red Zone".
+  //!
+  //! \note Used by AMD64-ABI (128 bytes).
+  uint16_t _redZoneSize;
+
+  //! Size of "Spill Zone".
+  //!
+  //! \note Used by WIN64-ABI (32 bytes).
+  uint16_t _spillZoneSize;
+
+  //! Function arguments (including HI arguments) mapped to physical
+  //! registers and stack offset.
+  FuncInOut _argList[kFuncArgCountLoHi];
+
+  //! Function return value(s).
+  FuncInOut _retList[2];
+};
+
+// ============================================================================
+// [asmjit::Node]
+// ============================================================================
+
+//! Base node.
+//!
+//! `Every` node represents an abstract instruction, directive, label, or
+//! macro-instruction generated by compiler.
+struct Node {
+  ASMJIT_NO_COPY(Node)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create new `Node`.
+  //!
+  //! \note Always use compiler to create nodes.
+  ASMJIT_INLINE Node(Compiler* compiler, uint32_t type); // Defined-Later.
+
+  //! Destroy `Node`.
+  ASMJIT_INLINE ~Node() {}
+
+  // --------------------------------------------------------------------------
+  // [Accessors - List]
+  // --------------------------------------------------------------------------
+
+  //! Get previous node in the compiler stream.
+  ASMJIT_INLINE Node* getPrev() const {
+    return _prev;
+  }
+
+  //! Get next node in the compiler stream.
+  ASMJIT_INLINE Node* getNext() const {
+    return _next;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Accessors - Comment]
+  // --------------------------------------------------------------------------
+
+  //! Get comment string.
+  ASMJIT_INLINE const char* getComment() const {
+    return _comment;
+  }
+
+  //! Set comment string to `str`.
+  ASMJIT_INLINE void setComment(const char* comment) {
+    _comment = comment;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Accessors - Type and Flags]
+  // --------------------------------------------------------------------------
+
+  //! Get type of node, see `kNodeType`.
+  ASMJIT_INLINE uint32_t getType() const {
+    return _type;
+  }
+
+  //! Get node flags.
+  ASMJIT_INLINE uint32_t getFlags() const {
+    return _flags;
+  }
+
+  //! Set node flags to `flags`.
+  ASMJIT_INLINE void setFlags(uint32_t flags) {
+    _flags = static_cast<uint16_t>(flags);
+  }
+
+  //! Get whether the instruction has flag `flag`.
+  ASMJIT_INLINE bool hasFlag(uint32_t flag) const {
+    return (static_cast<uint32_t>(_flags) & flag) != 0;
+  }
+
+  //! Add instruction `flags`.
+  ASMJIT_INLINE void addFlags(uint32_t flags) {
+    _flags |= static_cast<uint16_t>(flags);
+  }
+
+  //! Clear instruction `flags`.
+  ASMJIT_INLINE void delFlags(uint32_t flags) {
+    _flags &= static_cast<uint16_t>(~flags);
+  }
+
+  //! Get whether the node has beed fetched.
+  ASMJIT_INLINE bool isFetched() const {
+    return _flowId != 0;
+  }
+
+  //! Get whether the node has been translated.
+  ASMJIT_INLINE bool isTranslated() const {
+    return hasFlag(kNodeFlagIsTranslated);
+  }
+
+  //! Get whether the node has been translated.
+  ASMJIT_INLINE bool isScheduled() const {
+    return hasFlag(kNodeFlagIsScheduled);
+  }
+
+  //! Get whether the node is informative only and can be safely removed after
+  //! translation.
+  //!
+  //! Informative nodes are comments and hints.
+  ASMJIT_INLINE bool isInformative() const {
+    return hasFlag(kNodeFlagIsInformative);
+  }
+
+  //! Whether the instruction is an unconditional jump.
+  ASMJIT_INLINE bool isJmp() const { return hasFlag(kNodeFlagIsJmp); }
+  //! Whether the instruction is a conditional jump.
+  ASMJIT_INLINE bool isJcc() const { return hasFlag(kNodeFlagIsJcc); }
+  //! Whether the instruction is an unconditional or conditional jump.
+  ASMJIT_INLINE bool isJmpOrJcc() const { return hasFlag(kNodeFlagIsJmp | kNodeFlagIsJcc); }
+  //! Whether the instruction is a return.
+  ASMJIT_INLINE bool isRet() const { return hasFlag(kNodeFlagIsRet); }
+
+  //! Get whether the instruction is special.
+  ASMJIT_INLINE bool isSpecial() const { return hasFlag(kNodeFlagIsSpecial); }
+  //! Get whether the instruction accesses FPU.
+  ASMJIT_INLINE bool isFp() const { return hasFlag(kNodeFlagIsFp); }
+
+  // --------------------------------------------------------------------------
+  // [Accessors - FlowId]
+  // --------------------------------------------------------------------------
+
+  //! Get flow index.
+  ASMJIT_INLINE uint32_t getFlowId() const { return _flowId; }
+  //! Set flow index.
+  ASMJIT_INLINE void setFlowId(uint32_t flowId) { _flowId = flowId; }
+
+  // --------------------------------------------------------------------------
+  // [Accessors - VarMap]
+  // --------------------------------------------------------------------------
+
+  //! Get whether node contains variable allocation instructions.
+  ASMJIT_INLINE bool hasMap() const {
+    return _map != NULL;
+  }
+
+  //! Get variable allocation instructions.
+  ASMJIT_INLINE VarMap* getMap() const {
+    return _map;
+  }
+
+  //! Get variable allocation instructions casted to `T*`.
+  template<typename T>
+  ASMJIT_INLINE T* getMap() const {
+    return static_cast<T*>(_map);
+  }
+
+  //! Set variable allocation instructions.
+  ASMJIT_INLINE void setMap(VarMap* map) {
+    _map = map;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Accessors - VarState]
+  // --------------------------------------------------------------------------
+
+  //! Get node state.
+  ASMJIT_INLINE VarState* getState() const {
+    return _state;
+  }
+
+  //! Get node state casted to `T*`.
+  template<typename T>
+  ASMJIT_INLINE T* getState() const {
+    return static_cast<VarState*>(_state);
+  }
+
+  //! Set node state.
+  ASMJIT_INLINE void setState(VarState* state) {
+    _state = state;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Accessors - Liveness]
+  // --------------------------------------------------------------------------
+
+  //! Get whether the node has variable liveness bits.
+  ASMJIT_INLINE bool hasLiveness() const {
+    return _liveness != NULL;
+  }
+
+  //! Get variable liveness bits.
+  ASMJIT_INLINE VarBits* getLiveness() const {
+    return _liveness;
+  }
+
+  //! Set variable liveness bits.
+  ASMJIT_INLINE void setLiveness(VarBits* liveness) {
+    _liveness = liveness;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Previous node.
+  Node* _prev;
+  //! Next node.
+  Node* _next;
+
+  //! Node type, see `kNodeType`.
+  uint8_t _type;
+  //! Operands count (if the node has operands, otherwise zero).
+  uint8_t _opCount;
+  //! Node flags, different meaning for every node type.
+  uint16_t _flags;
+
+  //! Flow index.
+  uint32_t _flowId;
+
+  //! Inline comment string, initially set to NULL.
+  const char* _comment;
+
+  //! Variable mapping (VarAttr to VarData), initially NULL, filled during
+  //! fetch phase.
+  VarMap* _map;
+
+  //! Variable liveness bits (initially NULL, filled by analysis phase).
+  VarBits* _liveness;
+
+  //! Saved state.
+  //!
+  //! Initially NULL, not all nodes have saved state, only branch/flow control
+  //! nodes.
+  VarState* _state;
+};
+
+// ============================================================================
+// [asmjit::AlignNode]
+// ============================================================================
+
+//! Align node.
+struct AlignNode : public Node {
+  ASMJIT_NO_COPY(AlignNode)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `AlignNode` instance.
+  ASMJIT_INLINE AlignNode(Compiler* compiler, uint32_t mode, uint32_t offset) :
+    Node(compiler, kNodeTypeAlign) {
+
+    _mode = mode;
+    _offset = offset;
+  }
+
+  //! Destroy the `AlignNode` instance.
+  ASMJIT_INLINE ~AlignNode() {}
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get alignment mode.
+  ASMJIT_INLINE uint32_t getMode() const {
+    return _mode;
+  }
+
+  //! Set alignment mode.
+  ASMJIT_INLINE void setMode(uint32_t mode) {
+    _mode = mode;
+  }
+
+  //! Get align offset in bytes.
+  ASMJIT_INLINE uint32_t getOffset() const {
+    return _offset;
+  }
+
+  //! Set align offset in bytes to `offset`.
+  ASMJIT_INLINE void setOffset(uint32_t offset) {
+    _offset = offset;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Alignment mode, see \ref kAlignMode.
+  uint32_t _mode;
+  //! Alignment offset in bytes.
+  uint32_t _offset;
+};
+
+// ============================================================================
+// [asmjit::EmbedNode]
+// ============================================================================
+
+//! Embed node.
+//!
+//! Embed node is used to embed data into final assembler stream. The data is
+//! considered to be RAW; No analysis is performed on RAW data.
+struct EmbedNode : public Node {
+  ASMJIT_NO_COPY(EmbedNode)
+
+  // --------------------------------------------------------------------------
+  // [Enums]
+  // --------------------------------------------------------------------------
+
+  enum { kInlineBufferSize = 8 };
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `EmbedNode` instance.
+  ASMJIT_INLINE EmbedNode(Compiler* compiler, void* data, uint32_t size) : Node(compiler, kNodeTypeEmbed) {
+    _size = size;
+    if (size <= kInlineBufferSize) {
+      if (data != NULL)
+        ::memcpy(_data.buf, data, size);
+    }
+    else {
+      _data.ptr = static_cast<uint8_t*>(data);
+    }
+  }
+
+  //! Destroy the `EmbedNode` instance.
+  ASMJIT_INLINE ~EmbedNode() {}
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get pointer to data.
+  uint8_t* getData() { return getSize() <= kInlineBufferSize ? const_cast<uint8_t*>(_data.buf) : _data.ptr; }
+  //! Get size of data.
+  uint32_t getSize() const { return _size; }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Size of the embedded data.
+  uint32_t _size;
+
+  union {
+    //! data buffer.
+    uint8_t buf[kInlineBufferSize];
+    //! Data buffer.
+    uint8_t* ptr;
+  } _data;
+};
+
+// ============================================================================
+// [asmjit::CommentNode]
+// ============================================================================
+
+//! Comment node.
+//!
+//! Comments allows to comment your assembler stream for better debugging
+//! and visualization. Comments are usually ignored in release builds unless
+//! the logger is present.
+struct CommentNode : public Node {
+  ASMJIT_NO_COPY(CommentNode)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `CommentNode` instance.
+  ASMJIT_INLINE CommentNode(Compiler* compiler, const char* comment) : Node(compiler, kNodeTypeComment) {
+    addFlags(kNodeFlagIsInformative);
+    _comment = comment;
+  }
+
+  //! Destroy the `CommentNode` instance.
+  ASMJIT_INLINE ~CommentNode() {}
+};
+
+// ============================================================================
+// [asmjit::HintNode]
+// ============================================================================
+
+//! Hint node.
+struct HintNode : public Node {
+  ASMJIT_NO_COPY(HintNode)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `HintNode` instance.
+  ASMJIT_INLINE HintNode(Compiler* compiler, VarData* vd, uint32_t hint, uint32_t value) : Node(compiler, kNodeTypeHint) {
+    addFlags(kNodeFlagIsInformative);
+    _vd = vd;
+    _hint = hint;
+    _value = value;
+  }
+
+  //! Destroy the `HintNode` instance.
+  ASMJIT_INLINE ~HintNode() {}
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get variable.
+  ASMJIT_INLINE VarData* getVd() const { return _vd; }
+
+  //! Get hint it (see `kVarHint)`.
+  ASMJIT_INLINE uint32_t getHint() const{ return _hint; }
+  //! Set hint it (see `kVarHint)`.
+  ASMJIT_INLINE void setHint(uint32_t hint) { _hint = hint; }
+
+  //! Get hint value.
+  ASMJIT_INLINE uint32_t getValue() const { return _value; }
+  //! Set hint value.
+  ASMJIT_INLINE void setValue(uint32_t value) { _value = value; }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Variable.
+  VarData* _vd;
+  //! Hint id.
+  uint32_t _hint;
+  //! Value.
+  uint32_t _value;
+};
+
+// ============================================================================
+// [asmjit::TargetNode]
+// ============================================================================
+
+//! label node.
+struct TargetNode : public Node {
+  ASMJIT_NO_COPY(TargetNode)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `TargetNode` instance.
+  ASMJIT_INLINE TargetNode(Compiler* compiler, uint32_t labelId) : Node(compiler, kNodeTypeTarget) {
+    _id = labelId;
+    _numRefs = 0;
+    _offset = -1;
+    _from = NULL;
+  }
+
+  //! Destroy the `TargetNode` instance.
+  ASMJIT_INLINE ~TargetNode() {}
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get target label.
+  ASMJIT_INLINE Label getLabel() const { return Label(_id); }
+  //! Get target label id.
+  ASMJIT_INLINE uint32_t getLabelId() const { return _id; }
+
+  //! Get first jmp instruction.
+  ASMJIT_INLINE JumpNode* getFrom() const { return _from; }
+
+  //! Get whether the node has assigned state.
+  ASMJIT_INLINE bool hasState() const { return _state != NULL; }
+  //! Get state for this target.
+  ASMJIT_INLINE VarState* getState() const { return _state; }
+  //! Set state for this target.
+  ASMJIT_INLINE void setState(VarState* state) { _state = state; }
+
+  //! Get number of jumps to this target.
+  ASMJIT_INLINE uint32_t getNumRefs() const { return _numRefs; }
+  //! Set number of jumps to this target.
+  ASMJIT_INLINE void setNumRefs(uint32_t i) { _numRefs = i; }
+
+  //! Add number of jumps to this target.
+  ASMJIT_INLINE void addNumRefs(uint32_t i = 1) { _numRefs += i; }
+  //! Subtract number of jumps to this target.
+  ASMJIT_INLINE void subNumRefs(uint32_t i = 1) { _numRefs -= i; }
+
+  //! Get the label offset.
+  //!
+  //! \note Only valid after the content has been serialized to the `Assembler`.
+  ASMJIT_INLINE intptr_t getOffset() const { return _offset; }
+
+  //! Set the label offset.
+  ASMJIT_INLINE void setOffset(intptr_t offset) { _offset = offset; }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Label id.
+  uint32_t _id;
+  //! Count of jumps here.
+  uint32_t _numRefs;
+
+  //! Label offset, after serialization.
+  intptr_t _offset;
+  //! First jump instruction that points to this target (label).
+  JumpNode* _from;
+};
+
+// ============================================================================
+// [asmjit::InstNode]
+// ============================================================================
+
+//! Instruction node.
+struct InstNode : public Node {
+  ASMJIT_NO_COPY(InstNode)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `InstNode` instance.
+  ASMJIT_INLINE InstNode(Compiler* compiler, uint32_t code, uint32_t options, Operand* opList, uint32_t opCount) : Node(compiler, kNodeTypeInst) {
+    _code = static_cast<uint16_t>(code);
+    _options = static_cast<uint8_t>(options);
+
+    _opCount = static_cast<uint8_t>(opCount);
+    _opList = opList;
+
+    _updateMemOp();
+  }
+
+  //! Destroy the `InstNode` instance.
+  ASMJIT_INLINE ~InstNode() {}
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get instruction code, see `kX86InstId`.
+  ASMJIT_INLINE uint32_t getCode() const {
+    return _code;
+  }
+
+  //! Set instruction code to `code`.
+  //!
+  //! Please do not modify instruction code if you are not know what you are
+  //! doing. Incorrect instruction code or operands can raise assertion() at
+  //! runtime.
+  ASMJIT_INLINE void setCode(uint32_t code) {
+    _code = static_cast<uint16_t>(code);
+  }
+
+  //! Whether the instruction is an unconditional jump or whether the
+  //! instruction is a conditional jump which is likely to be taken.
+  ASMJIT_INLINE bool isTaken() const {
+    return hasFlag(kNodeFlagIsTaken);
+  }
+
+  //! Get emit options.
+  ASMJIT_INLINE uint32_t getOptions() const {
+    return _options;
+  }
+  //! Set emit options.
+  ASMJIT_INLINE void setOptions(uint32_t options) {
+    _options = static_cast<uint8_t>(options);
+  }
+  //! Add emit options.
+  ASMJIT_INLINE void addOptions(uint32_t options) {
+    _options |= static_cast<uint8_t>(options);
+  }
+  //! Mask emit options.
+  ASMJIT_INLINE void andOptions(uint32_t options) {
+    _options &= static_cast<uint8_t>(options);
+  }
+  //! Clear emit options.
+  ASMJIT_INLINE void delOptions(uint32_t options) {
+    _options &= static_cast<uint8_t>(~options);
+  }
+
+  //! Get operands list.
+  ASMJIT_INLINE Operand* getOpList() {
+    return _opList;
+  }
+  //! \overload
+  ASMJIT_INLINE const Operand* getOpList() const {
+    return _opList;
+  }
+
+  //! Get operands count.
+  ASMJIT_INLINE uint32_t getOpCount() const {
+    return _opCount;
+  }
+
+  //! Get whether the instruction contains a memory operand.
+  ASMJIT_INLINE bool hasMemOp() const {
+    return _memOpIndex != 0xFF;
+  }
+
+  //! Set memory operand index (in opList), 0xFF means that instruction
+  //! doesn't have a memory operand.
+  ASMJIT_INLINE void setMemOpIndex(uint32_t index) {
+    _memOpIndex = static_cast<uint8_t>(index);
+  }
+  //! Reset memory operand index, setting it to 0xFF.
+  ASMJIT_INLINE void resetMemOpIndex() {
+    _memOpIndex = 0xFF;
+  }
+
+  //! Get memory operand.
+  //!
+  //! Can only be called if the instruction has such operand, see `hasMemOp()`.
+  ASMJIT_INLINE BaseMem* getMemOp() const {
+    ASMJIT_ASSERT(hasMemOp());
+    return static_cast<BaseMem*>(&_opList[_memOpIndex]);
+  }
+
+  //! \overload
+  template<typename T>
+  ASMJIT_INLINE T* getMemOp() const {
+    ASMJIT_ASSERT(hasMemOp());
+    return static_cast<T*>(&_opList[_memOpIndex]);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Utils]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE void _updateMemOp() {
+    Operand* opList = getOpList();
+    uint32_t opCount = getOpCount();
+
+    uint32_t i;
+    for (i = 0; i < opCount; i++)
+      if (opList[i].isMem())
+        goto _Update;
+    i = 0xFF;
+
+_Update:
+    setMemOpIndex(i);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Instruction code, see `kInstId`.
+  uint16_t _code;
+  //! Instruction options, see `kInstOptions`.
+  uint8_t _options;
+  //! \internal
+  uint8_t _memOpIndex;
+
+  //! Operands list.
+  Operand* _opList;
+};
+
+// ============================================================================
+// [asmjit::JumpNode]
+// ============================================================================
+
+//! Jump node.
+struct JumpNode : public InstNode {
+  ASMJIT_NO_COPY(JumpNode)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE JumpNode(Compiler* compiler, uint32_t code, uint32_t options, Operand* opList, uint32_t opCount) :
+    InstNode(compiler, code, options, opList, opCount) {}
+  ASMJIT_INLINE ~JumpNode() {}
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE TargetNode* getTarget() const { return _target; }
+  ASMJIT_INLINE JumpNode* getJumpNext() const { return _jumpNext; }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Target node.
+  TargetNode* _target;
+  //! Next jump to the same target in a single linked-list.
+  JumpNode *_jumpNext;
+};
+
+// ============================================================================
+// [asmjit::FuncNode]
+// ============================================================================
+
+//! Function declaration node.
+//!
+//! Functions are base blocks for generating assembler output. Each generated
+//! assembler stream needs standard entry and leave sequences which are compatible
+//! with the operating system ABI.
+//!
+//! `FuncNode` can be used to generate function prolog and epilog which are
+//! compatible with a given function calling convention and to allocate and
+//! manage variables that can be allocated/spilled during compilation phase.
+struct FuncNode : public Node {
+  ASMJIT_NO_COPY(FuncNode)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `FuncNode` instance.
+  //!
+  //! Always use `Compiler::addFunc()` to create a `FuncNode` instance.
+  ASMJIT_INLINE FuncNode(Compiler* compiler) :
+    Node(compiler, kNodeTypeFunc),
+    _entryNode(NULL),
+    _exitNode(NULL),
+    _decl(NULL),
+    _end(NULL),
+    _argList(NULL),
+    _funcHints(IntUtil::mask(kFuncHintNaked)),
+    _funcFlags(0),
+    _expectedStackAlignment(0),
+    _requiredStackAlignment(0),
+    _redZoneSize(0),
+    _spillZoneSize(0),
+    _argStackSize(0),
+    _memStackSize(0),
+    _callStackSize(0) {}
+
+  //! Destroy the `FuncNode` instance.
+  ASMJIT_INLINE ~FuncNode() {}
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get function entry `TargetNode`.
+  ASMJIT_INLINE TargetNode* getEntryNode() const { return _entryNode; }
+  //! Get function exit `TargetNode`.
+  ASMJIT_INLINE TargetNode* getExitNode() const { return _exitNode; }
+
+  //! Get function entry label.
+  ASMJIT_INLINE Label getEntryLabel() const { return _entryNode->getLabel(); }
+  //! Get function exit label.
+  ASMJIT_INLINE Label getExitLabel() const { return _exitNode->getLabel(); }
+
+  //! Get function `EndNode`.
+  ASMJIT_INLINE EndNode* getEnd() const { return _end; }
+  //! Get function declaration.
+  ASMJIT_INLINE FuncDecl* getDecl() const { return _decl; }
+
+  //! Get arguments list.
+  ASMJIT_INLINE VarData** getArgList() const { return _argList; }
+  //! Get arguments count.
+  ASMJIT_INLINE uint32_t getArgCount() const { return _decl->getArgCount(); }
+
+  //! Get argument at `i`.
+  ASMJIT_INLINE VarData* getArg(uint32_t i) const {
+    ASMJIT_ASSERT(i < getArgCount());
+    return _argList[i];
+  }
+
+  //! Set argument at `i`.
+  ASMJIT_INLINE void setArg(uint32_t i, VarData* vd) {
+    ASMJIT_ASSERT(i < getArgCount());
+    _argList[i] = vd;
+  }
+
+  //! Reset argument at `i`.
+  ASMJIT_INLINE void resetArg(uint32_t i) {
+    ASMJIT_ASSERT(i < getArgCount());
+    _argList[i] = NULL;
+  }
+
+  //! Get function hints.
+  ASMJIT_INLINE uint32_t getFuncHints() const { return _funcHints; }
+  //! Get function flags.
+  ASMJIT_INLINE uint32_t getFuncFlags() const { return _funcFlags; }
+
+  //! Get whether the _funcFlags has `flag`
+  ASMJIT_INLINE bool hasFuncFlag(uint32_t flag) const { return (_funcFlags & flag) != 0; }
+  //! Set function `flag`.
+  ASMJIT_INLINE void addFuncFlags(uint32_t flags) { _funcFlags |= flags; }
+  //! Clear function `flag`.
+  ASMJIT_INLINE void clearFuncFlags(uint32_t flags) { _funcFlags &= ~flags; }
+
+  //! Get whether the function is naked.
+  ASMJIT_INLINE bool isNaked() const { return hasFuncFlag(kFuncFlagIsNaked); }
+  //! Get whether the function is also a caller.
+  ASMJIT_INLINE bool isCaller() const { return hasFuncFlag(kFuncFlagIsCaller); }
+  //! Get whether the required stack alignment is lower than expected one,
+  //! thus it has to be aligned manually.
+  ASMJIT_INLINE bool isStackMisaligned() const { return hasFuncFlag(kFuncFlagIsStackMisaligned); }
+  //! Get whether the stack pointer is adjusted inside function prolog/epilog.
+  ASMJIT_INLINE bool isStackAdjusted() const { return hasFuncFlag(kFuncFlagIsStackAdjusted); }
+
+  //! Get whether the function is finished.
+  ASMJIT_INLINE bool isFinished() const { return hasFuncFlag(kFuncFlagIsFinished); }
+
+  //! Get expected stack alignment.
+  ASMJIT_INLINE uint32_t getExpectedStackAlignment() const { return _expectedStackAlignment; }
+  //! Set expected stack alignment.
+  ASMJIT_INLINE void setExpectedStackAlignment(uint32_t alignment) { _expectedStackAlignment = alignment; }
+
+  //! Get required stack alignment.
+  ASMJIT_INLINE uint32_t getRequiredStackAlignment() const { return _requiredStackAlignment; }
+  //! Set required stack alignment.
+  ASMJIT_INLINE void setRequiredStackAlignment(uint32_t alignment) { _requiredStackAlignment = alignment; }
+
+  //! Update required stack alignment so it's not lower than expected
+  //! stack alignment.
+  ASMJIT_INLINE void updateRequiredStackAlignment() {
+    if (_requiredStackAlignment <= _expectedStackAlignment) {
+      _requiredStackAlignment = _expectedStackAlignment;
+      clearFuncFlags(kFuncFlagIsStackMisaligned);
+    }
+    else {
+      addFuncFlags(kFuncFlagIsStackMisaligned);
+    }
+  }
+
+  //! Set stack "Red Zone" size.
+  ASMJIT_INLINE uint32_t getRedZoneSize() const { return _redZoneSize; }
+  //! Get stack "Red Zone" size.
+  ASMJIT_INLINE void setRedZoneSize(uint32_t s) { _redZoneSize = static_cast<uint16_t>(s); }
+
+  //! Set stack "Spill Zone" size.
+  ASMJIT_INLINE uint32_t getSpillZoneSize() const { return _spillZoneSize; }
+  //! Get stack "Spill Zone" size.
+  ASMJIT_INLINE void setSpillZoneSize(uint32_t s) { _spillZoneSize = static_cast<uint16_t>(s); }
+
+  //! Get stack size used by function arguments.
+  ASMJIT_INLINE uint32_t getArgStackSize() const { return _argStackSize; }
+
+  //! Get stack size used by variables and memory allocated on the stack.
+  ASMJIT_INLINE uint32_t getMemStackSize() const { return _memStackSize; }
+
+  //! Get stack size used by function calls.
+  ASMJIT_INLINE uint32_t getCallStackSize() const { return _callStackSize; }
+  //! Merge stack size used by function call with `s`.
+  ASMJIT_INLINE void mergeCallStackSize(uint32_t s) { if (_callStackSize < s) _callStackSize = s; }
+
+  // --------------------------------------------------------------------------
+  // [Hints]
+  // --------------------------------------------------------------------------
+
+  //! Set function hint.
+  ASMJIT_INLINE void setHint(uint32_t hint, uint32_t value) {
+    ASMJIT_ASSERT(hint <= 31);
+    ASMJIT_ASSERT(value <= 1);
+
+    _funcHints &= ~(1     << hint);
+    _funcHints |=  (value << hint);
+  }
+
+  //! Get function hint.
+  ASMJIT_INLINE uint32_t getHint(uint32_t hint) const {
+    ASMJIT_ASSERT(hint <= 31);
+    return (_funcHints >> hint) & 0x1;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Function entry.
+  TargetNode* _entryNode;
+  //! Function exit.
+  TargetNode* _exitNode;
+
+  //! Function declaration.
+  FuncDecl* _decl;
+  //! Function end.
+  EndNode* _end;
+
+  //! Arguments list as `VarData`.
+  VarData** _argList;
+
+  //! Function hints;
+  uint32_t _funcHints;
+  //! Function flags.
+  uint32_t _funcFlags;
+
+  //! Expected stack alignment (we depend on this value).
+  //!
+  //! \note It can be global alignment given by the OS or described by an
+  //! target platform ABI.
+  uint32_t _expectedStackAlignment;
+  //! Required stack alignment (usually for multimedia instructions).
+  uint32_t _requiredStackAlignment;
+
+  //! The "Red Zone" size - count of bytes which might be accessed without
+  //! adjusting the stack pointer.
+  uint16_t _redZoneSize;
+  //! Spill zone size (zone used by WIN64ABI).
+  uint16_t _spillZoneSize;
+
+  //! Stack size needed for function arguments.
+  uint32_t _argStackSize;
+  //! Stack size needed for all variables and memory allocated on the stack.
+  uint32_t _memStackSize;
+  //! Stack size needed to call other functions.
+  uint32_t _callStackSize;
+};
+
+// ============================================================================
+// [asmjit::EndNode]
+// ============================================================================
+
+//! End of function/block node.
+struct EndNode : public Node {
+  ASMJIT_NO_COPY(EndNode)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `EndNode` instance.
+  ASMJIT_INLINE EndNode(Compiler* compiler) : Node(compiler, kNodeTypeEnd) {
+    _flags |= kNodeFlagIsRet;
+  }
+
+  //! Destroy the `EndNode` instance.
+  ASMJIT_INLINE ~EndNode() {}
+};
+
+// ============================================================================
+// [asmjit::RetNode]
+// ============================================================================
+
+//! Function return node.
+struct RetNode : public Node {
+  ASMJIT_NO_COPY(RetNode)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `RetNode` instance.
+  ASMJIT_INLINE RetNode(Compiler* compiler, const Operand& o0, const Operand& o1) : Node(compiler, kNodeTypeRet) {
+    _flags |= kNodeFlagIsRet;
+    _ret[0] = o0;
+    _ret[1] = o1;
+  }
+
+  //! Destroy the `RetNode` instance.
+  ASMJIT_INLINE ~RetNode() {}
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get the first return operand.
+  ASMJIT_INLINE Operand& getFirst() { return _ret[0]; }
+  //! \overload
+  ASMJIT_INLINE const Operand& getFirst() const { return _ret[0]; }
+
+  //! Get the second return operand.
+  ASMJIT_INLINE Operand& getSecond() { return _ret[1]; }
+   //! \overload
+  ASMJIT_INLINE const Operand& getSecond() const { return _ret[1]; }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Ret operand(s).
+  Operand _ret[2];
+};
+
+// ============================================================================
+// [asmjit::CallNode]
+// ============================================================================
+
+//! Function-call node.
+struct CallNode : public Node {
+  ASMJIT_NO_COPY(CallNode)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `CallNode` instance.
+  ASMJIT_INLINE CallNode(Compiler* compiler, const Operand& target) :
+    Node(compiler, kNodeTypeCall),
+    _decl(NULL),
+    _target(target),
+    _args(NULL) {}
+
+  //! Destroy the `CallNode` instance.
+  ASMJIT_INLINE ~CallNode() {}
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get function declaration.
+  ASMJIT_INLINE FuncDecl* getDecl() const { return _decl; }
+
+  //! Get target operand.
+  ASMJIT_INLINE Operand& getTarget() { return _target; }
+  //! \overload
+  ASMJIT_INLINE const Operand& getTarget() const  { return _target; }
+
+  //! Get return at `i`.
+  ASMJIT_INLINE Operand& getRet(uint32_t i = 0) {
+    ASMJIT_ASSERT(i < 2);
+    return _ret[i];
+  }
+  //! \overload
+  ASMJIT_INLINE const Operand& getRet(uint32_t i = 0) const  {
+    ASMJIT_ASSERT(i < 2);
+    return _ret[i];
+  }
+
+  //! Get argument at `i`.
+  ASMJIT_INLINE Operand& getArg(uint32_t i) {
+    ASMJIT_ASSERT(i < kFuncArgCountLoHi);
+    return _args[i];
+  }
+  //! \overload
+  ASMJIT_INLINE const Operand& getArg(uint32_t i) const  {
+    ASMJIT_ASSERT(i < kFuncArgCountLoHi);
+    return _args[i];
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Function declaration.
+  FuncDecl* _decl;
+
+  //! Target (address of function, register, label, ...).
+  Operand _target;
+  //! Return.
+  Operand _ret[2];
+  //! Arguments.
+  Operand* _args;
+};
+
+// ============================================================================
+// [asmjit::SArgNode]
+// ============================================================================
+
+//! Function-call 'argument on the stack' node.
+struct SArgNode : public Node {
+  ASMJIT_NO_COPY(SArgNode)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `SArgNode` instance.
+  ASMJIT_INLINE SArgNode(Compiler* compiler, CallNode* call, VarData* sVd, VarData* cVd) :
+    Node(compiler, kNodeTypeSArg),
+    _call(call),
+    _sVd(sVd),
+    _cVd(cVd),
+    _args(0) {}
+
+  //! Destroy the `SArgNode` instance.
+  ASMJIT_INLINE ~SArgNode() {}
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get the associated function-call.
+  ASMJIT_INLINE CallNode* getCall() const { return _call; }
+  //! Get source variable.
+  ASMJIT_INLINE VarData* getSVd() const { return _sVd; }
+  //! Get conversion variable.
+  ASMJIT_INLINE VarData* getCVd() const { return _cVd; }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Associated `CallNode`.
+  CallNode* _call;
+  //! Source variable.
+  VarData* _sVd;
+  //! Temporary variable used for conversion (or NULL).
+  VarData* _cVd;
+
+  //! Affected arguments bit-array.
+  uint32_t _args;
+};
+
+//! \}
+
+// ============================================================================
+// [asmjit::Compiler]
+// ============================================================================
+
+//! \addtogroup asmjit_base_general
+//! \{
+
+//! Base compiler.
+//!
+//! \sa Assembler.
+struct ASMJIT_VCLASS Compiler : public CodeGen {
+  ASMJIT_NO_COPY(Compiler)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `Compiler` instance.
+  ASMJIT_API Compiler(Runtime* runtime);
+  //! Destroy the `Compiler` instance.
+  ASMJIT_API virtual ~Compiler();
+
+  // --------------------------------------------------------------------------
+  // [LookAhead]
+  // --------------------------------------------------------------------------
+
+  //! Get maximum look ahead.
+  ASMJIT_INLINE uint32_t getMaxLookAhead() const {
+    return _maxLookAhead;
+  }
+
+  //! Set maximum look ahead to `val`.
+  ASMJIT_INLINE void setMaxLookAhead(uint32_t val) {
+    _maxLookAhead = val;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Clear / Reset]
+  // --------------------------------------------------------------------------
+
+  //! Reset the compiler.
+  //!
+  //! If `releaseMemory` is true all buffers will be released to the system.
+  ASMJIT_API void reset(bool releaseMemory = false);
+
+  // --------------------------------------------------------------------------
+  // [Nodes]
+  // --------------------------------------------------------------------------
+
+  template<typename T>
+  ASMJIT_INLINE T* newNode() {
+    void* p = _baseZone.alloc(sizeof(T));
+    return new(p) T(this);
+  }
+
+  template<typename T, typename P0>
+  ASMJIT_INLINE T* newNode(P0 p0) {
+    void* p = _baseZone.alloc(sizeof(T));
+    return new(p) T(this, p0);
+  }
+
+  template<typename T, typename P0, typename P1>
+  ASMJIT_INLINE T* newNode(P0 p0, P1 p1) {
+    void* p = _baseZone.alloc(sizeof(T));
+    return new(p) T(this, p0, p1);
+  }
+
+  template<typename T, typename P0, typename P1, typename P2>
+  ASMJIT_INLINE T* newNode(P0 p0, P1 p1, P2 p2) {
+    void* p = _baseZone.alloc(sizeof(T));
+    return new(p) T(this, p0, p1, p2);
+  }
+
+  //! Get first node.
+  ASMJIT_INLINE Node* getFirstNode() const { return _firstNode; }
+  //! Get last node.
+  ASMJIT_INLINE Node* getLastNode() const { return _lastNode; }
+
+  //! Get current node.
+  //!
+  //! \note If this method returns `NULL` it means that nothing has been emitted
+  //! yet.
+  ASMJIT_INLINE Node* getCursor() const { return _cursor; }
+  //! Set the current node without returning the previous node (private).
+  ASMJIT_INLINE void _setCursor(Node* node) { _cursor = node; }
+  //! Set the current node to `node` and return the previous one.
+  ASMJIT_API Node* setCursor(Node* node);
+
+  //! Add node `node` after current and set current to `node`.
+  ASMJIT_API Node* addNode(Node* node);
+  //! Add node before `ref`.
+  ASMJIT_API Node* addNodeBefore(Node* node, Node* ref);
+  //! Add node after `ref`.
+  ASMJIT_API Node* addNodeAfter(Node* node, Node* ref);
+  //! Remove node `node`.
+  ASMJIT_API Node* removeNode(Node* node);
+  //! Remove multiple nodes.
+  ASMJIT_API void removeNodes(Node* first, Node* last);
+
+  // --------------------------------------------------------------------------
+  // [Func]
+  // --------------------------------------------------------------------------
+
+  //! Get current function.
+  ASMJIT_INLINE FuncNode* getFunc() const { return _func; }
+
+  // --------------------------------------------------------------------------
+  // [Align]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `AlignNode`.
+  ASMJIT_API AlignNode* newAlign(uint32_t mode, uint32_t offset);
+  //! Add a new `AlignNode`.
+  ASMJIT_API AlignNode* addAlign(uint32_t mode, uint32_t offset);
+
+  //! Align target buffer to `m` bytes.
+  //!
+  //! Typical usage of this is to align labels at start of the inner loops.
+  //!
+  //! Inserts `nop()` instructions or CPU optimized NOPs.
+  ASMJIT_INLINE AlignNode* align(uint32_t mode, uint32_t offset) {
+    return addAlign(mode, offset);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Target]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `TargetNode`.
+  ASMJIT_API TargetNode* newTarget();
+  //! Add a new `TargetNode`.
+  ASMJIT_API TargetNode* addTarget();
+
+  //! Get `TargetNode` by `id`.
+  ASMJIT_INLINE TargetNode* getTargetById(uint32_t id) {
+    ASMJIT_ASSERT(OperandUtil::isLabelId(id));
+    ASMJIT_ASSERT(id < _targetList.getLength());
+
+    return _targetList[id];
+  }
+
+  //! Get `TargetNode` by `label`.
+  ASMJIT_INLINE TargetNode* getTarget(const Label& label) {
+    return getTargetById(label.getId());
+  }
+
+  // --------------------------------------------------------------------------
+  // [Label]
+  // --------------------------------------------------------------------------
+
+  //! Get count of created labels.
+  ASMJIT_INLINE size_t getLabelsCount() const {
+    return _targetList.getLength();
+  }
+
+  //! Get whether `label` is created.
+  ASMJIT_INLINE bool isLabelValid(const Label& label) const {
+    return isLabelValid(label.getId());
+  }
+
+  //! \overload
+  ASMJIT_INLINE bool isLabelValid(uint32_t id) const {
+    return static_cast<size_t>(id) < _targetList.getLength();
+  }
+
+  //! Get `TargetNode` by `label`.
+  ASMJIT_INLINE TargetNode* getTargetByLabel(const Label& label) {
+    return getTargetByLabel(label.getId());
+  }
+
+  //! \overload
+  ASMJIT_INLINE TargetNode* getTargetByLabel(uint32_t id) {
+    ASMJIT_ASSERT(isLabelValid(id));
+    return _targetList[id];
+  }
+
+  //! Get `label` offset or -1 if the label is not bound.
+  //!
+  //! This method can be only called after the code has been serialized to the
+  //! `Assembler`, otherwise the offset returned will be -1 (even if the label
+  //! has been bound).
+  ASMJIT_INLINE intptr_t getLabelOffset(const Label& label) const {
+    return getLabelOffset(label.getId());
+  }
+
+  //! \overload
+  ASMJIT_INLINE intptr_t getLabelOffset(uint32_t id) const {
+    ASMJIT_ASSERT(isLabelValid(id));
+    return _targetList[id]->getOffset();
+  }
+
+  //! \internal
+  //!
+  //! Create and initialize a new `Label`.
+  ASMJIT_API Error _newLabel(Label* dst);
+
+  //! Create and return a new `Label`.
+  ASMJIT_INLINE Label newLabel() {
+    Label result(NoInit);
+    _newLabel(&result);
+    return result;
+  }
+
+  //! Bind label to the current offset.
+  //!
+  //! \note Label can be bound only once!
+  ASMJIT_API Error bind(const Label& label);
+
+  // --------------------------------------------------------------------------
+  // [Embed]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `EmbedNode`.
+  ASMJIT_API EmbedNode* newEmbed(const void* data, uint32_t size);
+  //! Add a new `EmbedNode`.
+  ASMJIT_API EmbedNode* addEmbed(const void* data, uint32_t size);
+
+  //! Embed data.
+  ASMJIT_INLINE EmbedNode* embed(const void* data, uint32_t size) {
+    return addEmbed(data, size);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Comment]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `CommentNode`.
+  ASMJIT_API CommentNode* newComment(const char* str);
+  //! Add a new `CommentNode`.
+  ASMJIT_API CommentNode* addComment(const char* str);
+
+  //! Emit a single comment line.
+  ASMJIT_API CommentNode* comment(const char* fmt, ...);
+
+  // --------------------------------------------------------------------------
+  // [Hint]
+  // --------------------------------------------------------------------------
+
+  //! Create a new `HintNode`.
+  ASMJIT_API HintNode* newHint(Var& var, uint32_t hint, uint32_t value);
+  //! Add a new `HintNode`.
+  ASMJIT_API HintNode* addHint(Var& var, uint32_t hint, uint32_t value);
+
+  // --------------------------------------------------------------------------
+  // [Vars]
+  // --------------------------------------------------------------------------
+
+  //! Get whether variable `var` is created.
+  ASMJIT_INLINE bool isVarValid(const Var& var) const {
+    return static_cast<size_t>(var.getId() & kOperandIdNum) < _varList.getLength();
+  }
+
+  //! \internal
+  //!
+  //! Get `VarData` by `var`.
+  ASMJIT_INLINE VarData* getVd(const Var& var) const {
+    return getVdById(var.getId());
+  }
+
+  //! \internal
+  //!
+  //! Get `VarData` by `id`.
+  ASMJIT_INLINE VarData* getVdById(uint32_t id) const {
+    ASMJIT_ASSERT(id != kInvalidValue);
+    ASMJIT_ASSERT(static_cast<size_t>(id & kOperandIdNum) < _varList.getLength());
+
+    return _varList[id & kOperandIdNum];
+  }
+
+  //! \internal
+  //!
+  //! Get an array of 'VarData*'.
+  ASMJIT_INLINE VarData** _getVdArray() const {
+    return const_cast<VarData**>(_varList.getData());
+  }
+
+  //! \internal
+  //!
+  //! Create a new `VarData`.
+  ASMJIT_API VarData* _newVd(uint32_t type, uint32_t size, uint32_t c, const char* name);
+
+  //! Create a new `Var`.
+  virtual Error _newVar(Var* var, uint32_t type, const char* name) = 0;
+
+  //! Alloc variable `var`.
+  ASMJIT_API void alloc(Var& var);
+  //! Alloc variable `var` using `regIndex` as a register index.
+  ASMJIT_API void alloc(Var& var, uint32_t regIndex);
+  //! Alloc variable `var` using `reg` as a demanded register.
+  ASMJIT_API void alloc(Var& var, const Reg& reg);
+  //! Spill variable `var`.
+  ASMJIT_API void spill(Var& var);
+  //! Save variable `var` if modified.
+  ASMJIT_API void save(Var& var);
+  //! Unuse variable `var`.
+  ASMJIT_API void unuse(Var& var);
+
+  //! Get priority of variable `var`.
+  ASMJIT_API uint32_t getPriority(Var& var) const;
+  //! Set priority of variable `var` to `priority`.
+  ASMJIT_API void setPriority(Var& var, uint32_t priority);
+
+  //! Get save-on-unuse `var` property.
+  ASMJIT_API bool getSaveOnUnuse(Var& var) const;
+  //! Set save-on-unuse `var` property to `value`.
+  ASMJIT_API void setSaveOnUnuse(Var& var, bool value);
+
+  //! Rename variable `var` to `name`.
+  //!
+  //! \note Only new name will appear in the logger.
+  ASMJIT_API void rename(Var& var, const char* name);
+
+  // --------------------------------------------------------------------------
+  // [Stack]
+  // --------------------------------------------------------------------------
+
+  //! \internal
+  //!
+  //! Create a new memory chunk allocated on the current function's stack.
+  virtual Error _newStack(BaseMem* mem, uint32_t size, uint32_t alignment, const char* name) = 0;
+
+  // --------------------------------------------------------------------------
+  // [Const]
+  // --------------------------------------------------------------------------
+
+  //! \internal
+  //!
+  //! Put data to a constant-pool and get a memory reference to it.
+  virtual Error _newConst(BaseMem* mem, uint32_t scope, const void* data, size_t size) = 0;
+
+  // --------------------------------------------------------------------------
+  // [Assembler]
+  // --------------------------------------------------------------------------
+
+  //! Get an assembler instance that is associated with the compiler.
+  //!
+  //! \note One instance of `Assembler` is shared and has lifetime same as the
+  //! compiler, however, each call to `getAssembler()` resets the assembler so
+  //! new code can be serialized into it.
+  ASMJIT_API Assembler* getAssembler();
+
+  //! \internal
+  //!
+  //! Create a new `Assembler` instance associated with the compiler.
+  virtual Assembler* _newAssembler() = 0;
+
+  // --------------------------------------------------------------------------
+  // [Serialize]
+  // --------------------------------------------------------------------------
+
+  //! Serialize a compiled code to `assembler`.
+  virtual Error serialize(Assembler* assembler) = 0;
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Internal assembler.
+  Assembler* _assembler;
+
+  //! Flow id added to each node created (used only by `Context)`.
+  uint32_t _nodeFlowId;
+  //! Flags added to each node created (used only by `Context)`.
+  uint32_t _nodeFlags;
+
+  //! Maximum count of nodes to look ahead when allocating/spilling
+  //! registers.
+  uint32_t _maxLookAhead;
+
+  //! Variable mapping (translates incoming kVarType into target).
+  const uint8_t* _targetVarMapping;
+
+  //! First node.
+  Node* _firstNode;
+  //! Last node.
+  Node* _lastNode;
+
+  //! Current node.
+  Node* _cursor;
+  //! Current function.
+  FuncNode* _func;
+
+  //! Variable zone.
+  Zone _varZone;
+  //! String/data zone.
+  Zone _stringZone;
+  //! Local constant pool zone.
+  Zone _localConstZone;
+
+  //! TargetNode list.
+  PodVector<TargetNode*> _targetList;
+  //! VarData list.
+  PodVector<VarData*> _varList;
+
+  //! Local constant pool, flushed at the end of each function.
+  ConstPool _localConstPool;
+  //! Global constant pool, flushed at the end of the compilation.
+  ConstPool _globalConstPool;
+
+  //! Label to start of the local constant pool.
+  Label _localConstPoolLabel;
+  //! Label to start of the global constant pool.
+  Label _globalConstPoolLabel;
+};
+
+//! \}
+
+// ============================================================================
+// [Defined-Later]
+// ============================================================================
+
+ASMJIT_INLINE Label::Label(Compiler& c) : Operand(NoInit) {
+  c._newLabel(this);
+}
+
+ASMJIT_INLINE Node::Node(Compiler* compiler, uint32_t type) {
+  _prev = NULL;
+  _next = NULL;
+  _type = static_cast<uint8_t>(type);
+  _opCount = 0;
+  _flags = static_cast<uint16_t>(compiler->_nodeFlags);
+  _flowId = compiler->_nodeFlowId;
+  _comment = NULL;
+  _map = NULL;
+  _liveness = NULL;
+  _state = NULL;
+}
+
+} // asmjit namespace
+
+// [Api-End]
+#include "../apiend.h"
+
+// [Guard]
+#endif // !ASMJIT_DISABLE_COMPILER
+#endif // _ASMJIT_BASE_COMPILER_H

libraries/asmjit/base/constpool.cpp

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Export]
+#define ASMJIT_EXPORTS
+
+// [Dependencies - AsmJit]
+#include "../base/constpool.h"
+#include "../base/intutil.h"
+
+// [Api-Begin]
+#include "../apibegin.h"
+
+namespace asmjit {
+
+// Binary tree code is based on Julienne Walker's "Andersson Binary Trees"
+// article and implementation. However, only three operations are implemented -
+// get, insert and traverse.
+
+// ============================================================================
+// [asmjit::ConstPoolTree - Ops]
+// ============================================================================
+
+//! \internal
+//!
+//! Remove left horizontal links.
+static ASMJIT_INLINE ConstPoolNode* ConstPoolTree_skewNode(ConstPoolNode* node) {
+  ConstPoolNode* link = node->_link[0];
+  uint32_t level = node->_level;
+
+  if (level != 0 && link != NULL && link->_level == level) {
+    node->_link[0] = link->_link[1];
+    link->_link[1] = node;
+
+    node = link;
+  }
+
+  return node;
+}
+
+//! \internal
+//!
+//! Remove consecutive horizontal links.
+static ASMJIT_INLINE ConstPoolNode* ConstPoolTree_splitNode(ConstPoolNode* node) {
+  ConstPoolNode* link = node->_link[1];
+  uint32_t level = node->_level;
+
+  if (level != 0 && link != NULL && link->_link[1] != NULL && link->_link[1]->_level == level) {
+    node->_link[1] = link->_link[0];
+    link->_link[0] = node;
+
+    node = link;
+    node->_level++;
+  }
+
+  return node;
+}
+
+ConstPoolNode* ConstPoolTree::get(const void* data) {
+  ConstPoolNode* node = _root;
+  size_t dataSize = _dataSize;
+
+  while (node != NULL) {
+    int c = ::memcmp(node->getData(), data, dataSize);
+    if (c == 0)
+      return node;
+    node = node->_link[c < 0];
+  }
+
+  return NULL;
+}
+
+void ConstPoolTree::put(ConstPoolNode* newNode) {
+  size_t dataSize = _dataSize;
+
+  _length++;
+  if (_root == NULL) {
+    _root = newNode;
+    return;
+  }
+
+  ConstPoolNode* node = _root;
+  ConstPoolNode* stack[kHeightLimit];
+
+  unsigned int top = 0;
+  unsigned int dir;
+
+  // Find a spot and save the stack.
+  for (;;) {
+    stack[top++] = node;
+    dir = ::memcmp(node->getData(), newNode->getData(), dataSize) < 0;
+
+    ConstPoolNode* link = node->_link[dir];
+    if (link == NULL)
+      break;
+
+    node = link;
+  }
+
+  // Link and rebalance.
+  node->_link[dir] = newNode;
+
+  while (top > 0) {
+    // Which child?
+    node = stack[--top];
+
+    if (top != 0) {
+      dir = stack[top - 1]->_link[1] == node;
+    }
+
+    node = ConstPoolTree_skewNode(node);
+    node = ConstPoolTree_splitNode(node);
+
+    // Fix the parent.
+    if (top != 0)
+      stack[top - 1]->_link[dir] = node;
+    else
+      _root = node;
+  }
+}
+
+// ============================================================================
+// [asmjit::ConstPool - Construction / Destruction]
+// ============================================================================
+
+ConstPool::ConstPool(Zone* zone) {
+  _zone = zone;
+
+  size_t dataSize = 1;
+  for (size_t i = 0; i < ASMJIT_ARRAY_SIZE(_tree); i++) {
+    _tree[i].setDataSize(dataSize);
+    _gaps[i] = NULL;
+    dataSize <<= 1;
+  }
+
+  _gapPool = NULL;
+  _size = 0;
+  _alignment = 0;
+}
+
+ConstPool::~ConstPool() {}
+
+// ============================================================================
+// [asmjit::ConstPool - Reset]
+// ============================================================================
+
+void ConstPool::reset() {
+  for (size_t i = 0; i < ASMJIT_ARRAY_SIZE(_tree); i++) {
+    _tree[i].reset();
+    _gaps[i] = NULL;
+  }
+
+  _gapPool = NULL;
+  _size = 0;
+  _alignment = 0;
+}
+
+// ============================================================================
+// [asmjit::ConstPool - Ops]
+// ============================================================================
+
+static ASMJIT_INLINE size_t ConstPool_getGapIndex(size_t size) {
+  if (size <=  1)
+    return ConstPool::kIndex1;
+  else if (size <=  3)
+    return ConstPool::kIndex2;
+  else if (size <=  7)
+    return ConstPool::kIndex4;
+  else if (size <= 15)
+    return ConstPool::kIndex8;
+  else
+    return ConstPool::kIndex16;
+}
+
+static ASMJIT_INLINE ConstPoolGap* ConstPool_allocGap(ConstPool* self) {
+  ConstPoolGap* gap = self->_gapPool;
+  if (gap == NULL)
+    return self->_zone->allocT<ConstPoolGap>();
+
+  self->_gapPool = gap->_next;
+  return gap;
+}
+
+static ASMJIT_INLINE void ConstPool_freeGap(ConstPool* self,  ConstPoolGap* gap) {
+  gap->_next = self->_gapPool;
+  self->_gapPool = gap;
+}
+
+static void ConstPool_addGap(ConstPool* self, size_t offset, size_t length) {
+  ASMJIT_ASSERT(length > 0);
+
+  while (length > 0) {
+    size_t gapIndex;
+    size_t gapLength;
+
+    if (length >= 16 && IntUtil::isAligned<size_t>(offset, 16)) {
+      gapIndex = ConstPool::kIndex16;
+      gapLength = 16;
+    }
+    else if (length >= 8 && IntUtil::isAligned<size_t>(offset, 8)) {
+      gapIndex = ConstPool::kIndex8;
+      gapLength = 8;
+    }
+    else if (length >= 4 && IntUtil::isAligned<size_t>(offset, 4)) {
+      gapIndex = ConstPool::kIndex4;
+      gapLength = 4;
+    }
+    else if (length >= 2 && IntUtil::isAligned<size_t>(offset, 2)) {
+      gapIndex = ConstPool::kIndex2;
+      gapLength = 2;
+    }
+    else {
+      gapIndex = ConstPool::kIndex1;
+      gapLength = 1;
+    }
+
+    // We don't have to check for errors here, if this failed nothing really
+    // happened (just the gap won't be visible) and it will fail again at
+    // place where checking will cause kErrorNoHeapMemory.
+    ConstPoolGap* gap = ConstPool_allocGap(self);
+    if (gap == NULL)
+      return;
+
+    gap->_next = self->_gaps[gapIndex];
+    self->_gaps[gapIndex] = gap;
+
+    gap->_offset = offset;
+    gap->_length = gapLength;
+
+    offset += gapLength;
+    length -= gapLength;
+  }
+}
+
+Error ConstPool::add(const void* data, size_t size, size_t& dstOffset) {
+  size_t treeIndex;
+
+  if (size == 32)
+    treeIndex = kIndex32;
+  else if (size == 16)
+    treeIndex = kIndex16;
+  else if (size == 8)
+    treeIndex = kIndex8;
+  else if (size == 4)
+    treeIndex = kIndex4;
+  else if (size == 2)
+    treeIndex = kIndex2;
+  else if (size == 1)
+    treeIndex = kIndex1;
+  else
+    return kErrorInvalidArgument;
+
+  ConstPoolNode* node = _tree[treeIndex].get(data);
+  if (node != NULL) {
+    dstOffset = node->_offset;
+    return kErrorOk;
+  }
+
+  // Before incrementing the current offset try if there is a gap that can
+  // be used for the requested data.
+  size_t offset = ~static_cast<size_t>(0);
+  size_t gapIndex = treeIndex;
+
+  while (gapIndex != kIndexCount - 1) {
+    ConstPoolGap* gap = _gaps[treeIndex];
+
+    // Check if there is a gap.
+    if (gap != NULL) {
+      size_t gapOffset = gap->_offset;
+      size_t gapLength = gap->_length;
+
+      // Destroy the gap for now.
+      _gaps[treeIndex] = gap->_next;
+      ConstPool_freeGap(this, gap);
+
+      offset = gapOffset;
+      ASMJIT_ASSERT(IntUtil::isAligned<size_t>(offset, size));
+
+      gapLength -= size;
+      if (gapLength > 0)
+        ConstPool_addGap(this, gapOffset, gapLength);
+    }
+
+    gapIndex++;
+  }
+
+  if (offset == ~static_cast<size_t>(0)) {
+    // Get how many bytes have to be skipped so the address is aligned accordingly
+    // to the 'size'.
+    size_t deltaTo = IntUtil::deltaTo<size_t>(_size, size);
+
+    if (deltaTo != 0) {
+      ConstPool_addGap(this, _size, deltaTo);
+      _size += deltaTo;
+    }
+
+    offset = _size;
+    _size += size;
+  }
+
+  // Add the initial node to the right index.
+  node = ConstPoolTree::_newNode(_zone, data, size, offset, false);
+  if (node == NULL)
+    return kErrorNoHeapMemory;
+
+  _tree[treeIndex].put(node);
+  _alignment = IntUtil::iMax<size_t>(_alignment, size);
+
+  dstOffset = offset;
+
+  // Now create a bunch of shared constants that are based on the data pattern.
+  // We stop at size 4, it probably doesn't make sense to split constants down
+  // to 1 byte.
+  size_t pCount = 1;
+  while (size > 4) {
+    size >>= 1;
+    pCount <<= 1;
+
+    ASMJIT_ASSERT(treeIndex != 0);
+    treeIndex--;
+
+    const uint8_t* pData = static_cast<const uint8_t*>(data);
+    for (size_t i = 0; i < pCount; i++, pData += size) {
+      node = _tree[treeIndex].get(pData);
+
+      if (node != NULL)
+        continue;
+
+      node = ConstPoolTree::_newNode(_zone, pData, size, offset + (i * size), true);
+      _tree[treeIndex].put(node);
+    }
+  }
+
+  return kErrorOk;
+}
+
+// ============================================================================
+// [asmjit::ConstPool - Reset]
+// ============================================================================
+
+struct ConstPoolFill {
+  ASMJIT_INLINE ConstPoolFill(uint8_t* dst, size_t dataSize) :
+    _dst(dst),
+    _dataSize(dataSize) {}
+
+  ASMJIT_INLINE void visit(const ConstPoolNode* node) {
+    if (!node->_shared)
+      ::memcpy(_dst + node->_offset, node->getData(), _dataSize);
+  }
+
+  uint8_t* _dst;
+  size_t _dataSize;
+};
+
+void ConstPool::fill(void* dst) {
+  // Clears possible gaps, asmjit should never emit garbage to the output.
+  ::memset(dst, 0, _size);
+
+  ConstPoolFill filler(static_cast<uint8_t*>(dst), 1);
+  for (size_t i = 0; i < ASMJIT_ARRAY_SIZE(_tree); i++) {
+    _tree[i].iterate(filler);
+    filler._dataSize <<= 1;
+  }
+}
+
+// ============================================================================
+// [asmjit::ConstPool - Test]
+// ============================================================================
+
+#if defined(ASMJIT_TEST)
+UNIT(base_constpool) {
+  Zone zone(32384 - kZoneOverhead);
+  ConstPool pool(&zone);
+
+  uint32_t i;
+  uint32_t kCount = 1000000;
+
+  INFO("Adding %u constants to the pool.", kCount);
+  {
+    size_t prevOffset;
+    size_t curOffset;
+    uint64_t c = ASMJIT_UINT64_C(0x0101010101010101);
+
+    EXPECT(pool.add(&c, 8, prevOffset) == kErrorOk,
+      "pool.add() - Returned error.");
+    EXPECT(prevOffset == 0,
+      "pool.add() - First constant should have zero offset.");
+
+    for (i = 1; i < kCount; i++) {
+      c++;
+      EXPECT(pool.add(&c, 8, curOffset) == kErrorOk,
+        "pool.add() - Returned error.");
+      EXPECT(prevOffset + 8 == curOffset,
+        "pool.add() - Returned incorrect curOffset.");
+      EXPECT(pool.getSize() == (i + 1) * 8,
+        "pool.getSize() - Reports incorrect size.");
+      prevOffset = curOffset;
+    }
+
+    EXPECT(pool.getAlignment() == 8,
+      "pool.getAlignment() - Expected 8-byte alignment.");
+  }
+
+  INFO("Retrieving %u constants from the pool.", kCount);
+  {
+    uint64_t c = ASMJIT_UINT64_C(0x0101010101010101);
+
+    for (i = 0; i < kCount; i++) {
+      size_t offset;
+      EXPECT(pool.add(&c, 8, offset) == kErrorOk,
+        "pool.add() - Returned error.");
+      EXPECT(offset == i * 8,
+        "pool.add() - Should have reused constant.");
+      c++;
+    }
+  }
+
+  INFO("Checking if the constants were split into 4-byte patterns.");
+  {
+    uint32_t c = 0x01010101;
+    for (i = 0; i < kCount; i++) {
+      size_t offset;
+      EXPECT(pool.add(&c, 4, offset) == kErrorOk,
+        "pool.add() - Returned error.");
+      EXPECT(offset == i * 8,
+        "pool.add() - Should reuse existing constant.");
+      c++;
+    }
+  }
+
+  INFO("Adding 2 byte constant to misalign the current offset.");
+  {
+    uint16_t c = 0xFFFF;
+    size_t offset;
+
+    EXPECT(pool.add(&c, 2, offset) == kErrorOk,
+      "pool.add() - Returned error.");
+    EXPECT(offset == kCount * 8,
+      "pool.add() - Didn't return expected position.");
+    EXPECT(pool.getAlignment() == 8,
+      "pool.getAlignment() - Expected 8-byte alignment.");
+  }
+
+  INFO("Adding 8 byte constant to check if pool gets aligned again.");
+  {
+    uint64_t c = ASMJIT_UINT64_C(0xFFFFFFFFFFFFFFFF);
+    size_t offset;
+
+    EXPECT(pool.add(&c, 8, offset) == kErrorOk,
+      "pool.add() - Returned error.");
+    EXPECT(offset == kCount * 8 + 8,
+      "pool.add() - Didn't return aligned offset.");
+  }
+
+  INFO("Adding 2 byte constant to verify the gap is filled.");
+  {
+    uint16_t c = 0xFFFE;
+    size_t offset;
+
+    EXPECT(pool.add(&c, 2, offset) == kErrorOk,
+      "pool.add() - Returned error.");
+    EXPECT(offset == kCount * 8 + 2,
+      "pool.add() - Didn't fill the gap.");
+    EXPECT(pool.getAlignment() == 8,
+      "pool.getAlignment() - Expected 8-byte alignment.");
+  }
+
+  INFO("Checking reset functionality.");
+  {
+    pool.reset();
+
+    EXPECT(pool.getSize() == 0,
+      "pool.getSize() - Expected pool size to be zero.");
+    EXPECT(pool.getAlignment() == 0,
+      "pool.getSize() - Expected pool alignment to be zero.");
+  }
+
+  INFO("Checking pool alignment when combined constants are added.");
+  {
+    uint8_t bytes[32] = { 0 };
+    uint64_t c = 0;
+    size_t offset;
+
+    pool.add(bytes, 1, offset);
+
+    EXPECT(pool.getSize() == 1,
+      "pool.getSize() - Expected pool size to be 1 byte.");
+    EXPECT(pool.getAlignment() == 1,
+      "pool.getSize() - Expected pool alignment to be 1 byte.");
+    EXPECT(offset == 0,
+      "pool.getSize() - Expected offset returned to be zero.");
+
+    pool.add(bytes, 2, offset);
+
+    EXPECT(pool.getSize() == 4,
+      "pool.getSize() - Expected pool size to be 4 bytes.");
+    EXPECT(pool.getAlignment() == 2,
+      "pool.getSize() - Expected pool alignment to be 2 bytes.");
+    EXPECT(offset == 2,
+      "pool.getSize() - Expected offset returned to be 2.");
+
+    pool.add(bytes, 4, offset);
+
+    EXPECT(pool.getSize() == 8,
+      "pool.getSize() - Expected pool size to be 8 bytes.");
+    EXPECT(pool.getAlignment() == 4,
+      "pool.getSize() - Expected pool alignment to be 4 bytes.");
+    EXPECT(offset == 4,
+      "pool.getSize() - Expected offset returned to be 4.");
+
+    pool.add(bytes, 4, offset);
+
+    EXPECT(pool.getSize() == 8,
+      "pool.getSize() - Expected pool size to be 8 bytes.");
+    EXPECT(pool.getAlignment() == 4,
+      "pool.getSize() - Expected pool alignment to be 4 bytes.");
+    EXPECT(offset == 4,
+      "pool.getSize() - Expected offset returned to be 8.");
+
+    pool.add(bytes, 32, offset);
+    EXPECT(pool.getSize() == 64,
+      "pool.getSize() - Expected pool size to be 64 bytes.");
+    EXPECT(pool.getAlignment() == 32,
+      "pool.getSize() - Expected pool alignment to be 32 bytes.");
+    EXPECT(offset == 32,
+      "pool.getSize() - Expected offset returned to be 32.");
+  }
+}
+#endif // ASMJIT_TEST
+
+} // asmjit namespace
+
+// [Api-End]
+#include "../apiend.h"

libraries/asmjit/base/constpool.h

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Guard]
+#ifndef _ASMJIT_BASE_CONSTPOOL_H
+#define _ASMJIT_BASE_CONSTPOOL_H
+
+// [Dependencies - AsmJit]
+#include "../base/error.h"
+#include "../base/zone.h"
+
+// [Api-Begin]
+#include "../apibegin.h"
+
+namespace asmjit {
+
+//! \addtogroup asmjit_base_util
+//! \{
+
+// ============================================================================
+// [asmjit::ConstPoolNode]
+// ============================================================================
+
+//! \internal
+//!
+//! Zone-allocated constant-pool node.
+struct ConstPoolNode {
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE void* getData() const {
+    return static_cast<void*>(const_cast<ConstPoolNode*>(this) + 1);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Left/Right nodes.
+  ConstPoolNode* _link[2];
+  //! Horizontal level for balance.
+  uint32_t _level : 31;
+  //! Whether this constant is shared with another.
+  uint32_t _shared : 1;
+  //! Data offset from the beginning of the pool.
+  uint32_t _offset;
+};
+
+// ============================================================================
+// [asmjit::ConstPoolTree]
+// ============================================================================
+
+//! \internal
+//!
+//! Zone-allocated constant-pool tree.
+struct ConstPoolTree {
+  enum {
+    //! Maximum tree height == log2(1 << 64).
+    kHeightLimit = 64
+  };
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE ConstPoolTree(size_t dataSize = 0) :
+    _root(NULL),
+    _length(0),
+    _dataSize(dataSize) {}
+  ASMJIT_INLINE ~ConstPoolTree() {}
+
+  // --------------------------------------------------------------------------
+  // [Reset]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE void reset() {
+    _root = NULL;
+    _length = 0;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE bool isEmpty() const {
+    return _length == 0;
+  }
+
+  ASMJIT_INLINE size_t getLength() const {
+    return _length;
+  }
+
+  ASMJIT_INLINE void setDataSize(size_t dataSize) {
+    ASMJIT_ASSERT(isEmpty());
+    _dataSize = dataSize;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Ops]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_API ConstPoolNode* get(const void* data);
+  ASMJIT_API void put(ConstPoolNode* node);
+
+  // --------------------------------------------------------------------------
+  // [Iterate]
+  // --------------------------------------------------------------------------
+
+  template<typename Visitor>
+  ASMJIT_INLINE void iterate(Visitor& visitor) const {
+    ConstPoolNode* node = const_cast<ConstPoolNode*>(_root);
+    ConstPoolNode* link;
+
+    ConstPoolNode* stack[kHeightLimit];
+
+    if (node == NULL)
+      return;
+
+    size_t top = 0;
+
+    for (;;) {
+      link = node->_link[0];
+
+      if (link != NULL) {
+        ASMJIT_ASSERT(top != kHeightLimit);
+        stack[top++] = node;
+        continue;
+      }
+
+      visitor.visit(node);
+      link = node->_link[1];
+
+      if (link != NULL) {
+        node = link;
+        continue;
+      }
+
+      if (top == 0)
+        break;
+
+      node = stack[--top];
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  // [Helpers]
+  // --------------------------------------------------------------------------
+
+  static ASMJIT_INLINE ConstPoolNode* _newNode(Zone* zone, const void* data, size_t size, size_t offset, bool shared) {
+    ConstPoolNode* node = zone->allocT<ConstPoolNode>(sizeof(ConstPoolNode) + size);
+    if (node == NULL)
+      return NULL;
+
+    node->_link[0] = NULL;
+    node->_link[1] = NULL;
+    node->_level = 1;
+    node->_shared = shared;
+    node->_offset = static_cast<uint32_t>(offset);
+
+    ::memcpy(node->getData(), data, size);
+    return node;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Root of the tree
+  ConstPoolNode* _root;
+  //! Length of the tree (count of nodes).
+  size_t _length;
+  //! Size of the data.
+  size_t _dataSize;
+};
+
+// ============================================================================
+// [asmjit::ConstPoolGap]
+// ============================================================================
+
+//! \internal
+//!
+//! Zone-allocated constant-pool gap.
+struct ConstPoolGap {
+  //! Link to the next gap
+  ConstPoolGap* _next;
+  //! Offset of the gap.
+  size_t _offset;
+  //! Remaining bytes of the gap (basically a gap size).
+  size_t _length;
+};
+
+// ============================================================================
+// [asmjit::ConstPool]
+// ============================================================================
+
+//! Constant pool.
+struct ConstPool {
+  ASMJIT_NO_COPY(ConstPool)
+
+  enum {
+    kIndex1 = 0,
+    kIndex2 = 1,
+    kIndex4 = 2,
+    kIndex8 = 3,
+    kIndex16 = 4,
+    kIndex32 = 5,
+    kIndexCount = 6
+  };
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_API ConstPool(Zone* zone);
+  ASMJIT_API ~ConstPool();
+
+  // --------------------------------------------------------------------------
+  // [Reset]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_API void reset();
+
+  // --------------------------------------------------------------------------
+  // [Ops]
+  // --------------------------------------------------------------------------
+
+  //! Get whether the constant-pool is empty.
+  ASMJIT_INLINE bool isEmpty() const {
+    return _size == 0;
+  }
+
+  //! Get the size of the constant-pool in bytes.
+  ASMJIT_INLINE size_t getSize() const {
+    return _size;
+  }
+
+  //! Get minimum alignment.
+  ASMJIT_INLINE size_t getAlignment() const {
+    return _alignment;
+  }
+
+  //! Add a constant to the constant pool.
+  //!
+  //! The constant must have known size, which is 1, 2, 4, 8, 16 or 32 bytes.
+  //! The constant is added to the pool only if it doesn't not exist, otherwise
+  //! cached value is returned.
+  //!
+  //! AsmJit is able to subdivide added constants, so for example if you add
+  //! 8-byte constant 0x1122334455667788 it will create the following slots:
+  //!
+  //!   8-byte: 0x1122334455667788
+  //!   4-byte: 0x11223344, 0x55667788
+  //!
+  //! The reason is that when combining MMX/SSE/AVX code some patterns are used
+  //! frequently. However, AsmJit is not able to reallocate a constant that has
+  //! been already added. For example if you try to add 4-byte constant and then
+  //! 8-byte constant having the same 4-byte pattern as the previous one, two
+  //! independent slots will be generated by the pool.
+  ASMJIT_API Error add(const void* data, size_t size, size_t& dstOffset);
+
+  // --------------------------------------------------------------------------
+  // [Fill]
+  // --------------------------------------------------------------------------
+
+  //! Fill the destination with the constants from the pool.
+  ASMJIT_API void fill(void* dst);
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Zone allocator.
+  Zone* _zone;
+  //! Tree per size.
+  ConstPoolTree _tree[kIndexCount];
+  //! Gaps per size.
+  ConstPoolGap* _gaps[kIndexCount];
+  //! Gaps pool
+  ConstPoolGap* _gapPool;
+
+  //! Size of the pool (in bytes).
+  size_t _size;
+  //! Alignemnt.
+  size_t _alignment;
+};
+
+//! \}
+
+} // asmjit namespace
+
+// [Api-End]
+#include "../apiend.h"
+
+// [Guard]
+#endif // _ASMJIT_BASE_CONSTPOOL_H

libraries/asmjit/base/containers.cpp

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Export]
+#define ASMJIT_EXPORTS
+
+// [Dependencies - AsmJit]
+#include "../base/containers.h"
+#include "../base/intutil.h"
+
+// [Api-Begin]
+#include "../apibegin.h"
+
+namespace asmjit {
+
+// ============================================================================
+// [asmjit::PodVectorBase - NullData]
+// ============================================================================
+
+const PodVectorData PodVectorBase::_nullData = { 0, 0 };
+
+// ============================================================================
+// [asmjit::PodVectorBase - Reset]
+// ============================================================================
+
+//! Clear vector data and free internal buffer.
+void PodVectorBase::reset(bool releaseMemory) {
+  PodVectorData* d = _d;
+
+  if (d == &_nullData)
+    return;
+
+  if (releaseMemory) {
+    ASMJIT_FREE(d);
+    _d = const_cast<PodVectorData*>(&_nullData);
+    return;
+  }
+
+  d->length = 0;
+}
+
+// ============================================================================
+// [asmjit::PodVectorBase - Helpers]
+// ============================================================================
+
+Error PodVectorBase::_grow(size_t n, size_t sizeOfT) {
+  PodVectorData* d = _d;
+
+  size_t threshold = kMemAllocGrowMax / sizeOfT;
+  size_t capacity = d->capacity;
+  size_t after = d->length;
+
+  if (IntUtil::maxUInt<size_t>() - n < after)
+    return kErrorNoHeapMemory;
+
+  after += n;
+
+  if (capacity >= after)
+    return kErrorOk;
+
+  // PodVector is used as a linear array for some data structures used by
+  // AsmJit code generation. The purpose of this agressive growing schema
+  // is to minimize memory reallocations, because AsmJit code generation
+  // classes live short life and will be freed or reused soon.
+  if (capacity < 32)
+    capacity = 32;
+  else if (capacity < 128)
+    capacity = 128;
+  else if (capacity < 512)
+    capacity = 512;
+
+  while (capacity < after) {
+    if (capacity < threshold)
+      capacity *= 2;
+    else
+      capacity += threshold;
+  }
+
+  return _reserve(capacity, sizeOfT);
+}
+
+Error PodVectorBase::_reserve(size_t n, size_t sizeOfT) {
+  PodVectorData* d = _d;
+
+  if (d->capacity >= n)
+    return kErrorOk;
+
+  size_t nBytes = sizeof(PodVectorData) + n * sizeOfT;
+  if (nBytes < n)
+    return kErrorNoHeapMemory;
+
+  if (d == &_nullData) {
+    d = static_cast<PodVectorData*>(ASMJIT_ALLOC(nBytes));
+    if (d == NULL)
+      return kErrorNoHeapMemory;
+    d->length = 0;
+  }
+  else {
+    d = static_cast<PodVectorData*>(ASMJIT_REALLOC(d, nBytes));
+    if (d == NULL)
+      return kErrorNoHeapMemory;
+  }
+
+  d->capacity = n;
+  _d = d;
+
+  return kErrorOk;
+}
+
+} // asmjit namespace
+
+// [Api-End]
+#include "../apiend.h"

libraries/asmjit/base/containers.h

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Guard]
+#ifndef _ASMJIT_BASE_CONTAINERS_H
+#define _ASMJIT_BASE_CONTAINERS_H
+
+// [Dependencies - AsmJit]
+#include "../base/error.h"
+#include "../base/globals.h"
+
+// [Api-Begin]
+#include "../apibegin.h"
+
+namespace asmjit {
+
+//! \addtogroup asmjit_base_util
+//! \{
+
+// ============================================================================
+// [asmjit::PodVectorData]
+// ============================================================================
+
+//! \internal
+struct PodVectorData {
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get data.
+  ASMJIT_INLINE void* getData() const {
+    return (void*)(this + 1);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Capacity of the vector.
+  size_t capacity;
+  //! Length of the vector.
+  size_t length;
+};
+
+// ============================================================================
+// [asmjit::PodVectorBase]
+// ============================================================================
+
+//! \internal
+struct PodVectorBase {
+  static ASMJIT_API const PodVectorData _nullData;
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new instance of `PodVectorBase`.
+  ASMJIT_INLINE PodVectorBase() :
+    _d(const_cast<PodVectorData*>(&_nullData)) {}
+
+  //! Destroy the `PodVectorBase` and data.
+  ASMJIT_INLINE ~PodVectorBase() {
+    reset(true);
+  }
+
+  // --------------------------------------------------------------------------
+  // [Reset]
+  // --------------------------------------------------------------------------
+
+  //! Reset the vector data and set its `length` to zero.
+  //!
+  //! If `releaseMemory` is true the vector buffer will be released to the
+  //! system.
+  ASMJIT_API void reset(bool releaseMemory = false);
+
+  // --------------------------------------------------------------------------
+  // [Grow / Reserve]
+  // --------------------------------------------------------------------------
+
+protected:
+  ASMJIT_API Error _grow(size_t n, size_t sizeOfT);
+  ASMJIT_API Error _reserve(size_t n, size_t sizeOfT);
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+public:
+  PodVectorData* _d;
+};
+
+// ============================================================================
+// [asmjit::PodVector<T>]
+// ============================================================================
+
+//! Template used to store and manage array of POD data.
+//!
+//! This template has these adventages over other vector<> templates:
+//! - Non-copyable (designed to be non-copyable, we want it)
+//! - No copy-on-write (some implementations of stl can use it)
+//! - Optimized for working only with POD types
+//! - Uses ASMJIT_... memory management macros
+template <typename T>
+struct PodVector : PodVectorBase {
+  ASMJIT_NO_COPY(PodVector<T>)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  //! Create a new instance of `PodVector<T>`.
+  ASMJIT_INLINE PodVector() {}
+  //! Destroy the `PodVector<>` and data.
+  ASMJIT_INLINE ~PodVector() {}
+
+  // --------------------------------------------------------------------------
+  // [Data]
+  // --------------------------------------------------------------------------
+
+  //! Get whether the vector is empty.
+  ASMJIT_INLINE bool isEmpty() const {
+    return _d->length == 0;
+  }
+
+  //! Get length.
+  ASMJIT_INLINE size_t getLength() const {
+    return _d->length;
+  }
+
+  //! Get capacity.
+  ASMJIT_INLINE size_t getCapacity() const {
+    return _d->capacity;
+  }
+
+  //! Get data.
+  ASMJIT_INLINE T* getData() {
+    return static_cast<T*>(_d->getData());
+  }
+
+  //! \overload
+  ASMJIT_INLINE const T* getData() const {
+    return static_cast<const T*>(_d->getData());
+  }
+
+  // --------------------------------------------------------------------------
+  // [Grow / Reserve]
+  // --------------------------------------------------------------------------
+
+  //! Called to grow the buffer to fit at least `n` elements more.
+  ASMJIT_INLINE Error _grow(size_t n) {
+    return PodVectorBase::_grow(n, sizeof(T));
+  }
+
+  //! Realloc internal array to fit at least `n` items.
+  ASMJIT_INLINE Error _reserve(size_t n) {
+    return PodVectorBase::_reserve(n, sizeof(T));
+  }
+
+  // --------------------------------------------------------------------------
+  // [Ops]
+  // --------------------------------------------------------------------------
+
+  //! Prepend `item` to vector.
+  Error prepend(const T& item) {
+    PodVectorData* d = _d;
+
+    if (d->length == d->capacity) {
+      ASMJIT_PROPAGATE_ERROR(_grow(1));
+      _d = d;
+    }
+
+    ::memmove(static_cast<T*>(d->getData()) + 1, d->getData(), d->length * sizeof(T));
+    ::memcpy(d->getData(), &item, sizeof(T));
+
+    d->length++;
+    return kErrorOk;
+  }
+
+  //! Insert an `item` at the `index`.
+  Error insert(size_t index, const T& item) {
+    PodVectorData* d = _d;
+    ASMJIT_ASSERT(index <= d->length);
+
+    if (d->length == d->capacity) {
+      ASMJIT_PROPAGATE_ERROR(_grow(1));
+      d = _d;
+    }
+
+    T* dst = static_cast<T*>(d->getData()) + index;
+    ::memmove(dst + 1, dst, d->length - index);
+    ::memcpy(dst, &item, sizeof(T));
+
+    d->length++;
+    return kErrorOk;
+  }
+
+  //! Append `item` to vector.
+  Error append(const T& item) {
+    PodVectorData* d = _d;
+
+    if (d->length == d->capacity) {
+      ASMJIT_PROPAGATE_ERROR(_grow(1));
+      d = _d;
+    }
+
+    ::memcpy(static_cast<T*>(d->getData()) + d->length, &item, sizeof(T));
+
+    d->length++;
+    return kErrorOk;
+  }
+
+  //! Get index of `val` or `kInvalidIndex` if not found.
+  size_t indexOf(const T& val) const {
+    PodVectorData* d = _d;
+
+    const T* data = static_cast<const T*>(d->getData());
+    size_t len = d->length;
+
+    for (size_t i = 0; i < len; i++)
+      if (data[i] == val)
+        return i;
+
+    return kInvalidIndex;
+  }
+
+  //! Remove item at index `i`.
+  void removeAt(size_t i) {
+    PodVectorData* d = _d;
+    ASMJIT_ASSERT(i < d->length);
+
+    T* data = static_cast<T*>(d->getData()) + i;
+    d->length--;
+    ::memmove(data, data + 1, d->length - i);
+  }
+
+  //! Swap this pod-vector with `other`.
+  void swap(PodVector<T>& other) {
+    T* otherData = other._d;
+    other._d = _d;
+    _d = otherData;
+  }
+
+  //! Get item at index `i`.
+  ASMJIT_INLINE T& operator[](size_t i) {
+    ASMJIT_ASSERT(i < getLength());
+    return getData()[i];
+  }
+
+  //! Get item at index `i`.
+  ASMJIT_INLINE const T& operator[](size_t i) const {
+    ASMJIT_ASSERT(i < getLength());
+    return getData()[i];
+  }
+};
+
+// ============================================================================
+// [asmjit::PodList<T>]
+// ============================================================================
+
+//! \internal
+template <typename T>
+struct PodList {
+  ASMJIT_NO_COPY(PodList<T>)
+
+  // --------------------------------------------------------------------------
+  // [Link]
+  // --------------------------------------------------------------------------
+
+  struct Link {
+    // --------------------------------------------------------------------------
+    // [Accessors]
+    // --------------------------------------------------------------------------
+
+    //! Get next node.
+    ASMJIT_INLINE Link* getNext() const { return _next; }
+
+    //! Get value.
+    ASMJIT_INLINE T getValue() const { return _value; }
+    //! Set value to `value`.
+    ASMJIT_INLINE void setValue(const T& value) { _value = value; }
+
+    // --------------------------------------------------------------------------
+    // [Members]
+    // --------------------------------------------------------------------------
+
+    Link* _next;
+    T _value;
+  };
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE PodList() : _first(NULL), _last(NULL) {}
+  ASMJIT_INLINE ~PodList() {}
+
+  // --------------------------------------------------------------------------
+  // [Data]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE bool isEmpty() const { return _first != NULL; }
+
+  ASMJIT_INLINE Link* getFirst() const { return _first; }
+  ASMJIT_INLINE Link* getLast() const { return _last; }
+
+  // --------------------------------------------------------------------------
+  // [Ops]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE void reset() {
+    _first = NULL;
+    _last = NULL;
+  }
+
+  ASMJIT_INLINE void prepend(Link* link) {
+    link->_next = _first;
+    if (_first == NULL)
+      _last = link;
+    _first = link;
+  }
+
+  ASMJIT_INLINE void append(Link* link) {
+    link->_next = NULL;
+    if (_first == NULL)
+      _first = link;
+    else
+      _last->_next = link;
+    _last = link;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  Link* _first;
+  Link* _last;
+};
+
+//! \}
+
+} // asmjit namespace
+
+// [Api-End]
+#include "../apiend.h"
+
+// [Guard]
+#endif // _ASMJIT_BASE_CONTAINERS_H

libraries/asmjit/base/context.cpp

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Export]
+#define ASMJIT_EXPORTS
+
+// [Guard]
+#include "../build.h"
+#if !defined(ASMJIT_DISABLE_COMPILER)
+
+// [Dependencies - AsmJit]
+#include "../base/context_p.h"
+#include "../base/intutil.h"
+
+// [Api-Begin]
+#include "../apibegin.h"
+
+namespace asmjit {
+
+// ============================================================================
+// [asmjit::Context - Construction / Destruction]
+// ============================================================================
+
+Context::Context(Compiler* compiler) :
+  _compiler(compiler),
+  _varMapToVaListOffset(0),
+  _baseZone(8192 - kZoneOverhead) {
+
+  Context::reset();
+}
+
+Context::~Context() {}
+
+// ============================================================================
+// [asmjit::Context - Reset]
+// ============================================================================
+
+void Context::reset(bool releaseMemory) {
+  _baseZone.reset(releaseMemory);
+
+  _func = NULL;
+  _start = NULL;
+  _end = NULL;
+  _extraBlock = NULL;
+  _stop = NULL;
+
+  _unreachableList.reset();
+  _jccList.reset();
+  _contextVd.reset(releaseMemory);
+
+  _memVarCells = NULL;
+  _memStackCells = NULL;
+
+  _mem1ByteVarsUsed = 0;
+  _mem2ByteVarsUsed = 0;
+  _mem4ByteVarsUsed = 0;
+  _mem8ByteVarsUsed = 0;
+  _mem16ByteVarsUsed = 0;
+  _mem32ByteVarsUsed = 0;
+  _mem64ByteVarsUsed = 0;
+  _memStackCellsUsed = 0;
+
+  _memMaxAlign = 0;
+  _memVarTotal = 0;
+  _memStackTotal = 0;
+  _memAllTotal = 0;
+  _annotationLength = 12;
+
+  _state = NULL;
+}
+
+// ============================================================================
+// [asmjit::Context - Mem]
+// ============================================================================
+
+static ASMJIT_INLINE uint32_t BaseContext_getDefaultAlignment(uint32_t size) {
+  if (size > 32)
+    return 64;
+  else if (size > 16)
+    return 32;
+  else if (size > 8)
+    return 16;
+  else if (size > 4)
+    return 8;
+  else if (size > 2)
+    return 4;
+  else if (size > 1)
+    return 2;
+  else
+    return 1;
+}
+
+MemCell* Context::_newVarCell(VarData* vd) {
+  ASMJIT_ASSERT(vd->_memCell == NULL);
+
+  MemCell* cell;
+  uint32_t size = vd->getSize();
+
+  if (vd->isStack()) {
+    cell = _newStackCell(size, vd->getAlignment());
+
+    if (cell == NULL)
+      return NULL;
+  }
+  else {
+    cell = static_cast<MemCell*>(_baseZone.alloc(sizeof(MemCell)));
+    if (cell == NULL)
+      goto _NoMemory;
+
+    cell->_next = _memVarCells;
+    _memVarCells = cell;
+
+    cell->_offset = 0;
+    cell->_size = size;
+    cell->_alignment = size;
+
+    _memMaxAlign = IntUtil::iMax<uint32_t>(_memMaxAlign, size);
+    _memVarTotal += size;
+
+    switch (size) {
+      case  1: _mem1ByteVarsUsed++ ; break;
+      case  2: _mem2ByteVarsUsed++ ; break;
+      case  4: _mem4ByteVarsUsed++ ; break;
+      case  8: _mem8ByteVarsUsed++ ; break;
+      case 16: _mem16ByteVarsUsed++; break;
+      case 32: _mem32ByteVarsUsed++; break;
+      case 64: _mem64ByteVarsUsed++; break;
+      default: ASMJIT_ASSERT(!"Reached");
+    }
+  }
+
+  vd->_memCell = cell;
+  return cell;
+
+_NoMemory:
+  _compiler->setError(kErrorNoHeapMemory);
+  return NULL;
+}
+
+MemCell* Context::_newStackCell(uint32_t size, uint32_t alignment) {
+  MemCell* cell = static_cast<MemCell*>(_baseZone.alloc(sizeof(MemCell)));
+  if (cell == NULL)
+    goto _NoMemory;
+
+  if (alignment == 0)
+    alignment = BaseContext_getDefaultAlignment(size);
+
+  if (alignment > 64)
+    alignment = 64;
+
+  ASMJIT_ASSERT(IntUtil::isPowerOf2(alignment));
+  size = IntUtil::alignTo<uint32_t>(size, alignment);
+
+  // Insert it sorted according to the alignment and size.
+  {
+    MemCell** pPrev = &_memStackCells;
+    MemCell* cur = *pPrev;
+
+    for (cur = *pPrev; cur != NULL; cur = cur->_next) {
+      if (cur->getAlignment() > alignment)
+        continue;
+      if (cur->getAlignment() == alignment && cur->getSize() > size)
+        continue;
+      break;
+    }
+
+    cell->_next = cur;
+    cell->_offset = 0;
+    cell->_size = size;
+    cell->_alignment = alignment;
+
+    *pPrev = cell;
+    _memStackCellsUsed++;
+
+    _memMaxAlign = IntUtil::iMax<uint32_t>(_memMaxAlign, alignment);
+    _memStackTotal += size;
+  }
+
+  return cell;
+
+_NoMemory:
+  _compiler->setError(kErrorNoHeapMemory);
+  return NULL;
+}
+
+Error Context::resolveCellOffsets() {
+  MemCell* varCell = _memVarCells;
+  MemCell* stackCell = _memStackCells;
+
+  uint32_t stackAlignment = 0;
+  if (stackCell != NULL)
+    stackAlignment = stackCell->getAlignment();
+
+  uint32_t pos64 = 0;
+  uint32_t pos32 = pos64 + _mem64ByteVarsUsed * 64;
+  uint32_t pos16 = pos32 + _mem32ByteVarsUsed * 32;
+  uint32_t pos8  = pos16 + _mem16ByteVarsUsed * 16;
+  uint32_t pos4  = pos8  + _mem8ByteVarsUsed  * 8 ;
+  uint32_t pos2  = pos4  + _mem4ByteVarsUsed  * 4 ;
+  uint32_t pos1  = pos2  + _mem2ByteVarsUsed  * 2 ;
+
+  uint32_t stackPos = pos1 + _mem1ByteVarsUsed;
+
+  uint32_t gapAlignment = stackAlignment;
+  uint32_t gapSize = 0;
+
+  if (gapAlignment)
+    IntUtil::deltaTo(stackPos, gapAlignment);
+  stackPos += gapSize;
+
+  uint32_t gapPos = stackPos;
+  uint32_t allTotal = stackPos;
+
+  // Vars - Allocated according to alignment/width.
+  while (varCell != NULL) {
+    uint32_t size = varCell->getSize();
+    uint32_t offset;
+
+    switch (size) {
+      case  1: offset = pos1 ; pos1  += 1 ; break;
+      case  2: offset = pos2 ; pos2  += 2 ; break;
+      case  4: offset = pos4 ; pos4  += 4 ; break;
+      case  8: offset = pos8 ; pos8  += 8 ; break;
+      case 16: offset = pos16; pos16 += 16; break;
+      case 32: offset = pos32; pos32 += 32; break;
+      case 64: offset = pos64; pos64 += 64; break;
+      default: ASMJIT_ASSERT(!"Reached");
+    }
+
+    varCell->setOffset(static_cast<int32_t>(offset));
+    varCell = varCell->_next;
+  }
+
+  // Stack - Allocated according to alignment and width.
+  while (stackCell != NULL) {
+    uint32_t size = stackCell->getSize();
+    uint32_t alignment = stackCell->getAlignment();
+    uint32_t offset;
+
+    // Try to fill the gap between variables / stack first.
+    if (size <= gapSize && alignment <= gapAlignment) {
+      offset = gapPos;
+
+      gapSize -= size;
+      gapPos -= size;
+
+      if (alignment < gapAlignment)
+        gapAlignment = alignment;
+    }
+    else {
+      offset = stackPos;
+
+      stackPos += size;
+      allTotal += size;
+    }
+
+    stackCell->setOffset(offset);
+    stackCell = stackCell->_next;
+  }
+
+  _memAllTotal = allTotal;
+  return kErrorOk;
+}
+
+// ============================================================================
+// [asmjit::Context - RemoveUnreachableCode]
+// ============================================================================
+
+Error Context::removeUnreachableCode() {
+  PodList<Node*>::Link* link = _unreachableList.getFirst();
+  Node* stop = getStop();
+
+  while (link != NULL) {
+    Node* node = link->getValue();
+    if (node != NULL && node->getPrev() != NULL) {
+      // Locate all unreachable nodes.
+      Node* first = node;
+      do {
+        if (node->isFetched())
+          break;
+        node = node->getNext();
+      } while (node != stop);
+
+      // Remove.
+      if (node != first) {
+        Node* last = (node != NULL) ? node->getPrev() : getCompiler()->getLastNode();
+        getCompiler()->removeNodes(first, last);
+      }
+    }
+
+    link = link->getNext();
+  }
+
+  return kErrorOk;
+}
+
+// ============================================================================
+// [asmjit::Context - Liveness Analysis]
+// ============================================================================
+
+//! \internal
+struct LivenessTarget {
+  //! Previous target.
+  LivenessTarget* prev;
+
+  //! Target node.
+  TargetNode* node;
+  //! Jumped from.
+  JumpNode* from;
+};
+
+Error Context::livenessAnalysis() {
+  FuncNode* func = getFunc();
+  JumpNode* from = NULL;
+
+  Node* node = func->getEnd();
+  uint32_t bLen = static_cast<uint32_t>(
+    ((_contextVd.getLength() + VarBits::kEntityBits - 1) / VarBits::kEntityBits));
+
+  LivenessTarget* ltCur = NULL;
+  LivenessTarget* ltUnused = NULL;
+
+  size_t varMapToVaListOffset = _varMapToVaListOffset;
+
+  // No variables.
+  if (bLen == 0)
+    return kErrorOk;
+
+  VarBits* bCur = newBits(bLen);
+  if (bCur == NULL)
+    goto _NoMemory;
+
+  // Allocate bits for code visited first time.
+_OnVisit:
+  for (;;) {
+    if (node->hasLiveness()) {
+      if (bCur->_addBitsDelSource(node->getLiveness(), bCur, bLen))
+        goto _OnPatch;
+      else
+        goto _OnDone;
+    }
+
+    VarBits* bTmp = copyBits(bCur, bLen);
+    if (bTmp == NULL)
+      goto _NoMemory;
+
+    node->setLiveness(bTmp);
+    VarMap* map = node->getMap();
+
+    if (map != NULL) {
+      uint32_t vaCount = map->getVaCount();
+      VarAttr* vaList = reinterpret_cast<VarAttr*>(((uint8_t*)map) + varMapToVaListOffset);
+
+      for (uint32_t i = 0; i < vaCount; i++) {
+        VarAttr* va = &vaList[i];
+        VarData* vd = va->getVd();
+
+        uint32_t flags = va->getFlags();
+        uint32_t ctxId = vd->getContextId();
+
+        if ((flags & kVarAttrOutAll) && !(flags & kVarAttrInAll)) {
+          // Write-Only.
+          bTmp->setBit(ctxId);
+          bCur->delBit(ctxId);
+        }
+        else {
+          // Read-Only or Read/Write.
+          bTmp->setBit(ctxId);
+          bCur->setBit(ctxId);
+        }
+      }
+    }
+
+    if (node->getType() == kNodeTypeTarget)
+      goto _OnTarget;
+
+    if (node == func)
+      goto _OnDone;
+
+    ASMJIT_ASSERT(node->getPrev());
+    node = node->getPrev();
+  }
+
+  // Patch already generated liveness bits.
+_OnPatch:
+  for (;;) {
+    ASMJIT_ASSERT(node->hasLiveness());
+    VarBits* bNode = node->getLiveness();
+
+    if (!bNode->_addBitsDelSource(bCur, bLen))
+      goto _OnDone;
+
+    if (node->getType() == kNodeTypeTarget)
+      goto _OnTarget;
+
+    if (node == func)
+      goto _OnDone;
+
+    node = node->getPrev();
+  }
+
+_OnTarget:
+  if (static_cast<TargetNode*>(node)->getNumRefs() != 0) {
+    // Push a new LivenessTarget onto the stack if needed.
+    if (ltCur == NULL || ltCur->node != node) {
+      // Allocate a new LivenessTarget object (from pool or zone).
+      LivenessTarget* ltTmp = ltUnused;
+
+      if (ltTmp != NULL) {
+        ltUnused = ltUnused->prev;
+      }
+      else {
+        ltTmp = _baseZone.allocT<LivenessTarget>(
+          sizeof(LivenessTarget) - sizeof(VarBits) + bLen * sizeof(uintptr_t));
+
+        if (ltTmp == NULL)
+          goto _NoMemory;
+      }
+
+      // Initialize and make current - ltTmp->from will be set later on.
+      ltTmp->prev = ltCur;
+      ltTmp->node = static_cast<TargetNode*>(node);
+      ltCur = ltTmp;
+
+      from = static_cast<TargetNode*>(node)->getFrom();
+      ASMJIT_ASSERT(from != NULL);
+    }
+    else {
+      from = ltCur->from;
+      goto _OnJumpNext;
+    }
+
+    // Visit/Patch.
+    do {
+      ltCur->from = from;
+      bCur->copyBits(node->getLiveness(), bLen);
+
+      if (!from->hasLiveness()) {
+        node = from;
+        goto _OnVisit;
+      }
+
+      // Issue #25: Moved '_OnJumpNext' here since it's important to patch
+      // code again if there are more live variables than before.
+_OnJumpNext:
+      if (bCur->delBits(from->getLiveness(), bLen)) {
+        node = from;
+        goto _OnPatch;
+      }
+
+      from = from->getJumpNext();
+    } while (from != NULL);
+
+    // Pop the current LivenessTarget from the stack.
+    {
+      LivenessTarget* ltTmp = ltCur;
+
+      ltCur = ltCur->prev;
+      ltTmp->prev = ltUnused;
+      ltUnused = ltTmp;
+    }
+  }
+
+  bCur->copyBits(node->getLiveness(), bLen);
+  node = node->getPrev();
+
+  if (node->isJmp() || !node->isFetched())
+    goto _OnDone;
+
+  if (!node->hasLiveness())
+    goto _OnVisit;
+
+  if (bCur->delBits(node->getLiveness(), bLen))
+    goto _OnPatch;
+
+_OnDone:
+  if (ltCur != NULL) {
+    node = ltCur->node;
+    from = ltCur->from;
+
+    goto _OnJumpNext;
+  }
+  return kErrorOk;
+
+_NoMemory:
+  return setError(kErrorNoHeapMemory);
+}
+
+// ============================================================================
+// [asmjit::Context - Schedule]
+// ============================================================================
+
+Error Context::schedule() {
+  // By default there is no instruction scheduler implemented.
+  return kErrorOk;
+}
+
+// ============================================================================
+// [asmjit::Context - Cleanup]
+// ============================================================================
+
+void Context::cleanup() {
+  VarData** array = _contextVd.getData();
+  size_t length = _contextVd.getLength();
+
+  for (size_t i = 0; i < length; i++) {
+    VarData* vd = array[i];
+    vd->resetContextId();
+    vd->resetRegIndex();
+  }
+
+  _contextVd.reset(false);
+  _extraBlock = NULL;
+}
+
+// ============================================================================
+// [asmjit::Context - CompileFunc]
+// ============================================================================
+
+Error Context::compile(FuncNode* func) {
+  Node* end = func->getEnd();
+  Node* stop = end->getNext();
+
+  _func = func;
+  _stop = stop;
+  _extraBlock = end;
+
+  ASMJIT_PROPAGATE_ERROR(fetch());
+  ASMJIT_PROPAGATE_ERROR(removeUnreachableCode());
+  ASMJIT_PROPAGATE_ERROR(livenessAnalysis());
+
+  Compiler* compiler = getCompiler();
+
+#if !defined(ASMJIT_DISABLE_LOGGER)
+  if (compiler->hasLogger())
+    ASMJIT_PROPAGATE_ERROR(annotate());
+#endif // !ASMJIT_DISABLE_LOGGER
+
+  ASMJIT_PROPAGATE_ERROR(translate());
+
+  if (compiler->hasFeature(kCodeGenEnableScheduler))
+    ASMJIT_PROPAGATE_ERROR(schedule());
+
+  // We alter the compiler cursor, because it doesn't make sense to reference
+  // it after compilation - some nodes may disappear and it's forbidden to add
+  // new code after the compilation is done.
+  compiler->_setCursor(NULL);
+
+  return kErrorOk;
+}
+
+} // asmjit namespace
+
+// [Api-End]
+#include "../apiend.h"
+
+// [Guard]
+#endif // !ASMJIT_DISABLE_COMPILER

libraries/asmjit/base/context_p.h

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Guard]
+#ifndef _ASMJIT_BASE_CONTEXT_P_H
+#define _ASMJIT_BASE_CONTEXT_P_H
+
+#include "../build.h"
+#if !defined(ASMJIT_DISABLE_COMPILER)
+
+// [Dependencies - AsmJit]
+#include "../base/compiler.h"
+#include "../base/zone.h"
+
+// [Api-Begin]
+#include "../apibegin.h"
+
+namespace asmjit {
+
+//! \addtogroup asmjit_base_compiler
+//! \{
+
+// ============================================================================
+// [asmjit::Context]
+// ============================================================================
+
+//! \internal
+//!
+//! Code generation context is the logic behind `Compiler`. The context is
+//! used to compile the code stored in `Compiler`.
+struct Context {
+  ASMJIT_NO_COPY(Context)
+
+  // --------------------------------------------------------------------------
+  // [Construction / Destruction]
+  // --------------------------------------------------------------------------
+
+  Context(Compiler* compiler);
+  virtual ~Context();
+
+  // --------------------------------------------------------------------------
+  // [Reset]
+  // --------------------------------------------------------------------------
+
+  //! Reset the whole context.
+  virtual void reset(bool releaseMemory = false);
+
+  // --------------------------------------------------------------------------
+  // [Accessors]
+  // --------------------------------------------------------------------------
+
+  //! Get compiler.
+  ASMJIT_INLINE Compiler* getCompiler() const { return _compiler; }
+
+  //! Get function.
+  ASMJIT_INLINE FuncNode* getFunc() const { return _func; }
+  //! Get stop node.
+  ASMJIT_INLINE Node* getStop() const { return _stop; }
+
+  //! Get start of the current scope.
+  ASMJIT_INLINE Node* getStart() const { return _start; }
+  //! Get end of the current scope.
+  ASMJIT_INLINE Node* getEnd() const { return _end; }
+
+  //! Get extra block.
+  ASMJIT_INLINE Node* getExtraBlock() const { return _extraBlock; }
+  //! Set extra block.
+  ASMJIT_INLINE void setExtraBlock(Node* node) { _extraBlock = node; }
+
+  // --------------------------------------------------------------------------
+  // [Error]
+  // --------------------------------------------------------------------------
+
+  //! Get the last error code.
+  ASMJIT_INLINE Error getError() const {
+    return getCompiler()->getError();
+  }
+
+  //! Set the last error code and propagate it through the error handler.
+  ASMJIT_INLINE Error setError(Error error, const char* message = NULL) {
+    return getCompiler()->setError(error, message);
+  }
+
+  // --------------------------------------------------------------------------
+  // [State]
+  // --------------------------------------------------------------------------
+
+  //! Get current state.
+  ASMJIT_INLINE VarState* getState() const {
+    return _state;
+  }
+
+  //! Load current state from `target` state.
+  virtual void loadState(VarState* src) = 0;
+
+  //! Save current state, returning new `VarState` instance.
+  virtual VarState* saveState() = 0;
+
+  //! Change the current state to `target` state.
+  virtual void switchState(VarState* src) = 0;
+
+  //! Change the current state to the intersection of two states `a` and `b`.
+  virtual void intersectStates(VarState* a, VarState* b) = 0;
+
+  // --------------------------------------------------------------------------
+  // [Context]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE Error _registerContextVar(VarData* vd) {
+    if (vd->hasContextId())
+      return kErrorOk;
+
+    uint32_t cid = static_cast<uint32_t>(_contextVd.getLength());
+    ASMJIT_PROPAGATE_ERROR(_contextVd.append(vd));
+
+    vd->setContextId(cid);
+    return kErrorOk;
+  }
+
+  // --------------------------------------------------------------------------
+  // [Mem]
+  // --------------------------------------------------------------------------
+
+  MemCell* _newVarCell(VarData* vd);
+  MemCell* _newStackCell(uint32_t size, uint32_t alignment);
+
+  ASMJIT_INLINE MemCell* getVarCell(VarData* vd) {
+    MemCell* cell = vd->getMemCell();
+    return cell ? cell : _newVarCell(vd);
+  }
+
+  virtual Error resolveCellOffsets();
+
+  // --------------------------------------------------------------------------
+  // [Bits]
+  // --------------------------------------------------------------------------
+
+  ASMJIT_INLINE VarBits* newBits(uint32_t len) {
+    return static_cast<VarBits*>(
+      _baseZone.allocZeroed(static_cast<size_t>(len) * VarBits::kEntitySize));
+  }
+
+  ASMJIT_INLINE VarBits* copyBits(const VarBits* src, uint32_t len) {
+    return static_cast<VarBits*>(
+      _baseZone.dup(src, static_cast<size_t>(len) * VarBits::kEntitySize));
+  }
+
+  // --------------------------------------------------------------------------
+  // [Fetch]
+  // --------------------------------------------------------------------------
+
+  //! Fetch.
+  //!
+  //! Fetch iterates over all nodes and gathers information about all variables
+  //! used. The process generates information required by register allocator,
+  //! variable liveness analysis and translator.
+  virtual Error fetch() = 0;
+
+  // --------------------------------------------------------------------------
+  // [RemoveUnreachableCode]
+  // --------------------------------------------------------------------------
+
+  //! Remove unreachable code.
+  virtual Error removeUnreachableCode();
+
+  // --------------------------------------------------------------------------
+  // [Analyze]
+  // --------------------------------------------------------------------------
+
+  //! Perform variable liveness analysis.
+  //!
+  //! Analysis phase iterates over nodes in reverse order and generates a bit
+  //! array describing variables that are alive at every node in the function.
+  //! When the analysis start all variables are assumed dead. When a read or
+  //! read/write operations of a variable is detected the variable becomes
+  //! alive; when only write operation is detected the variable becomes dead.
+  //!
+  //! When a label is found all jumps to that label are followed and analysis
+  //! repeats until all variables are resolved.
+  virtual Error livenessAnalysis();
+
+  // --------------------------------------------------------------------------
+  // [Annotate]
+  // --------------------------------------------------------------------------
+
+  virtual Error annotate() = 0;
+
+  // --------------------------------------------------------------------------
+  // [Translate]
+  // --------------------------------------------------------------------------
+
+  //! Translate code by allocating registers and handling state changes.
+  virtual Error translate() = 0;
+
+  // --------------------------------------------------------------------------
+  // [Schedule]
+  // --------------------------------------------------------------------------
+
+  virtual Error schedule();
+
+  // --------------------------------------------------------------------------
+  // [Cleanup]
+  // --------------------------------------------------------------------------
+
+  virtual void cleanup();
+
+  // --------------------------------------------------------------------------
+  // [Compile]
+  // --------------------------------------------------------------------------
+
+  virtual Error compile(FuncNode* func);
+
+  // --------------------------------------------------------------------------
+  // [Serialize]
+  // --------------------------------------------------------------------------
+
+  virtual Error serialize(Assembler* assembler, Node* start, Node* stop) = 0;
+
+  // --------------------------------------------------------------------------
+  // [Members]
+  // --------------------------------------------------------------------------
+
+  //! Compiler.
+  Compiler* _compiler;
+  //! Function.
+  FuncNode* _func;
+
+  //! Zone allocator.
+  Zone _baseZone;
+
+  //! \internal
+  //!
+  //! Offset (how many bytes to add) to `VarMap` to get `VarAttr` array. Used
+  //! by liveness analysis shared across all backends. This is needed because
+  //! `VarMap` is a base class for a specialized version that liveness analysis
+  //! doesn't use, it just needs `VarAttr` array.
+  uint32_t _varMapToVaListOffset;
+
+  //! Start of the current active scope.
+  Node* _start;
+  //! End of the current active scope.
+  Node* _end;
+
+  //! Node that is used to insert extra code after the function body.
+  Node* _extraBlock;
+  //! Stop node.
+  Node* _stop;
+
+  //! Unreachable nodes.
+  PodList<Node*> _unreachableList;
+  //! Jump nodes.
+  PodList<Node*> _jccList;
+
+  //! All variables used by the current function.
+  PodVector<VarData*> _contextVd;
+
+  //! Memory used to spill variables.
+  MemCell* _memVarCells;
+  //! Memory used to alloc memory on the stack.
+  MemCell* _memStackCells;
+
+  //! Count of 1-byte cells.
+  uint32_t _mem1ByteVarsUsed;
+  //! Count of 2-byte cells.
+  uint32_t _mem2ByteVarsUsed;
+  //! Count of 4-byte cells.
+  uint32_t _mem4ByteVarsUsed;
+  //! Count of 8-byte cells.
+  uint32_t _mem8ByteVarsUsed;
+  //! Count of 16-byte cells.
+  uint32_t _mem16ByteVarsUsed;
+  //! Count of 32-byte cells.
+  uint32_t _mem32ByteVarsUsed;
+  //! Count of 64-byte cells.
+  uint32_t _mem64ByteVarsUsed;
+  //! Count of stack memory cells.
+  uint32_t _memStackCellsUsed;
+
+  //! Maximum memory alignment used by the function.
+  uint32_t _memMaxAlign;
+  //! Count of bytes used by variables.
+  uint32_t _memVarTotal;
+  //! Count of bytes used by stack.
+  uint32_t _memStackTotal;
+  //! Count of bytes used by variables and stack after alignment.
+  uint32_t _memAllTotal;
+
+  //! Default lenght of annotated instruction.
+  uint32_t _annotationLength;
+
+  //! Current state (used by register allocator).
+  VarState* _state;
+};
+
+//! \}
+
+} // asmjit namespace
+
+// [Api-End]
+#include "../apiend.h"
+
+// [Guard]
+#endif // !ASMJIT_DISABLE_COMPILER
+#endif // _ASMJIT_BASE_CONTEXT_P_H

libraries/asmjit/base/cpuinfo.cpp

+// [AsmJit]
+// Complete x86/x64 JIT and Remote Assembler for C++.
+//
+// [License]
+// Zlib - See LICENSE.md file in the package.
+
+// [Export]
+#define ASMJIT_EXPORTS
+
+// [Dependencies - AsmJit]
+#include "../base/cpuinfo.h"
+
+#if defined(ASMJIT_HOST_X86) || defined(ASMJIT_HOST_X64)
+#include "../x86/x86cpuinfo.h"
+#else
+// ?
+#endif // ASMJIT_HOST || ASMJIT_HOST_X64
+
+// [Dependencies - Posix]
+#if defined(ASMJIT_OS_POSIX)
+# include <errno.h>
+# include <sys/statvfs.h>
+# include <sys/utsname.h>
+# include <unistd.h>
+#endif // ASMJIT_OS_POSIX
+
+// [Api-Begin]
+#include "../apibegin.h"
+
+namespace asmjit {
+
+// ============================================================================
+// [asmjit::CpuInfo - DetectHwThreadsCount]
+// ============================================================================
+
+uint32_t CpuInfo::detectHwThreadsCount() {
+#if defined(ASMJIT_OS_WINDOWS)
+  SYSTEM_INFO info;
+  ::GetSystemInfo(&info);
+  return info.dwNumberOfProcessors;
+#elif defined(ASMJIT_OS_POSIX) && defined(_SC_NPROCESSORS_ONLN)
+  // It seems that sysconf returns the number of "logical" processors on both
+  // mac and linux.  So we get the number of "online logical" processors.
+  long res = ::sysconf(_SC_NPROCESSORS_ONLN);
+  if (res == -1) return 1;
+
+  return static_cast<uint32_t>(res);
+#else
+  return 1;
+#endif
+}
+
+// ============================================================================
+// [asmjit::CpuInfo - GetHost]
+// ============================================================================
+
+#if defined(ASMJIT_HOST_X86) || defined(ASMJIT_HOST_X64)
+struct AutoX86CpuInfo : public X86CpuInfo {
+  ASMJIT_INLINE AutoX86CpuInfo() : X86CpuInfo() {
+    X86CpuUtil::detect(this);
+  }
+};
+#else
+#error "AsmJit - Unsupported CPU."
+#endif // ASMJIT_HOST || ASMJIT_HOST_X64
+
+const CpuInfo* CpuInfo::getHost() {
+#if defined(ASMJIT_HOST_X86) || defined(ASMJIT_HOST_X64)
+  static AutoX86CpuInfo cpuInfo;
+#else
+#error "AsmJit - Unsupported CPU."
+#endif // ASMJIT_HOST || ASMJIT_HOST_X64
+  return &cpuInfo;
+}
+
+} // asmjit namespace
+
+// [Api-End]
+#include "../apiend.h"