src/mesa/main/imports.c

   1 /**
   2  * \file imports.c
   3  * Standard C library function wrappers.
   4  *
   5  * Imports are services which the device driver or window system or
   6  * operating system provides to the core renderer.  The core renderer (Mesa)
   7  * will call these functions in order to do memory allocation, simple I/O,
   8  * etc.
   9  *
  10  * Some drivers will want to override/replace this file with something
  11  * specialized, but that'll be rare.
  12  *
  13  * Eventually, I want to move roll the glheader.h file into this.
  14  *
  15  * \todo Functions still needed:
  16  * - scanf
  17  * - qsort
  18  * - rand and RAND_MAX
  19  */
  20
  21 /*
  22  * Mesa 3-D graphics library
  23  *
  24  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  25  *
  26  * Permission is hereby granted, free of charge, to any person obtaining a
  27  * copy of this software and associated documentation files (the "Software"),
  28  * to deal in the Software without restriction, including without limitation
  29  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  30  * and/or sell copies of the Software, and to permit persons to whom the
  31  * Software is furnished to do so, subject to the following conditions:
  32  *
  33  * The above copyright notice and this permission notice shall be included
  34  * in all copies or substantial portions of the Software.
  35  *
  36  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  37  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  38  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  39  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  40  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  41  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  42  * OTHER DEALINGS IN THE SOFTWARE.
  43  */
  44
  45 #include <stdio.h>
  46 #include <stdarg.h>
  47 #include "c99_math.h"
  48 #include "util/rounding.h" /* for _mesa_roundeven */
  49 #include "imports.h"
  50 #include "context.h"
  51 #include "version.h"
  52
  53 #ifdef _GNU_SOURCE
  54 #include <locale.h>
  55 #ifdef __APPLE__
  56 #include <xlocale.h>
  57 #endif
  58 #endif
  59
  60
  61 #ifdef _WIN32
  62 #define vsnprintf _vsnprintf
  63 #elif defined(__IBMC__) || defined(__IBMCPP__)
  64 extern int vsnprintf(char *str, size_t count, const char *fmt, va_list arg);
  65 #endif
  66
  67 /**********************************************************************/
  68 /** \name Memory */
  69 /*@{*/
  70
  71 /**
  72  * Allocate aligned memory.
  73  *
  74  * \param bytes number of bytes to allocate.
  75  * \param alignment alignment (must be greater than zero).
  76  *
  77  * Allocates extra memory to accommodate rounding up the address for
  78  * alignment and to record the real malloc address.
  79  *
  80  * \sa _mesa_align_free().
  81  */
  82 void *
  83 _mesa_align_malloc(size_t bytes, unsigned long alignment)
  84 {
  85 #if defined(HAVE_POSIX_MEMALIGN)
  86    void *mem;
  87    int err = posix_memalign(& mem, alignment, bytes);
  88    if (err)
  89       return NULL;
  90    return mem;
  91 #elif defined(_WIN32)
  92    return _aligned_malloc(bytes, alignment);
  93 #else
  94    uintptr_t ptr, buf;
  95
  96    assert( alignment > 0 );
  97
  98    ptr = (uintptr_t)malloc(bytes + alignment + sizeof(void *));
  99    if (!ptr)
 100       return NULL;
 101
 102    buf = (ptr + alignment + sizeof(void *)) & ~(uintptr_t)(alignment - 1);
 103    *(uintptr_t *)(buf - sizeof(void *)) = ptr;
 104
 105 #ifndef NDEBUG
 106    /* mark the non-aligned area */
 107    while ( ptr < buf - sizeof(void *) ) {
 108       *(unsigned long *)ptr = 0xcdcdcdcd;
 109       ptr += sizeof(unsigned long);
 110    }
 111 #endif
 112
 113    return (void *) buf;
 114 #endif /* defined(HAVE_POSIX_MEMALIGN) */
 115 }
 116
 117 /**
 118  * Same as _mesa_align_malloc(), but using calloc(1, ) instead of
 119  * malloc()
 120  */
 121 void *
 122 _mesa_align_calloc(size_t bytes, unsigned long alignment)
 123 {
 124 #if defined(HAVE_POSIX_MEMALIGN)
 125    void *mem;
 126
 127    mem = _mesa_align_malloc(bytes, alignment);
 128    if (mem != NULL) {
 129       (void) memset(mem, 0, bytes);
 130    }
 131
 132    return mem;
 133 #elif defined(_WIN32)
 134    void *mem;
 135
 136    mem = _aligned_malloc(bytes, alignment);
 137    if (mem != NULL) {
 138       (void) memset(mem, 0, bytes);
 139    }
 140
 141    return mem;
 142 #else
 143    uintptr_t ptr, buf;
 144
 145    assert( alignment > 0 );
 146
 147    ptr = (uintptr_t)calloc(1, bytes + alignment + sizeof(void *));
 148    if (!ptr)
 149       return NULL;
 150
 151    buf = (ptr + alignment + sizeof(void *)) & ~(uintptr_t)(alignment - 1);
 152    *(uintptr_t *)(buf - sizeof(void *)) = ptr;
 153
 154 #ifndef NDEBUG
 155    /* mark the non-aligned area */
 156    while ( ptr < buf - sizeof(void *) ) {
 157       *(unsigned long *)ptr = 0xcdcdcdcd;
 158       ptr += sizeof(unsigned long);
 159    }
 160 #endif
 161
 162    return (void *)buf;
 163 #endif /* defined(HAVE_POSIX_MEMALIGN) */
 164 }
 165
 166 /**
 167  * Free memory which was allocated with either _mesa_align_malloc()
 168  * or _mesa_align_calloc().
 169  * \param ptr pointer to the memory to be freed.
 170  * The actual address to free is stored in the word immediately before the
 171  * address the client sees.
 172  * Note that it is legal to pass NULL pointer to this function and will be
 173  * handled accordingly.
 174  */
 175 void
 176 _mesa_align_free(void *ptr)
 177 {
 178 #if defined(HAVE_POSIX_MEMALIGN)
 179    free(ptr);
 180 #elif defined(_WIN32)
 181    _aligned_free(ptr);
 182 #else
 183    if (ptr) {
 184       void **cubbyHole = (void **) ((char *) ptr - sizeof(void *));
 185       void *realAddr = *cubbyHole;
 186       free(realAddr);
 187    }
 188 #endif /* defined(HAVE_POSIX_MEMALIGN) */
 189 }
 190
 191 /**
 192  * Reallocate memory, with alignment.
 193  */
 194 void *
 195 _mesa_align_realloc(void *oldBuffer, size_t oldSize, size_t newSize,
 196                     unsigned long alignment)
 197 {
 198 #if defined(_WIN32)
 199    (void) oldSize;
 200    return _aligned_realloc(oldBuffer, newSize, alignment);
 201 #else
 202    const size_t copySize = (oldSize < newSize) ? oldSize : newSize;
 203    void *newBuf = _mesa_align_malloc(newSize, alignment);
 204    if (newBuf && oldBuffer && copySize > 0) {
 205       memcpy(newBuf, oldBuffer, copySize);
 206    }
 207
 208    _mesa_align_free(oldBuffer);
 209    return newBuf;
 210 #endif
 211 }
 212
 213 /*@}*/
 214
 215
 216 /** Needed due to #ifdef's, above. */
 217 int
 218 _mesa_vsnprintf(char *str, size_t size, const char *fmt, va_list args)
 219 {
 220    return vsnprintf( str, size, fmt, args);
 221 }
 222
 223 /** Wrapper around vsnprintf() */
 224 int
 225 _mesa_snprintf( char *str, size_t size, const char *fmt, ... )
 226 {
 227    int r;
 228    va_list args;
 229    va_start( args, fmt );
 230    r = vsnprintf( str, size, fmt, args );
 231    va_end( args );
 232    return r;
 233 }
 234
 235