[BACK]Return to sljitConfigInternal.h CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre / sljit

Diff for /embedaddon/pcre/sljit/sljitConfigInternal.h between versions 1.1.1.1 and 1.1.1.5

version 1.1.1.1, 2012/02/21 23:05:52 version 1.1.1.5, 2014/06/15 19:46:05
Line 1 Line 1
 /*  /*
  *    Stack-less Just-In-Time compiler   *    Stack-less Just-In-Time compiler
  *   *
 *    Copyright 2009-2010 Zoltan Herczeg (hzmester@freemail.hu). All rights reserved. *    Copyright 2009-2012 Zoltan Herczeg (hzmester@freemail.hu). All rights reserved.
  *   *
  * Redistribution and use in source and binary forms, with or without modification, are   * Redistribution and use in source and binary forms, with or without modification, are
  * permitted provided that the following conditions are met:   * permitted provided that the following conditions are met:
Line 28 Line 28
 #define _SLJIT_CONFIG_INTERNAL_H_  #define _SLJIT_CONFIG_INTERNAL_H_
   
 /*  /*
   SLJIT defines the following variables itself depending on the configuration:   SLJIT defines the following macros depending on the target architecture:
   sljit_b, sljit_ub : signed and unsigned 8 bit byte
   sljit_h, sljit_uh : signed and unsigned 16 bit half-word (short) type   Feature detection (boolean) macros:
   sljit_i, sljit_ui : signed and unsigned 32 bit integer type 
   sljit_w, sljit_uw : signed and unsigned machine word, enough to store a pointer (same as intptr_t) 
   SLJIT_CALL : C calling convention for both calling JIT and C callbacks from JIT 
    SLJIT_32BIT_ARCHITECTURE : 32 bit architecture     SLJIT_32BIT_ARCHITECTURE : 32 bit architecture
    SLJIT_64BIT_ARCHITECTURE : 64 bit architecture     SLJIT_64BIT_ARCHITECTURE : 64 bit architecture
   SLJIT_WORD_SHIFT : the shift required to apply when accessing a sljit_w/sljit_uw array by index   SLJIT_WORD_SHIFT : the shift required to apply when accessing a sljit_sw/sljit_uw array by index
   SLJIT_FLOAT_SHIFT : the shift required to apply when accessing a double array by index   SLJIT_DOUBLE_SHIFT : the shift required to apply when accessing a double array by index
   SLJIT_BIG_ENDIAN : big endian architecture 
    SLJIT_LITTLE_ENDIAN : little endian architecture     SLJIT_LITTLE_ENDIAN : little endian architecture
   SLJIT_INDIRECT_CALL : see SLJIT_FUNC_OFFSET()   SLJIT_BIG_ENDIAN : big endian architecture
   SLJIT_W : for defining 64 bit constants on 64 bit architectures (compiler workaround)   SLJIT_UNALIGNED : allows unaligned memory accesses for non-fpu operations (only!)
   SLJIT_UNALIGNED : allows unaligned memory accesses for integer arithmetic (only!)   SLJIT_INDIRECT_CALL : see SLJIT_FUNC_OFFSET() for more information
    SLJIT_RETURN_ADDRESS_OFFSET : a return instruction always adds this offset to the return address
 
    Types and useful macros:
    sljit_sb, sljit_ub : signed and unsigned 8 bit byte
    sljit_sh, sljit_uh : signed and unsigned 16 bit half-word (short) type
    sljit_si, sljit_ui : signed and unsigned 32 bit integer type
    sljit_sw, sljit_uw : signed and unsigned machine word, enough to store a pointer
    sljit_p : unsgined pointer value (usually the same as sljit_uw, but
              some 64 bit ABIs may use 32 bit pointers)
    sljit_s : single precision floating point value
    sljit_d : double precision floating point value
    SLJIT_CALL : C calling convention define for both calling JIT form C and C callbacks for JIT
    SLJIT_W(number) : defining 64 bit constants on 64 bit architectures (compiler independent helper)
 */  */
   
 #if !((defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) \  #if !((defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) \
Line 53 Line 62
         || (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) \          || (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) \
         || (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) \          || (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) \
         || (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32) \          || (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32) \
           || (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32) \
           || (defined SLJIT_CONFIG_TILEGX && SLJIT_CONFIG_TILEGX) \
         || (defined SLJIT_CONFIG_AUTO && SLJIT_CONFIG_AUTO) \          || (defined SLJIT_CONFIG_AUTO && SLJIT_CONFIG_AUTO) \
         || (defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED))          || (defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED))
 #error "An architecture must be selected"  #error "An architecture must be selected"
Line 66 Line 77
         + (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2) \          + (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2) \
         + (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) \          + (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) \
         + (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) \          + (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) \
           + (defined SLJIT_CONFIG_TILEGX && SLJIT_CONFIG_TILEGX) \
         + (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32) \          + (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32) \
           + (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32) \
         + (defined SLJIT_CONFIG_AUTO && SLJIT_CONFIG_AUTO) \          + (defined SLJIT_CONFIG_AUTO && SLJIT_CONFIG_AUTO) \
         + (defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) >= 2          + (defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) >= 2
 #error "Multiple architectures are selected"  #error "Multiple architectures are selected"
Line 89 Line 102
 #else  #else
 #define SLJIT_CONFIG_ARM_V5 1  #define SLJIT_CONFIG_ARM_V5 1
 #endif  #endif
#elif defined(__ppc64__) || defined(__powerpc64__)#elif defined(__ppc64__) || defined(__powerpc64__) || defined(_ARCH_PPC64) || (defined(_POWER) && defined(__64BIT__))
 #define SLJIT_CONFIG_PPC_64 1  #define SLJIT_CONFIG_PPC_64 1
#elif defined(__ppc__) || defined(__powerpc__)#elif defined(__ppc__) || defined(__powerpc__) || defined(_ARCH_PPC) || defined(_ARCH_PWR) || defined(_ARCH_PWR2) || defined(_POWER)
 #define SLJIT_CONFIG_PPC_32 1  #define SLJIT_CONFIG_PPC_32 1
#elif defined(__mips__)#elif defined(__mips__) && !defined(_LP64)
 #define SLJIT_CONFIG_MIPS_32 1  #define SLJIT_CONFIG_MIPS_32 1
   #elif defined(__sparc__) || defined(__sparc)
   #define SLJIT_CONFIG_SPARC_32 1
   #elif defined(__tilegx__)
   #define SLJIT_CONFIG_TILEGX 1
 #else  #else
 /* Unsupported architecture */  /* Unsupported architecture */
 #define SLJIT_CONFIG_UNSUPPORTED 1  #define SLJIT_CONFIG_UNSUPPORTED 1
Line 160 Line 177
 #endif /* !defined(SLJIT_LIKELY) && !defined(SLJIT_UNLIKELY) */  #endif /* !defined(SLJIT_LIKELY) && !defined(SLJIT_UNLIKELY) */
   
 #ifndef SLJIT_INLINE  #ifndef SLJIT_INLINE
/* Inline functions. *//* Inline functions. Some old compilers do not support them. */
 #if defined(__SUNPRO_C) && __SUNPRO_C <= 0x510
 #define SLJIT_INLINE
 #else
 #define SLJIT_INLINE __inline  #define SLJIT_INLINE __inline
 #endif  #endif
   #endif /* !SLJIT_INLINE */
   
 #ifndef SLJIT_CONST  #ifndef SLJIT_CONST
 /* Const variables. */  /* Const variables. */
Line 190 Line 211
   
 #ifndef SLJIT_CACHE_FLUSH  #ifndef SLJIT_CACHE_FLUSH
   
#if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) || (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)#if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
   
   /* Not required to implement on archs with unified caches. */
   #define SLJIT_CACHE_FLUSH(from, to)
   
   #elif defined __APPLE__
   
   /* Supported by all macs since Mac OS 10.5.
      However, it does not work on non-jailbroken iOS devices,
      although the compilation is successful. */
   
   #define SLJIT_CACHE_FLUSH(from, to) \
           sys_icache_invalidate((char*)(from), (char*)(to) - (char*)(from))
   
   #elif defined __ANDROID__
   
   /* Android lacks __clear_cache; instead, cacheflush should be used. */
   
   #define SLJIT_CACHE_FLUSH(from, to) \
       cacheflush((long)(from), (long)(to), 0)
   
   #elif (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) || (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
   
 /* The __clear_cache() implementation of GCC is a dummy function on PowerPC. */  /* The __clear_cache() implementation of GCC is a dummy function on PowerPC. */
 #define SLJIT_CACHE_FLUSH(from, to) \  #define SLJIT_CACHE_FLUSH(from, to) \
         ppc_cache_flush((from), (to))          ppc_cache_flush((from), (to))
   
#elif (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)#elif (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)
   
/* Not required to implement on archs with unified caches. *//* The __clear_cache() implementation of GCC is a dummy function on Sparc. */
#define SLJIT_CACHE_FLUSH(from, to)#define SLJIT_CACHE_FLUSH(from, to) \
         sparc_cache_flush((from), (to))
   
 #else  #else
   
Line 213 Line 256
   
 /* 8 bit byte type. */  /* 8 bit byte type. */
 typedef unsigned char sljit_ub;  typedef unsigned char sljit_ub;
typedef signed char sljit_b;typedef signed char sljit_sb;
   
 /* 16 bit half-word type. */  /* 16 bit half-word type. */
 typedef unsigned short int sljit_uh;  typedef unsigned short int sljit_uh;
typedef signed short int sljit_h;typedef signed short int sljit_sh;
   
 /* 32 bit integer type. */  /* 32 bit integer type. */
 typedef unsigned int sljit_ui;  typedef unsigned int sljit_ui;
typedef signed int sljit_i;typedef signed int sljit_si;
   
 /* Machine word type. Can encapsulate a pointer.  /* Machine word type. Can encapsulate a pointer.
      32 bit for 32 bit machines.       32 bit for 32 bit machines.
      64 bit for 64 bit machines. */       64 bit for 64 bit machines. */
#if !(defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) && !(defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)#if (defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
 /* Just to have something. */
 #define SLJIT_WORD_SHIFT 0
 typedef unsigned long int sljit_uw;
 typedef long int sljit_sw;
 #elif !(defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) \
         && !(defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) \
         && !(defined SLJIT_CONFIG_TILEGX && SLJIT_CONFIG_TILEGX)
 #define SLJIT_32BIT_ARCHITECTURE 1  #define SLJIT_32BIT_ARCHITECTURE 1
 #define SLJIT_WORD_SHIFT 2  #define SLJIT_WORD_SHIFT 2
 typedef unsigned int sljit_uw;  typedef unsigned int sljit_uw;
typedef int sljit_w;typedef int sljit_sw;
 #else  #else
 #define SLJIT_64BIT_ARCHITECTURE 1  #define SLJIT_64BIT_ARCHITECTURE 1
 #define SLJIT_WORD_SHIFT 3  #define SLJIT_WORD_SHIFT 3
 #ifdef _WIN32  #ifdef _WIN32
 typedef unsigned __int64 sljit_uw;  typedef unsigned __int64 sljit_uw;
typedef __int64 sljit_w;typedef __int64 sljit_sw;
 #else  #else
 typedef unsigned long int sljit_uw;  typedef unsigned long int sljit_uw;
typedef long int sljit_w;typedef long int sljit_sw;
 #endif  #endif
 #endif  #endif
   
/* Double precision. */typedef sljit_uw sljit_p;
#define SLJIT_FLOAT_SHIFT 3 
   
   /* Floating point types. */
   typedef float sljit_s;
   typedef double sljit_d;
   
   /* Shift for pointer sized data. */
   #define SLJIT_POINTER_SHIFT SLJIT_WORD_SHIFT
   
   /* Shift for double precision sized data. */
   #define SLJIT_DOUBLE_SHIFT 3
   
 #ifndef SLJIT_W  #ifndef SLJIT_W
   
 /* Defining long constants. */  /* Defining long constants. */
Line 262  typedef long int sljit_w; Line 321  typedef long int sljit_w;
 /* ABI (Application Binary Interface) types. */  /* ABI (Application Binary Interface) types. */
 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
   
#if defined(__GNUC__)#if defined(__GNUC__) && !defined(__APPLE__)
   
 #define SLJIT_CALL __attribute__ ((fastcall))  #define SLJIT_CALL __attribute__ ((fastcall))
 #define SLJIT_X86_32_FASTCALL 1  #define SLJIT_X86_32_FASTCALL 1
   
#elif defined(_WIN32)#elif defined(_MSC_VER)
   
 #ifdef __BORLANDC__  
 #define SLJIT_CALL __msfastcall  
 #else /* __BORLANDC__ */  
 #define SLJIT_CALL __fastcall  #define SLJIT_CALL __fastcall
 #endif /* __BORLANDC__ */  
 #define SLJIT_X86_32_FASTCALL 1  #define SLJIT_X86_32_FASTCALL 1
   
#else /* defined(_WIN32) */#elif defined(__BORLANDC__)
#define SLJIT_CALL __stdcall
 #define SLJIT_CALL __msfastcall
 #define SLJIT_X86_32_FASTCALL 1
 
 #else /* Unknown compiler. */
 
 /* The cdecl attribute is the default. */
 #define SLJIT_CALL
 
 #endif  #endif
   
#else /* Other architectures. */#else /* Non x86-32 architectures. */
   
 #define SLJIT_CALL  #define SLJIT_CALL
   
Line 291  typedef long int sljit_w; Line 354  typedef long int sljit_w;
 #if !defined(SLJIT_BIG_ENDIAN) && !defined(SLJIT_LITTLE_ENDIAN)  #if !defined(SLJIT_BIG_ENDIAN) && !defined(SLJIT_LITTLE_ENDIAN)
   
 /* These macros are useful for the application. */  /* These macros are useful for the application. */
#if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) || (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)#if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) \
         || (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) \
         || (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)
 #define SLJIT_BIG_ENDIAN 1  #define SLJIT_BIG_ENDIAN 1
   
 #elif (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)  #elif (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
Line 317  typedef long int sljit_w; Line 382  typedef long int sljit_w;
 #error "Exactly one endianness must be selected"  #error "Exactly one endianness must be selected"
 #endif  #endif
   
#if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)#ifndef SLJIT_INDIRECT_CALL
/* It seems ppc64 compilers use an indirect addressing for functions.#if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) || (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32 && defined _AIX)
   It makes things really complicated. *//* It seems certain ppc compilers use an indirect addressing for functions
    which makes things complicated. */
 #define SLJIT_INDIRECT_CALL 1  #define SLJIT_INDIRECT_CALL 1
 #endif  #endif
   #endif /* SLJIT_INDIRECT_CALL */
   
   #ifndef SLJIT_RETURN_ADDRESS_OFFSET
   #if (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)
   #define SLJIT_RETURN_ADDRESS_OFFSET 8
   #else
   #define SLJIT_RETURN_ADDRESS_OFFSET 0
   #endif
   #endif /* SLJIT_RETURN_ADDRESS_OFFSET */
   
 #ifndef SLJIT_SSE2  #ifndef SLJIT_SSE2
   
 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
/* Turn on SSE2 support on x86 (operating on doubles)./* Turn on SSE2 support on x86. */
   (Better performance than legacy fpu instructions). */ 
 #define SLJIT_SSE2 1  #define SLJIT_SSE2 1
   
 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
 /* Auto detect SSE2 support using CPUID.  /* Auto detect SSE2 support using CPUID.
    On 64 bit x86 cpus, sse2 must be present. */     On 64 bit x86 cpus, sse2 must be present. */
#define SLJIT_SSE2_AUTO 1#define SLJIT_DETECT_SSE2 1
 #endif  #endif
   
 #endif /* (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) */  #endif /* (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) */
Line 356  typedef long int sljit_w; Line 430  typedef long int sljit_w;
 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)  #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
 SLJIT_API_FUNC_ATTRIBUTE void* sljit_malloc_exec(sljit_uw size);  SLJIT_API_FUNC_ATTRIBUTE void* sljit_malloc_exec(sljit_uw size);
 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_exec(void* ptr);  SLJIT_API_FUNC_ATTRIBUTE void sljit_free_exec(void* ptr);
   SLJIT_API_FUNC_ATTRIBUTE void sljit_free_unused_memory_exec(void);
 #define SLJIT_MALLOC_EXEC(size) sljit_malloc_exec(size)  #define SLJIT_MALLOC_EXEC(size) sljit_malloc_exec(size)
 #define SLJIT_FREE_EXEC(ptr) sljit_free_exec(ptr)  #define SLJIT_FREE_EXEC(ptr) sljit_free_exec(ptr)
 #endif  #endif
   
#if (defined SLJIT_DEBUG && SLJIT_DEBUG) || (defined SLJIT_VERBOSE && SLJIT_VERBOSE)#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 #include <stdio.h>  #include <stdio.h>
 #endif  #endif
   
 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
   
/* Feel free to redefine these two macros. */#if !defined(SLJIT_ASSERT) || !defined(SLJIT_ASSERT_STOP)
#ifndef SLJIT_ASSERT 
   
   /* SLJIT_HALT_PROCESS must halt the process. */
   #ifndef SLJIT_HALT_PROCESS
   #include <stdlib.h>
   
 #define SLJIT_HALT_PROCESS() \  #define SLJIT_HALT_PROCESS() \
        *((int*)0) = 0        abort();
 #endif /* !SLJIT_HALT_PROCESS */
   
   #include <stdio.h>
   
   #endif /* !SLJIT_ASSERT || !SLJIT_ASSERT_STOP */
   
   /* Feel free to redefine these two macros. */
   #ifndef SLJIT_ASSERT
   
 #define SLJIT_ASSERT(x) \  #define SLJIT_ASSERT(x) \
         do { \          do { \
                 if (SLJIT_UNLIKELY(!(x))) { \                  if (SLJIT_UNLIKELY(!(x))) { \
Line 394  SLJIT_API_FUNC_ATTRIBUTE void sljit_free_exec(void* pt Line 480  SLJIT_API_FUNC_ATTRIBUTE void sljit_free_exec(void* pt
   
 #else /* (defined SLJIT_DEBUG && SLJIT_DEBUG) */  #else /* (defined SLJIT_DEBUG && SLJIT_DEBUG) */
   
   /* Forcing empty, but valid statements. */
 #undef SLJIT_ASSERT  #undef SLJIT_ASSERT
 #undef SLJIT_ASSERT_STOP  #undef SLJIT_ASSERT_STOP
   
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.5

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>