src/parsec/disk-image/parsec/parsec-benchmark/pkgs/libs/mesa/src/src/glx/x11/packrender.h - public/gem5-resources - Git at Google

 #ifndef __GLX_packrender_h__
 #define __GLX_packrender_h__

 /*
  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
  * Copyright (C) 1991-2000 Silicon Graphics, Inc. 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 including the dates of first publication and
  * either this permission notice or a reference to
  * http://oss.sgi.com/projects/FreeB/
  * 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
  * SILICON GRAPHICS, INC. 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.
  *
  * Except as contained in this notice, the name of Silicon Graphics, Inc.
  * shall not be used in advertising or otherwise to promote the sale, use or
  * other dealings in this Software without prior written authorization from
  * Silicon Graphics, Inc.
  */

 #include "glxclient.h"

 /*
 ** The macros in this header convert the client machine's native data types to
 ** wire protocol data types.  The header is part of the porting layer of the
 ** client library, and it is intended that hardware vendors will rewrite this
 ** header to suit their own machines.
 */

 /*
 ** Pad a count of bytes to the nearest multiple of 4.  The X protocol
 ** transfers data in 4 byte quantities, so this macro is used to
 ** insure the right amount of data being sent.
 */
 #define __GLX_PAD(a) (((a)+3) & ~3)

 /*
  ** Network size parameters
  */
 #define sz_double 8

 /* Setup for all commands */
 #define __GLX_DECLARE_VARIABLES() \
     __GLXcontext *gc;		  \
     GLubyte *pc, *pixelHeaderPC;  \
     GLuint compsize, cmdlen

 #define __GLX_LOAD_VARIABLES()	   \
     gc = __glXGetCurrentContext(); \
     pc = gc->pc;                   \
     /* Muffle compilers */		    \
     cmdlen = 0;         (void)cmdlen;	    \
     compsize = 0;       (void)compsize;	    \
     pixelHeaderPC = 0;  (void)pixelHeaderPC

 /*
 ** Variable sized command support macro.  This macro is used by calls
 ** that are potentially larger than __GLX_SMALL_RENDER_CMD_SIZE.
 ** Because of their size, they may not automatically fit in the buffer.
 ** If the buffer can't hold the command then it is flushed so that
 ** the command will fit in the next buffer.
 */
 #define __GLX_BEGIN_VARIABLE(opcode,size)	\
     if (pc + (size) > gc->bufEnd) {		\
 	pc = __glXFlushRenderBuffer(gc, pc);	\
     }						\
     __GLX_PUT_SHORT(0,size);			\
     __GLX_PUT_SHORT(2,opcode)

 #define __GLX_BEGIN_VARIABLE_LARGE(opcode,size)	\
     pc = __glXFlushRenderBuffer(gc, pc);	\
     __GLX_PUT_LONG(0,size);			\
     __GLX_PUT_LONG(4,opcode)

 #define __GLX_BEGIN_VARIABLE_WITH_PIXEL(opcode,size) \
     if (pc + (size) > gc->bufEnd) {		     \
 	pc = __glXFlushRenderBuffer(gc, pc);	     \
     }						     \
     __GLX_PUT_SHORT(0,size);			     \
     __GLX_PUT_SHORT(2,opcode);			     \
     pc += __GLX_RENDER_HDR_SIZE;		     \
     pixelHeaderPC = pc;				     \
     pc += __GLX_PIXEL_HDR_SIZE

 #define __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(opcode,size) \
     pc = __glXFlushRenderBuffer(gc, pc);		   \
     __GLX_PUT_LONG(0,size);				   \
     __GLX_PUT_LONG(4,opcode);				   \
     pc += __GLX_RENDER_LARGE_HDR_SIZE;			   \
     pixelHeaderPC = pc;					   \
     pc += __GLX_PIXEL_HDR_SIZE

 #define __GLX_BEGIN_VARIABLE_WITH_PIXEL_3D(opcode,size) \
     if (pc + (size) > gc->bufEnd) {		        \
 	pc = __glXFlushRenderBuffer(gc, pc); 	        \
     }						        \
     __GLX_PUT_SHORT(0,size);			        \
     __GLX_PUT_SHORT(2,opcode);			        \
     pc += __GLX_RENDER_HDR_SIZE;		        \
     pixelHeaderPC = pc;				        \
     pc += __GLX_PIXEL_3D_HDR_SIZE

 #define __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL_3D(opcode,size) \
     pc = __glXFlushRenderBuffer(gc, pc);	   	      \
     __GLX_PUT_LONG(0,size);				      \
     __GLX_PUT_LONG(4,opcode);				      \
     pc += __GLX_RENDER_LARGE_HDR_SIZE;			      \
     pixelHeaderPC = pc;					      \
     pc += __GLX_PIXEL_3D_HDR_SIZE

 /*
 ** Fixed size command support macro.  This macro is used by calls that
 ** are never larger than __GLX_SMALL_RENDER_CMD_SIZE.  Because they
 ** always fit in the buffer, and because the buffer promises to
 ** maintain enough room for them, we don't need to check for space
 ** before doing the storage work.
 */
 #define __GLX_BEGIN(opcode,size) \
     __GLX_PUT_SHORT(0,size);     \
     __GLX_PUT_SHORT(2,opcode)

 /*
 ** Finish a rendering command by advancing the pc.  If the pc is now past
 ** the limit pointer then there is no longer room for a
 ** __GLX_SMALL_RENDER_CMD_SIZE sized command, which will break the
 ** assumptions present in the __GLX_BEGIN macro.  In this case the
 ** rendering buffer is flushed out into the X protocol stream (which may
 ** or may not do I/O).
 */
 #define __GLX_END(size)			       \
     pc += size;				       \
     if (pc > gc->limit) {		       \
 	(void) __glXFlushRenderBuffer(gc, pc); \
     } else {				       \
 	gc->pc = pc;			       \
     }

 /* Array copy macros */
 #define __GLX_MEM_COPY(dest,src,bytes) \
     if (src && dest) \
     	memcpy(dest, src, bytes)

 /* Single item copy macros */
 #define __GLX_PUT_CHAR(offset,a) \
     *((INT8 *) (pc + offset)) = a

 #ifndef _CRAY
 #define __GLX_PUT_SHORT(offset,a) \
     *((INT16 *) (pc + offset)) = a

 #define __GLX_PUT_LONG(offset,a) \
     *((INT32 *) (pc + offset)) = a

 #define __GLX_PUT_FLOAT(offset,a) \
     *((FLOAT32 *) (pc + offset)) = a

 #else
 #define __GLX_PUT_SHORT(offset,a) \
  { GLubyte *cp = (pc+offset); \
    int shift = (64-16) - ((int)(cp) >> (64-6)); \
    *(int *)cp = (*(int *)cp & ~(0xffff << shift)) | ((a & 0xffff) << shift); }

 #define __GLX_PUT_LONG(offset,a) \
  { GLubyte *cp = (pc+offset); \
    int shift = (64-32) - ((int)(cp) >> (64-6)); \
    *(int *)cp = (*(int *)cp & ~(0xffffffff << shift)) | ((a & 0xffffffff) << shift); }

 #define __GLX_PUT_FLOAT(offset,a) \
     gl_put_float((pc + offset),a)

 #define __GLX_PUT_DOUBLE(offset,a) \
     gl_put_double(pc + offset, a)

 extern void gl_put_float(/*GLubyte *, struct cray_single*/);
 extern void gl_put_double(/*GLubyte *, struct cray_double*/);
 #endif

 #ifndef _CRAY

 #ifdef __GLX_ALIGN64
 /*
 ** This can certainly be done better for a particular machine
 ** architecture!
 */
 #define __GLX_PUT_DOUBLE(offset,a) \
     __GLX_MEM_COPY(pc + offset, &a, 8)
 #else
 #define __GLX_PUT_DOUBLE(offset,a) \
     *((FLOAT64 *) (pc + offset)) = a
 #endif

 #endif

 #define __GLX_PUT_CHAR_ARRAY(offset,a,alen) \
     __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT8)

 #ifndef _CRAY
 #define __GLX_PUT_SHORT_ARRAY(offset,a,alen) \
     __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT16)

 #define __GLX_PUT_LONG_ARRAY(offset,a,alen) \
     __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT32)

 #define __GLX_PUT_FLOAT_ARRAY(offset,a,alen) \
     __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT32)

 #define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen) \
     __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT64)

 #else
 #define __GLX_PUT_SHORT_ARRAY(offset,a,alen) \
     gl_put_short_array((GLubyte *)(pc + offset), a, alen * __GLX_SIZE_INT16)

 #define __GLX_PUT_LONG_ARRAY(offset,a,alen) \
     gl_put_long_array((GLubyte *)(pc + offset), (long *)a, alen * __GLX_SIZE_INT32)

 #define __GLX_PUT_FLOAT_ARRAY(offset,a,alen) \
     gl_put_float_array((GLubyte *)(pc + offset), (float *)a, alen * __GLX_SIZE_FLOAT32)

 #define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen) \
     gl_put_double_array((GLubyte *)(pc + offset), (double *)a, alen * __GLX_SIZE_FLOAT64)

 extern gl_put_short_array (GLubyte *, short *, int);
 extern gl_put_long_array (GLubyte *, long *, int);
 extern gl_put_float_array (GLubyte *, float *, int);
 extern gl_put_double_array (GLubyte *, double *, int);

 #endif /* _CRAY */

 #endif /* !__GLX_packrender_h__ */
	#ifndef __GLX_packrender_h__
	#define __GLX_packrender_h__

	/*
	* SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
	* Copyright (C) 1991-2000 Silicon Graphics, Inc. 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 including the dates of first publication and
	* either this permission notice or a reference to
	* http://oss.sgi.com/projects/FreeB/
	* 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
	* SILICON GRAPHICS, INC. 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.
	*
	* Except as contained in this notice, the name of Silicon Graphics, Inc.
	* shall not be used in advertising or otherwise to promote the sale, use or
	* other dealings in this Software without prior written authorization from
	* Silicon Graphics, Inc.
	*/

	#include "glxclient.h"

	/*
	** The macros in this header convert the client machine's native data types to
	** wire protocol data types. The header is part of the porting layer of the
	** client library, and it is intended that hardware vendors will rewrite this
	** header to suit their own machines.
	*/

	/*
	** Pad a count of bytes to the nearest multiple of 4. The X protocol
	** transfers data in 4 byte quantities, so this macro is used to
	** insure the right amount of data being sent.
	*/
	#define __GLX_PAD(a) (((a)+3) & ~3)

	/*
	** Network size parameters
	*/
	#define sz_double 8

	/* Setup for all commands */
	#define __GLX_DECLARE_VARIABLES() \
	__GLXcontext *gc; \
	GLubyte pc, pixelHeaderPC; \
	GLuint compsize, cmdlen

	#define __GLX_LOAD_VARIABLES() \
	gc = __glXGetCurrentContext(); \
	pc = gc->pc; \
	/* Muffle compilers */ \
	cmdlen = 0; (void)cmdlen; \
	compsize = 0; (void)compsize; \
	pixelHeaderPC = 0; (void)pixelHeaderPC

	/*
	** Variable sized command support macro. This macro is used by calls
	** that are potentially larger than __GLX_SMALL_RENDER_CMD_SIZE.
	** Because of their size, they may not automatically fit in the buffer.
	** If the buffer can't hold the command then it is flushed so that
	** the command will fit in the next buffer.
	*/
	#define __GLX_BEGIN_VARIABLE(opcode,size) \
	if (pc + (size) > gc->bufEnd) { \
	pc = __glXFlushRenderBuffer(gc, pc); \
	} \
	__GLX_PUT_SHORT(0,size); \
	__GLX_PUT_SHORT(2,opcode)

	#define __GLX_BEGIN_VARIABLE_LARGE(opcode,size) \
	pc = __glXFlushRenderBuffer(gc, pc); \
	__GLX_PUT_LONG(0,size); \
	__GLX_PUT_LONG(4,opcode)

	#define __GLX_BEGIN_VARIABLE_WITH_PIXEL(opcode,size) \
	if (pc + (size) > gc->bufEnd) { \
	pc = __glXFlushRenderBuffer(gc, pc); \
	} \
	__GLX_PUT_SHORT(0,size); \
	__GLX_PUT_SHORT(2,opcode); \
	pc += __GLX_RENDER_HDR_SIZE; \
	pixelHeaderPC = pc; \
	pc += __GLX_PIXEL_HDR_SIZE

	#define __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(opcode,size) \
	pc = __glXFlushRenderBuffer(gc, pc); \
	__GLX_PUT_LONG(0,size); \
	__GLX_PUT_LONG(4,opcode); \
	pc += __GLX_RENDER_LARGE_HDR_SIZE; \
	pixelHeaderPC = pc; \
	pc += __GLX_PIXEL_HDR_SIZE

	#define __GLX_BEGIN_VARIABLE_WITH_PIXEL_3D(opcode,size) \
	if (pc + (size) > gc->bufEnd) { \
	pc = __glXFlushRenderBuffer(gc, pc); \
	} \
	__GLX_PUT_SHORT(0,size); \
	__GLX_PUT_SHORT(2,opcode); \
	pc += __GLX_RENDER_HDR_SIZE; \
	pixelHeaderPC = pc; \
	pc += __GLX_PIXEL_3D_HDR_SIZE

	#define __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL_3D(opcode,size) \
	pc = __glXFlushRenderBuffer(gc, pc); \
	__GLX_PUT_LONG(0,size); \
	__GLX_PUT_LONG(4,opcode); \
	pc += __GLX_RENDER_LARGE_HDR_SIZE; \
	pixelHeaderPC = pc; \
	pc += __GLX_PIXEL_3D_HDR_SIZE

	/*
	** Fixed size command support macro. This macro is used by calls that
	** are never larger than __GLX_SMALL_RENDER_CMD_SIZE. Because they
	** always fit in the buffer, and because the buffer promises to
	** maintain enough room for them, we don't need to check for space
	** before doing the storage work.
	*/
	#define __GLX_BEGIN(opcode,size) \
	__GLX_PUT_SHORT(0,size); \
	__GLX_PUT_SHORT(2,opcode)

	/*
	** Finish a rendering command by advancing the pc. If the pc is now past
	** the limit pointer then there is no longer room for a
	** __GLX_SMALL_RENDER_CMD_SIZE sized command, which will break the
	** assumptions present in the __GLX_BEGIN macro. In this case the
	** rendering buffer is flushed out into the X protocol stream (which may
	** or may not do I/O).
	*/
	#define __GLX_END(size) \
	pc += size; \
	if (pc > gc->limit) { \
	(void) __glXFlushRenderBuffer(gc, pc); \
	} else { \
	gc->pc = pc; \
	}

	/* Array copy macros */
	#define __GLX_MEM_COPY(dest,src,bytes) \
	if (src && dest) \
	memcpy(dest, src, bytes)

	/* Single item copy macros */
	#define __GLX_PUT_CHAR(offset,a) \
	((INT8 ) (pc + offset)) = a

	#ifndef _CRAY
	#define __GLX_PUT_SHORT(offset,a) \
	((INT16 ) (pc + offset)) = a

	#define __GLX_PUT_LONG(offset,a) \
	((INT32 ) (pc + offset)) = a

	#define __GLX_PUT_FLOAT(offset,a) \
	((FLOAT32 ) (pc + offset)) = a

	#else
	#define __GLX_PUT_SHORT(offset,a) \
	{ GLubyte *cp = (pc+offset); \
	int shift = (64-16) - ((int)(cp) >> (64-6)); \
	(int )cp = ((int )cp & ~(0xffff << shift)) \| ((a & 0xffff) << shift); }

	#define __GLX_PUT_LONG(offset,a) \
	{ GLubyte *cp = (pc+offset); \
	int shift = (64-32) - ((int)(cp) >> (64-6)); \
	(int )cp = ((int )cp & ~(0xffffffff << shift)) \| ((a & 0xffffffff) << shift); }

	#define __GLX_PUT_FLOAT(offset,a) \
	gl_put_float((pc + offset),a)

	#define __GLX_PUT_DOUBLE(offset,a) \
	gl_put_double(pc + offset, a)

	extern void gl_put_float(/GLubyte , struct cray_single*/);
	extern void gl_put_double(/GLubyte , struct cray_double*/);
	#endif

	#ifndef _CRAY

	#ifdef __GLX_ALIGN64
	/*
	** This can certainly be done better for a particular machine
	** architecture!
	*/
	#define __GLX_PUT_DOUBLE(offset,a) \
	__GLX_MEM_COPY(pc + offset, &a, 8)
	#else
	#define __GLX_PUT_DOUBLE(offset,a) \
	((FLOAT64 ) (pc + offset)) = a
	#endif

	#endif

	#define __GLX_PUT_CHAR_ARRAY(offset,a,alen) \
	__GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT8)

	#ifndef _CRAY
	#define __GLX_PUT_SHORT_ARRAY(offset,a,alen) \
	__GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT16)

	#define __GLX_PUT_LONG_ARRAY(offset,a,alen) \
	__GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT32)

	#define __GLX_PUT_FLOAT_ARRAY(offset,a,alen) \
	__GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT32)

	#define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen) \
	__GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT64)

	#else
	#define __GLX_PUT_SHORT_ARRAY(offset,a,alen) \
	gl_put_short_array((GLubyte )(pc + offset), a, alen __GLX_SIZE_INT16)

	#define __GLX_PUT_LONG_ARRAY(offset,a,alen) \
	gl_put_long_array((GLubyte )(pc + offset), (long )a, alen * __GLX_SIZE_INT32)

	#define __GLX_PUT_FLOAT_ARRAY(offset,a,alen) \
	gl_put_float_array((GLubyte )(pc + offset), (float )a, alen * __GLX_SIZE_FLOAT32)

	#define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen) \
	gl_put_double_array((GLubyte )(pc + offset), (double )a, alen * __GLX_SIZE_FLOAT64)

	extern gl_put_short_array (GLubyte , short , int);
	extern gl_put_long_array (GLubyte , long , int);
	extern gl_put_float_array (GLubyte , float , int);
	extern gl_put_double_array (GLubyte , double , int);

	#endif /* _CRAY */

	#endif /* !__GLX_packrender_h__ */