Home | History | Annotate | Download | only in sljit
      1 /*
      2  *    Stack-less Just-In-Time compiler
      3  *
      4  *    Copyright 2009-2012 Zoltan Herczeg (hzmester (at) freemail.hu). All rights reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without modification, are
      7  * permitted provided that the following conditions are met:
      8  *
      9  *   1. Redistributions of source code must retain the above copyright notice, this list of
     10  *      conditions and the following disclaimer.
     11  *
     12  *   2. Redistributions in binary form must reproduce the above copyright notice, this list
     13  *      of conditions and the following disclaimer in the documentation and/or other materials
     14  *      provided with the distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY
     17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
     19  * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
     20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
     21  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
     22  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
     24  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     25  */
     26 
     27 #ifndef _SLJIT_CONFIG_INTERNAL_H_
     28 #define _SLJIT_CONFIG_INTERNAL_H_
     29 
     30 /*
     31    SLJIT defines the following architecture dependent types and macros:
     32 
     33    Types:
     34      sljit_s8, sljit_u8   : signed and unsigned 8 bit integer type
     35      sljit_s16, sljit_u16 : signed and unsigned 16 bit integer type
     36      sljit_s32, sljit_u32 : signed and unsigned 32 bit integer type
     37      sljit_sw, sljit_uw   : signed and unsigned machine word, enough to store a pointer
     38      sljit_p              : unsgined pointer value (usually the same as sljit_uw, but
     39                             some 64 bit ABIs may use 32 bit pointers)
     40      sljit_f32            : 32 bit single precision floating point value
     41      sljit_f64            : 64 bit double precision floating point value
     42 
     43    Macros for feature detection (boolean):
     44      SLJIT_32BIT_ARCHITECTURE : 32 bit architecture
     45      SLJIT_64BIT_ARCHITECTURE : 64 bit architecture
     46      SLJIT_LITTLE_ENDIAN : little endian architecture
     47      SLJIT_BIG_ENDIAN : big endian architecture
     48      SLJIT_UNALIGNED : allows unaligned memory accesses for non-fpu operations (only!)
     49      SLJIT_INDIRECT_CALL : see SLJIT_FUNC_OFFSET() for more information
     50 
     51    Constants:
     52      SLJIT_NUMBER_OF_REGISTERS : number of available registers
     53      SLJIT_NUMBER_OF_SCRATCH_REGISTERS : number of available scratch registers
     54      SLJIT_NUMBER_OF_SAVED_REGISTERS : number of available saved registers
     55      SLJIT_NUMBER_OF_FLOAT_REGISTERS : number of available floating point registers
     56      SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS : number of available floating point scratch registers
     57      SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS : number of available floating point saved registers
     58      SLJIT_WORD_SHIFT : the shift required to apply when accessing a sljit_sw/sljit_uw array by index
     59      SLJIT_F32_SHIFT : the shift required to apply when accessing
     60                        a single precision floating point array by index
     61      SLJIT_F64_SHIFT : the shift required to apply when accessing
     62                        a double precision floating point array by index
     63      SLJIT_LOCALS_OFFSET : local space starting offset (SLJIT_SP + SLJIT_LOCALS_OFFSET)
     64      SLJIT_RETURN_ADDRESS_OFFSET : a return instruction always adds this offset to the return address
     65 
     66    Other macros:
     67      SLJIT_CALL : C calling convention define for both calling JIT form C and C callbacks for JIT
     68      SLJIT_W(number) : defining 64 bit constants on 64 bit architectures (compiler independent helper)
     69 */
     70 
     71 /*****************/
     72 /* Sanity check. */
     73 /*****************/
     74 
     75 #if !((defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) \
     76 	|| (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) \
     77 	|| (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) \
     78 	|| (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7) \
     79 	|| (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2) \
     80 	|| (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64) \
     81 	|| (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) \
     82 	|| (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) \
     83 	|| (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32) \
     84 	|| (defined SLJIT_CONFIG_MIPS_64 && SLJIT_CONFIG_MIPS_64) \
     85 	|| (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32) \
     86 	|| (defined SLJIT_CONFIG_TILEGX && SLJIT_CONFIG_TILEGX) \
     87 	|| (defined SLJIT_CONFIG_AUTO && SLJIT_CONFIG_AUTO) \
     88 	|| (defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED))
     89 #error "An architecture must be selected"
     90 #endif
     91 
     92 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) \
     93 	+ (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) \
     94 	+ (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) \
     95 	+ (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7) \
     96 	+ (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2) \
     97 	+ (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64) \
     98 	+ (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) \
     99 	+ (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) \
    100 	+ (defined SLJIT_CONFIG_TILEGX && SLJIT_CONFIG_TILEGX) \
    101 	+ (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32) \
    102 	+ (defined SLJIT_CONFIG_MIPS_64 && SLJIT_CONFIG_MIPS_64) \
    103 	+ (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32) \
    104 	+ (defined SLJIT_CONFIG_AUTO && SLJIT_CONFIG_AUTO) \
    105 	+ (defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) >= 2
    106 #error "Multiple architectures are selected"
    107 #endif
    108 
    109 /********************************************************/
    110 /* Automatic CPU detection (requires compiler support). */
    111 /********************************************************/
    112 
    113 #if (defined SLJIT_CONFIG_AUTO && SLJIT_CONFIG_AUTO)
    114 
    115 #ifndef _WIN32
    116 
    117 #if defined(__i386__) || defined(__i386)
    118 #define SLJIT_CONFIG_X86_32 1
    119 #elif defined(__x86_64__)
    120 #define SLJIT_CONFIG_X86_64 1
    121 #elif defined(__arm__) || defined(__ARM__)
    122 #ifdef __thumb2__
    123 #define SLJIT_CONFIG_ARM_THUMB2 1
    124 #elif defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__)
    125 #define SLJIT_CONFIG_ARM_V7 1
    126 #else
    127 #define SLJIT_CONFIG_ARM_V5 1
    128 #endif
    129 #elif defined (__aarch64__)
    130 #define SLJIT_CONFIG_ARM_64 1
    131 #elif defined(__ppc64__) || defined(__powerpc64__) || defined(_ARCH_PPC64) || (defined(_POWER) && defined(__64BIT__))
    132 #define SLJIT_CONFIG_PPC_64 1
    133 #elif defined(__ppc__) || defined(__powerpc__) || defined(_ARCH_PPC) || defined(_ARCH_PWR) || defined(_ARCH_PWR2) || defined(_POWER)
    134 #define SLJIT_CONFIG_PPC_32 1
    135 #elif defined(__mips__) && !defined(_LP64)
    136 #define SLJIT_CONFIG_MIPS_32 1
    137 #elif defined(__mips64)
    138 #define SLJIT_CONFIG_MIPS_64 1
    139 #elif defined(__sparc__) || defined(__sparc)
    140 #define SLJIT_CONFIG_SPARC_32 1
    141 #elif defined(__tilegx__)
    142 #define SLJIT_CONFIG_TILEGX 1
    143 #else
    144 /* Unsupported architecture */
    145 #define SLJIT_CONFIG_UNSUPPORTED 1
    146 #endif
    147 
    148 #else /* !_WIN32 */
    149 
    150 #if defined(_M_X64) || defined(__x86_64__)
    151 #define SLJIT_CONFIG_X86_64 1
    152 #elif defined(_ARM_)
    153 #define SLJIT_CONFIG_ARM_V5 1
    154 #else
    155 #define SLJIT_CONFIG_X86_32 1
    156 #endif
    157 
    158 #endif /* !WIN32 */
    159 #endif /* SLJIT_CONFIG_AUTO */
    160 
    161 #if (defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
    162 #undef SLJIT_EXECUTABLE_ALLOCATOR
    163 #endif
    164 
    165 /******************************/
    166 /* CPU family type detection. */
    167 /******************************/
    168 
    169 #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) || (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7) \
    170 	|| (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
    171 #define SLJIT_CONFIG_ARM_32 1
    172 #endif
    173 
    174 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
    175 #define SLJIT_CONFIG_X86 1
    176 #elif (defined SLJIT_CONFIG_ARM_32 && SLJIT_CONFIG_ARM_32) || (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
    177 #define SLJIT_CONFIG_ARM 1
    178 #elif (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) || (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
    179 #define SLJIT_CONFIG_PPC 1
    180 #elif (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32) || (defined SLJIT_CONFIG_MIPS_64 && SLJIT_CONFIG_MIPS_64)
    181 #define SLJIT_CONFIG_MIPS 1
    182 #elif (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32) || (defined SLJIT_CONFIG_SPARC_64 && SLJIT_CONFIG_SPARC_64)
    183 #define SLJIT_CONFIG_SPARC 1
    184 #endif
    185 
    186 /**********************************/
    187 /* External function definitions. */
    188 /**********************************/
    189 
    190 #if !(defined SLJIT_STD_MACROS_DEFINED && SLJIT_STD_MACROS_DEFINED)
    191 
    192 /* These libraries are needed for the macros below. */
    193 #include <stdlib.h>
    194 #include <string.h>
    195 
    196 #endif /* SLJIT_STD_MACROS_DEFINED */
    197 
    198 /* General macros:
    199    Note: SLJIT is designed to be independent from them as possible.
    200 
    201    In release mode (SLJIT_DEBUG is not defined) only the following
    202    external functions are needed:
    203 */
    204 
    205 #ifndef SLJIT_MALLOC
    206 #define SLJIT_MALLOC(size, allocator_data) malloc(size)
    207 #endif
    208 
    209 #ifndef SLJIT_FREE
    210 #define SLJIT_FREE(ptr, allocator_data) free(ptr)
    211 #endif
    212 
    213 #ifndef SLJIT_MEMCPY
    214 #define SLJIT_MEMCPY(dest, src, len) memcpy(dest, src, len)
    215 #endif
    216 
    217 #ifndef SLJIT_ZEROMEM
    218 #define SLJIT_ZEROMEM(dest, len) memset(dest, 0, len)
    219 #endif
    220 
    221 /***************************/
    222 /* Compiler helper macros. */
    223 /***************************/
    224 
    225 #if !defined(SLJIT_LIKELY) && !defined(SLJIT_UNLIKELY)
    226 
    227 #if defined(__GNUC__) && (__GNUC__ >= 3)
    228 #define SLJIT_LIKELY(x)		__builtin_expect((x), 1)
    229 #define SLJIT_UNLIKELY(x)	__builtin_expect((x), 0)
    230 #else
    231 #define SLJIT_LIKELY(x)		(x)
    232 #define SLJIT_UNLIKELY(x)	(x)
    233 #endif
    234 
    235 #endif /* !defined(SLJIT_LIKELY) && !defined(SLJIT_UNLIKELY) */
    236 
    237 #ifndef SLJIT_INLINE
    238 /* Inline functions. Some old compilers do not support them. */
    239 #if defined(__SUNPRO_C) && __SUNPRO_C <= 0x510
    240 #define SLJIT_INLINE
    241 #else
    242 #define SLJIT_INLINE __inline
    243 #endif
    244 #endif /* !SLJIT_INLINE */
    245 
    246 #ifndef SLJIT_NOINLINE
    247 /* Not inline functions. */
    248 #if defined(__GNUC__)
    249 #define SLJIT_NOINLINE __attribute__ ((noinline))
    250 #else
    251 #define SLJIT_NOINLINE
    252 #endif
    253 #endif /* !SLJIT_INLINE */
    254 
    255 #ifndef SLJIT_UNUSED_ARG
    256 /* Unused arguments. */
    257 #define SLJIT_UNUSED_ARG(arg) (void)arg
    258 #endif
    259 
    260 /*********************************/
    261 /* Type of public API functions. */
    262 /*********************************/
    263 
    264 #if (defined SLJIT_CONFIG_STATIC && SLJIT_CONFIG_STATIC)
    265 /* Static ABI functions. For all-in-one programs. */
    266 
    267 #if defined(__GNUC__)
    268 /* Disable unused warnings in gcc. */
    269 #define SLJIT_API_FUNC_ATTRIBUTE static __attribute__((unused))
    270 #else
    271 #define SLJIT_API_FUNC_ATTRIBUTE static
    272 #endif
    273 
    274 #else
    275 #define SLJIT_API_FUNC_ATTRIBUTE
    276 #endif /* (defined SLJIT_CONFIG_STATIC && SLJIT_CONFIG_STATIC) */
    277 
    278 /****************************/
    279 /* Instruction cache flush. */
    280 /****************************/
    281 
    282 #if (!defined SLJIT_CACHE_FLUSH && defined __has_builtin)
    283 #if __has_builtin(__builtin___clear_cache)
    284 
    285 #define SLJIT_CACHE_FLUSH(from, to) \
    286 	__builtin___clear_cache((char*)from, (char*)to)
    287 
    288 #endif /* __has_builtin(__builtin___clear_cache) */
    289 #endif /* (!defined SLJIT_CACHE_FLUSH && defined __has_builtin) */
    290 
    291 #ifndef SLJIT_CACHE_FLUSH
    292 
    293 #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
    294 
    295 /* Not required to implement on archs with unified caches. */
    296 #define SLJIT_CACHE_FLUSH(from, to)
    297 
    298 #elif defined __APPLE__
    299 
    300 /* Supported by all macs since Mac OS 10.5.
    301    However, it does not work on non-jailbroken iOS devices,
    302    although the compilation is successful. */
    303 
    304 #define SLJIT_CACHE_FLUSH(from, to) \
    305 	sys_icache_invalidate((char*)(from), (char*)(to) - (char*)(from))
    306 
    307 #elif (defined(__GNUC__) && (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)))
    308 
    309 #define SLJIT_CACHE_FLUSH(from, to) \
    310 	__builtin___clear_cache((char*)from, (char*)to)
    311 
    312 #elif defined __ANDROID__
    313 
    314 /* Android lacks __clear_cache; instead, cacheflush should be used. */
    315 
    316 #define SLJIT_CACHE_FLUSH(from, to) \
    317     cacheflush((long)(from), (long)(to), 0)
    318 
    319 #elif (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC)
    320 
    321 /* The __clear_cache() implementation of GCC is a dummy function on PowerPC. */
    322 #define SLJIT_CACHE_FLUSH(from, to) \
    323 	ppc_cache_flush((from), (to))
    324 #define SLJIT_CACHE_FLUSH_OWN_IMPL 1
    325 
    326 #elif (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)
    327 
    328 /* The __clear_cache() implementation of GCC is a dummy function on Sparc. */
    329 #define SLJIT_CACHE_FLUSH(from, to) \
    330 	sparc_cache_flush((from), (to))
    331 #define SLJIT_CACHE_FLUSH_OWN_IMPL 1
    332 
    333 #else
    334 
    335 /* Calls __ARM_NR_cacheflush on ARM-Linux. */
    336 #define SLJIT_CACHE_FLUSH(from, to) \
    337 	__clear_cache((char*)(from), (char*)(to))
    338 
    339 #endif
    340 
    341 #endif /* !SLJIT_CACHE_FLUSH */
    342 
    343 /******************************************************/
    344 /*    Integer and floating point type definitions.    */
    345 /******************************************************/
    346 
    347 /* 8 bit byte type. */
    348 typedef unsigned char sljit_u8;
    349 typedef signed char sljit_s8;
    350 
    351 /* 16 bit half-word type. */
    352 typedef unsigned short int sljit_u16;
    353 typedef signed short int sljit_s16;
    354 
    355 /* 32 bit integer type. */
    356 typedef unsigned int sljit_u32;
    357 typedef signed int sljit_s32;
    358 
    359 /* Machine word type. Enough for storing a pointer.
    360      32 bit for 32 bit machines.
    361      64 bit for 64 bit machines. */
    362 #if (defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
    363 /* Just to have something. */
    364 #define SLJIT_WORD_SHIFT 0
    365 typedef unsigned long int sljit_uw;
    366 typedef long int sljit_sw;
    367 #elif !(defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) \
    368 	&& !(defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64) \
    369 	&& !(defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) \
    370 	&& !(defined SLJIT_CONFIG_MIPS_64 && SLJIT_CONFIG_MIPS_64) \
    371 	&& !(defined SLJIT_CONFIG_TILEGX && SLJIT_CONFIG_TILEGX)
    372 #define SLJIT_32BIT_ARCHITECTURE 1
    373 #define SLJIT_WORD_SHIFT 2
    374 typedef unsigned int sljit_uw;
    375 typedef int sljit_sw;
    376 #else
    377 #define SLJIT_64BIT_ARCHITECTURE 1
    378 #define SLJIT_WORD_SHIFT 3
    379 #ifdef _WIN32
    380 typedef unsigned __int64 sljit_uw;
    381 typedef __int64 sljit_sw;
    382 #else
    383 typedef unsigned long int sljit_uw;
    384 typedef long int sljit_sw;
    385 #endif
    386 #endif
    387 
    388 typedef sljit_uw sljit_p;
    389 
    390 /* Floating point types. */
    391 typedef float sljit_f32;
    392 typedef double sljit_f64;
    393 
    394 /* Shift for pointer sized data. */
    395 #define SLJIT_POINTER_SHIFT SLJIT_WORD_SHIFT
    396 
    397 /* Shift for double precision sized data. */
    398 #define SLJIT_F32_SHIFT 2
    399 #define SLJIT_F64_SHIFT 3
    400 
    401 #ifndef SLJIT_W
    402 
    403 /* Defining long constants. */
    404 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
    405 #define SLJIT_W(w)	(w##ll)
    406 #else
    407 #define SLJIT_W(w)	(w)
    408 #endif
    409 
    410 #endif /* !SLJIT_W */
    411 
    412 /*************************/
    413 /* Endianness detection. */
    414 /*************************/
    415 
    416 #if !defined(SLJIT_BIG_ENDIAN) && !defined(SLJIT_LITTLE_ENDIAN)
    417 
    418 /* These macros are mostly useful for the applications. */
    419 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) \
    420 	|| (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
    421 
    422 #ifdef __LITTLE_ENDIAN__
    423 #define SLJIT_LITTLE_ENDIAN 1
    424 #else
    425 #define SLJIT_BIG_ENDIAN 1
    426 #endif
    427 
    428 #elif (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32) \
    429 	|| (defined SLJIT_CONFIG_MIPS_64 && SLJIT_CONFIG_MIPS_64)
    430 
    431 #ifdef __MIPSEL__
    432 #define SLJIT_LITTLE_ENDIAN 1
    433 #else
    434 #define SLJIT_BIG_ENDIAN 1
    435 #endif
    436 
    437 #elif (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)
    438 
    439 #define SLJIT_BIG_ENDIAN 1
    440 
    441 #else
    442 #define SLJIT_LITTLE_ENDIAN 1
    443 #endif
    444 
    445 #endif /* !defined(SLJIT_BIG_ENDIAN) && !defined(SLJIT_LITTLE_ENDIAN) */
    446 
    447 /* Sanity check. */
    448 #if (defined SLJIT_BIG_ENDIAN && SLJIT_BIG_ENDIAN) && (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
    449 #error "Exactly one endianness must be selected"
    450 #endif
    451 
    452 #if !(defined SLJIT_BIG_ENDIAN && SLJIT_BIG_ENDIAN) && !(defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
    453 #error "Exactly one endianness must be selected"
    454 #endif
    455 
    456 #ifndef SLJIT_UNALIGNED
    457 
    458 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) \
    459 	|| (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) \
    460 	|| (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7) \
    461 	|| (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2) \
    462 	|| (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64) \
    463 	|| (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) \
    464 	|| (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
    465 #define SLJIT_UNALIGNED 1
    466 #endif
    467 
    468 #endif /* !SLJIT_UNALIGNED */
    469 
    470 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
    471 /* Auto detect SSE2 support using CPUID.
    472    On 64 bit x86 cpus, sse2 must be present. */
    473 #define SLJIT_DETECT_SSE2 1
    474 #endif
    475 
    476 /*****************************************************************************************/
    477 /* Calling convention of functions generated by SLJIT or called from the generated code. */
    478 /*****************************************************************************************/
    479 
    480 #ifndef SLJIT_CALL
    481 
    482 #if (defined SLJIT_USE_CDECL_CALLING_CONVENTION && SLJIT_USE_CDECL_CALLING_CONVENTION)
    483 
    484 /* Force cdecl. */
    485 #define SLJIT_CALL
    486 
    487 #elif (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
    488 
    489 #if defined(__GNUC__) && !defined(__APPLE__)
    490 
    491 #define SLJIT_CALL __attribute__ ((fastcall))
    492 #define SLJIT_X86_32_FASTCALL 1
    493 
    494 #elif defined(_MSC_VER)
    495 
    496 #define SLJIT_CALL __fastcall
    497 #define SLJIT_X86_32_FASTCALL 1
    498 
    499 #elif defined(__BORLANDC__)
    500 
    501 #define SLJIT_CALL __msfastcall
    502 #define SLJIT_X86_32_FASTCALL 1
    503 
    504 #else /* Unknown compiler. */
    505 
    506 /* The cdecl attribute is the default. */
    507 #define SLJIT_CALL
    508 
    509 #endif
    510 
    511 #else /* Non x86-32 architectures. */
    512 
    513 #define SLJIT_CALL
    514 
    515 #endif /* SLJIT_CONFIG_X86_32 */
    516 
    517 #endif /* !SLJIT_CALL */
    518 
    519 #ifndef SLJIT_INDIRECT_CALL
    520 #if ((defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) && (defined SLJIT_BIG_ENDIAN && SLJIT_BIG_ENDIAN)) \
    521 	|| ((defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) && defined _AIX)
    522 /* It seems certain ppc compilers use an indirect addressing for functions
    523    which makes things complicated. */
    524 #define SLJIT_INDIRECT_CALL 1
    525 #endif
    526 #endif /* SLJIT_INDIRECT_CALL */
    527 
    528 /* The offset which needs to be substracted from the return address to
    529 determine the next executed instruction after return. */
    530 #ifndef SLJIT_RETURN_ADDRESS_OFFSET
    531 #if (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)
    532 #define SLJIT_RETURN_ADDRESS_OFFSET 8
    533 #else
    534 #define SLJIT_RETURN_ADDRESS_OFFSET 0
    535 #endif
    536 #endif /* SLJIT_RETURN_ADDRESS_OFFSET */
    537 
    538 /***************************************************/
    539 /* Functions of the built-in executable allocator. */
    540 /***************************************************/
    541 
    542 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
    543 SLJIT_API_FUNC_ATTRIBUTE void* sljit_malloc_exec(sljit_uw size);
    544 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_exec(void* ptr);
    545 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_unused_memory_exec(void);
    546 #define SLJIT_MALLOC_EXEC(size) sljit_malloc_exec(size)
    547 #define SLJIT_FREE_EXEC(ptr) sljit_free_exec(ptr)
    548 #endif
    549 
    550 /**********************************************/
    551 /* Registers and locals offset determination. */
    552 /**********************************************/
    553 
    554 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
    555 
    556 #define SLJIT_NUMBER_OF_REGISTERS 10
    557 #define SLJIT_NUMBER_OF_SAVED_REGISTERS 7
    558 #if (defined SLJIT_X86_32_FASTCALL && SLJIT_X86_32_FASTCALL)
    559 #define SLJIT_LOCALS_OFFSET_BASE ((2 + 4) * sizeof(sljit_sw))
    560 #else
    561 /* Maximum 3 arguments are passed on the stack, +1 for double alignment. */
    562 #define SLJIT_LOCALS_OFFSET_BASE ((3 + 1 + 4) * sizeof(sljit_sw))
    563 #endif /* SLJIT_X86_32_FASTCALL */
    564 
    565 #elif (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
    566 
    567 #ifndef _WIN64
    568 #define SLJIT_NUMBER_OF_REGISTERS 12
    569 #define SLJIT_NUMBER_OF_SAVED_REGISTERS 6
    570 #define SLJIT_LOCALS_OFFSET_BASE (sizeof(sljit_sw))
    571 #else
    572 #define SLJIT_NUMBER_OF_REGISTERS 12
    573 #define SLJIT_NUMBER_OF_SAVED_REGISTERS 8
    574 #define SLJIT_LOCALS_OFFSET_BASE ((4 + 2) * sizeof(sljit_sw))
    575 #endif /* _WIN64 */
    576 
    577 #elif (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) || (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
    578 
    579 #define SLJIT_NUMBER_OF_REGISTERS 11
    580 #define SLJIT_NUMBER_OF_SAVED_REGISTERS 8
    581 #define SLJIT_LOCALS_OFFSET_BASE 0
    582 
    583 #elif (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
    584 
    585 #define SLJIT_NUMBER_OF_REGISTERS 11
    586 #define SLJIT_NUMBER_OF_SAVED_REGISTERS 7
    587 #define SLJIT_LOCALS_OFFSET_BASE 0
    588 
    589 #elif (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
    590 
    591 #define SLJIT_NUMBER_OF_REGISTERS 25
    592 #define SLJIT_NUMBER_OF_SAVED_REGISTERS 10
    593 #define SLJIT_LOCALS_OFFSET_BASE (2 * sizeof(sljit_sw))
    594 
    595 #elif (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC)
    596 
    597 #define SLJIT_NUMBER_OF_REGISTERS 22
    598 #define SLJIT_NUMBER_OF_SAVED_REGISTERS 17
    599 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) || (defined _AIX)
    600 #define SLJIT_LOCALS_OFFSET_BASE ((6 + 8) * sizeof(sljit_sw))
    601 #elif (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
    602 /* Add +1 for double alignment. */
    603 #define SLJIT_LOCALS_OFFSET_BASE ((3 + 1) * sizeof(sljit_sw))
    604 #else
    605 #define SLJIT_LOCALS_OFFSET_BASE (3 * sizeof(sljit_sw))
    606 #endif /* SLJIT_CONFIG_PPC_64 || _AIX */
    607 
    608 #elif (defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS)
    609 
    610 #define SLJIT_NUMBER_OF_REGISTERS 17
    611 #define SLJIT_NUMBER_OF_SAVED_REGISTERS 8
    612 #if (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
    613 #define SLJIT_LOCALS_OFFSET_BASE (4 * sizeof(sljit_sw))
    614 #else
    615 #define SLJIT_LOCALS_OFFSET_BASE 0
    616 #endif
    617 
    618 #elif (defined SLJIT_CONFIG_SPARC && SLJIT_CONFIG_SPARC)
    619 
    620 #define SLJIT_NUMBER_OF_REGISTERS 18
    621 #define SLJIT_NUMBER_OF_SAVED_REGISTERS 14
    622 #if (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)
    623 /* Add +1 for double alignment. */
    624 #define SLJIT_LOCALS_OFFSET_BASE ((23 + 1) * sizeof(sljit_sw))
    625 #endif
    626 
    627 #elif (defined SLJIT_CONFIG_TILEGX && SLJIT_CONFIG_TILEGX)
    628 
    629 #define SLJIT_NUMBER_OF_REGISTERS 10
    630 #define SLJIT_NUMBER_OF_SAVED_REGISTERS 5
    631 #define SLJIT_LOCALS_OFFSET_BASE 0
    632 
    633 #elif (defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
    634 
    635 #define SLJIT_NUMBER_OF_REGISTERS 0
    636 #define SLJIT_NUMBER_OF_SAVED_REGISTERS 0
    637 #define SLJIT_LOCALS_OFFSET_BASE 0
    638 
    639 #endif
    640 
    641 #define SLJIT_LOCALS_OFFSET (SLJIT_LOCALS_OFFSET_BASE)
    642 
    643 #define SLJIT_NUMBER_OF_SCRATCH_REGISTERS \
    644 	(SLJIT_NUMBER_OF_REGISTERS - SLJIT_NUMBER_OF_SAVED_REGISTERS)
    645 
    646 #define SLJIT_NUMBER_OF_FLOAT_REGISTERS 6
    647 #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) && (defined _WIN64)
    648 #define SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS 1
    649 #else
    650 #define SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS 0
    651 #endif
    652 
    653 #define SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS \
    654 	(SLJIT_NUMBER_OF_FLOAT_REGISTERS - SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS)
    655 
    656 /*************************************/
    657 /* Debug and verbose related macros. */
    658 /*************************************/
    659 
    660 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
    661 #include <stdio.h>
    662 #endif
    663 
    664 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
    665 
    666 #if !defined(SLJIT_ASSERT) || !defined(SLJIT_ASSERT_STOP)
    667 
    668 /* SLJIT_HALT_PROCESS must halt the process. */
    669 #ifndef SLJIT_HALT_PROCESS
    670 #include <stdlib.h>
    671 
    672 #define SLJIT_HALT_PROCESS() \
    673 	abort();
    674 #endif /* !SLJIT_HALT_PROCESS */
    675 
    676 #include <stdio.h>
    677 
    678 #endif /* !SLJIT_ASSERT || !SLJIT_ASSERT_STOP */
    679 
    680 /* Feel free to redefine these two macros. */
    681 #ifndef SLJIT_ASSERT
    682 
    683 #define SLJIT_ASSERT(x) \
    684 	do { \
    685 		if (SLJIT_UNLIKELY(!(x))) { \
    686 			printf("Assertion failed at " __FILE__ ":%d\n", __LINE__); \
    687 			SLJIT_HALT_PROCESS(); \
    688 		} \
    689 	} while (0)
    690 
    691 #endif /* !SLJIT_ASSERT */
    692 
    693 #ifndef SLJIT_ASSERT_STOP
    694 
    695 #define SLJIT_ASSERT_STOP() \
    696 	do { \
    697 		printf("Should never been reached " __FILE__ ":%d\n", __LINE__); \
    698 		SLJIT_HALT_PROCESS(); \
    699 	} while (0)
    700 
    701 #endif /* !SLJIT_ASSERT_STOP */
    702 
    703 #else /* (defined SLJIT_DEBUG && SLJIT_DEBUG) */
    704 
    705 /* Forcing empty, but valid statements. */
    706 #undef SLJIT_ASSERT
    707 #undef SLJIT_ASSERT_STOP
    708 
    709 #define SLJIT_ASSERT(x) \
    710 	do { } while (0)
    711 #define SLJIT_ASSERT_STOP() \
    712 	do { } while (0)
    713 
    714 #endif /* (defined SLJIT_DEBUG && SLJIT_DEBUG) */
    715 
    716 #ifndef SLJIT_COMPILE_ASSERT
    717 
    718 /* Should be improved eventually. */
    719 #define SLJIT_COMPILE_ASSERT(x, description) \
    720 	SLJIT_ASSERT(x)
    721 
    722 #endif /* !SLJIT_COMPILE_ASSERT */
    723 
    724 #endif
    725