imports.h revision 9a548c27aa704236cc1d8a5d4ebf68cea9c5c99c
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 44extern "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 */ 84typedef 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 138#ifdef ANDROID 139#define log2f(f) (logf(f) * (float) (1.0 / M_LN2)) 140#else 141#define log2f(f) ((float) log2(f)) 142#endif 143 144#define powf(x,y) ((float) pow(x,y)) 145#define sinf(f) ((float) sin(f)) 146#define sinhf(f) ((float) sinh(f)) 147#define sqrtf(f) ((float) sqrt(f)) 148#define tanf(f) ((float) tan(f)) 149#define tanhf(f) ((float) tanh(f)) 150#define acoshf(f) ((float) acosh(f)) 151#define asinhf(f) ((float) asinh(f)) 152#define atanhf(f) ((float) atanh(f)) 153#endif 154 155#if defined(_MSC_VER) 156static inline float truncf(float x) { return x < 0.0f ? ceilf(x) : floorf(x); } 157static inline float exp2f(float x) { return powf(2.0f, x); } 158static inline float log2f(float x) { return logf(x) * 1.442695041f; } 159static inline float asinhf(float x) { return logf(x + sqrtf(x * x + 1.0f)); } 160static inline float acoshf(float x) { return logf(x + sqrtf(x * x - 1.0f)); } 161static inline float atanhf(float x) { return (logf(1.0f + x) - logf(1.0f - x)) / 2.0f; } 162static inline int isblank(int ch) { return ch == ' ' || ch == '\t'; } 163#define strtoll(p, e, b) _strtoi64(p, e, b) 164#endif 165/*@}*/ 166 167/*** 168 *** LOG2: Log base 2 of float 169 ***/ 170#ifdef USE_IEEE 171#if 0 172/* This is pretty fast, but not accurate enough (only 2 fractional bits). 173 * Based on code from http://www.stereopsis.com/log2.html 174 */ 175static inline GLfloat LOG2(GLfloat x) 176{ 177 const GLfloat y = x * x * x * x; 178 const GLuint ix = *((GLuint *) &y); 179 const GLuint exp = (ix >> 23) & 0xFF; 180 const GLint log2 = ((GLint) exp) - 127; 181 return (GLfloat) log2 * (1.0 / 4.0); /* 4, because of x^4 above */ 182} 183#endif 184/* Pretty fast, and accurate. 185 * Based on code from http://www.flipcode.com/totd/ 186 */ 187static inline GLfloat LOG2(GLfloat val) 188{ 189 fi_type num; 190 GLint log_2; 191 num.f = val; 192 log_2 = ((num.i >> 23) & 255) - 128; 193 num.i &= ~(255 << 23); 194 num.i += 127 << 23; 195 num.f = ((-1.0f/3) * num.f + 2) * num.f - 2.0f/3; 196 return num.f + log_2; 197} 198#else 199/* 200 * NOTE: log_base_2(x) = log(x) / log(2) 201 * NOTE: 1.442695 = 1/log(2). 202 */ 203#define LOG2(x) ((GLfloat) (log(x) * 1.442695F)) 204#endif 205 206 207/*** 208 *** IS_INF_OR_NAN: test if float is infinite or NaN 209 ***/ 210#ifdef USE_IEEE 211static inline int IS_INF_OR_NAN( float x ) 212{ 213 fi_type tmp; 214 tmp.f = x; 215 return !(int)((unsigned int)((tmp.i & 0x7fffffff)-0x7f800000) >> 31); 216} 217#elif defined(isfinite) 218#define IS_INF_OR_NAN(x) (!isfinite(x)) 219#elif defined(finite) 220#define IS_INF_OR_NAN(x) (!finite(x)) 221#elif defined(__VMS) 222#define IS_INF_OR_NAN(x) (!finite(x)) 223#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 224#define IS_INF_OR_NAN(x) (!isfinite(x)) 225#else 226#define IS_INF_OR_NAN(x) (!finite(x)) 227#endif 228 229 230/*** 231 *** IS_NEGATIVE: test if float is negative 232 ***/ 233#if defined(USE_IEEE) 234static inline int GET_FLOAT_BITS( float x ) 235{ 236 fi_type fi; 237 fi.f = x; 238 return fi.i; 239} 240#define IS_NEGATIVE(x) (GET_FLOAT_BITS(x) < 0) 241#else 242#define IS_NEGATIVE(x) (x < 0.0F) 243#endif 244 245 246/*** 247 *** DIFFERENT_SIGNS: test if two floats have opposite signs 248 ***/ 249#if defined(USE_IEEE) 250#define DIFFERENT_SIGNS(x,y) ((GET_FLOAT_BITS(x) ^ GET_FLOAT_BITS(y)) & (1<<31)) 251#else 252/* Could just use (x*y<0) except for the flatshading requirements. 253 * Maybe there's a better way? 254 */ 255#define DIFFERENT_SIGNS(x,y) ((x) * (y) <= 0.0F && (x) - (y) != 0.0F) 256#endif 257 258 259/*** 260 *** CEILF: ceiling of float 261 *** FLOORF: floor of float 262 *** FABSF: absolute value of float 263 *** LOGF: the natural logarithm (base e) of the value 264 *** EXPF: raise e to the value 265 *** LDEXPF: multiply value by an integral power of two 266 *** FREXPF: extract mantissa and exponent from value 267 ***/ 268#if defined(__gnu_linux__) 269/* C99 functions */ 270#define CEILF(x) ceilf(x) 271#define FLOORF(x) floorf(x) 272#define FABSF(x) fabsf(x) 273#define LOGF(x) logf(x) 274#define EXPF(x) expf(x) 275#define LDEXPF(x,y) ldexpf(x,y) 276#define FREXPF(x,y) frexpf(x,y) 277#else 278#define CEILF(x) ((GLfloat) ceil(x)) 279#define FLOORF(x) ((GLfloat) floor(x)) 280#define FABSF(x) ((GLfloat) fabs(x)) 281#define LOGF(x) ((GLfloat) log(x)) 282#define EXPF(x) ((GLfloat) exp(x)) 283#define LDEXPF(x,y) ((GLfloat) ldexp(x,y)) 284#define FREXPF(x,y) ((GLfloat) frexp(x,y)) 285#endif 286 287 288/*** 289 *** IROUND: return (as an integer) float rounded to nearest integer 290 ***/ 291#if defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__) 292static inline int iround(float f) 293{ 294 int r; 295 __asm__ ("fistpl %0" : "=m" (r) : "t" (f) : "st"); 296 return r; 297} 298#define IROUND(x) iround(x) 299#elif defined(USE_X86_ASM) && defined(_MSC_VER) 300static inline int iround(float f) 301{ 302 int r; 303 _asm { 304 fld f 305 fistp r 306 } 307 return r; 308} 309#define IROUND(x) iround(x) 310#elif defined(__WATCOMC__) && defined(__386__) 311long iround(float f); 312#pragma aux iround = \ 313 "push eax" \ 314 "fistp dword ptr [esp]" \ 315 "pop eax" \ 316 parm [8087] \ 317 value [eax] \ 318 modify exact [eax]; 319#define IROUND(x) iround(x) 320#else 321#define IROUND(f) ((int) (((f) >= 0.0F) ? ((f) + 0.5F) : ((f) - 0.5F))) 322#endif 323 324#define IROUND64(f) ((GLint64) (((f) >= 0.0F) ? ((f) + 0.5F) : ((f) - 0.5F))) 325 326/*** 327 *** IROUND_POS: return (as an integer) positive float rounded to nearest int 328 ***/ 329#ifdef DEBUG 330#define IROUND_POS(f) (assert((f) >= 0.0F), IROUND(f)) 331#else 332#define IROUND_POS(f) (IROUND(f)) 333#endif 334 335 336/*** 337 *** IFLOOR: return (as an integer) floor of float 338 ***/ 339#if defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__) 340/* 341 * IEEE floor for computers that round to nearest or even. 342 * 'f' must be between -4194304 and 4194303. 343 * This floor operation is done by "(iround(f + .5) + iround(f - .5)) >> 1", 344 * but uses some IEEE specific tricks for better speed. 345 * Contributed by Josh Vanderhoof 346 */ 347static inline int ifloor(float f) 348{ 349 int ai, bi; 350 double af, bf; 351 af = (3 << 22) + 0.5 + (double)f; 352 bf = (3 << 22) + 0.5 - (double)f; 353 /* GCC generates an extra fstp/fld without this. */ 354 __asm__ ("fstps %0" : "=m" (ai) : "t" (af) : "st"); 355 __asm__ ("fstps %0" : "=m" (bi) : "t" (bf) : "st"); 356 return (ai - bi) >> 1; 357} 358#define IFLOOR(x) ifloor(x) 359#elif defined(USE_IEEE) 360static inline int ifloor(float f) 361{ 362 int ai, bi; 363 double af, bf; 364 fi_type u; 365 366 af = (3 << 22) + 0.5 + (double)f; 367 bf = (3 << 22) + 0.5 - (double)f; 368 u.f = (float) af; ai = u.i; 369 u.f = (float) bf; bi = u.i; 370 return (ai - bi) >> 1; 371} 372#define IFLOOR(x) ifloor(x) 373#else 374static inline int ifloor(float f) 375{ 376 int i = IROUND(f); 377 return (i > f) ? i - 1 : i; 378} 379#define IFLOOR(x) ifloor(x) 380#endif 381 382 383/*** 384 *** ICEIL: return (as an integer) ceiling of float 385 ***/ 386#if defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__) 387/* 388 * IEEE ceil for computers that round to nearest or even. 389 * 'f' must be between -4194304 and 4194303. 390 * This ceil operation is done by "(iround(f + .5) + iround(f - .5) + 1) >> 1", 391 * but uses some IEEE specific tricks for better speed. 392 * Contributed by Josh Vanderhoof 393 */ 394static inline int iceil(float f) 395{ 396 int ai, bi; 397 double af, bf; 398 af = (3 << 22) + 0.5 + (double)f; 399 bf = (3 << 22) + 0.5 - (double)f; 400 /* GCC generates an extra fstp/fld without this. */ 401 __asm__ ("fstps %0" : "=m" (ai) : "t" (af) : "st"); 402 __asm__ ("fstps %0" : "=m" (bi) : "t" (bf) : "st"); 403 return (ai - bi + 1) >> 1; 404} 405#define ICEIL(x) iceil(x) 406#elif defined(USE_IEEE) 407static inline int iceil(float f) 408{ 409 int ai, bi; 410 double af, bf; 411 fi_type u; 412 af = (3 << 22) + 0.5 + (double)f; 413 bf = (3 << 22) + 0.5 - (double)f; 414 u.f = (float) af; ai = u.i; 415 u.f = (float) bf; bi = u.i; 416 return (ai - bi + 1) >> 1; 417} 418#define ICEIL(x) iceil(x) 419#else 420static inline int iceil(float f) 421{ 422 int i = IROUND(f); 423 return (i < f) ? i + 1 : i; 424} 425#define ICEIL(x) iceil(x) 426#endif 427 428 429/** 430 * Is x a power of two? 431 */ 432static inline int 433_mesa_is_pow_two(int x) 434{ 435 return !(x & (x - 1)); 436} 437 438/** 439 * Round given integer to next higer power of two 440 * If X is zero result is undefined. 441 * 442 * Source for the fallback implementation is 443 * Sean Eron Anderson's webpage "Bit Twiddling Hacks" 444 * http://graphics.stanford.edu/~seander/bithacks.html 445 * 446 * When using builtin function have to do some work 447 * for case when passed values 1 to prevent hiting 448 * undefined result from __builtin_clz. Undefined 449 * results would be different depending on optimization 450 * level used for build. 451 */ 452static inline int32_t 453_mesa_next_pow_two_32(uint32_t x) 454{ 455#if defined(__GNUC__) && \ 456 ((__GNUC__ * 100 + __GNUC_MINOR__) >= 304) /* gcc 3.4 or later */ 457 uint32_t y = (x != 1); 458 return (1 + y) << ((__builtin_clz(x - y) ^ 31) ); 459#else 460 x--; 461 x |= x >> 1; 462 x |= x >> 2; 463 x |= x >> 4; 464 x |= x >> 8; 465 x |= x >> 16; 466 x++; 467 return x; 468#endif 469} 470 471static inline int64_t 472_mesa_next_pow_two_64(uint64_t x) 473{ 474#if defined(__GNUC__) && \ 475 ((__GNUC__ * 100 + __GNUC_MINOR__) >= 304) /* gcc 3.4 or later */ 476 uint64_t y = (x != 1); 477 if (sizeof(x) == sizeof(long)) 478 return (1 + y) << ((__builtin_clzl(x - y) ^ 63)); 479 else 480 return (1 + y) << ((__builtin_clzll(x - y) ^ 63)); 481#else 482 x--; 483 x |= x >> 1; 484 x |= x >> 2; 485 x |= x >> 4; 486 x |= x >> 8; 487 x |= x >> 16; 488 x |= x >> 32; 489 x++; 490 return x; 491#endif 492} 493 494 495/* 496 * Returns the floor form of binary logarithm for a 32-bit integer. 497 */ 498static inline GLuint 499_mesa_logbase2(GLuint n) 500{ 501#if defined(__GNUC__) && \ 502 ((__GNUC__ * 100 + __GNUC_MINOR__) >= 304) /* gcc 3.4 or later */ 503 return (31 - __builtin_clz(n | 1)); 504#else 505 GLuint pos = 0; 506 if (n >= 1<<16) { n >>= 16; pos += 16; } 507 if (n >= 1<< 8) { n >>= 8; pos += 8; } 508 if (n >= 1<< 4) { n >>= 4; pos += 4; } 509 if (n >= 1<< 2) { n >>= 2; pos += 2; } 510 if (n >= 1<< 1) { pos += 1; } 511 return pos; 512#endif 513} 514 515 516/** 517 * Return 1 if this is a little endian machine, 0 if big endian. 518 */ 519static inline GLboolean 520_mesa_little_endian(void) 521{ 522 const GLuint ui = 1; /* intentionally not static */ 523 return *((const GLubyte *) &ui); 524} 525 526 527 528/********************************************************************** 529 * Functions 530 */ 531 532extern void * 533_mesa_align_malloc( size_t bytes, unsigned long alignment ); 534 535extern void * 536_mesa_align_calloc( size_t bytes, unsigned long alignment ); 537 538extern void 539_mesa_align_free( void *ptr ); 540 541extern void * 542_mesa_align_realloc(void *oldBuffer, size_t oldSize, size_t newSize, 543 unsigned long alignment); 544 545extern void * 546_mesa_exec_malloc( GLuint size ); 547 548extern void 549_mesa_exec_free( void *addr ); 550 551extern void * 552_mesa_realloc( void *oldBuffer, size_t oldSize, size_t newSize ); 553 554extern void 555_mesa_memset16( unsigned short *dst, unsigned short val, size_t n ); 556 557extern double 558_mesa_sqrtd(double x); 559 560extern float 561_mesa_sqrtf(float x); 562 563extern float 564_mesa_inv_sqrtf(float x); 565 566extern void 567_mesa_init_sqrt_table(void); 568 569#ifdef __GNUC__ 570 571#if defined(__MINGW32__) || defined(__CYGWIN__) || defined(ANDROID) || defined(__APPLE__) 572#define ffs __builtin_ffs 573#define ffsll __builtin_ffsll 574#endif 575 576#else 577 578extern int ffs(int i); 579extern int ffsll(long long int i); 580 581#endif /*__ GNUC__ */ 582 583 584#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 304) /* gcc 3.4 or later */ 585#define _mesa_bitcount(i) __builtin_popcount(i) 586#define _mesa_bitcount_64(i) __builtin_popcountll(i) 587#else 588extern unsigned int 589_mesa_bitcount(unsigned int n); 590extern unsigned int 591_mesa_bitcount_64(uint64_t n); 592#endif 593 594 595extern GLhalfARB 596_mesa_float_to_half(float f); 597 598extern float 599_mesa_half_to_float(GLhalfARB h); 600 601 602extern void * 603_mesa_bsearch( const void *key, const void *base, size_t nmemb, size_t size, 604 int (*compar)(const void *, const void *) ); 605 606extern char * 607_mesa_getenv( const char *var ); 608 609extern char * 610_mesa_strdup( const char *s ); 611 612extern float 613_mesa_strtof( const char *s, char **end ); 614 615extern unsigned int 616_mesa_str_checksum(const char *str); 617 618extern int 619_mesa_snprintf( char *str, size_t size, const char *fmt, ... ) PRINTFLIKE(3, 4); 620 621struct gl_context; 622 623extern void 624_mesa_warning( struct gl_context *gc, const char *fmtString, ... ) PRINTFLIKE(2, 3); 625 626extern void 627_mesa_problem( const struct gl_context *ctx, const char *fmtString, ... ) PRINTFLIKE(2, 3); 628 629extern void 630_mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... ) PRINTFLIKE(3, 4); 631 632extern void 633_mesa_debug( const struct gl_context *ctx, const char *fmtString, ... ) PRINTFLIKE(2, 3); 634 635 636#if defined(_MSC_VER) && !defined(snprintf) 637#define snprintf _snprintf 638#endif 639 640 641#ifdef __cplusplus 642} 643#endif 644 645 646#endif /* IMPORTS_H */ 647