| /** |
| * \file imports.c |
| * Standard C library function wrappers. |
| * |
| * Imports are services which the device driver or window system or |
| * operating system provides to the core renderer. The core renderer (Mesa) |
| * will call these functions in order to do memory allocation, simple I/O, |
| * etc. |
| * |
| * Some drivers will want to override/replace this file with something |
| * specialized, but that'll be rare. |
| * |
| * Eventually, I want to move roll the glheader.h file into this. |
| * |
| * \todo Functions still needed: |
| * - scanf |
| * - qsort |
| * - rand and RAND_MAX |
| */ |
| |
| /* |
| * Mesa 3-D graphics library |
| * Version: 7.1 |
| * |
| * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included |
| * in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN |
| * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| |
| |
| |
| #include "imports.h" |
| #include "context.h" |
| #include "mtypes.h" |
| #include "version.h" |
| |
| #ifdef _GNU_SOURCE |
| #include <locale.h> |
| #ifdef __APPLE__ |
| #include <xlocale.h> |
| #endif |
| #endif |
| |
| |
| #ifdef WIN32 |
| #define vsnprintf _vsnprintf |
| #elif defined(__IBMC__) || defined(__IBMCPP__) || ( defined(__VMS) && __CRTL_VER < 70312000 ) |
| extern int vsnprintf(char *str, size_t count, const char *fmt, va_list arg); |
| #ifdef __VMS |
| #include "vsnprintf.c" |
| #endif |
| #endif |
| |
| /**********************************************************************/ |
| /** \name Memory */ |
| /*@{*/ |
| |
| /** |
| * Allocate aligned memory. |
| * |
| * \param bytes number of bytes to allocate. |
| * \param alignment alignment (must be greater than zero). |
| * |
| * Allocates extra memory to accommodate rounding up the address for |
| * alignment and to record the real malloc address. |
| * |
| * \sa _mesa_align_free(). |
| */ |
| void * |
| _mesa_align_malloc(size_t bytes, unsigned long alignment) |
| { |
| #if defined(HAVE_POSIX_MEMALIGN) |
| void *mem; |
| int err = posix_memalign(& mem, alignment, bytes); |
| if (err) |
| return NULL; |
| return mem; |
| #elif defined(_WIN32) && defined(_MSC_VER) |
| return _aligned_malloc(bytes, alignment); |
| #else |
| uintptr_t ptr, buf; |
| |
| ASSERT( alignment > 0 ); |
| |
| ptr = (uintptr_t) malloc(bytes + alignment + sizeof(void *)); |
| if (!ptr) |
| return NULL; |
| |
| buf = (ptr + alignment + sizeof(void *)) & ~(uintptr_t)(alignment - 1); |
| *(uintptr_t *)(buf - sizeof(void *)) = ptr; |
| |
| #ifdef DEBUG |
| /* mark the non-aligned area */ |
| while ( ptr < buf - sizeof(void *) ) { |
| *(unsigned long *)ptr = 0xcdcdcdcd; |
| ptr += sizeof(unsigned long); |
| } |
| #endif |
| |
| return (void *) buf; |
| #endif /* defined(HAVE_POSIX_MEMALIGN) */ |
| } |
| |
| /** |
| * Same as _mesa_align_malloc(), but using calloc(1, ) instead of |
| * malloc() |
| */ |
| void * |
| _mesa_align_calloc(size_t bytes, unsigned long alignment) |
| { |
| #if defined(HAVE_POSIX_MEMALIGN) |
| void *mem; |
| |
| mem = _mesa_align_malloc(bytes, alignment); |
| if (mem != NULL) { |
| (void) memset(mem, 0, bytes); |
| } |
| |
| return mem; |
| #elif defined(_WIN32) && defined(_MSC_VER) |
| void *mem; |
| |
| mem = _aligned_malloc(bytes, alignment); |
| if (mem != NULL) { |
| (void) memset(mem, 0, bytes); |
| } |
| |
| return mem; |
| #else |
| uintptr_t ptr, buf; |
| |
| ASSERT( alignment > 0 ); |
| |
| ptr = (uintptr_t) calloc(1, bytes + alignment + sizeof(void *)); |
| if (!ptr) |
| return NULL; |
| |
| buf = (ptr + alignment + sizeof(void *)) & ~(uintptr_t)(alignment - 1); |
| *(uintptr_t *)(buf - sizeof(void *)) = ptr; |
| |
| #ifdef DEBUG |
| /* mark the non-aligned area */ |
| while ( ptr < buf - sizeof(void *) ) { |
| *(unsigned long *)ptr = 0xcdcdcdcd; |
| ptr += sizeof(unsigned long); |
| } |
| #endif |
| |
| return (void *)buf; |
| #endif /* defined(HAVE_POSIX_MEMALIGN) */ |
| } |
| |
| /** |
| * Free memory which was allocated with either _mesa_align_malloc() |
| * or _mesa_align_calloc(). |
| * \param ptr pointer to the memory to be freed. |
| * The actual address to free is stored in the word immediately before the |
| * address the client sees. |
| */ |
| void |
| _mesa_align_free(void *ptr) |
| { |
| #if defined(HAVE_POSIX_MEMALIGN) |
| free(ptr); |
| #elif defined(_WIN32) && defined(_MSC_VER) |
| _aligned_free(ptr); |
| #else |
| void **cubbyHole = (void **) ((char *) ptr - sizeof(void *)); |
| void *realAddr = *cubbyHole; |
| free(realAddr); |
| #endif /* defined(HAVE_POSIX_MEMALIGN) */ |
| } |
| |
| /** |
| * Reallocate memory, with alignment. |
| */ |
| void * |
| _mesa_align_realloc(void *oldBuffer, size_t oldSize, size_t newSize, |
| unsigned long alignment) |
| { |
| #if defined(_WIN32) && defined(_MSC_VER) |
| (void) oldSize; |
| return _aligned_realloc(oldBuffer, newSize, alignment); |
| #else |
| const size_t copySize = (oldSize < newSize) ? oldSize : newSize; |
| void *newBuf = _mesa_align_malloc(newSize, alignment); |
| if (newBuf && oldBuffer && copySize > 0) { |
| memcpy(newBuf, oldBuffer, copySize); |
| } |
| if (oldBuffer) |
| _mesa_align_free(oldBuffer); |
| return newBuf; |
| #endif |
| } |
| |
| |
| |
| /** Reallocate memory */ |
| void * |
| _mesa_realloc(void *oldBuffer, size_t oldSize, size_t newSize) |
| { |
| const size_t copySize = (oldSize < newSize) ? oldSize : newSize; |
| void *newBuffer = malloc(newSize); |
| if (newBuffer && oldBuffer && copySize > 0) |
| memcpy(newBuffer, oldBuffer, copySize); |
| if (oldBuffer) |
| free(oldBuffer); |
| return newBuffer; |
| } |
| |
| /*@}*/ |
| |
| |
| /**********************************************************************/ |
| /** \name Math */ |
| /*@{*/ |
| |
| |
| #ifndef __GNUC__ |
| /** |
| * Find the first bit set in a word. |
| */ |
| int |
| ffs(int i) |
| { |
| register int bit = 0; |
| if (i != 0) { |
| if ((i & 0xffff) == 0) { |
| bit += 16; |
| i >>= 16; |
| } |
| if ((i & 0xff) == 0) { |
| bit += 8; |
| i >>= 8; |
| } |
| if ((i & 0xf) == 0) { |
| bit += 4; |
| i >>= 4; |
| } |
| while ((i & 1) == 0) { |
| bit++; |
| i >>= 1; |
| } |
| bit++; |
| } |
| return bit; |
| } |
| |
| |
| /** |
| * Find position of first bit set in given value. |
| * XXX Warning: this function can only be used on 64-bit systems! |
| * \return position of least-significant bit set, starting at 1, return zero |
| * if no bits set. |
| */ |
| int |
| ffsll(long long int val) |
| { |
| int bit; |
| |
| assert(sizeof(val) == 8); |
| |
| bit = ffs((int) val); |
| if (bit != 0) |
| return bit; |
| |
| bit = ffs((int) (val >> 32)); |
| if (bit != 0) |
| return 32 + bit; |
| |
| return 0; |
| } |
| #endif /* __GNUC__ */ |
| |
| |
| #if !defined(__GNUC__) ||\ |
| ((__GNUC__ * 100 + __GNUC_MINOR__) < 304) /* Not gcc 3.4 or later */ |
| /** |
| * Return number of bits set in given GLuint. |
| */ |
| unsigned int |
| _mesa_bitcount(unsigned int n) |
| { |
| unsigned int bits; |
| for (bits = 0; n > 0; n = n >> 1) { |
| bits += (n & 1); |
| } |
| return bits; |
| } |
| |
| /** |
| * Return number of bits set in given 64-bit uint. |
| */ |
| unsigned int |
| _mesa_bitcount_64(uint64_t n) |
| { |
| unsigned int bits; |
| for (bits = 0; n > 0; n = n >> 1) { |
| bits += (n & 1); |
| } |
| return bits; |
| } |
| #endif |
| |
| |
| /** |
| * Convert a 4-byte float to a 2-byte half float. |
| * Based on code from: |
| * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html |
| */ |
| GLhalfARB |
| _mesa_float_to_half(float val) |
| { |
| const fi_type fi = {val}; |
| const int flt_m = fi.i & 0x7fffff; |
| const int flt_e = (fi.i >> 23) & 0xff; |
| const int flt_s = (fi.i >> 31) & 0x1; |
| int s, e, m = 0; |
| GLhalfARB result; |
| |
| /* sign bit */ |
| s = flt_s; |
| |
| /* handle special cases */ |
| if ((flt_e == 0) && (flt_m == 0)) { |
| /* zero */ |
| /* m = 0; - already set */ |
| e = 0; |
| } |
| else if ((flt_e == 0) && (flt_m != 0)) { |
| /* denorm -- denorm float maps to 0 half */ |
| /* m = 0; - already set */ |
| e = 0; |
| } |
| else if ((flt_e == 0xff) && (flt_m == 0)) { |
| /* infinity */ |
| /* m = 0; - already set */ |
| e = 31; |
| } |
| else if ((flt_e == 0xff) && (flt_m != 0)) { |
| /* NaN */ |
| m = 1; |
| e = 31; |
| } |
| else { |
| /* regular number */ |
| const int new_exp = flt_e - 127; |
| if (new_exp < -24) { |
| /* this maps to 0 */ |
| /* m = 0; - already set */ |
| e = 0; |
| } |
| else if (new_exp < -14) { |
| /* this maps to a denorm */ |
| unsigned int exp_val = (unsigned int) (-14 - new_exp); /* 2^-exp_val*/ |
| e = 0; |
| switch (exp_val) { |
| case 0: |
| _mesa_warning(NULL, |
| "float_to_half: logical error in denorm creation!\n"); |
| /* m = 0; - already set */ |
| break; |
| case 1: m = 512 + (flt_m >> 14); break; |
| case 2: m = 256 + (flt_m >> 15); break; |
| case 3: m = 128 + (flt_m >> 16); break; |
| case 4: m = 64 + (flt_m >> 17); break; |
| case 5: m = 32 + (flt_m >> 18); break; |
| case 6: m = 16 + (flt_m >> 19); break; |
| case 7: m = 8 + (flt_m >> 20); break; |
| case 8: m = 4 + (flt_m >> 21); break; |
| case 9: m = 2 + (flt_m >> 22); break; |
| case 10: m = 1; break; |
| } |
| } |
| else if (new_exp > 15) { |
| /* map this value to infinity */ |
| /* m = 0; - already set */ |
| e = 31; |
| } |
| else { |
| /* regular */ |
| e = new_exp + 15; |
| m = flt_m >> 13; |
| } |
| } |
| |
| result = (s << 15) | (e << 10) | m; |
| return result; |
| } |
| |
| |
| /** |
| * Convert a 2-byte half float to a 4-byte float. |
| * Based on code from: |
| * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html |
| */ |
| float |
| _mesa_half_to_float(GLhalfARB val) |
| { |
| /* XXX could also use a 64K-entry lookup table */ |
| const int m = val & 0x3ff; |
| const int e = (val >> 10) & 0x1f; |
| const int s = (val >> 15) & 0x1; |
| int flt_m, flt_e, flt_s; |
| fi_type fi; |
| float result; |
| |
| /* sign bit */ |
| flt_s = s; |
| |
| /* handle special cases */ |
| if ((e == 0) && (m == 0)) { |
| /* zero */ |
| flt_m = 0; |
| flt_e = 0; |
| } |
| else if ((e == 0) && (m != 0)) { |
| /* denorm -- denorm half will fit in non-denorm single */ |
| const float half_denorm = 1.0f / 16384.0f; /* 2^-14 */ |
| float mantissa = ((float) (m)) / 1024.0f; |
| float sign = s ? -1.0f : 1.0f; |
| return sign * mantissa * half_denorm; |
| } |
| else if ((e == 31) && (m == 0)) { |
| /* infinity */ |
| flt_e = 0xff; |
| flt_m = 0; |
| } |
| else if ((e == 31) && (m != 0)) { |
| /* NaN */ |
| flt_e = 0xff; |
| flt_m = 1; |
| } |
| else { |
| /* regular */ |
| flt_e = e + 112; |
| flt_m = m << 13; |
| } |
| |
| fi.i = (flt_s << 31) | (flt_e << 23) | flt_m; |
| result = fi.f; |
| return result; |
| } |
| |
| /*@}*/ |
| |
| |
| /**********************************************************************/ |
| /** \name Sort & Search */ |
| /*@{*/ |
| |
| /** |
| * Wrapper for bsearch(). |
| */ |
| void * |
| _mesa_bsearch( const void *key, const void *base, size_t nmemb, size_t size, |
| int (*compar)(const void *, const void *) ) |
| { |
| #if defined(_WIN32_WCE) |
| void *mid; |
| int cmp; |
| while (nmemb) { |
| nmemb >>= 1; |
| mid = (char *)base + nmemb * size; |
| cmp = (*compar)(key, mid); |
| if (cmp == 0) |
| return mid; |
| if (cmp > 0) { |
| base = (char *)mid + size; |
| --nmemb; |
| } |
| } |
| return NULL; |
| #else |
| return bsearch(key, base, nmemb, size, compar); |
| #endif |
| } |
| |
| /*@}*/ |
| |
| |
| /**********************************************************************/ |
| /** \name Environment vars */ |
| /*@{*/ |
| |
| /** |
| * Wrapper for getenv(). |
| */ |
| char * |
| _mesa_getenv( const char *var ) |
| { |
| #if defined(_XBOX) || defined(_WIN32_WCE) |
| return NULL; |
| #else |
| return getenv(var); |
| #endif |
| } |
| |
| /*@}*/ |
| |
| |
| /**********************************************************************/ |
| /** \name String */ |
| /*@{*/ |
| |
| /** |
| * Implemented using malloc() and strcpy. |
| * Note that NULL is handled accordingly. |
| */ |
| char * |
| _mesa_strdup( const char *s ) |
| { |
| if (s) { |
| size_t l = strlen(s); |
| char *s2 = (char *) malloc(l + 1); |
| if (s2) |
| strcpy(s2, s); |
| return s2; |
| } |
| else { |
| return NULL; |
| } |
| } |
| |
| /** Wrapper around strtof() */ |
| float |
| _mesa_strtof( const char *s, char **end ) |
| { |
| #if defined(_GNU_SOURCE) && !defined(__CYGWIN__) && !defined(__FreeBSD__) && \ |
| !defined(ANDROID) && !defined(__HAIKU__) && !defined(__UCLIBC__) |
| static locale_t loc = NULL; |
| if (!loc) { |
| loc = newlocale(LC_CTYPE_MASK, "C", NULL); |
| } |
| return strtof_l(s, end, loc); |
| #elif defined(_ISOC99_SOURCE) || (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600) |
| return strtof(s, end); |
| #else |
| return (float)strtod(s, end); |
| #endif |
| } |
| |
| /** Compute simple checksum/hash for a string */ |
| unsigned int |
| _mesa_str_checksum(const char *str) |
| { |
| /* This could probably be much better */ |
| unsigned int sum, i; |
| const char *c; |
| sum = i = 1; |
| for (c = str; *c; c++, i++) |
| sum += *c * (i % 100); |
| return sum + i; |
| } |
| |
| |
| /*@}*/ |
| |
| |
| /** Needed due to #ifdef's, above. */ |
| int |
| _mesa_vsnprintf(char *str, size_t size, const char *fmt, va_list args) |
| { |
| return vsnprintf( str, size, fmt, args); |
| } |
| |
| /** Wrapper around vsnprintf() */ |
| int |
| _mesa_snprintf( char *str, size_t size, const char *fmt, ... ) |
| { |
| int r; |
| va_list args; |
| va_start( args, fmt ); |
| r = vsnprintf( str, size, fmt, args ); |
| va_end( args ); |
| return r; |
| } |
| |
| |