1 /* 2 * Mesa 3-D graphics library 3 * Version: 7.5 4 * 5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 23 */ 24 25 26 /** 27 * \file imports.h 28 * Standard C library function wrappers. 29 * 30 * This file provides wrappers for all the standard C library functions 31 * like malloc(), free(), printf(), getenv(), etc. 32 */ 33 34 35 #ifndef IMPORTS_H 36 #define IMPORTS_H 37 38 39 #include "compiler.h" 40 #include "glheader.h" 41 42 43 #ifdef __cplusplus 44 extern "C" { 45 #endif 46 47 48 /**********************************************************************/ 49 /** Memory macros */ 50 /*@{*/ 51 52 /** Allocate \p BYTES bytes */ 53 #define MALLOC(BYTES) malloc(BYTES) 54 /** Allocate and zero \p BYTES bytes */ 55 #define CALLOC(BYTES) calloc(1, BYTES) 56 /** Allocate a structure of type \p T */ 57 #define MALLOC_STRUCT(T) (struct T *) malloc(sizeof(struct T)) 58 /** Allocate and zero a structure of type \p T */ 59 #define CALLOC_STRUCT(T) (struct T *) calloc(1, sizeof(struct T)) 60 /** Free memory */ 61 #define FREE(PTR) free(PTR) 62 63 /*@}*/ 64 65 66 /* 67 * For GL_ARB_vertex_buffer_object we need to treat vertex array pointers 68 * as offsets into buffer stores. Since the vertex array pointer and 69 * buffer store pointer are both pointers and we need to add them, we use 70 * this macro. 71 * Both pointers/offsets are expressed in bytes. 72 */ 73 #define ADD_POINTERS(A, B) ( (GLubyte *) (A) + (uintptr_t) (B) ) 74 75 76 /** 77 * Sometimes we treat GLfloats as GLints. On x86 systems, moving a float 78 * as a int (thereby using integer registers instead of FP registers) is 79 * a performance win. Typically, this can be done with ordinary casts. 80 * But with gcc's -fstrict-aliasing flag (which defaults to on in gcc 3.0) 81 * these casts generate warnings. 82 * The following union typedef is used to solve that. 83 */ 84 typedef union { GLfloat f; GLint i; } fi_type; 85 86 87 88 /********************************************************************** 89 * Math macros 90 */ 91 92 #define MAX_GLUSHORT 0xffff 93 #define MAX_GLUINT 0xffffffff 94 95 /* Degrees to radians conversion: */ 96 #define DEG2RAD (M_PI/180.0) 97 98 99 /*** 100 *** SQRTF: single-precision square root 101 ***/ 102 #if 0 /* _mesa_sqrtf() not accurate enough - temporarily disabled */ 103 # define SQRTF(X) _mesa_sqrtf(X) 104 #else 105 # define SQRTF(X) (float) sqrt((float) (X)) 106 #endif 107 108 109 /*** 110 *** INV_SQRTF: single-precision inverse square root 111 ***/ 112 #if 0 113 #define INV_SQRTF(X) _mesa_inv_sqrt(X) 114 #else 115 #define INV_SQRTF(X) (1.0F / SQRTF(X)) /* this is faster on a P4 */ 116 #endif 117 118 119 /** 120 * \name Work-arounds for platforms that lack C99 math functions 121 */ 122 /*@{*/ 123 #if (!defined(_XOPEN_SOURCE) || (_XOPEN_SOURCE < 600)) && !defined(_ISOC99_SOURCE) \ 124 && (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L)) \ 125 && (!defined(_MSC_VER) || (_MSC_VER < 1400)) 126 /*#define acosf(f) ((float) acos(f)) 127 #define asinf(f) ((float) asin(f)) 128 #define atan2f(x,y) ((float) atan2(x,y)) 129 #define atanf(f) ((float) atan(f)) 130 #define cielf(f) ((float) ciel(f)) 131 #define cosf(f) ((float) cos(f)) 132 #define coshf(f) ((float) cosh(f)) 133 #define expf(f) ((float) exp(f)) 134 #define exp2f(f) ((float) exp2(f)) 135 #define floorf(f) ((float) floor(f)) 136 #define logf(f) ((float) log(f)) 137 #define log2f(f) ((float) log2(f)) 138 #define powf(x,y) ((float) pow(x,y)) 139 #define sinf(f) ((float) sin(f)) 140 #define sinhf(f) ((float) sinh(f)) 141 #define sqrtf(f) ((float) sqrt(f)) 142 #define tanf(f) ((float) tan(f)) 143 #define tanhf(f) ((float) tanh(f)) 144 #define acoshf(f) ((float) acosh(f)) 145 #define asinhf(f) ((float) asinh(f)) 146 #define atanhf(f) ((float) atanh(f))*/ 147 #endif 148 149 #if defined(_MSC_VER) 150 static INLINE float truncf(float x) { return x < 0.0f ? ceilf(x) : floorf(x); } 151 static INLINE float exp2f(float x) { return powf(2.0f, x); } 152 static INLINE float log2f(float x) { return logf(x) * 1.442695041f; } 153 static INLINE float asinhf(float x) { return logf(x + sqrtf(x * x + 1.0f)); } 154 static INLINE float acoshf(float x) { return logf(x + sqrtf(x * x - 1.0f)); } 155 static INLINE float atanhf(float x) { return (logf(1.0f + x) - logf(1.0f - x)) / 2.0f; } 156 static INLINE int isblank(int ch) { return ch == ' ' || ch == '\t'; } 157 #define strtoll(p, e, b) _strtoi64(p, e, b) 158 #endif 159 /*@}*/ 160 161 /*** 162 *** LOG2: Log base 2 of float 163 ***/ 164 #ifdef USE_IEEE 165 #if 0 166 /* This is pretty fast, but not accurate enough (only 2 fractional bits). 167 * Based on code from http://www.stereopsis.com/log2.html 168 */ 169 static INLINE GLfloat LOG2(GLfloat x) 170 { 171 const GLfloat y = x * x * x * x; 172 const GLuint ix = *((GLuint *) &y); 173 const GLuint exp = (ix >> 23) & 0xFF; 174 const GLint log2 = ((GLint) exp) - 127; 175 return (GLfloat) log2 * (1.0 / 4.0); /* 4, because of x^4 above */ 176 } 177 #endif 178 /* Pretty fast, and accurate. 179 * Based on code from http://www.flipcode.com/totd/ 180 */ 181 static INLINE GLfloat LOG2(GLfloat val) 182 { 183 fi_type num; 184 GLint log_2; 185 num.f = val; 186 log_2 = ((num.i >> 23) & 255) - 128; 187 num.i &= ~(255 << 23); 188 num.i += 127 << 23; 189 num.f = ((-1.0f/3) * num.f + 2) * num.f - 2.0f/3; 190 return num.f + log_2; 191 } 192 #else 193 /* 194 * NOTE: log_base_2(x) = log(x) / log(2) 195 * NOTE: 1.442695 = 1/log(2). 196 */ 197 #define LOG2(x) ((GLfloat) (log(x) * 1.442695F)) 198 #endif 199 200 201 /*** 202 *** IS_INF_OR_NAN: test if float is infinite or NaN 203 ***/ 204 #ifdef USE_IEEE 205 static INLINE int IS_INF_OR_NAN( float x ) 206 { 207 fi_type tmp; 208 tmp.f = x; 209 return !(int)((unsigned int)((tmp.i & 0x7fffffff)-0x7f800000) >> 31); 210 } 211 #elif defined(isfinite) 212 #define IS_INF_OR_NAN(x) (!isfinite(x)) 213 #elif defined(finite) 214 #define IS_INF_OR_NAN(x) (!finite(x)) 215 #elif defined(__VMS) 216 #define IS_INF_OR_NAN(x) (!finite(x)) 217 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 218 #define IS_INF_OR_NAN(x) (!isfinite(x)) 219 #else 220 #define IS_INF_OR_NAN(x) (!finite(x)) 221 #endif 222 223 224 /*** 225 *** IS_NEGATIVE: test if float is negative 226 ***/ 227 #if defined(USE_IEEE) 228 static INLINE int GET_FLOAT_BITS( float x ) 229 { 230 fi_type fi; 231 fi.f = x; 232 return fi.i; 233 } 234 #define IS_NEGATIVE(x) (GET_FLOAT_BITS(x) < 0) 235 #else 236 #define IS_NEGATIVE(x) (x < 0.0F) 237 #endif 238 239 240 /*** 241 *** DIFFERENT_SIGNS: test if two floats have opposite signs 242 ***/ 243 #if defined(USE_IEEE) 244 #define DIFFERENT_SIGNS(x,y) ((GET_FLOAT_BITS(x) ^ GET_FLOAT_BITS(y)) & (1<<31)) 245 #else 246 /* Could just use (x*y<0) except for the flatshading requirements. 247 * Maybe there's a better way? 248 */ 249 #define DIFFERENT_SIGNS(x,y) ((x) * (y) <= 0.0F && (x) - (y) != 0.0F) 250 #endif 251 252 253 /*** 254 *** CEILF: ceiling of float 255 *** FLOORF: floor of float 256 *** FABSF: absolute value of float 257 *** LOGF: the natural logarithm (base e) of the value 258 *** EXPF: raise e to the value 259 *** LDEXPF: multiply value by an integral power of two 260 *** FREXPF: extract mantissa and exponent from value 261 ***/ 262 #if defined(__gnu_linux__) 263 /* C99 functions */ 264 #define CEILF(x) ceilf(x) 265 #define FLOORF(x) floorf(x) 266 #define FABSF(x) fabsf(x) 267 #define LOGF(x) logf(x) 268 #define EXPF(x) expf(x) 269 #define LDEXPF(x,y) ldexpf(x,y) 270 #define FREXPF(x,y) frexpf(x,y) 271 #else 272 #define CEILF(x) ((GLfloat) ceil(x)) 273 #define FLOORF(x) ((GLfloat) floor(x)) 274 #define FABSF(x) ((GLfloat) fabs(x)) 275 #define LOGF(x) ((GLfloat) log(x)) 276 #define EXPF(x) ((GLfloat) exp(x)) 277 #define LDEXPF(x,y) ((GLfloat) ldexp(x,y)) 278 #define FREXPF(x,y) ((GLfloat) frexp(x,y)) 279 #endif 280 281 282 /*** 283 *** IROUND: return (as an integer) float rounded to nearest integer 284 ***/ 285 #if defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__) 286 static INLINE int iround(float f) 287 { 288 int r; 289 __asm__ ("fistpl %0" : "=m" (r) : "t" (f) : "st"); 290 return r; 291 } 292 #define IROUND(x) iround(x) 293 #elif defined(USE_X86_ASM) && defined(_MSC_VER) 294 static INLINE int iround(float f) 295 { 296 int r; 297 _asm { 298 fld f 299 fistp r 300 } 301 return r; 302 } 303 #define IROUND(x) iround(x) 304 #elif defined(__WATCOMC__) && defined(__386__) 305 long iround(float f); 306 #pragma aux iround = \ 307 "push eax" \ 308 "fistp dword ptr [esp]" \ 309 "pop eax" \ 310 parm [8087] \ 311 value [eax] \ 312 modify exact [eax]; 313 #define IROUND(x) iround(x) 314 #else 315 #define IROUND(f) ((int) (((f) >= 0.0F) ? ((f) + 0.5F) : ((f) - 0.5F))) 316 #endif 317 318 #define IROUND64(f) ((GLint64) (((f) >= 0.0F) ? ((f) + 0.5F) : ((f) - 0.5F))) 319 320 /*** 321 *** IROUND_POS: return (as an integer) positive float rounded to nearest int 322 ***/ 323 #ifdef DEBUG 324 #define IROUND_POS(f) (assert((f) >= 0.0F), IROUND(f)) 325 #else 326 #define IROUND_POS(f) (IROUND(f)) 327 #endif 328 329 330 /*** 331 *** IFLOOR: return (as an integer) floor of float 332 ***/ 333 #if defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__) 334 /* 335 * IEEE floor for computers that round to nearest or even. 336 * 'f' must be between -4194304 and 4194303. 337 * This floor operation is done by "(iround(f + .5) + iround(f - .5)) >> 1", 338 * but uses some IEEE specific tricks for better speed. 339 * Contributed by Josh Vanderhoof 340 */ 341 static INLINE int ifloor(float f) 342 { 343 int ai, bi; 344 double af, bf; 345 af = (3 << 22) + 0.5 + (double)f; 346 bf = (3 << 22) + 0.5 - (double)f; 347 /* GCC generates an extra fstp/fld without this. */ 348 __asm__ ("fstps %0" : "=m" (ai) : "t" (af) : "st"); 349 __asm__ ("fstps %0" : "=m" (bi) : "t" (bf) : "st"); 350 return (ai - bi) >> 1; 351 } 352 #define IFLOOR(x) ifloor(x) 353 #elif defined(USE_IEEE) 354 static INLINE int ifloor(float f) 355 { 356 int ai, bi; 357 double af, bf; 358 fi_type u; 359 360 af = (3 << 22) + 0.5 + (double)f; 361 bf = (3 << 22) + 0.5 - (double)f; 362 u.f = (float) af; ai = u.i; 363 u.f = (float) bf; bi = u.i; 364 return (ai - bi) >> 1; 365 } 366 #define IFLOOR(x) ifloor(x) 367 #else 368 static INLINE int ifloor(float f) 369 { 370 int i = IROUND(f); 371 return (i > f) ? i - 1 : i; 372 } 373 #define IFLOOR(x) ifloor(x) 374 #endif 375 376 377 /*** 378 *** ICEIL: return (as an integer) ceiling of float 379 ***/ 380 #if defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__) 381 /* 382 * IEEE ceil for computers that round to nearest or even. 383 * 'f' must be between -4194304 and 4194303. 384 * This ceil operation is done by "(iround(f + .5) + iround(f - .5) + 1) >> 1", 385 * but uses some IEEE specific tricks for better speed. 386 * Contributed by Josh Vanderhoof 387 */ 388 static INLINE int iceil(float f) 389 { 390 int ai, bi; 391 double af, bf; 392 af = (3 << 22) + 0.5 + (double)f; 393 bf = (3 << 22) + 0.5 - (double)f; 394 /* GCC generates an extra fstp/fld without this. */ 395 __asm__ ("fstps %0" : "=m" (ai) : "t" (af) : "st"); 396 __asm__ ("fstps %0" : "=m" (bi) : "t" (bf) : "st"); 397 return (ai - bi + 1) >> 1; 398 } 399 #define ICEIL(x) iceil(x) 400 #elif defined(USE_IEEE) 401 static INLINE int iceil(float f) 402 { 403 int ai, bi; 404 double af, bf; 405 fi_type u; 406 af = (3 << 22) + 0.5 + (double)f; 407 bf = (3 << 22) + 0.5 - (double)f; 408 u.f = (float) af; ai = u.i; 409 u.f = (float) bf; bi = u.i; 410 return (ai - bi + 1) >> 1; 411 } 412 #define ICEIL(x) iceil(x) 413 #else 414 static INLINE int iceil(float f) 415 { 416 int i = IROUND(f); 417 return (i < f) ? i + 1 : i; 418 } 419 #define ICEIL(x) iceil(x) 420 #endif 421 422 423 /** 424 * Is x a power of two? 425 */ 426 static INLINE int 427 _mesa_is_pow_two(int x) 428 { 429 return !(x & (x - 1)); 430 } 431 432 /** 433 * Round given integer to next higer power of two 434 * If X is zero result is undefined. 435 * 436 * Source for the fallback implementation is 437 * Sean Eron Anderson's webpage "Bit Twiddling Hacks" 438 * http://graphics.stanford.edu/~seander/bithacks.html 439 * 440 * When using builtin function have to do some work 441 * for case when passed values 1 to prevent hiting 442 * undefined result from __builtin_clz. Undefined 443 * results would be different depending on optimization 444 * level used for build. 445 */ 446 static INLINE int32_t 447 _mesa_next_pow_two_32(uint32_t x) 448 { 449 #if defined(__GNUC__) && \ 450 ((__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || __GNUC__ >= 4) 451 uint32_t y = (x != 1); 452 return (1 + y) << ((__builtin_clz(x - y) ^ 31) ); 453 #else 454 x--; 455 x |= x >> 1; 456 x |= x >> 2; 457 x |= x >> 4; 458 x |= x >> 8; 459 x |= x >> 16; 460 x++; 461 return x; 462 #endif 463 } 464 465 static INLINE int64_t 466 _mesa_next_pow_two_64(uint64_t x) 467 { 468 #if defined(__GNUC__) && \ 469 ((__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || __GNUC__ >= 4) 470 uint64_t y = (x != 1); 471 if (sizeof(x) == sizeof(long)) 472 return (1 + y) << ((__builtin_clzl(x - y) ^ 63)); 473 else 474 return (1 + y) << ((__builtin_clzll(x - y) ^ 63)); 475 #else 476 x--; 477 x |= x >> 1; 478 x |= x >> 2; 479 x |= x >> 4; 480 x |= x >> 8; 481 x |= x >> 16; 482 x |= x >> 32; 483 x++; 484 return x; 485 #endif 486 } 487 488 489 /** 490 * Return 1 if this is a little endian machine, 0 if big endian. 491 */ 492 static INLINE GLboolean 493 _mesa_little_endian(void) 494 { 495 const GLuint ui = 1; /* intentionally not static */ 496 return *((const GLubyte *) &ui); 497 } 498 499 500 501 /********************************************************************** 502 * Functions 503 */ 504 505 extern void * 506 _mesa_align_malloc( size_t bytes, unsigned long alignment ); 507 508 extern void * 509 _mesa_align_calloc( size_t bytes, unsigned long alignment ); 510 511 extern void 512 _mesa_align_free( void *ptr ); 513 514 extern void * 515 _mesa_align_realloc(void *oldBuffer, size_t oldSize, size_t newSize, 516 unsigned long alignment); 517 518 extern void * 519 _mesa_exec_malloc( GLuint size ); 520 521 extern void 522 _mesa_exec_free( void *addr ); 523 524 extern void * 525 _mesa_realloc( void *oldBuffer, size_t oldSize, size_t newSize ); 526 527 extern void 528 _mesa_memset16( unsigned short *dst, unsigned short val, size_t n ); 529 530 extern double 531 _mesa_sqrtd(double x); 532 533 extern float 534 _mesa_sqrtf(float x); 535 536 extern float 537 _mesa_inv_sqrtf(float x); 538 539 extern void 540 _mesa_init_sqrt_table(void); 541 542 extern int 543 _mesa_ffs(int32_t i); 544 545 extern int 546 _mesa_ffsll(int64_t i); 547 548 extern unsigned int 549 _mesa_bitcount(unsigned int n); 550 551 extern GLhalfARB 552 _mesa_float_to_half(float f); 553 554 extern float 555 _mesa_half_to_float(GLhalfARB h); 556 557 558 extern void * 559 _mesa_bsearch( const void *key, const void *base, size_t nmemb, size_t size, 560 int (*compar)(const void *, const void *) ); 561 562 extern char * 563 _mesa_getenv( const char *var ); 564 565 extern char * 566 _mesa_strdup( const char *s ); 567 568 extern float 569 _mesa_strtof( const char *s, char **end ); 570 571 extern unsigned int 572 _mesa_str_checksum(const char *str); 573 574 extern int 575 _mesa_snprintf( char *str, size_t size, const char *fmt, ... ) PRINTFLIKE(3, 4); 576 577 struct gl_context; 578 579 extern void 580 _mesa_warning( struct gl_context *gc, const char *fmtString, ... ) PRINTFLIKE(2, 3); 581 582 extern void 583 _mesa_problem( const struct gl_context *ctx, const char *fmtString, ... ) PRINTFLIKE(2, 3); 584 585 extern void 586 _mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... ) PRINTFLIKE(3, 4); 587 588 extern void 589 _mesa_debug( const struct gl_context *ctx, const char *fmtString, ... ) PRINTFLIKE(2, 3); 590 591 592 #if defined(_MSC_VER) && !defined(snprintf) 593 #define snprintf _snprintf 594 #endif 595 596 597 #ifdef __cplusplus 598 } 599 #endif 600 601 602 #endif /* IMPORTS_H */ 603
