diff -Nru mesa-18.1.0/configure mesa-18.1.1/configure --- mesa-18.1.0/configure 2018-05-18 23:28:49.000000000 +0000 +++ mesa-18.1.1/configure 2018-06-01 15:18:28.000000000 +0000 @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.69 for Mesa 18.1.0. +# Generated by GNU Autoconf 2.69 for Mesa 18.1.1. # # Report bugs to . # @@ -591,8 +591,8 @@ # Identity of this package. PACKAGE_NAME='Mesa' PACKAGE_TARNAME='mesa' -PACKAGE_VERSION='18.1.0' -PACKAGE_STRING='Mesa 18.1.0' +PACKAGE_VERSION='18.1.1' +PACKAGE_STRING='Mesa 18.1.1' PACKAGE_BUGREPORT='https://bugs.freedesktop.org/enter_bug.cgi?product=Mesa' PACKAGE_URL='' @@ -1866,7 +1866,7 @@ # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures Mesa 18.1.0 to adapt to many kinds of systems. +\`configure' configures Mesa 18.1.1 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1937,7 +1937,7 @@ if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of Mesa 18.1.0:";; + short | recursive ) echo "Configuration of Mesa 18.1.1:";; esac cat <<\_ACEOF @@ -2309,7 +2309,7 @@ test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -Mesa configure 18.1.0 +Mesa configure 18.1.1 generated by GNU Autoconf 2.69 Copyright (C) 2012 Free Software Foundation, Inc. @@ -3028,7 +3028,7 @@ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by Mesa $as_me 18.1.0, which was +It was created by Mesa $as_me 18.1.1, which was generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ @@ -4003,7 +4003,7 @@ # Define the identity of the package. PACKAGE='mesa' - VERSION='18.1.0' + VERSION='18.1.1' cat >>confdefs.h <<_ACEOF @@ -30566,7 +30566,7 @@ # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by Mesa $as_me 18.1.0, which was +This file was extended by Mesa $as_me 18.1.1, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -30623,7 +30623,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ -Mesa config.status 18.1.0 +Mesa config.status 18.1.1 configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" diff -Nru mesa-18.1.0/debian/changelog mesa-18.1.1/debian/changelog --- mesa-18.1.0/debian/changelog 2018-06-13 09:19:16.000000000 +0000 +++ mesa-18.1.1/debian/changelog 2018-06-13 09:19:18.000000000 +0000 @@ -1,3 +1,17 @@ +mesa (18.1.1-1ubuntu1) cosmic; urgency=medium + + * Merge from Debian. + * glvnd-fix-a-segfault-in-eglgetprocaddess.diff: Backport a commit to + fix a segfault. (LP: #1776499) + + -- Timo Aaltonen Wed, 13 Jun 2018 12:10:21 +0300 + +mesa (18.1.1-1) unstable; urgency=medium + + * New upstream release. (Closes: #901342) + + -- Timo Aaltonen Wed, 13 Jun 2018 11:46:04 +0300 + mesa (18.1.0-1ubuntu1) cosmic; urgency=medium * Merge from Debian experimental. @@ -19,6 +33,13 @@ -- Andreas Boll Sat, 26 May 2018 10:34:44 +0200 +mesa (18.0.5-1) unstable; urgency=medium + + * New upstream release. + - Fixes compositor freezes with XServer 1.20. Closes: #900149. + + -- Emilio Pozuelo Monfort Mon, 04 Jun 2018 09:51:42 +0200 + mesa (18.0.4-1ubuntu1) cosmic; urgency=medium * Merge from Debian. diff -Nru mesa-18.1.0/debian/patches/glvnd-fix-a-segfault-in-eglgetprocaddess.diff mesa-18.1.1/debian/patches/glvnd-fix-a-segfault-in-eglgetprocaddess.diff --- mesa-18.1.0/debian/patches/glvnd-fix-a-segfault-in-eglgetprocaddess.diff 1970-01-01 00:00:00.000000000 +0000 +++ mesa-18.1.1/debian/patches/glvnd-fix-a-segfault-in-eglgetprocaddess.diff 2018-06-13 09:19:18.000000000 +0000 @@ -0,0 +1,67 @@ +commit 41642bdbca007035772fbfdc311f14daa5510d5d +Author: Kyle Brenneman +Date: Wed Jun 6 09:08:47 2018 -0600 + + egl/glvnd: Fix a segfault in eglGetProcAddress. + + If FindProcIndex in egldispatchstubs.c is called with a name that's less than + the first entry in the array, it would end up trying to store an index of -1 in + an unsigned integer, wrap around to 2^32, and then crash when it tries to look + that up. + + Change FindProcIndex so that it uses bsearch(3) instead of implementing its own + binary search, like the GLX equivalent FindGLXFunction does. + + Reviewed-by: Eric Engestrom + +diff --git a/src/egl/main/egldispatchstubs.c b/src/egl/main/egldispatchstubs.c +index e02abd7a9e0..bfc3195c779 100644 +--- a/src/egl/main/egldispatchstubs.c ++++ b/src/egl/main/egldispatchstubs.c +@@ -2,6 +2,7 @@ + #include "g_egldispatchstubs.h" + + #include ++#include + + #include "eglcurrent.h" + +@@ -10,26 +11,21 @@ static const __EGLapiExports *exports; + const int __EGL_DISPATCH_FUNC_COUNT = __EGL_DISPATCH_COUNT; + int __EGL_DISPATCH_FUNC_INDICES[__EGL_DISPATCH_COUNT + 1]; + ++static int Compare(const void *l, const void *r) ++{ ++ const char *s = *(const char **)r; ++ return strcmp(l, s); ++} ++ + static int FindProcIndex(const char *name) + { +- unsigned first = 0; +- unsigned last = __EGL_DISPATCH_COUNT - 1; +- +- while (first <= last) { +- unsigned middle = (first + last) / 2; +- int comp = strcmp(name, +- __EGL_DISPATCH_FUNC_NAMES[middle]); +- +- if (comp > 0) +- first = middle + 1; +- else if (comp < 0) +- last = middle - 1; +- else +- return middle; +- } ++ const char **match = bsearch(name, __EGL_DISPATCH_FUNC_NAMES, ++ __EGL_DISPATCH_COUNT, sizeof(const char *), Compare); ++ ++ if (match == NULL) ++ return __EGL_DISPATCH_COUNT; + +- /* Just point to the dummy entry at the end of the respective table */ +- return __EGL_DISPATCH_COUNT; ++ return match - __EGL_DISPATCH_FUNC_NAMES; + } + + void __eglInitDispatchStubs(const __EGLapiExports *exportsTable) diff -Nru mesa-18.1.0/debian/patches/series mesa-18.1.1/debian/patches/series --- mesa-18.1.0/debian/patches/series 2018-06-13 09:19:16.000000000 +0000 +++ mesa-18.1.1/debian/patches/series 2018-06-13 09:19:18.000000000 +0000 @@ -7,3 +7,4 @@ # Ubuntu patches. dont-enable-10bpc-by-default.diff disable-intel-ccs-compression.diff +glvnd-fix-a-segfault-in-eglgetprocaddess.diff diff -Nru mesa-18.1.0/docs/relnotes/18.1.0.html mesa-18.1.1/docs/relnotes/18.1.0.html --- mesa-18.1.0/docs/relnotes/18.1.0.html 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/docs/relnotes/18.1.0.html 2018-06-01 15:18:20.000000000 +0000 @@ -14,7 +14,7 @@
-

Mesa 18.1.0 Release Notes / TBD

+

Mesa 18.1.0 Release Notes / May 18 2018

Mesa 18.1.0 is a new development release. People who are concerned @@ -33,7 +33,8 @@

SHA256 checksums

-TBD.
+b1c1dbb42597190503d3abc518b12de880623f097c6cb6c293ecf69ae87e6fbf  mesa-18.1.0.tar.gz
+c855c5b67ef993b7621f76d8b120769ec0415f1c3616eaff44ef7f7f300aceba  mesa-18.1.0.tar.xz
diff -Nru mesa-18.1.0/docs/relnotes/18.1.1.html mesa-18.1.1/docs/relnotes/18.1.1.html --- mesa-18.1.0/docs/relnotes/18.1.1.html 1970-01-01 00:00:00.000000000 +0000 +++ mesa-18.1.1/docs/relnotes/18.1.1.html 2018-06-01 15:18:20.000000000 +0000 @@ -0,0 +1,167 @@ + + + + + Mesa Release Notes + + + + +
+

The Mesa 3D Graphics Library

+
+ + +
+ +

Mesa 18.1.1 Release Notes / June 1 2018

+ +

+Mesa 18.1.1 is a bug fix release which fixes bugs found since the 18.1.0 release. +

+

+Mesa 18.1.1 implements the OpenGL 4.5 API, but the version reported by +glGetString(GL_VERSION) or glGetIntegerv(GL_MAJOR_VERSION) / +glGetIntegerv(GL_MINOR_VERSION) depends on the particular driver being used. +Some drivers don't support all the features required in OpenGL 4.5. OpenGL +4.5 is only available if requested at context creation. +Compatibility contexts may report a lower version depending on each driver. +

+ + +

SHA256 checksums

+
+TBD
+
+ + +

New features

+ +

None

+ +

Bug fixes

+ +

None

+ +

Changes

+

Anuj Phogat (1):

+
    +
  • i965/glk: Add l3 banks count for 2x6 configuration
    • +
+ +

Bas Nieuwenhuizen (7):

+
    +
  • radv: Fix multiview queries.
    • +
  • radv: Translate logic ops.
    • +
  • radv: Fix up 2_10_10_10 alpha sign.
    • +
  • radv: Disable texel buffers with A2 SNORM/SSCALED/SINT for pre-vega.
    • +
  • amd/addrlib: Use defines in autotools build.
    • +
  • radv: Fix SRGB compute copies.
    • +
  • radv: Only expose subgroup shuffles on VI+.
    • +
+ +

Christoph Haag (1):

+
    +
  • radv: fix VK_EXT_descriptor_indexing
    • +
+ +

Dave Airlie (5):

+
    +
  • radv/resolve: do fmask decompress on all layers.
    • +
  • radv: resolve all layers in compute resolve path.
    • +
  • radv: use compute path for multi-layer images.
    • +
  • virgl: set texture buffer offset alignment to disable ARB_texture_buffer_range.
    • +
  • tgsi/scan: add hw atomic to the list of memory accessing files
    • +
+ +

Dylan Baker (2):

+
    +
  • docs: Add sha sums for release
    • +
  • VERSION: bump to 18.1.1 for next release
    • +
+ +

Eric Engestrom (1):

+
    +
  • vulkan: don't free uninitialised memory
    • +
+ +

Francisco Jerez (4):

+
    +
  • Revert "mesa: simplify _mesa_is_image_unit_valid for buffers"
    • +
  • i965: Move buffer texture size calculation into a common helper function.
    • +
  • i965: Handle non-zero texture buffer offsets in buffer object range calculation.
    • +
  • i965: Use intel_bufferobj_buffer() wrapper in image surface state setup.
    • +
+ +

Ilia Mirkin (1):

+
    +
  • nv30: ensure that displayable formats are marked accordingly
    • +
+ +

Jan Vesely (1):

+
    +
  • eg/compute: Use reference counting to handle compute memory pool.
    • +
+ +

Jason Ekstrand (2):

+
    +
  • intel/eu: Set EXECUTE_1 when setting the rounding mode in cr0
    • +
  • intel/blorp: Support blits and clears on surfaces with offsets
    • +
+ +

Jose Dapena Paz (1):

+
    +
  • mesa: do not leak ctx->Shader.ReferencedProgram references
    • +
+ +

Kai Wasserbäch (1):

+
    +
  • opencl: autotools: Fix linking order for OpenCL target
    • +
+ +

Marek Olšák (3):

+
    +
  • st/mesa: simplify lastLevel determination in st_finalize_texture
    • +
  • radeonsi: fix incorrect parentheses around VS-PS varying elimination
    • +
  • mesa: handle GL_UNSIGNED_INT64_ARB properly (v2)
    • +
+ +

Michel Dänzer (1):

+
    +
  • dri3: Stricter SBC wraparound handling
    • +
+ +

Nanley Chery (4):

+
    +
  • i965: Add and use a getter for the miptree aux buffer
    • +
  • i965: Add and use a single miptree aux_buf field
    • +
  • i965/miptree: Fix handling of uninitialized MCS buffers
    • +
  • i965/miptree: Zero-initialize CCS_D buffers
    • +
+ +

Samuel Pitoiset (2):

+
    +
  • spirv: fix visiting inner loops with same break/continue block
    • +
  • radv: fix centroid interpolation
    • +
+ +

Stuart Young (1):

+
    +
  • etnaviv: Fix missing rnndb file in tarballs
    • +
+ +

Thierry Reding (3):

+
    +
  • tegra: Treat resources with modifiers as scanout
    • +
  • tegra: Fix scanout resources without modifiers
    • +
  • tegra: Remove usage of non-stable UAPI
    • +
+ +

Timothy Arceri (1):

+
    +
  • mesa: add glUniform*ui{v} support to display lists
    • +
+ +
+ + diff -Nru mesa-18.1.0/src/amd/common/sid.h mesa-18.1.1/src/amd/common/sid.h --- mesa-18.1.0/src/amd/common/sid.h 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/amd/common/sid.h 2018-06-01 15:18:20.000000000 +0000 @@ -6892,34 +6892,22 @@ #define S_028808_ROP3(x) (((unsigned)(x) & 0xFF) << 16) #define G_028808_ROP3(x) (((x) >> 16) & 0xFF) #define C_028808_ROP3 0xFF00FFFF -#define V_028808_X_0X00 0x00 -#define V_028808_X_0X05 0x05 -#define V_028808_X_0X0A 0x0A -#define V_028808_X_0X0F 0x0F -#define V_028808_X_0X11 0x11 -#define V_028808_X_0X22 0x22 -#define V_028808_X_0X33 0x33 -#define V_028808_X_0X44 0x44 -#define V_028808_X_0X50 0x50 -#define V_028808_X_0X55 0x55 -#define V_028808_X_0X5A 0x5A -#define V_028808_X_0X5F 0x5F -#define V_028808_X_0X66 0x66 -#define V_028808_X_0X77 0x77 -#define V_028808_X_0X88 0x88 -#define V_028808_X_0X99 0x99 -#define V_028808_X_0XA0 0xA0 -#define V_028808_X_0XA5 0xA5 -#define V_028808_X_0XAA 0xAA -#define V_028808_X_0XAF 0xAF -#define V_028808_X_0XBB 0xBB -#define V_028808_X_0XCC 0xCC -#define V_028808_X_0XDD 0xDD -#define V_028808_X_0XEE 0xEE -#define V_028808_X_0XF0 0xF0 -#define V_028808_X_0XF5 0xF5 -#define V_028808_X_0XFA 0xFA -#define V_028808_X_0XFF 0xFF +#define V_028808_ROP3_CLEAR 0x00 +#define V_028808_ROP3_NOR 0x11 +#define V_028808_ROP3_AND_INVERTED 0x22 +#define V_028808_ROP3_COPY_INVERTED 0x33 +#define V_028808_ROP3_AND_REVERSE 0x44 +#define V_028808_ROP3_INVERT 0x55 +#define V_028808_ROP3_XOR 0x66 +#define V_028808_ROP3_NAND 0x77 +#define V_028808_ROP3_AND 0x88 +#define V_028808_ROP3_EQUIVALENT 0x99 +#define V_028808_ROP3_NO_OP 0xaa +#define V_028808_ROP3_OR_INVERTED 0xbb +#define V_028808_ROP3_COPY 0xcc +#define V_028808_ROP3_OR_REVERSE 0xdd +#define V_028808_ROP3_OR 0xee +#define V_028808_ROP3_SET 0xff #define R_02880C_DB_SHADER_CONTROL 0x02880C #define S_02880C_Z_EXPORT_ENABLE(x) (((unsigned)(x) & 0x1) << 0) #define G_02880C_Z_EXPORT_ENABLE(x) (((x) >> 0) & 0x1) diff -Nru mesa-18.1.0/src/amd/common/sid_tables.h mesa-18.1.1/src/amd/common/sid_tables.h --- mesa-18.1.0/src/amd/common/sid_tables.h 2018-05-18 23:29:43.000000000 +0000 +++ mesa-18.1.1/src/amd/common/sid_tables.h 2018-06-01 15:19:13.000000000 +0000 @@ -3588,240 +3588,240 @@ {22279, S_028808_MODE(~0u), 7, 902}, {56628, S_028808_ROP3(~0u), 256, 909}, /* 1549 */ - {57775, S_02880C_Z_EXPORT_ENABLE(~0u)}, - {57791, S_02880C_STENCIL_TEST_VAL_EXPORT_ENABLE(~0u)}, - {57822, S_02880C_STENCIL_OP_VAL_EXPORT_ENABLE(~0u)}, + {57780, S_02880C_Z_EXPORT_ENABLE(~0u)}, + {57796, S_02880C_STENCIL_TEST_VAL_EXPORT_ENABLE(~0u)}, + {57827, S_02880C_STENCIL_OP_VAL_EXPORT_ENABLE(~0u)}, {49012, S_02880C_Z_ORDER(~0u), 4, 1165}, - {57901, S_02880C_KILL_ENABLE(~0u)}, - {57913, S_02880C_COVERAGE_TO_MASK_ENABLE(~0u)}, - {57937, S_02880C_MASK_EXPORT_ENABLE(~0u)}, - {57956, S_02880C_EXEC_ON_HIER_FAIL(~0u)}, - {57974, S_02880C_EXEC_ON_NOOP(~0u)}, - {57987, S_02880C_ALPHA_TO_MASK_DISABLE(~0u)}, - {58009, S_02880C_DEPTH_BEFORE_SHADER(~0u)}, - {58099, S_02880C_CONSERVATIVE_Z_EXPORT(~0u), 4, 1169}, - {58121, S_02880C_DUAL_QUAD_DISABLE(~0u)}, + {57906, S_02880C_KILL_ENABLE(~0u)}, + {57918, S_02880C_COVERAGE_TO_MASK_ENABLE(~0u)}, + {57942, S_02880C_MASK_EXPORT_ENABLE(~0u)}, + {57961, S_02880C_EXEC_ON_HIER_FAIL(~0u)}, + {57979, S_02880C_EXEC_ON_NOOP(~0u)}, + {57992, S_02880C_ALPHA_TO_MASK_DISABLE(~0u)}, + {58014, S_02880C_DEPTH_BEFORE_SHADER(~0u)}, + {58104, S_02880C_CONSERVATIVE_Z_EXPORT(~0u), 4, 1169}, + {58126, S_02880C_DUAL_QUAD_DISABLE(~0u)}, /* 1562 */ - {58139, S_028810_UCP_ENA_0(~0u)}, - {58149, S_028810_UCP_ENA_1(~0u)}, - {58159, S_028810_UCP_ENA_2(~0u)}, - {58169, S_028810_UCP_ENA_3(~0u)}, - {58179, S_028810_UCP_ENA_4(~0u)}, - {58189, S_028810_UCP_ENA_5(~0u)}, - {58199, S_028810_PS_UCP_Y_SCALE_NEG(~0u)}, - {58218, S_028810_PS_UCP_MODE(~0u)}, - {58230, S_028810_CLIP_DISABLE(~0u)}, - {58243, S_028810_UCP_CULL_ONLY_ENA(~0u)}, - {58261, S_028810_BOUNDARY_EDGE_FLAG_ENA(~0u)}, - {58284, S_028810_DX_CLIP_SPACE_DEF(~0u)}, - {58302, S_028810_DIS_CLIP_ERR_DETECT(~0u)}, - {58322, S_028810_VTX_KILL_OR(~0u)}, - {58334, S_028810_DX_RASTERIZATION_KILL(~0u)}, - {58356, S_028810_DX_LINEAR_ATTR_CLIP_ENA(~0u)}, - {58380, S_028810_VTE_VPORT_PROVOKE_DISABLE(~0u)}, - {58406, S_028810_ZCLIP_NEAR_DISABLE(~0u)}, - {58425, S_028810_ZCLIP_FAR_DISABLE(~0u)}, + {58144, S_028810_UCP_ENA_0(~0u)}, + {58154, S_028810_UCP_ENA_1(~0u)}, + {58164, S_028810_UCP_ENA_2(~0u)}, + {58174, S_028810_UCP_ENA_3(~0u)}, + {58184, S_028810_UCP_ENA_4(~0u)}, + {58194, S_028810_UCP_ENA_5(~0u)}, + {58204, S_028810_PS_UCP_Y_SCALE_NEG(~0u)}, + {58223, S_028810_PS_UCP_MODE(~0u)}, + {58235, S_028810_CLIP_DISABLE(~0u)}, + {58248, S_028810_UCP_CULL_ONLY_ENA(~0u)}, + {58266, S_028810_BOUNDARY_EDGE_FLAG_ENA(~0u)}, + {58289, S_028810_DX_CLIP_SPACE_DEF(~0u)}, + {58307, S_028810_DIS_CLIP_ERR_DETECT(~0u)}, + {58327, S_028810_VTX_KILL_OR(~0u)}, + {58339, S_028810_DX_RASTERIZATION_KILL(~0u)}, + {58361, S_028810_DX_LINEAR_ATTR_CLIP_ENA(~0u)}, + {58385, S_028810_VTE_VPORT_PROVOKE_DISABLE(~0u)}, + {58411, S_028810_ZCLIP_NEAR_DISABLE(~0u)}, + {58430, S_028810_ZCLIP_FAR_DISABLE(~0u)}, /* 1581 */ - {58443, S_028814_CULL_FRONT(~0u)}, - {58454, S_028814_CULL_BACK(~0u)}, + {58448, S_028814_CULL_FRONT(~0u)}, + {58459, S_028814_CULL_BACK(~0u)}, {22820, S_028814_FACE(~0u)}, - {58474, S_028814_POLY_MODE(~0u), 2, 1173}, - {58540, S_028814_POLYMODE_FRONT_PTYPE(~0u), 3, 1175}, - {58561, S_028814_POLYMODE_BACK_PTYPE(~0u), 3, 1175}, - {58581, S_028814_POLY_OFFSET_FRONT_ENABLE(~0u)}, - {58606, S_028814_POLY_OFFSET_BACK_ENABLE(~0u)}, - {58630, S_028814_POLY_OFFSET_PARA_ENABLE(~0u)}, - {58654, S_028814_VTX_WINDOW_OFFSET_ENABLE(~0u)}, - {58679, S_028814_PROVOKING_VTX_LAST(~0u)}, - {58698, S_028814_PERSP_CORR_DIS(~0u)}, - {58713, S_028814_MULTI_PRIM_IB_ENA(~0u)}, + {58479, S_028814_POLY_MODE(~0u), 2, 1173}, + {58545, S_028814_POLYMODE_FRONT_PTYPE(~0u), 3, 1175}, + {58566, S_028814_POLYMODE_BACK_PTYPE(~0u), 3, 1175}, + {58586, S_028814_POLY_OFFSET_FRONT_ENABLE(~0u)}, + {58611, S_028814_POLY_OFFSET_BACK_ENABLE(~0u)}, + {58635, S_028814_POLY_OFFSET_PARA_ENABLE(~0u)}, + {58659, S_028814_VTX_WINDOW_OFFSET_ENABLE(~0u)}, + {58684, S_028814_PROVOKING_VTX_LAST(~0u)}, + {58703, S_028814_PERSP_CORR_DIS(~0u)}, + {58718, S_028814_MULTI_PRIM_IB_ENA(~0u)}, /* 1594 */ - {58731, S_028818_VPORT_X_SCALE_ENA(~0u)}, - {58749, S_028818_VPORT_X_OFFSET_ENA(~0u)}, - {58768, S_028818_VPORT_Y_SCALE_ENA(~0u)}, - {58786, S_028818_VPORT_Y_OFFSET_ENA(~0u)}, - {58805, S_028818_VPORT_Z_SCALE_ENA(~0u)}, - {58823, S_028818_VPORT_Z_OFFSET_ENA(~0u)}, - {58842, S_028818_VTX_XY_FMT(~0u)}, - {58853, S_028818_VTX_Z_FMT(~0u)}, - {58863, S_028818_VTX_W0_FMT(~0u)}, + {58736, S_028818_VPORT_X_SCALE_ENA(~0u)}, + {58754, S_028818_VPORT_X_OFFSET_ENA(~0u)}, + {58773, S_028818_VPORT_Y_SCALE_ENA(~0u)}, + {58791, S_028818_VPORT_Y_OFFSET_ENA(~0u)}, + {58810, S_028818_VPORT_Z_SCALE_ENA(~0u)}, + {58828, S_028818_VPORT_Z_OFFSET_ENA(~0u)}, + {58847, S_028818_VTX_XY_FMT(~0u)}, + {58858, S_028818_VTX_Z_FMT(~0u)}, + {58868, S_028818_VTX_W0_FMT(~0u)}, /* 1603 */ - {58874, S_02881C_CLIP_DIST_ENA_0(~0u)}, - {58890, S_02881C_CLIP_DIST_ENA_1(~0u)}, - {58906, S_02881C_CLIP_DIST_ENA_2(~0u)}, - {58922, S_02881C_CLIP_DIST_ENA_3(~0u)}, - {58938, S_02881C_CLIP_DIST_ENA_4(~0u)}, - {58954, S_02881C_CLIP_DIST_ENA_5(~0u)}, - {58970, S_02881C_CLIP_DIST_ENA_6(~0u)}, - {58986, S_02881C_CLIP_DIST_ENA_7(~0u)}, - {59002, S_02881C_CULL_DIST_ENA_0(~0u)}, - {59018, S_02881C_CULL_DIST_ENA_1(~0u)}, - {59034, S_02881C_CULL_DIST_ENA_2(~0u)}, - {59050, S_02881C_CULL_DIST_ENA_3(~0u)}, - {59066, S_02881C_CULL_DIST_ENA_4(~0u)}, - {59082, S_02881C_CULL_DIST_ENA_5(~0u)}, - {59098, S_02881C_CULL_DIST_ENA_6(~0u)}, - {59114, S_02881C_CULL_DIST_ENA_7(~0u)}, - {59130, S_02881C_USE_VTX_POINT_SIZE(~0u)}, - {59149, S_02881C_USE_VTX_EDGE_FLAG(~0u)}, - {59167, S_02881C_USE_VTX_RENDER_TARGET_INDX(~0u)}, - {59194, S_02881C_USE_VTX_VIEWPORT_INDX(~0u)}, - {59216, S_02881C_USE_VTX_KILL_FLAG(~0u)}, - {59234, S_02881C_VS_OUT_MISC_VEC_ENA(~0u)}, - {59254, S_02881C_VS_OUT_CCDIST0_VEC_ENA(~0u)}, - {59277, S_02881C_VS_OUT_CCDIST1_VEC_ENA(~0u)}, - {59300, S_02881C_VS_OUT_MISC_SIDE_BUS_ENA(~0u)}, - {59325, S_02881C_USE_VTX_GS_CUT_FLAG(~0u)}, - {59345, S_02881C_USE_VTX_LINE_WIDTH(~0u)}, + {58879, S_02881C_CLIP_DIST_ENA_0(~0u)}, + {58895, S_02881C_CLIP_DIST_ENA_1(~0u)}, + {58911, S_02881C_CLIP_DIST_ENA_2(~0u)}, + {58927, S_02881C_CLIP_DIST_ENA_3(~0u)}, + {58943, S_02881C_CLIP_DIST_ENA_4(~0u)}, + {58959, S_02881C_CLIP_DIST_ENA_5(~0u)}, + {58975, S_02881C_CLIP_DIST_ENA_6(~0u)}, + {58991, S_02881C_CLIP_DIST_ENA_7(~0u)}, + {59007, S_02881C_CULL_DIST_ENA_0(~0u)}, + {59023, S_02881C_CULL_DIST_ENA_1(~0u)}, + {59039, S_02881C_CULL_DIST_ENA_2(~0u)}, + {59055, S_02881C_CULL_DIST_ENA_3(~0u)}, + {59071, S_02881C_CULL_DIST_ENA_4(~0u)}, + {59087, S_02881C_CULL_DIST_ENA_5(~0u)}, + {59103, S_02881C_CULL_DIST_ENA_6(~0u)}, + {59119, S_02881C_CULL_DIST_ENA_7(~0u)}, + {59135, S_02881C_USE_VTX_POINT_SIZE(~0u)}, + {59154, S_02881C_USE_VTX_EDGE_FLAG(~0u)}, + {59172, S_02881C_USE_VTX_RENDER_TARGET_INDX(~0u)}, + {59199, S_02881C_USE_VTX_VIEWPORT_INDX(~0u)}, + {59221, S_02881C_USE_VTX_KILL_FLAG(~0u)}, + {59239, S_02881C_VS_OUT_MISC_VEC_ENA(~0u)}, + {59259, S_02881C_VS_OUT_CCDIST0_VEC_ENA(~0u)}, + {59282, S_02881C_VS_OUT_CCDIST1_VEC_ENA(~0u)}, + {59305, S_02881C_VS_OUT_MISC_SIDE_BUS_ENA(~0u)}, + {59330, S_02881C_USE_VTX_GS_CUT_FLAG(~0u)}, + {59350, S_02881C_USE_VTX_LINE_WIDTH(~0u)}, /* 1630 */ - {59364, S_028820_VTE_XY_INF_DISCARD(~0u)}, - {59383, S_028820_VTE_Z_INF_DISCARD(~0u)}, - {59401, S_028820_VTE_W_INF_DISCARD(~0u)}, - {59419, S_028820_VTE_0XNANINF_IS_0(~0u)}, - {59437, S_028820_VTE_XY_NAN_RETAIN(~0u)}, - {59455, S_028820_VTE_Z_NAN_RETAIN(~0u)}, - {59472, S_028820_VTE_W_NAN_RETAIN(~0u)}, - {59489, S_028820_VTE_W_RECIP_NAN_IS_0(~0u)}, - {59510, S_028820_VS_XY_NAN_TO_INF(~0u)}, - {59527, S_028820_VS_XY_INF_RETAIN(~0u)}, - {59544, S_028820_VS_Z_NAN_TO_INF(~0u)}, - {59560, S_028820_VS_Z_INF_RETAIN(~0u)}, - {59576, S_028820_VS_W_NAN_TO_INF(~0u)}, - {59592, S_028820_VS_W_INF_RETAIN(~0u)}, - {59608, S_028820_VS_CLIP_DIST_INF_DISCARD(~0u)}, - {59633, S_028820_VTE_NO_OUTPUT_NEG_0(~0u)}, + {59369, S_028820_VTE_XY_INF_DISCARD(~0u)}, + {59388, S_028820_VTE_Z_INF_DISCARD(~0u)}, + {59406, S_028820_VTE_W_INF_DISCARD(~0u)}, + {59424, S_028820_VTE_0XNANINF_IS_0(~0u)}, + {59442, S_028820_VTE_XY_NAN_RETAIN(~0u)}, + {59460, S_028820_VTE_Z_NAN_RETAIN(~0u)}, + {59477, S_028820_VTE_W_NAN_RETAIN(~0u)}, + {59494, S_028820_VTE_W_RECIP_NAN_IS_0(~0u)}, + {59515, S_028820_VS_XY_NAN_TO_INF(~0u)}, + {59532, S_028820_VS_XY_INF_RETAIN(~0u)}, + {59549, S_028820_VS_Z_NAN_TO_INF(~0u)}, + {59565, S_028820_VS_Z_INF_RETAIN(~0u)}, + {59581, S_028820_VS_W_NAN_TO_INF(~0u)}, + {59597, S_028820_VS_W_INF_RETAIN(~0u)}, + {59613, S_028820_VS_CLIP_DIST_INF_DISCARD(~0u)}, + {59638, S_028820_VTE_NO_OUTPUT_NEG_0(~0u)}, /* 1646 */ - {59653, S_028824_LINE_STIPPLE_RESET(~0u)}, - {59672, S_028824_EXPAND_FULL_LENGTH(~0u)}, - {59691, S_028824_FRACTIONAL_ACCUM(~0u)}, - {59708, S_028824_DIAMOND_ADJUST(~0u)}, + {59658, S_028824_LINE_STIPPLE_RESET(~0u)}, + {59677, S_028824_EXPAND_FULL_LENGTH(~0u)}, + {59696, S_028824_FRACTIONAL_ACCUM(~0u)}, + {59713, S_028824_DIAMOND_ADJUST(~0u)}, /* 1650 */ - {59723, S_02882C_TRIANGLE_FILTER_DISABLE(~0u)}, - {59747, S_02882C_LINE_FILTER_DISABLE(~0u)}, - {59767, S_02882C_POINT_FILTER_DISABLE(~0u)}, - {59788, S_02882C_RECTANGLE_FILTER_DISABLE(~0u)}, - {59813, S_02882C_TRIANGLE_EXPAND_ENA(~0u)}, - {59833, S_02882C_LINE_EXPAND_ENA(~0u)}, - {59849, S_02882C_POINT_EXPAND_ENA(~0u)}, - {59866, S_02882C_RECTANGLE_EXPAND_ENA(~0u)}, - {59887, S_02882C_PRIM_EXPAND_CONSTANT(~0u)}, - {59908, S_02882C_XMAX_RIGHT_EXCLUSION(~0u)}, - {59929, S_02882C_YMAX_BOTTOM_EXCLUSION(~0u)}, + {59728, S_02882C_TRIANGLE_FILTER_DISABLE(~0u)}, + {59752, S_02882C_LINE_FILTER_DISABLE(~0u)}, + {59772, S_02882C_POINT_FILTER_DISABLE(~0u)}, + {59793, S_02882C_RECTANGLE_FILTER_DISABLE(~0u)}, + {59818, S_02882C_TRIANGLE_EXPAND_ENA(~0u)}, + {59838, S_02882C_LINE_EXPAND_ENA(~0u)}, + {59854, S_02882C_POINT_EXPAND_ENA(~0u)}, + {59871, S_02882C_RECTANGLE_EXPAND_ENA(~0u)}, + {59892, S_02882C_PRIM_EXPAND_CONSTANT(~0u)}, + {59913, S_02882C_XMAX_RIGHT_EXCLUSION(~0u)}, + {59934, S_02882C_YMAX_BOTTOM_EXCLUSION(~0u)}, /* 1661 */ - {59951, S_028830_SMALL_PRIM_FILTER_ENABLE(~0u)}, - {59723, S_028830_TRIANGLE_FILTER_DISABLE(~0u)}, - {59747, S_028830_LINE_FILTER_DISABLE(~0u)}, - {59767, S_028830_POINT_FILTER_DISABLE(~0u)}, - {59788, S_028830_RECTANGLE_FILTER_DISABLE(~0u)}, + {59956, S_028830_SMALL_PRIM_FILTER_ENABLE(~0u)}, + {59728, S_028830_TRIANGLE_FILTER_DISABLE(~0u)}, + {59752, S_028830_LINE_FILTER_DISABLE(~0u)}, + {59772, S_028830_POINT_FILTER_DISABLE(~0u)}, + {59793, S_028830_RECTANGLE_FILTER_DISABLE(~0u)}, /* 1666 */ {42242, S_028A00_HEIGHT(~0u)}, {42236, S_028A00_WIDTH(~0u)}, /* 1668 */ - {59976, S_028A04_MIN_SIZE(~0u)}, + {59981, S_028A04_MIN_SIZE(~0u)}, {22515, S_028A04_MAX_SIZE(~0u)}, /* 1670 */ {42236, S_028A08_WIDTH(~0u)}, /* 1671 */ - {59985, S_028A0C_LINE_PATTERN(~0u)}, - {59998, S_028A0C_REPEAT_COUNT(~0u)}, - {60011, S_028A0C_PATTERN_BIT_ORDER(~0u)}, - {60029, S_028A0C_AUTO_RESET_CNTL(~0u)}, + {59990, S_028A0C_LINE_PATTERN(~0u)}, + {60003, S_028A0C_REPEAT_COUNT(~0u)}, + {60016, S_028A0C_PATTERN_BIT_ORDER(~0u)}, + {60034, S_028A0C_AUTO_RESET_CNTL(~0u)}, /* 1675 */ - {60150, S_028A10_PATH_SELECT(~0u), 5, 1178}, + {60155, S_028A10_PATH_SELECT(~0u), 5, 1178}, /* 1676 */ - {60162, S_028A14_TESS_MODE(~0u)}, + {60167, S_028A14_TESS_MODE(~0u)}, /* 1677 */ {22108, S_028A20_REUSE_DEPTH(~0u)}, /* 1678 */ {22130, S_028A24_PRIM_TYPE(~0u), 18, 1183}, - {60527, S_028A24_RETAIN_ORDER(~0u)}, - {60540, S_028A24_RETAIN_QUADS(~0u)}, - {60621, S_028A24_PRIM_ORDER(~0u), 5, 1201}, + {60532, S_028A24_RETAIN_ORDER(~0u)}, + {60545, S_028A24_RETAIN_QUADS(~0u)}, + {60626, S_028A24_PRIM_ORDER(~0u), 5, 1201}, /* 1682 */ {22150, S_028A28_FIRST_DECR(~0u)}, /* 1683 */ {22156, S_028A2C_DECR(~0u)}, /* 1684 */ - {60632, S_028A30_COMP_X_EN(~0u)}, - {60642, S_028A30_COMP_Y_EN(~0u)}, - {60652, S_028A30_COMP_Z_EN(~0u)}, - {60662, S_028A30_COMP_W_EN(~0u)}, + {60637, S_028A30_COMP_X_EN(~0u)}, + {60647, S_028A30_COMP_Y_EN(~0u)}, + {60657, S_028A30_COMP_Z_EN(~0u)}, + {60667, S_028A30_COMP_W_EN(~0u)}, {23319, S_028A30_STRIDE(~0u)}, - {60672, S_028A30_SHIFT(~0u)}, + {60677, S_028A30_SHIFT(~0u)}, /* 1690 */ - {60632, S_028A34_COMP_X_EN(~0u)}, - {60642, S_028A34_COMP_Y_EN(~0u)}, - {60652, S_028A34_COMP_Z_EN(~0u)}, - {60662, S_028A34_COMP_W_EN(~0u)}, + {60637, S_028A34_COMP_X_EN(~0u)}, + {60647, S_028A34_COMP_Y_EN(~0u)}, + {60657, S_028A34_COMP_Z_EN(~0u)}, + {60667, S_028A34_COMP_W_EN(~0u)}, {23319, S_028A34_STRIDE(~0u)}, - {60672, S_028A34_SHIFT(~0u)}, + {60677, S_028A34_SHIFT(~0u)}, /* 1696 */ - {60837, S_028A38_X_CONV(~0u), 9, 1206}, + {60842, S_028A38_X_CONV(~0u), 9, 1206}, {17707, S_028A38_X_OFFSET(~0u)}, - {60844, S_028A38_Y_CONV(~0u), 9, 1206}, + {60849, S_028A38_Y_CONV(~0u), 9, 1206}, {50257, S_028A38_Y_OFFSET(~0u)}, - {60851, S_028A38_Z_CONV(~0u), 9, 1206}, - {60858, S_028A38_Z_OFFSET(~0u)}, - {60867, S_028A38_W_CONV(~0u), 9, 1206}, + {60856, S_028A38_Z_CONV(~0u), 9, 1206}, + {60863, S_028A38_Z_OFFSET(~0u)}, + {60872, S_028A38_W_CONV(~0u), 9, 1206}, {15767, S_028A38_W_OFFSET(~0u)}, /* 1704 */ - {60837, S_028A3C_X_CONV(~0u), 9, 1206}, + {60842, S_028A3C_X_CONV(~0u), 9, 1206}, {17707, S_028A3C_X_OFFSET(~0u)}, - {60844, S_028A3C_Y_CONV(~0u), 9, 1206}, + {60849, S_028A3C_Y_CONV(~0u), 9, 1206}, {50257, S_028A3C_Y_OFFSET(~0u)}, - {60851, S_028A3C_Z_CONV(~0u), 9, 1206}, - {60858, S_028A3C_Z_OFFSET(~0u)}, - {60867, S_028A3C_W_CONV(~0u), 9, 1206}, + {60856, S_028A3C_Z_CONV(~0u), 9, 1206}, + {60863, S_028A3C_Z_OFFSET(~0u)}, + {60872, S_028A3C_W_CONV(~0u), 9, 1206}, {15767, S_028A3C_W_OFFSET(~0u)}, /* 1712 */ {22279, S_028A40_MODE(~0u), 6, 1215}, {39383, S_028A40_RESERVED_0(~0u)}, - {60992, S_028A40_CUT_MODE(~0u), 4, 1221}, + {60997, S_028A40_CUT_MODE(~0u), 4, 1221}, {39401, S_028A40_RESERVED_1(~0u)}, - {61001, S_028A40_GS_C_PACK_EN(~0u)}, - {61014, S_028A40_RESERVED_2(~0u)}, - {61025, S_028A40_ES_PASSTHRU(~0u)}, - {61037, S_028A40_COMPUTE_MODE(~0u)}, - {61050, S_028A40_FAST_COMPUTE_MODE(~0u)}, - {61068, S_028A40_ELEMENT_INFO_EN(~0u)}, - {61084, S_028A40_PARTIAL_THD_AT_EOI(~0u)}, - {61103, S_028A40_SUPPRESS_CUTS(~0u)}, - {61117, S_028A40_ES_WRITE_OPTIMIZE(~0u)}, - {61135, S_028A40_GS_WRITE_OPTIMIZE(~0u)}, - {61186, S_028A40_ONCHIP(~0u), 4, 1225}, + {61006, S_028A40_GS_C_PACK_EN(~0u)}, + {61019, S_028A40_RESERVED_2(~0u)}, + {61030, S_028A40_ES_PASSTHRU(~0u)}, + {61042, S_028A40_COMPUTE_MODE(~0u)}, + {61055, S_028A40_FAST_COMPUTE_MODE(~0u)}, + {61073, S_028A40_ELEMENT_INFO_EN(~0u)}, + {61089, S_028A40_PARTIAL_THD_AT_EOI(~0u)}, + {61108, S_028A40_SUPPRESS_CUTS(~0u)}, + {61122, S_028A40_ES_WRITE_OPTIMIZE(~0u)}, + {61140, S_028A40_GS_WRITE_OPTIMIZE(~0u)}, + {61191, S_028A40_ONCHIP(~0u), 4, 1225}, /* 1727 */ - {61193, S_028A44_ES_VERTS_PER_SUBGRP(~0u)}, - {61213, S_028A44_GS_PRIMS_PER_SUBGRP(~0u)}, + {61198, S_028A44_ES_VERTS_PER_SUBGRP(~0u)}, + {61218, S_028A44_GS_PRIMS_PER_SUBGRP(~0u)}, /* 1729 */ - {61233, S_028A48_MSAA_ENABLE(~0u)}, - {61245, S_028A48_VPORT_SCISSOR_ENABLE(~0u)}, - {61266, S_028A48_LINE_STIPPLE_ENABLE(~0u)}, - {61286, S_028A48_SEND_UNLIT_STILES_TO_PKR(~0u)}, + {61238, S_028A48_MSAA_ENABLE(~0u)}, + {61250, S_028A48_VPORT_SCISSOR_ENABLE(~0u)}, + {61271, S_028A48_LINE_STIPPLE_ENABLE(~0u)}, + {61291, S_028A48_SEND_UNLIT_STILES_TO_PKR(~0u)}, /* 1733 */ - {61311, S_028A4C_WALK_SIZE(~0u)}, - {61321, S_028A4C_WALK_ALIGNMENT(~0u)}, - {61336, S_028A4C_WALK_ALIGN8_PRIM_FITS_ST(~0u)}, - {61361, S_028A4C_WALK_FENCE_ENABLE(~0u)}, - {61379, S_028A4C_WALK_FENCE_SIZE(~0u)}, - {61395, S_028A4C_SUPERTILE_WALK_ORDER_ENABLE(~0u)}, - {61400, S_028A4C_TILE_WALK_ORDER_ENABLE(~0u)}, - {61423, S_028A4C_TILE_COVER_DISABLE(~0u)}, - {61442, S_028A4C_TILE_COVER_NO_SCISSOR(~0u)}, - {61464, S_028A4C_ZMM_LINE_EXTENT(~0u)}, - {61480, S_028A4C_ZMM_LINE_OFFSET(~0u)}, - {61496, S_028A4C_ZMM_RECT_EXTENT(~0u)}, - {61512, S_028A4C_KILL_PIX_POST_HI_Z(~0u)}, - {61531, S_028A4C_KILL_PIX_POST_DETAIL_MASK(~0u)}, - {61557, S_028A4C_PS_ITER_SAMPLE(~0u)}, - {61572, S_028A4C_MULTI_SHADER_ENGINE_PRIM_DISCARD_ENABLE(~0u)}, - {61612, S_028A4C_MULTI_GPU_SUPERTILE_ENABLE(~0u)}, - {61639, S_028A4C_GPU_ID_OVERRIDE_ENABLE(~0u)}, - {61662, S_028A4C_GPU_ID_OVERRIDE(~0u)}, - {61678, S_028A4C_MULTI_GPU_PRIM_DISCARD_ENABLE(~0u)}, - {61708, S_028A4C_FORCE_EOV_CNTDWN_ENABLE(~0u)}, - {61732, S_028A4C_FORCE_EOV_REZ_ENABLE(~0u)}, - {61753, S_028A4C_OUT_OF_ORDER_PRIMITIVE_ENABLE(~0u)}, - {61783, S_028A4C_OUT_OF_ORDER_WATER_MARK(~0u)}, + {61316, S_028A4C_WALK_SIZE(~0u)}, + {61326, S_028A4C_WALK_ALIGNMENT(~0u)}, + {61341, S_028A4C_WALK_ALIGN8_PRIM_FITS_ST(~0u)}, + {61366, S_028A4C_WALK_FENCE_ENABLE(~0u)}, + {61384, S_028A4C_WALK_FENCE_SIZE(~0u)}, + {61400, S_028A4C_SUPERTILE_WALK_ORDER_ENABLE(~0u)}, + {61405, S_028A4C_TILE_WALK_ORDER_ENABLE(~0u)}, + {61428, S_028A4C_TILE_COVER_DISABLE(~0u)}, + {61447, S_028A4C_TILE_COVER_NO_SCISSOR(~0u)}, + {61469, S_028A4C_ZMM_LINE_EXTENT(~0u)}, + {61485, S_028A4C_ZMM_LINE_OFFSET(~0u)}, + {61501, S_028A4C_ZMM_RECT_EXTENT(~0u)}, + {61517, S_028A4C_KILL_PIX_POST_HI_Z(~0u)}, + {61536, S_028A4C_KILL_PIX_POST_DETAIL_MASK(~0u)}, + {61562, S_028A4C_PS_ITER_SAMPLE(~0u)}, + {61577, S_028A4C_MULTI_SHADER_ENGINE_PRIM_DISCARD_ENABLE(~0u)}, + {61617, S_028A4C_MULTI_GPU_SUPERTILE_ENABLE(~0u)}, + {61644, S_028A4C_GPU_ID_OVERRIDE_ENABLE(~0u)}, + {61667, S_028A4C_GPU_ID_OVERRIDE(~0u)}, + {61683, S_028A4C_MULTI_GPU_PRIM_DISCARD_ENABLE(~0u)}, + {61713, S_028A4C_FORCE_EOV_CNTDWN_ENABLE(~0u)}, + {61737, S_028A4C_FORCE_EOV_REZ_ENABLE(~0u)}, + {61758, S_028A4C_OUT_OF_ORDER_PRIMITIVE_ENABLE(~0u)}, + {61788, S_028A4C_OUT_OF_ORDER_WATER_MARK(~0u)}, /* 1757 */ {22355, S_028A54_GS_PER_ES(~0u)}, /* 1758 */ @@ -3835,38 +3835,38 @@ /* 1762 */ {669, S_028A68_OFFSET(~0u)}, /* 1763 */ - {61875, S_028A6C_OUTPRIM_TYPE(~0u), 3, 1229}, - {61888, S_028A6C_OUTPRIM_TYPE_1(~0u)}, - {61903, S_028A6C_OUTPRIM_TYPE_2(~0u)}, - {61918, S_028A6C_OUTPRIM_TYPE_3(~0u)}, - {61933, S_028A6C_UNIQUE_TYPE_PER_STREAM(~0u)}, + {61880, S_028A6C_OUTPRIM_TYPE(~0u), 3, 1229}, + {61893, S_028A6C_OUTPRIM_TYPE_1(~0u)}, + {61908, S_028A6C_OUTPRIM_TYPE_2(~0u)}, + {61923, S_028A6C_OUTPRIM_TYPE_3(~0u)}, + {61938, S_028A6C_UNIQUE_TYPE_PER_STREAM(~0u)}, /* 1768 */ {203, S_028A7C_INDEX_TYPE(~0u), 3, 1232}, - {62070, S_028A7C_SWAP_MODE(~0u), 4, 1235}, - {62131, S_028A7C_BUF_TYPE(~0u), 3, 1239}, - {62173, S_028A7C_RDREQ_POLICY_CIK(~0u), 2, 1242}, - {62190, S_028A7C_RDREQ_POLICY(~0u)}, + {62075, S_028A7C_SWAP_MODE(~0u), 4, 1235}, + {62136, S_028A7C_BUF_TYPE(~0u), 3, 1239}, + {62178, S_028A7C_RDREQ_POLICY_CIK(~0u), 2, 1242}, + {62195, S_028A7C_RDREQ_POLICY(~0u)}, {40107, S_028A7C_ATC(~0u)}, {56796, S_028A7C_NOT_EOP(~0u)}, - {62203, S_028A7C_REQ_PATH(~0u)}, + {62208, S_028A7C_REQ_PATH(~0u)}, {40128, S_028A7C_MTYPE(~0u)}, /* 1777 */ {22558, S_028A84_PRIMITIVEID_EN(~0u)}, - {62212, S_028A84_DISABLE_RESET_ON_EOI(~0u)}, + {62217, S_028A84_DISABLE_RESET_ON_EOI(~0u)}, /* 1779 */ - {63168, S_028A90_EVENT_TYPE(~0u), 59, 1244}, - {63179, S_028A90_ADDRESS_HI_GFX6(~0u)}, - {63195, S_028A90_EXTENDED_EVENT(~0u)}, + {63173, S_028A90_EVENT_TYPE(~0u), 59, 1244}, + {63184, S_028A90_ADDRESS_HI_GFX6(~0u)}, + {63200, S_028A90_EXTENDED_EVENT(~0u)}, /* 1782 */ {22655, S_028A94_RESET_EN(~0u)}, /* 1783 */ - {63210, S_028AA8_PRIMGROUP_SIZE(~0u)}, - {63225, S_028AA8_PARTIAL_VS_WAVE_ON(~0u)}, - {63244, S_028AA8_SWITCH_ON_EOP(~0u)}, - {63258, S_028AA8_PARTIAL_ES_WAVE_ON(~0u)}, - {63277, S_028AA8_SWITCH_ON_EOI(~0u)}, - {63291, S_028AA8_WD_SWITCH_ON_EOP(~0u)}, - {63308, S_028AA8_MAX_PRIMGRP_IN_WAVE(~0u)}, + {63215, S_028AA8_PRIMGROUP_SIZE(~0u)}, + {63230, S_028AA8_PARTIAL_VS_WAVE_ON(~0u)}, + {63249, S_028AA8_SWITCH_ON_EOP(~0u)}, + {63263, S_028AA8_PARTIAL_ES_WAVE_ON(~0u)}, + {63282, S_028AA8_SWITCH_ON_EOI(~0u)}, + {63296, S_028AA8_WD_SWITCH_ON_EOP(~0u)}, + {63313, S_028AA8_MAX_PRIMGRP_IN_WAVE(~0u)}, /* 1790 */ {22747, S_028AAC_ITEMSIZE(~0u)}, /* 1791 */ @@ -3877,28 +3877,28 @@ {22797, S_028AB8_VTX_CNT_EN(~0u)}, /* 1794 */ {43461, S_028ABC_LINEAR(~0u)}, - {63328, S_028ABC_FULL_CACHE(~0u)}, - {63339, S_028ABC_HTILE_USES_PRELOAD_WIN(~0u)}, - {63362, S_028ABC_PRELOAD(~0u)}, - {63370, S_028ABC_PREFETCH_WIDTH(~0u)}, - {63385, S_028ABC_PREFETCH_HEIGHT(~0u)}, - {63401, S_028ABC_DST_OUTSIDE_ZERO_TO_ONE(~0u)}, - {63425, S_028ABC_TC_COMPATIBLE(~0u)}, + {63333, S_028ABC_FULL_CACHE(~0u)}, + {63344, S_028ABC_HTILE_USES_PRELOAD_WIN(~0u)}, + {63367, S_028ABC_PRELOAD(~0u)}, + {63375, S_028ABC_PREFETCH_WIDTH(~0u)}, + {63390, S_028ABC_PREFETCH_HEIGHT(~0u)}, + {63406, S_028ABC_DST_OUTSIDE_ZERO_TO_ONE(~0u)}, + {63430, S_028ABC_TC_COMPATIBLE(~0u)}, /* 1802 */ - {63439, S_028AC0_COMPAREFUNC0(~0u), 8, 894}, - {63452, S_028AC0_COMPAREVALUE0(~0u)}, - {63466, S_028AC0_COMPAREMASK0(~0u)}, + {63444, S_028AC0_COMPAREFUNC0(~0u), 8, 894}, + {63457, S_028AC0_COMPAREVALUE0(~0u)}, + {63471, S_028AC0_COMPAREMASK0(~0u)}, {48973, S_028AC0_ENABLE0(~0u)}, /* 1806 */ - {63479, S_028AC4_COMPAREFUNC1(~0u), 8, 894}, - {63492, S_028AC4_COMPAREVALUE1(~0u)}, - {63506, S_028AC4_COMPAREMASK1(~0u)}, + {63484, S_028AC4_COMPAREFUNC1(~0u), 8, 894}, + {63497, S_028AC4_COMPAREVALUE1(~0u)}, + {63511, S_028AC4_COMPAREMASK1(~0u)}, {48991, S_028AC4_ENABLE1(~0u)}, /* 1810 */ {7499, S_028AC8_START_X(~0u)}, {7515, S_028AC8_START_Y(~0u)}, - {63519, S_028AC8_MAX_X(~0u)}, - {63525, S_028AC8_MAX_Y(~0u)}, + {63524, S_028AC8_MAX_X(~0u)}, + {63530, S_028AC8_MAX_Y(~0u)}, /* 1814 */ {23319, S_028AD4_STRIDE(~0u)}, /* 1815 */ @@ -3912,26 +3912,26 @@ /* 1819 */ {23333, S_028B38_MAX_VERT_OUT(~0u)}, /* 1820 */ - {63531, S_028B50_ACCUM_ISOLINE(~0u)}, - {63545, S_028B50_ACCUM_TRI(~0u)}, - {63555, S_028B50_ACCUM_QUAD(~0u)}, - {63566, S_028B50_DONUT_SPLIT(~0u)}, - {63578, S_028B50_TRAP_SPLIT(~0u)}, + {63536, S_028B50_ACCUM_ISOLINE(~0u)}, + {63550, S_028B50_ACCUM_TRI(~0u)}, + {63560, S_028B50_ACCUM_QUAD(~0u)}, + {63571, S_028B50_DONUT_SPLIT(~0u)}, + {63583, S_028B50_TRAP_SPLIT(~0u)}, /* 1825 */ {48157, S_028B54_LS_EN(~0u), 3, 1303}, {48151, S_028B54_HS_EN(~0u)}, {23383, S_028B54_ES_EN(~0u), 3, 1306}, {48145, S_028B54_GS_EN(~0u)}, {48139, S_028B54_VS_EN(~0u), 3, 1309}, - {63712, S_028B54_DYNAMIC_HS(~0u)}, + {63717, S_028B54_DYNAMIC_HS(~0u)}, {46732, S_028B54_DISPATCH_DRAW_EN(~0u)}, - {63723, S_028B54_DIS_DEALLOC_ACCUM_0(~0u)}, - {63743, S_028B54_DIS_DEALLOC_ACCUM_1(~0u)}, - {63763, S_028B54_VS_WAVE_ID_EN(~0u)}, + {63728, S_028B54_DIS_DEALLOC_ACCUM_0(~0u)}, + {63748, S_028B54_DIS_DEALLOC_ACCUM_1(~0u)}, + {63768, S_028B54_VS_WAVE_ID_EN(~0u)}, /* 1835 */ - {63777, S_028B58_NUM_PATCHES(~0u)}, - {63789, S_028B58_HS_NUM_INPUT_CP(~0u)}, - {63805, S_028B58_HS_NUM_OUTPUT_CP(~0u)}, + {63782, S_028B58_NUM_PATCHES(~0u)}, + {63794, S_028B58_HS_NUM_INPUT_CP(~0u)}, + {63810, S_028B58_HS_NUM_OUTPUT_CP(~0u)}, /* 1838 */ {22747, S_028B5C_ITEMSIZE(~0u)}, /* 1839 */ @@ -3942,275 +3942,275 @@ {22747, S_028B68_ITEMSIZE(~0u)}, /* 1842 */ {209, S_028B6C_TYPE(~0u), 3, 1312}, - {63911, S_028B6C_PARTITIONING(~0u), 4, 1315}, - {63988, S_028B6C_TOPOLOGY(~0u), 4, 1319}, - {63997, S_028B6C_RESERVED_REDUC_AXIS(~0u)}, - {64017, S_028B6C_DEPRECATED(~0u)}, - {64028, S_028B6C_NUM_DS_WAVES_PER_SIMD(~0u)}, - {64050, S_028B6C_DISABLE_DONUTS(~0u)}, - {62173, S_028B6C_RDREQ_POLICY_CIK(~0u), 3, 1323}, - {62190, S_028B6C_RDREQ_POLICY(~0u)}, - {64189, S_028B6C_DISTRIBUTION_MODE(~0u), 4, 1326}, + {63916, S_028B6C_PARTITIONING(~0u), 4, 1315}, + {63993, S_028B6C_TOPOLOGY(~0u), 4, 1319}, + {64002, S_028B6C_RESERVED_REDUC_AXIS(~0u)}, + {64022, S_028B6C_DEPRECATED(~0u)}, + {64033, S_028B6C_NUM_DS_WAVES_PER_SIMD(~0u)}, + {64055, S_028B6C_DISABLE_DONUTS(~0u)}, + {62178, S_028B6C_RDREQ_POLICY_CIK(~0u), 3, 1323}, + {62195, S_028B6C_RDREQ_POLICY(~0u)}, + {64194, S_028B6C_DISTRIBUTION_MODE(~0u), 4, 1326}, {40128, S_028B6C_MTYPE(~0u)}, /* 1853 */ - {64207, S_028B70_ALPHA_TO_MASK_ENABLE(~0u)}, - {64228, S_028B70_ALPHA_TO_MASK_OFFSET0(~0u)}, - {64250, S_028B70_ALPHA_TO_MASK_OFFSET1(~0u)}, - {64272, S_028B70_ALPHA_TO_MASK_OFFSET2(~0u)}, - {64294, S_028B70_ALPHA_TO_MASK_OFFSET3(~0u)}, - {64316, S_028B70_OFFSET_ROUND(~0u)}, + {64212, S_028B70_ALPHA_TO_MASK_ENABLE(~0u)}, + {64233, S_028B70_ALPHA_TO_MASK_OFFSET0(~0u)}, + {64255, S_028B70_ALPHA_TO_MASK_OFFSET1(~0u)}, + {64277, S_028B70_ALPHA_TO_MASK_OFFSET2(~0u)}, + {64299, S_028B70_ALPHA_TO_MASK_OFFSET3(~0u)}, + {64321, S_028B70_OFFSET_ROUND(~0u)}, /* 1859 */ - {64329, S_028B78_POLY_OFFSET_NEG_NUM_DB_BITS(~0u)}, - {64357, S_028B78_POLY_OFFSET_DB_IS_FLOAT_FMT(~0u)}, + {64334, S_028B78_POLY_OFFSET_NEG_NUM_DB_BITS(~0u)}, + {64362, S_028B78_POLY_OFFSET_DB_IS_FLOAT_FMT(~0u)}, /* 1861 */ {7643, S_028B90_ENABLE(~0u)}, {23740, S_028B90_CNT(~0u)}, /* 1863 */ - {64385, S_028B94_STREAMOUT_0_EN(~0u)}, - {64400, S_028B94_STREAMOUT_1_EN(~0u)}, - {64415, S_028B94_STREAMOUT_2_EN(~0u)}, - {64430, S_028B94_STREAMOUT_3_EN(~0u)}, - {64445, S_028B94_RAST_STREAM(~0u)}, - {64457, S_028B94_RAST_STREAM_MASK(~0u)}, - {64474, S_028B94_USE_RAST_STREAM_MASK(~0u)}, + {64390, S_028B94_STREAMOUT_0_EN(~0u)}, + {64405, S_028B94_STREAMOUT_1_EN(~0u)}, + {64420, S_028B94_STREAMOUT_2_EN(~0u)}, + {64435, S_028B94_STREAMOUT_3_EN(~0u)}, + {64450, S_028B94_RAST_STREAM(~0u)}, + {64462, S_028B94_RAST_STREAM_MASK(~0u)}, + {64479, S_028B94_USE_RAST_STREAM_MASK(~0u)}, /* 1870 */ - {64495, S_028B98_STREAM_0_BUFFER_EN(~0u)}, - {64514, S_028B98_STREAM_1_BUFFER_EN(~0u)}, - {64533, S_028B98_STREAM_2_BUFFER_EN(~0u)}, - {64552, S_028B98_STREAM_3_BUFFER_EN(~0u)}, + {64500, S_028B98_STREAM_0_BUFFER_EN(~0u)}, + {64519, S_028B98_STREAM_1_BUFFER_EN(~0u)}, + {64538, S_028B98_STREAM_2_BUFFER_EN(~0u)}, + {64557, S_028B98_STREAM_3_BUFFER_EN(~0u)}, /* 1874 */ - {64571, S_028BD4_DISTANCE_0(~0u)}, - {64582, S_028BD4_DISTANCE_1(~0u)}, - {64593, S_028BD4_DISTANCE_2(~0u)}, - {64604, S_028BD4_DISTANCE_3(~0u)}, - {64615, S_028BD4_DISTANCE_4(~0u)}, - {64626, S_028BD4_DISTANCE_5(~0u)}, - {64637, S_028BD4_DISTANCE_6(~0u)}, - {64648, S_028BD4_DISTANCE_7(~0u)}, + {64576, S_028BD4_DISTANCE_0(~0u)}, + {64587, S_028BD4_DISTANCE_1(~0u)}, + {64598, S_028BD4_DISTANCE_2(~0u)}, + {64609, S_028BD4_DISTANCE_3(~0u)}, + {64620, S_028BD4_DISTANCE_4(~0u)}, + {64631, S_028BD4_DISTANCE_5(~0u)}, + {64642, S_028BD4_DISTANCE_6(~0u)}, + {64653, S_028BD4_DISTANCE_7(~0u)}, /* 1882 */ - {64659, S_028BD8_DISTANCE_8(~0u)}, - {64670, S_028BD8_DISTANCE_9(~0u)}, - {64681, S_028BD8_DISTANCE_10(~0u)}, - {64693, S_028BD8_DISTANCE_11(~0u)}, - {64705, S_028BD8_DISTANCE_12(~0u)}, - {64717, S_028BD8_DISTANCE_13(~0u)}, - {64729, S_028BD8_DISTANCE_14(~0u)}, - {64741, S_028BD8_DISTANCE_15(~0u)}, + {64664, S_028BD8_DISTANCE_8(~0u)}, + {64675, S_028BD8_DISTANCE_9(~0u)}, + {64686, S_028BD8_DISTANCE_10(~0u)}, + {64698, S_028BD8_DISTANCE_11(~0u)}, + {64710, S_028BD8_DISTANCE_12(~0u)}, + {64722, S_028BD8_DISTANCE_13(~0u)}, + {64734, S_028BD8_DISTANCE_14(~0u)}, + {64746, S_028BD8_DISTANCE_15(~0u)}, /* 1890 */ - {64753, S_028BDC_EXPAND_LINE_WIDTH(~0u)}, - {64771, S_028BDC_LAST_PIXEL(~0u)}, - {64782, S_028BDC_PERPENDICULAR_ENDCAP_ENA(~0u)}, - {64807, S_028BDC_DX10_DIAMOND_TEST_ENA(~0u)}, + {64758, S_028BDC_EXPAND_LINE_WIDTH(~0u)}, + {64776, S_028BDC_LAST_PIXEL(~0u)}, + {64787, S_028BDC_PERPENDICULAR_ENDCAP_ENA(~0u)}, + {64812, S_028BDC_DX10_DIAMOND_TEST_ENA(~0u)}, /* 1894 */ - {64829, S_028BE0_MSAA_NUM_SAMPLES(~0u)}, - {64846, S_028BE0_AA_MASK_CENTROID_DTMN(~0u)}, - {64868, S_028BE0_MAX_SAMPLE_DIST(~0u)}, - {64884, S_028BE0_MSAA_EXPOSED_SAMPLES(~0u)}, - {64905, S_028BE0_DETAIL_TO_EXPOSED_MODE(~0u)}, + {64834, S_028BE0_MSAA_NUM_SAMPLES(~0u)}, + {64851, S_028BE0_AA_MASK_CENTROID_DTMN(~0u)}, + {64873, S_028BE0_MAX_SAMPLE_DIST(~0u)}, + {64889, S_028BE0_MSAA_EXPOSED_SAMPLES(~0u)}, + {64910, S_028BE0_DETAIL_TO_EXPOSED_MODE(~0u)}, /* 1899 */ - {64928, S_028BE4_PIX_CENTER(~0u)}, - {64989, S_028BE4_ROUND_MODE(~0u), 4, 1330}, - {65205, S_028BE4_QUANT_MODE(~0u), 8, 1334}, + {64933, S_028BE4_PIX_CENTER(~0u)}, + {64994, S_028BE4_ROUND_MODE(~0u), 4, 1330}, + {65210, S_028BE4_QUANT_MODE(~0u), 8, 1334}, /* 1902 */ - {65216, S_028BF8_S0_X(~0u)}, - {65221, S_028BF8_S0_Y(~0u)}, - {65226, S_028BF8_S1_X(~0u)}, - {65231, S_028BF8_S1_Y(~0u)}, - {65236, S_028BF8_S2_X(~0u)}, - {65241, S_028BF8_S2_Y(~0u)}, - {65246, S_028BF8_S3_X(~0u)}, - {65251, S_028BF8_S3_Y(~0u)}, + {65221, S_028BF8_S0_X(~0u)}, + {65226, S_028BF8_S0_Y(~0u)}, + {65231, S_028BF8_S1_X(~0u)}, + {65236, S_028BF8_S1_Y(~0u)}, + {65241, S_028BF8_S2_X(~0u)}, + {65246, S_028BF8_S2_Y(~0u)}, + {65251, S_028BF8_S3_X(~0u)}, + {65256, S_028BF8_S3_Y(~0u)}, /* 1910 */ - {65256, S_028BFC_S4_X(~0u)}, - {65261, S_028BFC_S4_Y(~0u)}, - {65266, S_028BFC_S5_X(~0u)}, - {65271, S_028BFC_S5_Y(~0u)}, - {65276, S_028BFC_S6_X(~0u)}, - {65281, S_028BFC_S6_Y(~0u)}, - {65286, S_028BFC_S7_X(~0u)}, - {65291, S_028BFC_S7_Y(~0u)}, + {65261, S_028BFC_S4_X(~0u)}, + {65266, S_028BFC_S4_Y(~0u)}, + {65271, S_028BFC_S5_X(~0u)}, + {65276, S_028BFC_S5_Y(~0u)}, + {65281, S_028BFC_S6_X(~0u)}, + {65286, S_028BFC_S6_Y(~0u)}, + {65291, S_028BFC_S7_X(~0u)}, + {65296, S_028BFC_S7_Y(~0u)}, /* 1918 */ - {65296, S_028C00_S8_X(~0u)}, - {65301, S_028C00_S8_Y(~0u)}, - {65306, S_028C00_S9_X(~0u)}, - {65311, S_028C00_S9_Y(~0u)}, - {65316, S_028C00_S10_X(~0u)}, - {65322, S_028C00_S10_Y(~0u)}, - {65328, S_028C00_S11_X(~0u)}, - {65334, S_028C00_S11_Y(~0u)}, + {65301, S_028C00_S8_X(~0u)}, + {65306, S_028C00_S8_Y(~0u)}, + {65311, S_028C00_S9_X(~0u)}, + {65316, S_028C00_S9_Y(~0u)}, + {65321, S_028C00_S10_X(~0u)}, + {65327, S_028C00_S10_Y(~0u)}, + {65333, S_028C00_S11_X(~0u)}, + {65339, S_028C00_S11_Y(~0u)}, /* 1926 */ - {65340, S_028C04_S12_X(~0u)}, - {65346, S_028C04_S12_Y(~0u)}, - {65352, S_028C04_S13_X(~0u)}, - {65358, S_028C04_S13_Y(~0u)}, - {65364, S_028C04_S14_X(~0u)}, - {65370, S_028C04_S14_Y(~0u)}, - {65376, S_028C04_S15_X(~0u)}, - {65382, S_028C04_S15_Y(~0u)}, + {65345, S_028C04_S12_X(~0u)}, + {65351, S_028C04_S12_Y(~0u)}, + {65357, S_028C04_S13_X(~0u)}, + {65363, S_028C04_S13_Y(~0u)}, + {65369, S_028C04_S14_X(~0u)}, + {65375, S_028C04_S14_Y(~0u)}, + {65381, S_028C04_S15_X(~0u)}, + {65387, S_028C04_S15_Y(~0u)}, /* 1934 */ - {65216, S_028C08_S0_X(~0u)}, - {65221, S_028C08_S0_Y(~0u)}, - {65226, S_028C08_S1_X(~0u)}, - {65231, S_028C08_S1_Y(~0u)}, - {65236, S_028C08_S2_X(~0u)}, - {65241, S_028C08_S2_Y(~0u)}, - {65246, S_028C08_S3_X(~0u)}, - {65251, S_028C08_S3_Y(~0u)}, + {65221, S_028C08_S0_X(~0u)}, + {65226, S_028C08_S0_Y(~0u)}, + {65231, S_028C08_S1_X(~0u)}, + {65236, S_028C08_S1_Y(~0u)}, + {65241, S_028C08_S2_X(~0u)}, + {65246, S_028C08_S2_Y(~0u)}, + {65251, S_028C08_S3_X(~0u)}, + {65256, S_028C08_S3_Y(~0u)}, /* 1942 */ - {65256, S_028C0C_S4_X(~0u)}, - {65261, S_028C0C_S4_Y(~0u)}, - {65266, S_028C0C_S5_X(~0u)}, - {65271, S_028C0C_S5_Y(~0u)}, - {65276, S_028C0C_S6_X(~0u)}, - {65281, S_028C0C_S6_Y(~0u)}, - {65286, S_028C0C_S7_X(~0u)}, - {65291, S_028C0C_S7_Y(~0u)}, + {65261, S_028C0C_S4_X(~0u)}, + {65266, S_028C0C_S4_Y(~0u)}, + {65271, S_028C0C_S5_X(~0u)}, + {65276, S_028C0C_S5_Y(~0u)}, + {65281, S_028C0C_S6_X(~0u)}, + {65286, S_028C0C_S6_Y(~0u)}, + {65291, S_028C0C_S7_X(~0u)}, + {65296, S_028C0C_S7_Y(~0u)}, /* 1950 */ - {65296, S_028C10_S8_X(~0u)}, - {65301, S_028C10_S8_Y(~0u)}, - {65306, S_028C10_S9_X(~0u)}, - {65311, S_028C10_S9_Y(~0u)}, - {65316, S_028C10_S10_X(~0u)}, - {65322, S_028C10_S10_Y(~0u)}, - {65328, S_028C10_S11_X(~0u)}, - {65334, S_028C10_S11_Y(~0u)}, + {65301, S_028C10_S8_X(~0u)}, + {65306, S_028C10_S8_Y(~0u)}, + {65311, S_028C10_S9_X(~0u)}, + {65316, S_028C10_S9_Y(~0u)}, + {65321, S_028C10_S10_X(~0u)}, + {65327, S_028C10_S10_Y(~0u)}, + {65333, S_028C10_S11_X(~0u)}, + {65339, S_028C10_S11_Y(~0u)}, /* 1958 */ - {65340, S_028C14_S12_X(~0u)}, - {65346, S_028C14_S12_Y(~0u)}, - {65352, S_028C14_S13_X(~0u)}, - {65358, S_028C14_S13_Y(~0u)}, - {65364, S_028C14_S14_X(~0u)}, - {65370, S_028C14_S14_Y(~0u)}, - {65376, S_028C14_S15_X(~0u)}, - {65382, S_028C14_S15_Y(~0u)}, + {65345, S_028C14_S12_X(~0u)}, + {65351, S_028C14_S12_Y(~0u)}, + {65357, S_028C14_S13_X(~0u)}, + {65363, S_028C14_S13_Y(~0u)}, + {65369, S_028C14_S14_X(~0u)}, + {65375, S_028C14_S14_Y(~0u)}, + {65381, S_028C14_S15_X(~0u)}, + {65387, S_028C14_S15_Y(~0u)}, /* 1966 */ - {65216, S_028C18_S0_X(~0u)}, - {65221, S_028C18_S0_Y(~0u)}, - {65226, S_028C18_S1_X(~0u)}, - {65231, S_028C18_S1_Y(~0u)}, - {65236, S_028C18_S2_X(~0u)}, - {65241, S_028C18_S2_Y(~0u)}, - {65246, S_028C18_S3_X(~0u)}, - {65251, S_028C18_S3_Y(~0u)}, + {65221, S_028C18_S0_X(~0u)}, + {65226, S_028C18_S0_Y(~0u)}, + {65231, S_028C18_S1_X(~0u)}, + {65236, S_028C18_S1_Y(~0u)}, + {65241, S_028C18_S2_X(~0u)}, + {65246, S_028C18_S2_Y(~0u)}, + {65251, S_028C18_S3_X(~0u)}, + {65256, S_028C18_S3_Y(~0u)}, /* 1974 */ - {65256, S_028C1C_S4_X(~0u)}, - {65261, S_028C1C_S4_Y(~0u)}, - {65266, S_028C1C_S5_X(~0u)}, - {65271, S_028C1C_S5_Y(~0u)}, - {65276, S_028C1C_S6_X(~0u)}, - {65281, S_028C1C_S6_Y(~0u)}, - {65286, S_028C1C_S7_X(~0u)}, - {65291, S_028C1C_S7_Y(~0u)}, + {65261, S_028C1C_S4_X(~0u)}, + {65266, S_028C1C_S4_Y(~0u)}, + {65271, S_028C1C_S5_X(~0u)}, + {65276, S_028C1C_S5_Y(~0u)}, + {65281, S_028C1C_S6_X(~0u)}, + {65286, S_028C1C_S6_Y(~0u)}, + {65291, S_028C1C_S7_X(~0u)}, + {65296, S_028C1C_S7_Y(~0u)}, /* 1982 */ - {65296, S_028C20_S8_X(~0u)}, - {65301, S_028C20_S8_Y(~0u)}, - {65306, S_028C20_S9_X(~0u)}, - {65311, S_028C20_S9_Y(~0u)}, - {65316, S_028C20_S10_X(~0u)}, - {65322, S_028C20_S10_Y(~0u)}, - {65328, S_028C20_S11_X(~0u)}, - {65334, S_028C20_S11_Y(~0u)}, + {65301, S_028C20_S8_X(~0u)}, + {65306, S_028C20_S8_Y(~0u)}, + {65311, S_028C20_S9_X(~0u)}, + {65316, S_028C20_S9_Y(~0u)}, + {65321, S_028C20_S10_X(~0u)}, + {65327, S_028C20_S10_Y(~0u)}, + {65333, S_028C20_S11_X(~0u)}, + {65339, S_028C20_S11_Y(~0u)}, /* 1990 */ - {65340, S_028C24_S12_X(~0u)}, - {65346, S_028C24_S12_Y(~0u)}, - {65352, S_028C24_S13_X(~0u)}, - {65358, S_028C24_S13_Y(~0u)}, - {65364, S_028C24_S14_X(~0u)}, - {65370, S_028C24_S14_Y(~0u)}, - {65376, S_028C24_S15_X(~0u)}, - {65382, S_028C24_S15_Y(~0u)}, + {65345, S_028C24_S12_X(~0u)}, + {65351, S_028C24_S12_Y(~0u)}, + {65357, S_028C24_S13_X(~0u)}, + {65363, S_028C24_S13_Y(~0u)}, + {65369, S_028C24_S14_X(~0u)}, + {65375, S_028C24_S14_Y(~0u)}, + {65381, S_028C24_S15_X(~0u)}, + {65387, S_028C24_S15_Y(~0u)}, /* 1998 */ - {65216, S_028C28_S0_X(~0u)}, - {65221, S_028C28_S0_Y(~0u)}, - {65226, S_028C28_S1_X(~0u)}, - {65231, S_028C28_S1_Y(~0u)}, - {65236, S_028C28_S2_X(~0u)}, - {65241, S_028C28_S2_Y(~0u)}, - {65246, S_028C28_S3_X(~0u)}, - {65251, S_028C28_S3_Y(~0u)}, + {65221, S_028C28_S0_X(~0u)}, + {65226, S_028C28_S0_Y(~0u)}, + {65231, S_028C28_S1_X(~0u)}, + {65236, S_028C28_S1_Y(~0u)}, + {65241, S_028C28_S2_X(~0u)}, + {65246, S_028C28_S2_Y(~0u)}, + {65251, S_028C28_S3_X(~0u)}, + {65256, S_028C28_S3_Y(~0u)}, /* 2006 */ - {65256, S_028C2C_S4_X(~0u)}, - {65261, S_028C2C_S4_Y(~0u)}, - {65266, S_028C2C_S5_X(~0u)}, - {65271, S_028C2C_S5_Y(~0u)}, - {65276, S_028C2C_S6_X(~0u)}, - {65281, S_028C2C_S6_Y(~0u)}, - {65286, S_028C2C_S7_X(~0u)}, - {65291, S_028C2C_S7_Y(~0u)}, + {65261, S_028C2C_S4_X(~0u)}, + {65266, S_028C2C_S4_Y(~0u)}, + {65271, S_028C2C_S5_X(~0u)}, + {65276, S_028C2C_S5_Y(~0u)}, + {65281, S_028C2C_S6_X(~0u)}, + {65286, S_028C2C_S6_Y(~0u)}, + {65291, S_028C2C_S7_X(~0u)}, + {65296, S_028C2C_S7_Y(~0u)}, /* 2014 */ - {65296, S_028C30_S8_X(~0u)}, - {65301, S_028C30_S8_Y(~0u)}, - {65306, S_028C30_S9_X(~0u)}, - {65311, S_028C30_S9_Y(~0u)}, - {65316, S_028C30_S10_X(~0u)}, - {65322, S_028C30_S10_Y(~0u)}, - {65328, S_028C30_S11_X(~0u)}, - {65334, S_028C30_S11_Y(~0u)}, + {65301, S_028C30_S8_X(~0u)}, + {65306, S_028C30_S8_Y(~0u)}, + {65311, S_028C30_S9_X(~0u)}, + {65316, S_028C30_S9_Y(~0u)}, + {65321, S_028C30_S10_X(~0u)}, + {65327, S_028C30_S10_Y(~0u)}, + {65333, S_028C30_S11_X(~0u)}, + {65339, S_028C30_S11_Y(~0u)}, /* 2022 */ - {65340, S_028C34_S12_X(~0u)}, - {65346, S_028C34_S12_Y(~0u)}, - {65352, S_028C34_S13_X(~0u)}, - {65358, S_028C34_S13_Y(~0u)}, - {65364, S_028C34_S14_X(~0u)}, - {65370, S_028C34_S14_Y(~0u)}, - {65376, S_028C34_S15_X(~0u)}, - {65382, S_028C34_S15_Y(~0u)}, + {65345, S_028C34_S12_X(~0u)}, + {65351, S_028C34_S12_Y(~0u)}, + {65357, S_028C34_S13_X(~0u)}, + {65363, S_028C34_S13_Y(~0u)}, + {65369, S_028C34_S14_X(~0u)}, + {65375, S_028C34_S14_Y(~0u)}, + {65381, S_028C34_S15_X(~0u)}, + {65387, S_028C34_S15_Y(~0u)}, /* 2030 */ - {65388, S_028C38_AA_MASK_X0Y0(~0u)}, - {65401, S_028C38_AA_MASK_X1Y0(~0u)}, + {65393, S_028C38_AA_MASK_X0Y0(~0u)}, + {65406, S_028C38_AA_MASK_X1Y0(~0u)}, /* 2032 */ - {65414, S_028C3C_AA_MASK_X0Y1(~0u)}, - {65427, S_028C3C_AA_MASK_X1Y1(~0u)}, + {65419, S_028C3C_AA_MASK_X0Y1(~0u)}, + {65432, S_028C3C_AA_MASK_X1Y1(~0u)}, /* 2034 */ - {65440, S_028C40_REALIGN_DQUADS_AFTER_N_WAVES(~0u)}, + {65445, S_028C40_REALIGN_DQUADS_AFTER_N_WAVES(~0u)}, /* 2035 */ - {65469, S_028C58_VTX_REUSE_DEPTH(~0u)}, + {65474, S_028C58_VTX_REUSE_DEPTH(~0u)}, /* 2036 */ - {65485, S_028C5C_DEALLOC_DIST(~0u)}, + {65490, S_028C5C_DEALLOC_DIST(~0u)}, /* 2037 */ {50194, S_028C64_TILE_MAX(~0u)}, - {65498, S_028C64_FMASK_TILE_MAX(~0u)}, + {65503, S_028C64_FMASK_TILE_MAX(~0u)}, /* 2039 */ {50194, S_028C68_TILE_MAX(~0u)}, /* 2040 */ {48842, S_028C6C_SLICE_START(~0u)}, {48854, S_028C6C_SLICE_MAX(~0u)}, /* 2042 */ - {65564, S_028C70_ENDIAN(~0u), 4, 1342}, + {65569, S_028C70_ENDIAN(~0u), 4, 1342}, {21132, S_028C70_FORMAT(~0u), 23, 1346}, {45121, S_028C70_LINEAR_GENERAL(~0u)}, - {65931, S_028C70_NUMBER_TYPE(~0u), 8, 1369}, - {65987, S_028C70_COMP_SWAP(~0u), 4, 1377}, + {65936, S_028C70_NUMBER_TYPE(~0u), 8, 1369}, + {65992, S_028C70_COMP_SWAP(~0u), 4, 1377}, {57519, S_028C70_FAST_CLEAR(~0u)}, {49428, S_028C70_COMPRESSION(~0u)}, - {65997, S_028C70_BLEND_CLAMP(~0u)}, - {66009, S_028C70_BLEND_BYPASS(~0u)}, - {66022, S_028C70_SIMPLE_FLOAT(~0u)}, - {64989, S_028C70_ROUND_MODE(~0u)}, - {66035, S_028C70_CMASK_IS_LINEAR(~0u)}, - {66262, S_028C70_BLEND_OPT_DONT_RD_DST(~0u), 8, 1381}, - {66284, S_028C70_BLEND_OPT_DISCARD_PIXEL(~0u), 8, 1381}, - {66308, S_028C70_FMASK_COMPRESSION_DISABLE(~0u)}, - {66334, S_028C70_FMASK_COMPRESS_1FRAG_ONLY(~0u)}, - {66360, S_028C70_DCC_ENABLE(~0u)}, - {66371, S_028C70_CMASK_ADDR_TYPE(~0u)}, + {66002, S_028C70_BLEND_CLAMP(~0u)}, + {66014, S_028C70_BLEND_BYPASS(~0u)}, + {66027, S_028C70_SIMPLE_FLOAT(~0u)}, + {64994, S_028C70_ROUND_MODE(~0u)}, + {66040, S_028C70_CMASK_IS_LINEAR(~0u)}, + {66267, S_028C70_BLEND_OPT_DONT_RD_DST(~0u), 8, 1381}, + {66289, S_028C70_BLEND_OPT_DISCARD_PIXEL(~0u), 8, 1381}, + {66313, S_028C70_FMASK_COMPRESSION_DISABLE(~0u)}, + {66339, S_028C70_FMASK_COMPRESS_1FRAG_ONLY(~0u)}, + {66365, S_028C70_DCC_ENABLE(~0u)}, + {66376, S_028C70_CMASK_ADDR_TYPE(~0u)}, /* 2060 */ {50022, S_028C74_TILE_MODE_INDEX(~0u)}, - {66387, S_028C74_FMASK_TILE_MODE_INDEX(~0u)}, - {66409, S_028C74_FMASK_BANK_HEIGHT(~0u)}, + {66392, S_028C74_FMASK_TILE_MODE_INDEX(~0u)}, + {66414, S_028C74_FMASK_BANK_HEIGHT(~0u)}, {50010, S_028C74_NUM_SAMPLES(~0u)}, - {66427, S_028C74_NUM_FRAGMENTS(~0u)}, - {66441, S_028C74_FORCE_DST_ALPHA_1(~0u)}, + {66432, S_028C74_NUM_FRAGMENTS(~0u)}, + {66446, S_028C74_FORCE_DST_ALPHA_1(~0u)}, /* 2066 */ {52586, S_028C78_OVERWRITE_COMBINER_DISABLE(~0u)}, - {66459, S_028C78_KEY_CLEAR_ENABLE(~0u)}, - {66535, S_028C78_MAX_UNCOMPRESSED_BLOCK_SIZE(~0u), 3, 1389}, - {66601, S_028C78_MIN_COMPRESSED_BLOCK_SIZE(~0u), 2, 1392}, - {66627, S_028C78_MAX_COMPRESSED_BLOCK_SIZE(~0u)}, + {66464, S_028C78_KEY_CLEAR_ENABLE(~0u)}, + {66540, S_028C78_MAX_UNCOMPRESSED_BLOCK_SIZE(~0u), 3, 1389}, + {66606, S_028C78_MIN_COMPRESSED_BLOCK_SIZE(~0u), 2, 1392}, + {66632, S_028C78_MAX_COMPRESSED_BLOCK_SIZE(~0u)}, {42723, S_028C78_COLOR_TRANSFORM(~0u)}, - {66653, S_028C78_INDEPENDENT_64B_BLOCKS(~0u)}, - {66676, S_028C78_LOSSY_RGB_PRECISION(~0u)}, - {66696, S_028C78_LOSSY_ALPHA_PRECISION(~0u)}, + {66658, S_028C78_INDEPENDENT_64B_BLOCKS(~0u)}, + {66681, S_028C78_LOSSY_RGB_PRECISION(~0u)}, + {66701, S_028C78_LOSSY_ALPHA_PRECISION(~0u)}, /* 2075 */ {50194, S_028C80_TILE_MAX(~0u)}, /* 2076 */ @@ -4228,22 +4228,22 @@ {33389, S_008008_ME2PIPE2_RQ_PENDING(~0u)}, {33409, S_008008_ME2PIPE3_RQ_PENDING(~0u)}, {33429, S_008008_RLC_RQ_PENDING(~0u)}, - {66718, S_008008_UTCL2_BUSY(~0u)}, - {66729, S_008008_EA_BUSY(~0u)}, - {66737, S_008008_RMI_BUSY(~0u)}, - {66746, S_008008_UTCL2_RQ_PENDING(~0u)}, - {66763, S_008008_CPF_RQ_PENDING(~0u)}, - {66778, S_008008_EA_LINK_BUSY(~0u)}, + {66723, S_008008_UTCL2_BUSY(~0u)}, + {66734, S_008008_EA_BUSY(~0u)}, + {66742, S_008008_RMI_BUSY(~0u)}, + {66751, S_008008_UTCL2_RQ_PENDING(~0u)}, + {66768, S_008008_CPF_RQ_PENDING(~0u)}, + {66783, S_008008_EA_LINK_BUSY(~0u)}, {33444, S_008008_RLC_BUSY(~0u)}, {33453, S_008008_TC_BUSY(~0u)}, {33461, S_008008_TCC_CC_RESIDENT(~0u)}, {33477, S_008008_CPF_BUSY(~0u)}, {33486, S_008008_CPC_BUSY(~0u)}, {33495, S_008008_CPG_BUSY(~0u)}, - {66791, S_008008_CPAXI_BUSY(~0u)}, + {66796, S_008008_CPAXI_BUSY(~0u)}, /* 2102 */ {33504, S_008010_ME0PIPE0_CMDFIFO_AVAIL(~0u)}, - {66802, S_008010_RSMU_RQ_PENDING(~0u)}, + {66807, S_008010_RSMU_RQ_PENDING(~0u)}, {33543, S_008010_ME0PIPE0_CF_RQ_PENDING(~0u)}, {33566, S_008010_ME0PIPE0_PF_RQ_PENDING(~0u)}, {33589, S_008010_GDS_DMA_RQ_PENDING(~0u)}, @@ -4269,7 +4269,7 @@ /* 2126 */ {33608, S_008014_DB_CLEAN(~0u)}, {33617, S_008014_CB_CLEAN(~0u)}, - {66737, S_008014_RMI_BUSY(~0u)}, + {66742, S_008014_RMI_BUSY(~0u)}, {33715, S_008014_BCI_BUSY(~0u)}, {33658, S_008014_VGT_BUSY(~0u)}, {33732, S_008014_PA_BUSY(~0u)}, @@ -4282,7 +4282,7 @@ /* 2138 */ {33608, S_008018_DB_CLEAN(~0u)}, {33617, S_008018_CB_CLEAN(~0u)}, - {66737, S_008018_RMI_BUSY(~0u)}, + {66742, S_008018_RMI_BUSY(~0u)}, {33715, S_008018_BCI_BUSY(~0u)}, {33658, S_008018_VGT_BUSY(~0u)}, {33732, S_008018_PA_BUSY(~0u)}, @@ -4295,7 +4295,7 @@ /* 2150 */ {33608, S_008038_DB_CLEAN(~0u)}, {33617, S_008038_CB_CLEAN(~0u)}, - {66737, S_008038_RMI_BUSY(~0u)}, + {66742, S_008038_RMI_BUSY(~0u)}, {33715, S_008038_BCI_BUSY(~0u)}, {33658, S_008038_VGT_BUSY(~0u)}, {33732, S_008038_PA_BUSY(~0u)}, @@ -4308,7 +4308,7 @@ /* 2162 */ {33608, S_00803C_DB_CLEAN(~0u)}, {33617, S_00803C_CB_CLEAN(~0u)}, - {66737, S_00803C_RMI_BUSY(~0u)}, + {66742, S_00803C_RMI_BUSY(~0u)}, {33715, S_00803C_BCI_BUSY(~0u)}, {33658, S_00803C_VGT_BUSY(~0u)}, {33732, S_00803C_PA_BUSY(~0u)}, @@ -4320,8 +4320,8 @@ {32533, S_00803C_CB_BUSY(~0u)}, /* 2174 */ {34274, S_0301F0_TC_NC_ACTION_ENA(~0u)}, - {66818, S_0301F0_TC_WC_ACTION_ENA(~0u)}, - {66835, S_0301F0_TC_INV_METADATA_ACTION_ENA(~0u)}, + {66823, S_0301F0_TC_WC_ACTION_ENA(~0u)}, + {66840, S_0301F0_TC_INV_METADATA_ACTION_ENA(~0u)}, {34291, S_0301F0_TCL1_VOL_ACTION_ENA(~0u)}, {34329, S_0301F0_TC_WB_ACTION_ENA(~0u)}, {34120, S_0301F0_TCL1_ACTION_ENA(~0u)}, @@ -4347,8 +4347,8 @@ {34529, S_008210_TCIU_BUSY(~0u)}, {34539, S_008210_SCRATCH_RAM_BUSY(~0u)}, {34556, S_008210_QU_BUSY(~0u)}, - {66862, S_008210_UTCL2IU_BUSY(~0u)}, - {66875, S_008210_SAVE_RESTORE_BUSY(~0u)}, + {66867, S_008210_UTCL2IU_BUSY(~0u)}, + {66880, S_008210_SAVE_RESTORE_BUSY(~0u)}, {34577, S_008210_CPG_CPC_BUSY(~0u)}, {34590, S_008210_CPF_CPC_BUSY(~0u)}, {33486, S_008210_CPC_BUSY(~0u)}, @@ -4364,9 +4364,9 @@ {35250, S_008218_MEC2_WAIT_ON_RCIU(~0u)}, {35268, S_008218_MEC2_WAIT_ON_RCIU_READ(~0u)}, {35291, S_008218_MEC2_WAIT_ON_ROQ_DATA(~0u)}, - {66893, S_008218_UTCL2IU_WAITING_ON_FREE(~0u)}, - {66917, S_008218_UTCL2IU_WAITING_ON_TAGS(~0u)}, - {66941, S_008218_UTCL1_WAITING_ON_TRANS(~0u)}, + {66898, S_008218_UTCL2IU_WAITING_ON_FREE(~0u)}, + {66922, S_008218_UTCL2IU_WAITING_ON_TAGS(~0u)}, + {66946, S_008218_UTCL1_WAITING_ON_TRANS(~0u)}, /* 2219 */ {35384, S_00821C_POST_WPTR_GFX_BUSY(~0u)}, {35403, S_00821C_CSF_BUSY(~0u)}, @@ -4383,7 +4383,7 @@ {34529, S_00821C_TCIU_BUSY(~0u)}, {35585, S_00821C_HQD_BUSY(~0u)}, {35594, S_00821C_PRT_BUSY(~0u)}, - {66862, S_00821C_UTCL2IU_BUSY(~0u)}, + {66867, S_00821C_UTCL2IU_BUSY(~0u)}, {35603, S_00821C_CPF_GFX_BUSY(~0u)}, {35616, S_00821C_CPF_CMP_BUSY(~0u)}, {35629, S_00821C_GRBM_CPF_STAT_BUSY(~0u)}, @@ -4396,11 +4396,11 @@ {36295, S_008224_STATE_FETCHING_DATA(~0u)}, {36315, S_008224_TCIU_WAITING_ON_FREE(~0u)}, {36336, S_008224_TCIU_WAITING_ON_TAGS(~0u)}, - {66893, S_008224_UTCL2IU_WAITING_ON_FREE(~0u)}, - {66917, S_008224_UTCL2IU_WAITING_ON_TAGS(~0u)}, - {66964, S_008224_GFX_UTCL1_WAITING_ON_TRANS(~0u)}, - {66991, S_008224_CMP_UTCL1_WAITING_ON_TRANS(~0u)}, - {67018, S_008224_RCIU_WAITING_ON_FREE(~0u)}, + {66898, S_008224_UTCL2IU_WAITING_ON_FREE(~0u)}, + {66922, S_008224_UTCL2IU_WAITING_ON_TAGS(~0u)}, + {66969, S_008224_GFX_UTCL1_WAITING_ON_TRANS(~0u)}, + {66996, S_008224_CMP_UTCL1_WAITING_ON_TRANS(~0u)}, + {67023, S_008224_RCIU_WAITING_ON_FREE(~0u)}, /* 2251 */ {37126, S_008670_CE_TO_CSF_NOT_RDY_TO_RCV(~0u)}, {37151, S_008670_CE_TO_RAM_INIT_FETCHER_NOT_RDY_TO_RCV(~0u)}, @@ -4418,16 +4418,16 @@ {36336, S_008670_TCIU_WAITING_ON_TAGS(~0u)}, {37474, S_008670_CE_STALLED_ON_TC_WR_CONFIRM(~0u)}, {37502, S_008670_CE_STALLED_ON_ATOMIC_RTN_DATA(~0u)}, - {66893, S_008670_UTCL2IU_WAITING_ON_FREE(~0u)}, - {66917, S_008670_UTCL2IU_WAITING_ON_TAGS(~0u)}, - {66941, S_008670_UTCL1_WAITING_ON_TRANS(~0u)}, + {66898, S_008670_UTCL2IU_WAITING_ON_FREE(~0u)}, + {66922, S_008670_UTCL2IU_WAITING_ON_TAGS(~0u)}, + {66946, S_008670_UTCL1_WAITING_ON_TRANS(~0u)}, /* 2270 */ {35427, S_008680_ROQ_RING_BUSY(~0u)}, {35441, S_008680_ROQ_INDIRECT1_BUSY(~0u)}, {35460, S_008680_ROQ_INDIRECT2_BUSY(~0u)}, {35479, S_008680_ROQ_STATE_BUSY(~0u)}, {38732, S_008680_DC_BUSY(~0u)}, - {66862, S_008680_UTCL2IU_BUSY(~0u)}, + {66867, S_008680_UTCL2IU_BUSY(~0u)}, {38740, S_008680_PFP_BUSY(~0u)}, {38749, S_008680_MEQ_BUSY(~0u)}, {38758, S_008680_ME_BUSY(~0u)}, @@ -4448,10 +4448,10 @@ {22130, S_030908_PRIM_TYPE(~0u), 29, 26}, /* 2293 */ {203, S_03090C_INDEX_TYPE(~0u), 2, 55}, - {67039, S_03090C_PRIMGEN_EN(~0u)}, + {67044, S_03090C_PRIMGEN_EN(~0u)}, /* 2295 */ {22655, S_03092C_RESET_EN(~0u)}, - {67050, S_03092C_MATCH_ALL_BITS(~0u)}, + {67055, S_03092C_MATCH_ALL_BITS(~0u)}, /* 2297 */ {37005, S_03093C_OFFCHIP_BUFFERING(~0u)}, {38874, S_03093C_OFFCHIP_GRANULARITY(~0u)}, @@ -4464,30 +4464,30 @@ /* 2302 */ {880, S_03095C_BASE_HI(~0u)}, /* 2303 */ - {63210, S_030960_PRIMGROUP_SIZE(~0u)}, - {63225, S_030960_PARTIAL_VS_WAVE_ON(~0u)}, - {63244, S_030960_SWITCH_ON_EOP(~0u)}, - {63258, S_030960_PARTIAL_ES_WAVE_ON(~0u)}, - {63277, S_030960_SWITCH_ON_EOI(~0u)}, - {63291, S_030960_WD_SWITCH_ON_EOP(~0u)}, - {67065, S_030960_EN_INST_OPT_BASIC(~0u)}, - {67083, S_030960_EN_INST_OPT_ADV(~0u)}, - {67099, S_030960_HW_USE_ONLY(~0u)}, + {63215, S_030960_PRIMGROUP_SIZE(~0u)}, + {63230, S_030960_PARTIAL_VS_WAVE_ON(~0u)}, + {63249, S_030960_SWITCH_ON_EOP(~0u)}, + {63263, S_030960_PARTIAL_ES_WAVE_ON(~0u)}, + {63282, S_030960_SWITCH_ON_EOI(~0u)}, + {63296, S_030960_WD_SWITCH_ON_EOP(~0u)}, + {67070, S_030960_EN_INST_OPT_BASIC(~0u)}, + {67088, S_030960_EN_INST_OPT_ADV(~0u)}, + {67104, S_030960_HW_USE_ONLY(~0u)}, /* 2312 */ - {67111, S_030D20_TARGET_INST(~0u)}, - {67123, S_030D20_TARGET_DATA(~0u)}, + {67116, S_030D20_TARGET_INST(~0u)}, + {67128, S_030D20_TARGET_DATA(~0u)}, {39148, S_030D20_INVALIDATE(~0u)}, {26860, S_030D20_WRITEBACK(~0u)}, {46950, S_030D20_VOL(~0u)}, - {67135, S_030D20_COMPLETE(~0u)}, + {67140, S_030D20_COMPLETE(~0u)}, /* 2318 */ - {67144, S_030D24_DWB(~0u)}, + {67149, S_030D24_DWB(~0u)}, {49359, S_030D24_DIRTY(~0u)}, /* 2320 */ - {67148, S_030E08_GRAD_ADJ_0(~0u)}, - {67159, S_030E08_GRAD_ADJ_1(~0u)}, - {67170, S_030E08_GRAD_ADJ_2(~0u)}, - {67181, S_030E08_GRAD_ADJ_3(~0u)}, + {67153, S_030E08_GRAD_ADJ_0(~0u)}, + {67164, S_030E08_GRAD_ADJ_1(~0u)}, + {67175, S_030E08_GRAD_ADJ_2(~0u)}, + {67186, S_030E08_GRAD_ADJ_3(~0u)}, /* 2324 */ {39448, S_008F0C_DST_SEL_X(~0u), 8, 186}, {39458, S_008F0C_DST_SEL_Y(~0u), 8, 186}, @@ -4495,22 +4495,22 @@ {39478, S_008F0C_DST_SEL_W(~0u), 8, 186}, {39662, S_008F0C_NUM_FORMAT(~0u), 8, 194}, {40054, S_008F0C_DATA_FORMAT(~0u), 16, 202}, - {67192, S_008F0C_USER_VM_ENABLE(~0u)}, - {67207, S_008F0C_USER_VM_MODE(~0u)}, + {67197, S_008F0C_USER_VM_ENABLE(~0u)}, + {67212, S_008F0C_USER_VM_MODE(~0u)}, {40079, S_008F0C_INDEX_STRIDE(~0u)}, {40092, S_008F0C_ADD_TID_ENABLE(~0u)}, - {60841, S_008F0C_NV(~0u)}, + {60846, S_008F0C_NV(~0u)}, {209, S_008F0C_TYPE(~0u), 4, 218}, /* 2336 */ {39313, S_008F14_BASE_ADDRESS_HI(~0u)}, {40203, S_008F14_MIN_LOD(~0u)}, - {67792, S_008F14_DATA_FORMAT_GFX9(~0u), 64, 1394}, - {67885, S_008F14_NUM_FORMAT_GFX9(~0u), 11, 1458}, - {68120, S_008F14_NUM_FORMAT_FMASK(~0u), 13, 1469}, - {68370, S_008F14_NUM_FORMAT_ASTC_2D(~0u), 14, 1482}, - {68569, S_008F14_NUM_FORMAT_ASTC_3D(~0u), 10, 1496}, - {60841, S_008F14_NV(~0u)}, - {68588, S_008F14_META_DIRECT(~0u)}, + {67797, S_008F14_DATA_FORMAT_GFX9(~0u), 64, 1394}, + {67890, S_008F14_NUM_FORMAT_GFX9(~0u), 11, 1458}, + {68125, S_008F14_NUM_FORMAT_FMASK(~0u), 13, 1469}, + {68375, S_008F14_NUM_FORMAT_ASTC_2D(~0u), 14, 1482}, + {68574, S_008F14_NUM_FORMAT_ASTC_3D(~0u), 10, 1496}, + {60846, S_008F14_NV(~0u)}, + {68593, S_008F14_META_DIRECT(~0u)}, /* 2345 */ {39448, S_008F1C_DST_SEL_X(~0u), 8, 186}, {39458, S_008F1C_DST_SEL_Y(~0u), 8, 186}, @@ -4518,20 +4518,20 @@ {39478, S_008F1C_DST_SEL_W(~0u), 8, 186}, {42269, S_008F1C_BASE_LEVEL(~0u)}, {42280, S_008F1C_LAST_LEVEL(~0u)}, - {68600, S_008F1C_SW_MODE(~0u)}, + {68605, S_008F1C_SW_MODE(~0u)}, {209, S_008F1C_TYPE(~0u), 16, 302}, /* 2353 */ {22114, S_008F20_DEPTH(~0u)}, - {68608, S_008F20_PITCH_GFX9(~0u)}, - {68715, S_008F20_BC_SWIZZLE(~0u), 6, 1506}, + {68613, S_008F20_PITCH_GFX9(~0u)}, + {68720, S_008F20_BC_SWIZZLE(~0u), 6, 1506}, /* 2356 */ {42626, S_008F24_BASE_ARRAY(~0u)}, - {68726, S_008F24_ARRAY_PITCH(~0u)}, - {68738, S_008F24_META_DATA_ADDRESS(~0u)}, - {68756, S_008F24_META_LINEAR(~0u)}, - {68768, S_008F24_META_PIPE_ALIGNED(~0u)}, - {68786, S_008F24_META_RB_ALIGNED(~0u)}, - {68802, S_008F24_MAX_MIP(~0u)}, + {68731, S_008F24_ARRAY_PITCH(~0u)}, + {68743, S_008F24_META_DATA_ADDRESS(~0u)}, + {68761, S_008F24_META_LINEAR(~0u)}, + {68773, S_008F24_META_PIPE_ALIGNED(~0u)}, + {68791, S_008F24_META_RB_ALIGNED(~0u)}, + {68807, S_008F24_MAX_MIP(~0u)}, /* 2363 */ {43397, S_008F38_LOD_BIAS(~0u)}, {43406, S_008F38_LOD_BIAS_SEC(~0u)}, @@ -4540,12 +4540,12 @@ {43623, S_008F38_Z_FILTER(~0u), 3, 340}, {43632, S_008F38_MIP_FILTER(~0u), 3, 340}, {43643, S_008F38_MIP_POINT_PRECLAMP(~0u)}, - {68810, S_008F38_BLEND_ZERO_PRT(~0u)}, + {68815, S_008F38_BLEND_ZERO_PRT(~0u)}, {43679, S_008F38_FILTER_PREC_FIX(~0u)}, {43695, S_008F38_ANISO_OVERRIDE(~0u)}, /* 2373 */ {43710, S_008F3C_BORDER_COLOR_PTR(~0u)}, - {68825, S_008F3C_SKIP_DEGAMMA(~0u)}, + {68830, S_008F3C_SKIP_DEGAMMA(~0u)}, {43869, S_008F3C_BORDER_COLOR_TYPE(~0u), 4, 343}, /* 2376 */ {44220, S_031100_GPR_WRITE_PRIORITY(~0u)}, @@ -4553,39 +4553,39 @@ {44258, S_031100_ENABLE_SQG_TOP_EVENTS(~0u)}, {44280, S_031100_ENABLE_SQG_BOP_EVENTS(~0u)}, {44302, S_031100_RSRC_MGMT_RESET(~0u)}, - {68838, S_031100_TTRACE_STALL_ALL(~0u)}, - {68855, S_031100_ALLOC_ARB_LRU_ENA(~0u)}, - {68873, S_031100_EXP_ARB_LRU_ENA(~0u)}, - {68889, S_031100_PS_PKR_PRIORITY_CNTL(~0u)}, + {68843, S_031100_TTRACE_STALL_ALL(~0u)}, + {68860, S_031100_ALLOC_ARB_LRU_ENA(~0u)}, + {68878, S_031100_EXP_ARB_LRU_ENA(~0u)}, + {68894, S_031100_PS_PKR_PRIORITY_CNTL(~0u)}, /* 2385 */ {44571, S_031104_VTX_DONE_DELAY(~0u), 16, 348}, {44586, S_031104_INTERP_ONE_PRIM_PER_ROW(~0u)}, - {68910, S_031104_BATON_RESET_DISABLE(~0u)}, + {68915, S_031104_BATON_RESET_DISABLE(~0u)}, {44610, S_031104_PC_LIMIT_ENABLE(~0u)}, {44626, S_031104_PC_LIMIT_STRICT(~0u)}, - {68930, S_031104_CRC_SIMD_ID_WADDR_DISABLE(~0u)}, - {68956, S_031104_LBPW_CU_CHK_MODE(~0u)}, - {68973, S_031104_LBPW_CU_CHK_CNT(~0u)}, - {68989, S_031104_CSC_PWR_SAVE_DISABLE(~0u)}, - {69010, S_031104_CSG_PWR_SAVE_DISABLE(~0u)}, + {68935, S_031104_CRC_SIMD_ID_WADDR_DISABLE(~0u)}, + {68961, S_031104_LBPW_CU_CHK_MODE(~0u)}, + {68978, S_031104_LBPW_CU_CHK_CNT(~0u)}, + {68994, S_031104_CSC_PWR_SAVE_DISABLE(~0u)}, + {69015, S_031104_CSG_PWR_SAVE_DISABLE(~0u)}, {44642, S_031104_PC_LIMIT_SIZE(~0u)}, /* 2396 */ - {69031, S_031108_CONTEXT_SAVE_WAIT_GDS_REQUEST_CYCLE_OVHD(~0u)}, - {69072, S_031108_CONTEXT_SAVE_WAIT_GDS_GRANT_CYCLE_OVHD(~0u)}, + {69036, S_031108_CONTEXT_SAVE_WAIT_GDS_REQUEST_CYCLE_OVHD(~0u)}, + {69077, S_031108_CONTEXT_SAVE_WAIT_GDS_GRANT_CYCLE_OVHD(~0u)}, /* 2398 */ {44818, S_0098F8_NUM_PIPES(~0u)}, - {69111, S_0098F8_PIPE_INTERLEAVE_SIZE_GFX9(~0u)}, - {69137, S_0098F8_MAX_COMPRESSED_FRAGS(~0u)}, + {69116, S_0098F8_PIPE_INTERLEAVE_SIZE_GFX9(~0u)}, + {69142, S_0098F8_MAX_COMPRESSED_FRAGS(~0u)}, {44854, S_0098F8_BANK_INTERLEAVE_SIZE(~0u)}, {46305, S_0098F8_NUM_BANKS(~0u)}, {44899, S_0098F8_SHADER_ENGINE_TILE_SIZE(~0u)}, - {69158, S_0098F8_NUM_SHADER_ENGINES_GFX9(~0u)}, - {69182, S_0098F8_NUM_GPUS_GFX9(~0u)}, + {69163, S_0098F8_NUM_SHADER_ENGINES_GFX9(~0u)}, + {69187, S_0098F8_NUM_GPUS_GFX9(~0u)}, {44937, S_0098F8_MULTI_GPU_TILE_SIZE(~0u)}, - {69196, S_0098F8_NUM_RB_PER_SE(~0u)}, + {69201, S_0098F8_NUM_RB_PER_SE(~0u)}, {44957, S_0098F8_ROW_SIZE(~0u)}, {44966, S_0098F8_NUM_LOWER_PIPES(~0u)}, - {69210, S_0098F8_SE_ENABLE(~0u)}, + {69215, S_0098F8_SE_ENABLE(~0u)}, /* 2411 */ {45344, S_009910_ARRAY_MODE(~0u), 16, 368}, {45706, S_009910_PIPE_CONFIG(~0u), 15, 384}, @@ -4596,7 +4596,7 @@ {43975, S_00B01C_CU_EN(~0u)}, {46388, S_00B01C_WAVE_LIMIT(~0u)}, {46399, S_00B01C_LOCK_LOW_THRESHOLD(~0u)}, - {69220, S_00B01C_SIMD_DISABLE(~0u)}, + {69225, S_00B01C_SIMD_DISABLE(~0u)}, /* 2420 */ {46418, S_00B028_VGPRS(~0u)}, {46424, S_00B028_SGPRS(~0u)}, @@ -4608,7 +4608,7 @@ {46511, S_00B028_IEEE_MODE(~0u)}, {46521, S_00B028_CU_GROUP_DISABLE(~0u)}, {46548, S_00B028_CDBG_USER(~0u)}, - {69233, S_00B028_FP16_OVFL(~0u)}, + {69238, S_00B028_FP16_OVFL(~0u)}, /* 2431 */ {46558, S_00B02C_SCRATCH_EN(~0u)}, {46569, S_00B02C_USER_SGPR(~0u)}, @@ -4616,15 +4616,15 @@ {46592, S_00B02C_WAVE_CNT_EN(~0u)}, {46604, S_00B02C_EXTRA_LDS_SIZE(~0u)}, {46630, S_00B02C_EXCP_EN(~0u)}, - {69243, S_00B02C_LOAD_COLLISION_WAVEID(~0u)}, - {69265, S_00B02C_LOAD_INTRAWAVE_COLLISION(~0u)}, - {69290, S_00B02C_SKIP_USGPR0(~0u)}, - {69302, S_00B02C_USER_SGPR_MSB(~0u)}, + {69248, S_00B02C_LOAD_COLLISION_WAVEID(~0u)}, + {69270, S_00B02C_LOAD_INTRAWAVE_COLLISION(~0u)}, + {69295, S_00B02C_SKIP_USGPR0(~0u)}, + {69307, S_00B02C_USER_SGPR_MSB(~0u)}, /* 2441 */ {43975, S_00B118_CU_EN(~0u)}, {46388, S_00B118_WAVE_LIMIT(~0u)}, {46399, S_00B118_LOCK_LOW_THRESHOLD(~0u)}, - {69220, S_00B118_SIMD_DISABLE(~0u)}, + {69225, S_00B118_SIMD_DISABLE(~0u)}, /* 2445 */ {46418, S_00B128_VGPRS(~0u)}, {46424, S_00B128_SGPRS(~0u)}, @@ -4637,7 +4637,7 @@ {46638, S_00B128_VGPR_COMP_CNT(~0u)}, {46652, S_00B128_CU_GROUP_ENABLE(~0u)}, {46548, S_00B128_CDBG_USER(~0u)}, - {69233, S_00B128_FP16_OVFL(~0u)}, + {69238, S_00B128_FP16_OVFL(~0u)}, /* 2457 */ {46558, S_00B12C_SCRATCH_EN(~0u)}, {46569, S_00B12C_USER_SGPR(~0u)}, @@ -4649,10 +4649,10 @@ {46714, S_00B12C_SO_BASE3_EN(~0u)}, {46726, S_00B12C_SO_EN(~0u)}, {46630, S_00B12C_EXCP_EN(~0u)}, - {69316, S_00B12C_PC_BASE_EN(~0u)}, + {69321, S_00B12C_PC_BASE_EN(~0u)}, {46732, S_00B12C_DISPATCH_DRAW_EN(~0u)}, - {69290, S_00B12C_SKIP_USGPR0(~0u)}, - {69302, S_00B12C_USER_SGPR_MSB(~0u)}, + {69295, S_00B12C_SKIP_USGPR0(~0u)}, + {69307, S_00B12C_USER_SGPR_MSB(~0u)}, /* 2471 */ {46558, S_00B1F0_SCRATCH_EN(~0u)}, {46569, S_00B1F0_USER_SGPR(~0u)}, @@ -4661,18 +4661,18 @@ {46638, S_00B1F0_VGPR_COMP_CNT(~0u)}, {46668, S_00B1F0_OC_LDS_EN(~0u)}, {46610, S_00B1F0_LDS_SIZE(~0u)}, - {69290, S_00B1F0_SKIP_USGPR0(~0u)}, - {69302, S_00B1F0_USER_SGPR_MSB(~0u)}, + {69295, S_00B1F0_SKIP_USGPR0(~0u)}, + {69307, S_00B1F0_USER_SGPR_MSB(~0u)}, /* 2480 */ {46749, S_00B204_GROUP_FIFO_DEPTH(~0u)}, - {69327, S_00B204_SPI_SHADER_LATE_ALLOC_GS(~0u)}, + {69332, S_00B204_SPI_SHADER_LATE_ALLOC_GS(~0u)}, /* 2482 */ {46379, S_00B214_MEM_BASE(~0u)}, /* 2483 */ {43975, S_00B21C_CU_EN(~0u)}, {46388, S_00B21C_WAVE_LIMIT(~0u)}, {46399, S_00B21C_LOCK_LOW_THRESHOLD(~0u)}, - {69220, S_00B21C_SIMD_DISABLE(~0u)}, + {69225, S_00B21C_SIMD_DISABLE(~0u)}, /* 2487 */ {46418, S_00B228_VGPRS(~0u)}, {46424, S_00B228_SGPRS(~0u)}, @@ -4684,18 +4684,18 @@ {46511, S_00B228_IEEE_MODE(~0u)}, {46652, S_00B228_CU_GROUP_ENABLE(~0u)}, {46548, S_00B228_CDBG_USER(~0u)}, - {69352, S_00B228_GS_VGPR_COMP_CNT(~0u)}, - {69233, S_00B228_FP16_OVFL(~0u)}, + {69357, S_00B228_GS_VGPR_COMP_CNT(~0u)}, + {69238, S_00B228_FP16_OVFL(~0u)}, /* 2499 */ {46558, S_00B22C_SCRATCH_EN(~0u)}, {46569, S_00B22C_USER_SGPR(~0u)}, {46579, S_00B22C_TRAP_PRESENT(~0u)}, {46630, S_00B22C_EXCP_EN(~0u)}, - {69369, S_00B22C_ES_VGPR_COMP_CNT(~0u)}, + {69374, S_00B22C_ES_VGPR_COMP_CNT(~0u)}, {46668, S_00B22C_OC_LDS_EN(~0u)}, {46610, S_00B22C_LDS_SIZE(~0u)}, - {69290, S_00B22C_SKIP_USGPR0(~0u)}, - {69302, S_00B22C_USER_SGPR_MSB(~0u)}, + {69295, S_00B22C_SKIP_USGPR0(~0u)}, + {69307, S_00B22C_USER_SGPR_MSB(~0u)}, /* 2508 */ {46749, S_00B404_GROUP_FIFO_DEPTH(~0u)}, /* 2509 */ @@ -4703,7 +4703,7 @@ /* 2510 */ {46388, S_00B41C_WAVE_LIMIT(~0u)}, {46399, S_00B41C_LOCK_LOW_THRESHOLD(~0u)}, - {69220, S_00B41C_SIMD_DISABLE(~0u)}, + {69225, S_00B41C_SIMD_DISABLE(~0u)}, {43975, S_00B41C_CU_EN(~0u)}, /* 2514 */ {46418, S_00B428_VGPRS(~0u)}, @@ -4715,16 +4715,16 @@ {46500, S_00B428_DEBUG_MODE(~0u)}, {46511, S_00B428_IEEE_MODE(~0u)}, {46548, S_00B428_CDBG_USER(~0u)}, - {69386, S_00B428_LS_VGPR_COMP_CNT(~0u)}, - {69233, S_00B428_FP16_OVFL(~0u)}, + {69391, S_00B428_LS_VGPR_COMP_CNT(~0u)}, + {69238, S_00B428_FP16_OVFL(~0u)}, /* 2525 */ {46558, S_00B42C_SCRATCH_EN(~0u)}, {46569, S_00B42C_USER_SGPR(~0u)}, {46579, S_00B42C_TRAP_PRESENT(~0u)}, {46630, S_00B42C_EXCP_EN(~0u)}, {46610, S_00B42C_LDS_SIZE(~0u)}, - {69290, S_00B42C_SKIP_USGPR0(~0u)}, - {69302, S_00B42C_USER_SGPR_MSB(~0u)}, + {69295, S_00B42C_SKIP_USGPR0(~0u)}, + {69307, S_00B42C_USER_SGPR_MSB(~0u)}, /* 2532 */ {46792, S_00B800_COMPUTE_SHADER_EN(~0u)}, {46810, S_00B800_PARTIAL_TG_EN(~0u)}, @@ -4748,7 +4748,7 @@ {46511, S_00B848_IEEE_MODE(~0u)}, {47033, S_00B848_BULKY(~0u)}, {46548, S_00B848_CDBG_USER(~0u)}, - {69233, S_00B848_FP16_OVFL(~0u)}, + {69238, S_00B848_FP16_OVFL(~0u)}, /* 2554 */ {46558, S_00B84C_SCRATCH_EN(~0u)}, {46569, S_00B84C_USER_SGPR(~0u)}, @@ -4761,7 +4761,7 @@ {47084, S_00B84C_EXCP_EN_MSB(~0u)}, {46610, S_00B84C_LDS_SIZE(~0u)}, {46630, S_00B84C_EXCP_EN(~0u)}, - {69290, S_00B84C_SKIP_USGPR0(~0u)}, + {69295, S_00B84C_SKIP_USGPR0(~0u)}, /* 2566 */ {47112, S_00B854_WAVES_PER_SH(~0u)}, {47125, S_00B854_TG_PER_CU(~0u)}, @@ -4769,40 +4769,40 @@ {47150, S_00B854_SIMD_DEST_CNTL(~0u)}, {47165, S_00B854_FORCE_SIMD_DIST(~0u)}, {47181, S_00B854_CU_GROUP_COUNT(~0u)}, - {69220, S_00B854_SIMD_DISABLE(~0u)}, + {69225, S_00B854_SIMD_DISABLE(~0u)}, /* 2573 */ - {69403, S_036008_CNTR_SEL0(~0u)}, - {69413, S_036008_CNTR_SEL1(~0u)}, + {69408, S_036008_CNTR_SEL0(~0u)}, + {69418, S_036008_CNTR_SEL1(~0u)}, {48114, S_036008_SPM_MODE(~0u)}, - {69423, S_036008_CNTR_MODE1(~0u)}, - {69434, S_036008_CNTR_MODE0(~0u)}, + {69428, S_036008_CNTR_MODE1(~0u)}, + {69439, S_036008_CNTR_MODE0(~0u)}, /* 2578 */ - {69445, S_036004_CNTR_SEL2(~0u)}, - {69455, S_036004_CNTR_SEL3(~0u)}, - {69465, S_036004_CNTR_MODE3(~0u)}, - {69476, S_036004_CNTR_MODE2(~0u)}, + {69450, S_036004_CNTR_SEL2(~0u)}, + {69460, S_036004_CNTR_SEL3(~0u)}, + {69470, S_036004_CNTR_MODE3(~0u)}, + {69481, S_036004_CNTR_MODE2(~0u)}, /* 2582 */ - {69403, S_036024_CNTR_SEL0(~0u)}, - {69413, S_036024_CNTR_SEL1(~0u)}, + {69408, S_036024_CNTR_SEL0(~0u)}, + {69418, S_036024_CNTR_SEL1(~0u)}, {48114, S_036024_SPM_MODE(~0u)}, - {69423, S_036024_CNTR_MODE1(~0u)}, - {69434, S_036024_CNTR_MODE0(~0u)}, + {69428, S_036024_CNTR_MODE1(~0u)}, + {69439, S_036024_CNTR_MODE0(~0u)}, /* 2587 */ - {69445, S_036010_CNTR_SEL2(~0u)}, - {69455, S_036010_CNTR_SEL3(~0u)}, - {69465, S_036010_CNTR_MODE3(~0u)}, - {69476, S_036010_CNTR_MODE2(~0u)}, + {69450, S_036010_CNTR_SEL2(~0u)}, + {69460, S_036010_CNTR_SEL3(~0u)}, + {69470, S_036010_CNTR_MODE3(~0u)}, + {69481, S_036010_CNTR_MODE2(~0u)}, /* 2591 */ - {69403, S_03601C_CNTR_SEL0(~0u)}, - {69413, S_03601C_CNTR_SEL1(~0u)}, + {69408, S_03601C_CNTR_SEL0(~0u)}, + {69418, S_03601C_CNTR_SEL1(~0u)}, {48114, S_03601C_SPM_MODE(~0u)}, - {69423, S_03601C_CNTR_MODE1(~0u)}, - {69434, S_03601C_CNTR_MODE0(~0u)}, + {69428, S_03601C_CNTR_MODE1(~0u)}, + {69439, S_03601C_CNTR_MODE0(~0u)}, /* 2596 */ - {69445, S_036018_CNTR_SEL2(~0u)}, - {69455, S_036018_CNTR_SEL3(~0u)}, - {69465, S_036018_CNTR_MODE3(~0u)}, - {69476, S_036018_CNTR_MODE2(~0u)}, + {69450, S_036018_CNTR_SEL2(~0u)}, + {69460, S_036018_CNTR_SEL3(~0u)}, + {69470, S_036018_CNTR_MODE3(~0u)}, + {69481, S_036018_CNTR_MODE2(~0u)}, /* 2600 */ {441, S_036028_INDEX(~0u)}, {43218, S_036028_ALWAYS(~0u)}, @@ -4843,9 +4843,9 @@ {47868, S_036100_RLC_BUSY_USER_DEFINED_MASK(~0u)}, {47895, S_036100_TC_BUSY_USER_DEFINED_MASK(~0u)}, {47921, S_036100_WD_BUSY_USER_DEFINED_MASK(~0u)}, - {69487, S_036100_UTCL2_BUSY_USER_DEFINED_MASK(~0u)}, - {69516, S_036100_EA_BUSY_USER_DEFINED_MASK(~0u)}, - {69542, S_036100_RMI_BUSY_USER_DEFINED_MASK(~0u)}, + {69492, S_036100_UTCL2_BUSY_USER_DEFINED_MASK(~0u)}, + {69521, S_036100_EA_BUSY_USER_DEFINED_MASK(~0u)}, + {69547, S_036100_RMI_BUSY_USER_DEFINED_MASK(~0u)}, /* 2637 */ {47300, S_036108_PERF_SEL(~0u)}, {47470, S_036108_DB_CLEAN_USER_DEFINED_MASK(~0u)}, @@ -4859,7 +4859,7 @@ {47524, S_036108_VGT_BUSY_USER_DEFINED_MASK(~0u)}, {47656, S_036108_PA_BUSY_USER_DEFINED_MASK(~0u)}, {47841, S_036108_BCI_BUSY_USER_DEFINED_MASK(~0u)}, - {69542, S_036108_RMI_BUSY_USER_DEFINED_MASK(~0u)}, + {69547, S_036108_RMI_BUSY_USER_DEFINED_MASK(~0u)}, /* 2650 */ {47300, S_03610C_PERF_SEL(~0u)}, {47470, S_03610C_DB_CLEAN_USER_DEFINED_MASK(~0u)}, @@ -4873,7 +4873,7 @@ {47524, S_03610C_VGT_BUSY_USER_DEFINED_MASK(~0u)}, {47656, S_03610C_PA_BUSY_USER_DEFINED_MASK(~0u)}, {47841, S_03610C_BCI_BUSY_USER_DEFINED_MASK(~0u)}, - {69542, S_03610C_RMI_BUSY_USER_DEFINED_MASK(~0u)}, + {69547, S_03610C_RMI_BUSY_USER_DEFINED_MASK(~0u)}, /* 2663 */ {47300, S_036110_PERF_SEL(~0u)}, {47470, S_036110_DB_CLEAN_USER_DEFINED_MASK(~0u)}, @@ -4887,7 +4887,7 @@ {47524, S_036110_VGT_BUSY_USER_DEFINED_MASK(~0u)}, {47656, S_036110_PA_BUSY_USER_DEFINED_MASK(~0u)}, {47841, S_036110_BCI_BUSY_USER_DEFINED_MASK(~0u)}, - {69542, S_036110_RMI_BUSY_USER_DEFINED_MASK(~0u)}, + {69547, S_036110_RMI_BUSY_USER_DEFINED_MASK(~0u)}, /* 2676 */ {47300, S_036114_PERF_SEL(~0u)}, {47470, S_036114_DB_CLEAN_USER_DEFINED_MASK(~0u)}, @@ -4901,7 +4901,7 @@ {47524, S_036114_VGT_BUSY_USER_DEFINED_MASK(~0u)}, {47656, S_036114_PA_BUSY_USER_DEFINED_MASK(~0u)}, {47841, S_036114_BCI_BUSY_USER_DEFINED_MASK(~0u)}, - {69542, S_036114_RMI_BUSY_USER_DEFINED_MASK(~0u)}, + {69547, S_036114_RMI_BUSY_USER_DEFINED_MASK(~0u)}, /* 2689 */ {47300, S_036600_PERF_SEL(~0u)}, {47309, S_036600_PERF_SEL1(~0u)}, @@ -4918,7 +4918,7 @@ {48854, S_028008_SLICE_MAX(~0u)}, {48864, S_028008_Z_READ_ONLY(~0u)}, {48876, S_028008_STENCIL_READ_ONLY(~0u)}, - {69569, S_028008_MIPID(~0u)}, + {69574, S_028008_MIPID(~0u)}, /* 2703 */ {49493, S_028010_PARTIAL_SQUAD_LAUNCH_CONTROL(~0u), 4, 678}, {49522, S_028010_PARTIAL_SQUAD_LAUNCH_COUNTDOWN(~0u)}, @@ -4935,20 +4935,20 @@ {49786, S_028010_PRESERVE_ZRANGE(~0u)}, {49802, S_028010_PRESERVE_SRESULTS(~0u)}, {49820, S_028010_DISABLE_FAST_PASS(~0u)}, - {69575, S_028010_ALLOW_PARTIAL_RES_HIER_KILL(~0u)}, + {69580, S_028010_ALLOW_PARTIAL_RES_HIER_KILL(~0u)}, /* 2719 */ {880, S_028018_BASE_HI(~0u)}, /* 2720 */ - {69603, S_02801C_X_MAX(~0u)}, - {69609, S_02801C_Y_MAX(~0u)}, + {69608, S_02801C_X_MAX(~0u)}, + {69614, S_02801C_Y_MAX(~0u)}, /* 2722 */ {21132, S_028038_FORMAT(~0u), 4, 707}, {50010, S_028038_NUM_SAMPLES(~0u)}, - {68600, S_028038_SW_MODE(~0u)}, - {69615, S_028038_PARTIALLY_RESIDENT(~0u)}, - {69634, S_028038_FAULT_BEHAVIOR(~0u)}, - {69649, S_028038_ITERATE_FLUSH(~0u)}, - {69663, S_028038_MAXMIP(~0u)}, + {68605, S_028038_SW_MODE(~0u)}, + {69620, S_028038_PARTIALLY_RESIDENT(~0u)}, + {69639, S_028038_FAULT_BEHAVIOR(~0u)}, + {69654, S_028038_ITERATE_FLUSH(~0u)}, + {69668, S_028038_MAXMIP(~0u)}, {50038, S_028038_DECOMPRESS_ON_N_ZPLANES(~0u)}, {50062, S_028038_ALLOW_EXPCLEAR(~0u)}, {50077, S_028038_READ_SIZE(~0u)}, @@ -4957,10 +4957,10 @@ {50124, S_028038_ZRANGE_PRECISION(~0u)}, /* 2735 */ {21132, S_02803C_FORMAT(~0u), 2, 711}, - {68600, S_02803C_SW_MODE(~0u)}, - {69615, S_02803C_PARTIALLY_RESIDENT(~0u)}, - {69634, S_02803C_FAULT_BEHAVIOR(~0u)}, - {69649, S_02803C_ITERATE_FLUSH(~0u)}, + {68605, S_02803C_SW_MODE(~0u)}, + {69620, S_02803C_PARTIALLY_RESIDENT(~0u)}, + {69639, S_02803C_FAULT_BEHAVIOR(~0u)}, + {69654, S_02803C_ITERATE_FLUSH(~0u)}, {50062, S_02803C_ALLOW_EXPCLEAR(~0u)}, {50167, S_02803C_TILE_STENCIL_DISABLE(~0u)}, {50107, S_02803C_CLEAR_DISALLOWED(~0u)}, @@ -4973,23 +4973,23 @@ /* 2746 */ {880, S_02805C_BASE_HI(~0u)}, /* 2747 */ - {69679, S_028060_PUNCHOUT_MODE(~0u), 4, 1512}, - {69693, S_028060_POPS_DRAIN_PS_ON_OVERLAP(~0u)}, - {69718, S_028060_DISALLOW_OVERFLOW(~0u)}, + {69684, S_028060_PUNCHOUT_MODE(~0u), 4, 1512}, + {69698, S_028060_POPS_DRAIN_PS_ON_OVERLAP(~0u)}, + {69723, S_028060_DISALLOW_OVERFLOW(~0u)}, /* 2750 */ - {69736, S_028064_PS_INVOKE_MASK(~0u)}, + {69741, S_028064_PS_INVOKE_MASK(~0u)}, /* 2751 */ {30484, S_028068_EPITCH(~0u)}, /* 2752 */ {30484, S_02806C_EPITCH(~0u)}, /* 2753 */ - {69751, S_0281E8_DEST_BASE_HI_256B(~0u)}, + {69756, S_0281E8_DEST_BASE_HI_256B(~0u)}, /* 2754 */ - {69751, S_0281EC_DEST_BASE_HI_256B(~0u)}, + {69756, S_0281EC_DEST_BASE_HI_256B(~0u)}, /* 2755 */ - {69751, S_0281F0_DEST_BASE_HI_256B(~0u)}, + {69756, S_0281F0_DEST_BASE_HI_256B(~0u)}, /* 2756 */ - {69751, S_0281F4_DEST_BASE_HI_256B(~0u)}, + {69756, S_0281F4_DEST_BASE_HI_256B(~0u)}, /* 2757 */ {50727, S_028350_RB_MAP_PKR0(~0u), 4, 713}, {50739, S_028350_RB_MAP_PKR1(~0u), 4, 713}, @@ -5004,47 +5004,47 @@ {51550, S_028350_SC_XSEL(~0u), 4, 741}, {51697, S_028350_SC_YSEL(~0u), 4, 745}, {51797, S_028350_SE_MAP(~0u), 4, 749}, - {69769, S_028350_SE_XSEL_GFX9(~0u)}, - {69782, S_028350_SE_YSEL_GFX9(~0u)}, + {69774, S_028350_SE_XSEL_GFX9(~0u)}, + {69787, S_028350_SE_YSEL_GFX9(~0u)}, /* 2772 */ {52220, S_028354_SE_PAIR_MAP(~0u), 4, 761}, - {69795, S_028354_SE_PAIR_XSEL_GFX9(~0u)}, - {69813, S_028354_SE_PAIR_YSEL_GFX9(~0u)}, + {69800, S_028354_SE_PAIR_XSEL_GFX9(~0u)}, + {69818, S_028354_SE_PAIR_YSEL_GFX9(~0u)}, /* 2775 */ {7643, S_02835C_ENABLE(~0u)}, - {69831, S_02835C_NUM_SE(~0u)}, - {69196, S_02835C_NUM_RB_PER_SE(~0u)}, - {69838, S_02835C_DISABLE_SRBSL_DB_OPTIMIZED_PACKING(~0u)}, + {69836, S_02835C_NUM_SE(~0u)}, + {69201, S_02835C_NUM_RB_PER_SE(~0u)}, + {69843, S_02835C_DISABLE_SRBSL_DB_OPTIMIZED_PACKING(~0u)}, /* 2779 */ - {69873, S_028360_PERFMON_ENABLE(~0u)}, + {69878, S_028360_PERFMON_ENABLE(~0u)}, /* 2780 */ - {69888, S_0283A0_LEFT_QTR(~0u)}, - {69897, S_0283A0_LEFT_HALF(~0u)}, - {69907, S_0283A0_RIGHT_HALF(~0u)}, - {69918, S_0283A0_RIGHT_QTR(~0u)}, + {69893, S_0283A0_LEFT_QTR(~0u)}, + {69902, S_0283A0_LEFT_HALF(~0u)}, + {69912, S_0283A0_RIGHT_HALF(~0u)}, + {69923, S_0283A0_RIGHT_QTR(~0u)}, /* 2784 */ - {69888, S_0283A4_LEFT_QTR(~0u)}, - {69897, S_0283A4_LEFT_HALF(~0u)}, - {69907, S_0283A4_RIGHT_HALF(~0u)}, - {69918, S_0283A4_RIGHT_QTR(~0u)}, + {69893, S_0283A4_LEFT_QTR(~0u)}, + {69902, S_0283A4_LEFT_HALF(~0u)}, + {69912, S_0283A4_RIGHT_HALF(~0u)}, + {69923, S_0283A4_RIGHT_QTR(~0u)}, /* 2788 */ - {69928, S_0283A8_TOP_QTR(~0u)}, - {69936, S_0283A8_TOP_HALF(~0u)}, - {69945, S_0283A8_BOT_HALF(~0u)}, - {69954, S_0283A8_BOT_QTR(~0u)}, + {69933, S_0283A8_TOP_QTR(~0u)}, + {69941, S_0283A8_TOP_HALF(~0u)}, + {69950, S_0283A8_BOT_HALF(~0u)}, + {69959, S_0283A8_BOT_QTR(~0u)}, /* 2792 */ - {69962, S_0283AC_LEFT_EYE_FOV_LEFT(~0u)}, - {69980, S_0283AC_LEFT_EYE_FOV_RIGHT(~0u)}, - {69999, S_0283AC_RIGHT_EYE_FOV_LEFT(~0u)}, - {70018, S_0283AC_RIGHT_EYE_FOV_RIGHT(~0u)}, + {69967, S_0283AC_LEFT_EYE_FOV_LEFT(~0u)}, + {69985, S_0283AC_LEFT_EYE_FOV_RIGHT(~0u)}, + {70004, S_0283AC_RIGHT_EYE_FOV_LEFT(~0u)}, + {70023, S_0283AC_RIGHT_EYE_FOV_RIGHT(~0u)}, /* 2796 */ - {70038, S_0283B0_FOV_TOP(~0u)}, - {70046, S_0283B0_FOV_BOT(~0u)}, + {70043, S_0283B0_FOV_TOP(~0u)}, + {70051, S_0283B0_FOV_BOT(~0u)}, /* 2798 */ {53855, S_0286D8_NUM_INTERP(~0u)}, {53866, S_0286D8_PARAM_GEN(~0u)}, - {70054, S_0286D8_OFFCHIP_PARAM_EN(~0u)}, - {70071, S_0286D8_LATE_PC_DEALLOC(~0u)}, + {70059, S_0286D8_OFFCHIP_PARAM_EN(~0u)}, + {70076, S_0286D8_LATE_PC_DEALLOC(~0u)}, {53885, S_0286D8_BC_OPTIMIZE_DISABLE(~0u)}, /* 2803 */ {30484, S_0287A0_EPITCH(~0u)}, @@ -5063,171 +5063,171 @@ /* 2810 */ {30484, S_0287BC_EPITCH(~0u)}, /* 2811 */ - {70087, S_0287E4_BASE_ADDR_GFX9(~0u)}, + {70092, S_0287E4_BASE_ADDR_GFX9(~0u)}, /* 2812 */ {56739, S_0287F0_SOURCE_SELECT(~0u), 4, 880}, {56785, S_0287F0_MAJOR_MODE(~0u), 2, 884}, - {70102, S_0287F0_SPRITE_EN_R6XX(~0u)}, + {70107, S_0287F0_SPRITE_EN_R6XX(~0u)}, {56796, S_0287F0_NOT_EOP(~0u)}, {56804, S_0287F0_USE_OPAQUE(~0u)}, - {70117, S_0287F0_UNROLLED_INST(~0u)}, - {70131, S_0287F0_GRBM_SKEW_NO_DEC(~0u)}, - {70148, S_0287F0_REG_RT_INDEX(~0u)}, + {70122, S_0287F0_UNROLLED_INST(~0u)}, + {70136, S_0287F0_GRBM_SKEW_NO_DEC(~0u)}, + {70153, S_0287F0_REG_RT_INDEX(~0u)}, /* 2820 */ - {57775, S_02880C_Z_EXPORT_ENABLE(~0u)}, - {57791, S_02880C_STENCIL_TEST_VAL_EXPORT_ENABLE(~0u)}, - {57822, S_02880C_STENCIL_OP_VAL_EXPORT_ENABLE(~0u)}, + {57780, S_02880C_Z_EXPORT_ENABLE(~0u)}, + {57796, S_02880C_STENCIL_TEST_VAL_EXPORT_ENABLE(~0u)}, + {57827, S_02880C_STENCIL_OP_VAL_EXPORT_ENABLE(~0u)}, {49012, S_02880C_Z_ORDER(~0u), 4, 1165}, - {57901, S_02880C_KILL_ENABLE(~0u)}, - {57913, S_02880C_COVERAGE_TO_MASK_ENABLE(~0u)}, - {57937, S_02880C_MASK_EXPORT_ENABLE(~0u)}, - {57956, S_02880C_EXEC_ON_HIER_FAIL(~0u)}, - {57974, S_02880C_EXEC_ON_NOOP(~0u)}, - {57987, S_02880C_ALPHA_TO_MASK_DISABLE(~0u)}, - {58009, S_02880C_DEPTH_BEFORE_SHADER(~0u)}, - {58099, S_02880C_CONSERVATIVE_Z_EXPORT(~0u), 4, 1169}, - {58121, S_02880C_DUAL_QUAD_DISABLE(~0u)}, - {70161, S_02880C_PRIMITIVE_ORDERED_PIXEL_SHADER(~0u)}, - {70192, S_02880C_EXEC_IF_OVERLAPPED(~0u)}, - {70211, S_02880C_POPS_OVERLAP_NUM_SAMPLES(~0u)}, + {57906, S_02880C_KILL_ENABLE(~0u)}, + {57918, S_02880C_COVERAGE_TO_MASK_ENABLE(~0u)}, + {57942, S_02880C_MASK_EXPORT_ENABLE(~0u)}, + {57961, S_02880C_EXEC_ON_HIER_FAIL(~0u)}, + {57979, S_02880C_EXEC_ON_NOOP(~0u)}, + {57992, S_02880C_ALPHA_TO_MASK_DISABLE(~0u)}, + {58014, S_02880C_DEPTH_BEFORE_SHADER(~0u)}, + {58104, S_02880C_CONSERVATIVE_Z_EXPORT(~0u), 4, 1169}, + {58126, S_02880C_DUAL_QUAD_DISABLE(~0u)}, + {70166, S_02880C_PRIMITIVE_ORDERED_PIXEL_SHADER(~0u)}, + {70197, S_02880C_EXEC_IF_OVERLAPPED(~0u)}, + {70216, S_02880C_POPS_OVERLAP_NUM_SAMPLES(~0u)}, /* 2836 */ - {58443, S_028814_CULL_FRONT(~0u)}, - {58454, S_028814_CULL_BACK(~0u)}, + {58448, S_028814_CULL_FRONT(~0u)}, + {58459, S_028814_CULL_BACK(~0u)}, {22820, S_028814_FACE(~0u)}, - {58474, S_028814_POLY_MODE(~0u), 2, 1173}, - {58540, S_028814_POLYMODE_FRONT_PTYPE(~0u), 3, 1175}, - {58561, S_028814_POLYMODE_BACK_PTYPE(~0u), 3, 1175}, - {58581, S_028814_POLY_OFFSET_FRONT_ENABLE(~0u)}, - {58606, S_028814_POLY_OFFSET_BACK_ENABLE(~0u)}, - {58630, S_028814_POLY_OFFSET_PARA_ENABLE(~0u)}, - {58654, S_028814_VTX_WINDOW_OFFSET_ENABLE(~0u)}, - {58679, S_028814_PROVOKING_VTX_LAST(~0u)}, - {58698, S_028814_PERSP_CORR_DIS(~0u)}, - {58713, S_028814_MULTI_PRIM_IB_ENA(~0u)}, - {70236, S_028814_RIGHT_TRIANGLE_ALTERNATE_GRADIENT_REF(~0u)}, - {70274, S_028814_NEW_QUAD_DECOMPOSITION(~0u)}, + {58479, S_028814_POLY_MODE(~0u), 2, 1173}, + {58545, S_028814_POLYMODE_FRONT_PTYPE(~0u), 3, 1175}, + {58566, S_028814_POLYMODE_BACK_PTYPE(~0u), 3, 1175}, + {58586, S_028814_POLY_OFFSET_FRONT_ENABLE(~0u)}, + {58611, S_028814_POLY_OFFSET_BACK_ENABLE(~0u)}, + {58635, S_028814_POLY_OFFSET_PARA_ENABLE(~0u)}, + {58659, S_028814_VTX_WINDOW_OFFSET_ENABLE(~0u)}, + {58684, S_028814_PROVOKING_VTX_LAST(~0u)}, + {58703, S_028814_PERSP_CORR_DIS(~0u)}, + {58718, S_028814_MULTI_PRIM_IB_ENA(~0u)}, + {70241, S_028814_RIGHT_TRIANGLE_ALTERNATE_GRADIENT_REF(~0u)}, + {70279, S_028814_NEW_QUAD_DECOMPOSITION(~0u)}, /* 2851 */ - {58731, S_028818_VPORT_X_SCALE_ENA(~0u)}, - {58749, S_028818_VPORT_X_OFFSET_ENA(~0u)}, - {58768, S_028818_VPORT_Y_SCALE_ENA(~0u)}, - {58786, S_028818_VPORT_Y_OFFSET_ENA(~0u)}, - {58805, S_028818_VPORT_Z_SCALE_ENA(~0u)}, - {58823, S_028818_VPORT_Z_OFFSET_ENA(~0u)}, - {58842, S_028818_VTX_XY_FMT(~0u)}, - {58853, S_028818_VTX_Z_FMT(~0u)}, - {58863, S_028818_VTX_W0_FMT(~0u)}, - {70297, S_028818_PERFCOUNTER_REF(~0u)}, + {58736, S_028818_VPORT_X_SCALE_ENA(~0u)}, + {58754, S_028818_VPORT_X_OFFSET_ENA(~0u)}, + {58773, S_028818_VPORT_Y_SCALE_ENA(~0u)}, + {58791, S_028818_VPORT_Y_OFFSET_ENA(~0u)}, + {58810, S_028818_VPORT_Z_SCALE_ENA(~0u)}, + {58828, S_028818_VPORT_Z_OFFSET_ENA(~0u)}, + {58847, S_028818_VTX_XY_FMT(~0u)}, + {58858, S_028818_VTX_Z_FMT(~0u)}, + {58868, S_028818_VTX_W0_FMT(~0u)}, + {70302, S_028818_PERFCOUNTER_REF(~0u)}, /* 2861 */ - {58874, S_02881C_CLIP_DIST_ENA_0(~0u)}, - {58890, S_02881C_CLIP_DIST_ENA_1(~0u)}, - {58906, S_02881C_CLIP_DIST_ENA_2(~0u)}, - {58922, S_02881C_CLIP_DIST_ENA_3(~0u)}, - {58938, S_02881C_CLIP_DIST_ENA_4(~0u)}, - {58954, S_02881C_CLIP_DIST_ENA_5(~0u)}, - {58970, S_02881C_CLIP_DIST_ENA_6(~0u)}, - {58986, S_02881C_CLIP_DIST_ENA_7(~0u)}, - {59002, S_02881C_CULL_DIST_ENA_0(~0u)}, - {59018, S_02881C_CULL_DIST_ENA_1(~0u)}, - {59034, S_02881C_CULL_DIST_ENA_2(~0u)}, - {59050, S_02881C_CULL_DIST_ENA_3(~0u)}, - {59066, S_02881C_CULL_DIST_ENA_4(~0u)}, - {59082, S_02881C_CULL_DIST_ENA_5(~0u)}, - {59098, S_02881C_CULL_DIST_ENA_6(~0u)}, - {59114, S_02881C_CULL_DIST_ENA_7(~0u)}, - {59130, S_02881C_USE_VTX_POINT_SIZE(~0u)}, - {59149, S_02881C_USE_VTX_EDGE_FLAG(~0u)}, - {59167, S_02881C_USE_VTX_RENDER_TARGET_INDX(~0u)}, - {59194, S_02881C_USE_VTX_VIEWPORT_INDX(~0u)}, - {59216, S_02881C_USE_VTX_KILL_FLAG(~0u)}, - {59234, S_02881C_VS_OUT_MISC_VEC_ENA(~0u)}, - {59254, S_02881C_VS_OUT_CCDIST0_VEC_ENA(~0u)}, - {59277, S_02881C_VS_OUT_CCDIST1_VEC_ENA(~0u)}, - {59300, S_02881C_VS_OUT_MISC_SIDE_BUS_ENA(~0u)}, - {59325, S_02881C_USE_VTX_GS_CUT_FLAG(~0u)}, - {59345, S_02881C_USE_VTX_LINE_WIDTH(~0u)}, - {70313, S_02881C_USE_VTX_SHD_OBJPRIM_ID(~0u)}, + {58879, S_02881C_CLIP_DIST_ENA_0(~0u)}, + {58895, S_02881C_CLIP_DIST_ENA_1(~0u)}, + {58911, S_02881C_CLIP_DIST_ENA_2(~0u)}, + {58927, S_02881C_CLIP_DIST_ENA_3(~0u)}, + {58943, S_02881C_CLIP_DIST_ENA_4(~0u)}, + {58959, S_02881C_CLIP_DIST_ENA_5(~0u)}, + {58975, S_02881C_CLIP_DIST_ENA_6(~0u)}, + {58991, S_02881C_CLIP_DIST_ENA_7(~0u)}, + {59007, S_02881C_CULL_DIST_ENA_0(~0u)}, + {59023, S_02881C_CULL_DIST_ENA_1(~0u)}, + {59039, S_02881C_CULL_DIST_ENA_2(~0u)}, + {59055, S_02881C_CULL_DIST_ENA_3(~0u)}, + {59071, S_02881C_CULL_DIST_ENA_4(~0u)}, + {59087, S_02881C_CULL_DIST_ENA_5(~0u)}, + {59103, S_02881C_CULL_DIST_ENA_6(~0u)}, + {59119, S_02881C_CULL_DIST_ENA_7(~0u)}, + {59135, S_02881C_USE_VTX_POINT_SIZE(~0u)}, + {59154, S_02881C_USE_VTX_EDGE_FLAG(~0u)}, + {59172, S_02881C_USE_VTX_RENDER_TARGET_INDX(~0u)}, + {59199, S_02881C_USE_VTX_VIEWPORT_INDX(~0u)}, + {59221, S_02881C_USE_VTX_KILL_FLAG(~0u)}, + {59239, S_02881C_VS_OUT_MISC_VEC_ENA(~0u)}, + {59259, S_02881C_VS_OUT_CCDIST0_VEC_ENA(~0u)}, + {59282, S_02881C_VS_OUT_CCDIST1_VEC_ENA(~0u)}, + {59305, S_02881C_VS_OUT_MISC_SIDE_BUS_ENA(~0u)}, + {59330, S_02881C_USE_VTX_GS_CUT_FLAG(~0u)}, + {59350, S_02881C_USE_VTX_LINE_WIDTH(~0u)}, + {70318, S_02881C_USE_VTX_SHD_OBJPRIM_ID(~0u)}, /* 2889 */ - {59951, S_028830_SMALL_PRIM_FILTER_ENABLE(~0u)}, - {59723, S_028830_TRIANGLE_FILTER_DISABLE(~0u)}, - {59747, S_028830_LINE_FILTER_DISABLE(~0u)}, - {59767, S_028830_POINT_FILTER_DISABLE(~0u)}, - {59788, S_028830_RECTANGLE_FILTER_DISABLE(~0u)}, - {70336, S_028830_SRBSL_ENABLE(~0u)}, + {59956, S_028830_SMALL_PRIM_FILTER_ENABLE(~0u)}, + {59728, S_028830_TRIANGLE_FILTER_DISABLE(~0u)}, + {59752, S_028830_LINE_FILTER_DISABLE(~0u)}, + {59772, S_028830_POINT_FILTER_DISABLE(~0u)}, + {59793, S_028830_RECTANGLE_FILTER_DISABLE(~0u)}, + {70341, S_028830_SRBSL_ENABLE(~0u)}, /* 2895 */ - {70349, S_028834_OBJ_ID_SEL(~0u)}, - {70360, S_028834_ADD_PIPED_PRIM_ID(~0u)}, - {70378, S_028834_EN_32BIT_OBJPRIMID(~0u)}, + {70354, S_028834_OBJ_ID_SEL(~0u)}, + {70365, S_028834_ADD_PIPED_PRIM_ID(~0u)}, + {70383, S_028834_EN_32BIT_OBJPRIMID(~0u)}, /* 2898 */ - {70397, S_028838_VERTEX_REUSE_OFF(~0u)}, - {70414, S_028838_INDEX_BUF_EDGE_FLAG_ENA(~0u)}, + {70402, S_028838_VERTEX_REUSE_OFF(~0u)}, + {70419, S_028838_INDEX_BUF_EDGE_FLAG_ENA(~0u)}, /* 2900 */ - {70438, S_02883C_DISCARD_0_AREA_TRIANGLES(~0u)}, - {70463, S_02883C_DISCARD_0_AREA_LINES(~0u)}, - {70484, S_02883C_DISCARD_0_AREA_POINTS(~0u)}, - {70506, S_02883C_DISCARD_0_AREA_RECTANGLES(~0u)}, - {70532, S_02883C_USE_PROVOKING_ZW(~0u)}, + {70443, S_02883C_DISCARD_0_AREA_TRIANGLES(~0u)}, + {70468, S_02883C_DISCARD_0_AREA_LINES(~0u)}, + {70489, S_02883C_DISCARD_0_AREA_POINTS(~0u)}, + {70511, S_02883C_DISCARD_0_AREA_RECTANGLES(~0u)}, + {70537, S_02883C_USE_PROVOKING_ZW(~0u)}, /* 2905 */ {22279, S_028A40_MODE(~0u), 6, 1215}, {39383, S_028A40_RESERVED_0(~0u)}, - {60992, S_028A40_CUT_MODE(~0u), 4, 1221}, + {60997, S_028A40_CUT_MODE(~0u), 4, 1221}, {39401, S_028A40_RESERVED_1(~0u)}, - {61001, S_028A40_GS_C_PACK_EN(~0u)}, - {61014, S_028A40_RESERVED_2(~0u)}, - {61025, S_028A40_ES_PASSTHRU(~0u)}, - {70549, S_028A40_RESERVED_3(~0u)}, - {70560, S_028A40_RESERVED_4(~0u)}, - {70571, S_028A40_RESERVED_5(~0u)}, - {61084, S_028A40_PARTIAL_THD_AT_EOI(~0u)}, - {61103, S_028A40_SUPPRESS_CUTS(~0u)}, - {61117, S_028A40_ES_WRITE_OPTIMIZE(~0u)}, - {61135, S_028A40_GS_WRITE_OPTIMIZE(~0u)}, - {61186, S_028A40_ONCHIP(~0u), 4, 1225}, + {61006, S_028A40_GS_C_PACK_EN(~0u)}, + {61019, S_028A40_RESERVED_2(~0u)}, + {61030, S_028A40_ES_PASSTHRU(~0u)}, + {70554, S_028A40_RESERVED_3(~0u)}, + {70565, S_028A40_RESERVED_4(~0u)}, + {70576, S_028A40_RESERVED_5(~0u)}, + {61089, S_028A40_PARTIAL_THD_AT_EOI(~0u)}, + {61108, S_028A40_SUPPRESS_CUTS(~0u)}, + {61122, S_028A40_ES_WRITE_OPTIMIZE(~0u)}, + {61140, S_028A40_GS_WRITE_OPTIMIZE(~0u)}, + {61191, S_028A40_ONCHIP(~0u), 4, 1225}, /* 2920 */ - {61193, S_028A44_ES_VERTS_PER_SUBGRP(~0u)}, - {61213, S_028A44_GS_PRIMS_PER_SUBGRP(~0u)}, - {70582, S_028A44_GS_INST_PRIMS_IN_SUBGRP(~0u)}, + {61198, S_028A44_ES_VERTS_PER_SUBGRP(~0u)}, + {61218, S_028A44_GS_PRIMS_PER_SUBGRP(~0u)}, + {70587, S_028A44_GS_INST_PRIMS_IN_SUBGRP(~0u)}, /* 2923 */ - {61233, S_028A48_MSAA_ENABLE(~0u)}, - {61245, S_028A48_VPORT_SCISSOR_ENABLE(~0u)}, - {61266, S_028A48_LINE_STIPPLE_ENABLE(~0u)}, - {61286, S_028A48_SEND_UNLIT_STILES_TO_PKR(~0u)}, - {70606, S_028A48_SCALE_LINE_WIDTH_PAD(~0u)}, - {70627, S_028A48_ALTERNATE_RBS_PER_TILE(~0u)}, - {70650, S_028A48_COARSE_TILE_STARTS_ON_EVEN_RB(~0u)}, + {61238, S_028A48_MSAA_ENABLE(~0u)}, + {61250, S_028A48_VPORT_SCISSOR_ENABLE(~0u)}, + {61271, S_028A48_LINE_STIPPLE_ENABLE(~0u)}, + {61291, S_028A48_SEND_UNLIT_STILES_TO_PKR(~0u)}, + {70611, S_028A48_SCALE_LINE_WIDTH_PAD(~0u)}, + {70632, S_028A48_ALTERNATE_RBS_PER_TILE(~0u)}, + {70655, S_028A48_COARSE_TILE_STARTS_ON_EVEN_RB(~0u)}, /* 2930 */ {203, S_028A7C_INDEX_TYPE(~0u), 3, 1232}, - {62070, S_028A7C_SWAP_MODE(~0u), 4, 1235}, - {62131, S_028A7C_BUF_TYPE(~0u), 3, 1239}, - {62190, S_028A7C_RDREQ_POLICY(~0u)}, - {67039, S_028A7C_PRIMGEN_EN(~0u)}, + {62075, S_028A7C_SWAP_MODE(~0u), 4, 1235}, + {62136, S_028A7C_BUF_TYPE(~0u), 3, 1239}, + {62195, S_028A7C_RDREQ_POLICY(~0u)}, + {67044, S_028A7C_PRIMGEN_EN(~0u)}, {56796, S_028A7C_NOT_EOP(~0u)}, - {62203, S_028A7C_REQ_PATH(~0u)}, + {62208, S_028A7C_REQ_PATH(~0u)}, /* 2937 */ {22558, S_028A84_PRIMITIVEID_EN(~0u)}, - {62212, S_028A84_DISABLE_RESET_ON_EOI(~0u)}, - {70680, S_028A84_NGG_DISABLE_PROVOK_REUSE(~0u)}, + {62217, S_028A84_DISABLE_RESET_ON_EOI(~0u)}, + {70685, S_028A84_NGG_DISABLE_PROVOK_REUSE(~0u)}, /* 2940 */ - {63168, S_028A90_EVENT_TYPE(~0u), 63, 1516}, - {70805, S_028A90_ADDRESS_HI_GFX9(~0u)}, - {63195, S_028A90_EXTENDED_EVENT(~0u)}, + {63173, S_028A90_EVENT_TYPE(~0u), 63, 1516}, + {70810, S_028A90_ADDRESS_HI_GFX9(~0u)}, + {63200, S_028A90_EXTENDED_EVENT(~0u)}, /* 2943 */ {30670, S_028A94_MAX_PRIMS_PER_SUBGROUP(~0u)}, /* 2944 */ - {70821, S_028A98_OBJPRIM_ID_EN(~0u)}, - {70835, S_028A98_EN_REG_RT_INDEX(~0u)}, - {70851, S_028A98_EN_PIPELINE_PRIMID(~0u)}, - {70870, S_028A98_OBJECT_ID_INST_EN(~0u)}, + {70826, S_028A98_OBJPRIM_ID_EN(~0u)}, + {70840, S_028A98_EN_REG_RT_INDEX(~0u)}, + {70856, S_028A98_EN_PIPELINE_PRIMID(~0u)}, + {70875, S_028A98_OBJECT_ID_INST_EN(~0u)}, /* 2948 */ - {70888, S_028A9C_COMPOUND_INDEX_EN(~0u)}, + {70893, S_028A9C_COMPOUND_INDEX_EN(~0u)}, /* 2949 */ - {63328, S_028ABC_FULL_CACHE(~0u)}, - {63339, S_028ABC_HTILE_USES_PRELOAD_WIN(~0u)}, - {63362, S_028ABC_PRELOAD(~0u)}, - {63370, S_028ABC_PREFETCH_WIDTH(~0u)}, - {63385, S_028ABC_PREFETCH_HEIGHT(~0u)}, - {63401, S_028ABC_DST_OUTSIDE_ZERO_TO_ONE(~0u)}, - {68773, S_028ABC_PIPE_ALIGNED(~0u)}, - {68791, S_028ABC_RB_ALIGNED(~0u)}, + {63333, S_028ABC_FULL_CACHE(~0u)}, + {63344, S_028ABC_HTILE_USES_PRELOAD_WIN(~0u)}, + {63367, S_028ABC_PRELOAD(~0u)}, + {63375, S_028ABC_PREFETCH_WIDTH(~0u)}, + {63390, S_028ABC_PREFETCH_HEIGHT(~0u)}, + {63406, S_028ABC_DST_OUTSIDE_ZERO_TO_ONE(~0u)}, + {68778, S_028ABC_PIPE_ALIGNED(~0u)}, + {68796, S_028ABC_RB_ALIGNED(~0u)}, /* 2957 */ {48157, S_028B54_LS_EN(~0u), 3, 1303}, {48151, S_028B54_HS_EN(~0u)}, @@ -5235,125 +5235,125 @@ {48145, S_028B54_GS_EN(~0u)}, {48139, S_028B54_VS_EN(~0u), 3, 1309}, {46732, S_028B54_DISPATCH_DRAW_EN(~0u)}, - {63723, S_028B54_DIS_DEALLOC_ACCUM_0(~0u)}, - {63743, S_028B54_DIS_DEALLOC_ACCUM_1(~0u)}, - {63763, S_028B54_VS_WAVE_ID_EN(~0u)}, - {67039, S_028B54_PRIMGEN_EN(~0u)}, - {70906, S_028B54_ORDERED_ID_MODE(~0u)}, - {63308, S_028B54_MAX_PRIMGRP_IN_WAVE(~0u)}, - {70922, S_028B54_GS_FAST_LAUNCH(~0u)}, + {63728, S_028B54_DIS_DEALLOC_ACCUM_0(~0u)}, + {63748, S_028B54_DIS_DEALLOC_ACCUM_1(~0u)}, + {63768, S_028B54_VS_WAVE_ID_EN(~0u)}, + {67044, S_028B54_PRIMGEN_EN(~0u)}, + {70911, S_028B54_ORDERED_ID_MODE(~0u)}, + {63313, S_028B54_MAX_PRIMGRP_IN_WAVE(~0u)}, + {70927, S_028B54_GS_FAST_LAUNCH(~0u)}, /* 2970 */ {209, S_028B6C_TYPE(~0u), 3, 1312}, - {63911, S_028B6C_PARTITIONING(~0u), 4, 1315}, - {63988, S_028B6C_TOPOLOGY(~0u), 4, 1319}, - {63997, S_028B6C_RESERVED_REDUC_AXIS(~0u)}, - {64017, S_028B6C_DEPRECATED(~0u)}, - {64050, S_028B6C_DISABLE_DONUTS(~0u)}, - {62190, S_028B6C_RDREQ_POLICY(~0u)}, - {64189, S_028B6C_DISTRIBUTION_MODE(~0u), 4, 1326}, + {63916, S_028B6C_PARTITIONING(~0u), 4, 1315}, + {63993, S_028B6C_TOPOLOGY(~0u), 4, 1319}, + {64002, S_028B6C_RESERVED_REDUC_AXIS(~0u)}, + {64022, S_028B6C_DEPRECATED(~0u)}, + {64055, S_028B6C_DISABLE_DONUTS(~0u)}, + {62195, S_028B6C_RDREQ_POLICY(~0u)}, + {64194, S_028B6C_DISTRIBUTION_MODE(~0u), 4, 1326}, /* 2978 */ - {64385, S_028B94_STREAMOUT_0_EN(~0u)}, - {64400, S_028B94_STREAMOUT_1_EN(~0u)}, - {64415, S_028B94_STREAMOUT_2_EN(~0u)}, - {64430, S_028B94_STREAMOUT_3_EN(~0u)}, - {64445, S_028B94_RAST_STREAM(~0u)}, - {70937, S_028B94_EN_PRIMS_NEEDED_CNT(~0u)}, - {64457, S_028B94_RAST_STREAM_MASK(~0u)}, - {64474, S_028B94_USE_RAST_STREAM_MASK(~0u)}, + {64390, S_028B94_STREAMOUT_0_EN(~0u)}, + {64405, S_028B94_STREAMOUT_1_EN(~0u)}, + {64420, S_028B94_STREAMOUT_2_EN(~0u)}, + {64435, S_028B94_STREAMOUT_3_EN(~0u)}, + {64450, S_028B94_RAST_STREAM(~0u)}, + {70942, S_028B94_EN_PRIMS_NEEDED_CNT(~0u)}, + {64462, S_028B94_RAST_STREAM_MASK(~0u)}, + {64479, S_028B94_USE_RAST_STREAM_MASK(~0u)}, /* 2986 */ - {63168, S_028B9C_EVENT_TYPE(~0u)}, + {63173, S_028B9C_EVENT_TYPE(~0u)}, {39318, S_028B9C_ADDRESS_HI(~0u)}, - {63195, S_028B9C_EXTENDED_EVENT(~0u)}, + {63200, S_028B9C_EXTENDED_EVENT(~0u)}, /* 2989 */ - {64829, S_028BE0_MSAA_NUM_SAMPLES(~0u)}, - {64846, S_028BE0_AA_MASK_CENTROID_DTMN(~0u)}, - {64868, S_028BE0_MAX_SAMPLE_DIST(~0u)}, - {64884, S_028BE0_MSAA_EXPOSED_SAMPLES(~0u)}, - {64905, S_028BE0_DETAIL_TO_EXPOSED_MODE(~0u)}, - {70957, S_028BE0_COVERAGE_TO_SHADER_SELECT(~0u)}, + {64834, S_028BE0_MSAA_NUM_SAMPLES(~0u)}, + {64851, S_028BE0_AA_MASK_CENTROID_DTMN(~0u)}, + {64873, S_028BE0_MAX_SAMPLE_DIST(~0u)}, + {64889, S_028BE0_MSAA_EXPOSED_SAMPLES(~0u)}, + {64910, S_028BE0_DETAIL_TO_EXPOSED_MODE(~0u)}, + {70962, S_028BE0_COVERAGE_TO_SHADER_SELECT(~0u)}, /* 2995 */ - {65440, S_028C40_REALIGN_DQUADS_AFTER_N_WAVES(~0u)}, - {69243, S_028C40_LOAD_COLLISION_WAVEID(~0u)}, - {69265, S_028C40_LOAD_INTRAWAVE_COLLISION(~0u)}, + {65445, S_028C40_REALIGN_DQUADS_AFTER_N_WAVES(~0u)}, + {69248, S_028C40_LOAD_COLLISION_WAVEID(~0u)}, + {69270, S_028C40_LOAD_INTRAWAVE_COLLISION(~0u)}, /* 2998 */ - {71073, S_028C44_BINNING_MODE(~0u), 4, 1579}, - {71086, S_028C44_BIN_SIZE_X(~0u)}, - {71097, S_028C44_BIN_SIZE_Y(~0u)}, - {71108, S_028C44_BIN_SIZE_X_EXTEND(~0u)}, - {71126, S_028C44_BIN_SIZE_Y_EXTEND(~0u)}, - {71144, S_028C44_CONTEXT_STATES_PER_BIN(~0u)}, - {71167, S_028C44_PERSISTENT_STATES_PER_BIN(~0u)}, - {71193, S_028C44_DISABLE_START_OF_PRIM(~0u)}, - {71215, S_028C44_FPOVS_PER_BATCH(~0u)}, - {71231, S_028C44_OPTIMAL_BIN_SELECTION(~0u)}, + {71078, S_028C44_BINNING_MODE(~0u), 4, 1579}, + {71091, S_028C44_BIN_SIZE_X(~0u)}, + {71102, S_028C44_BIN_SIZE_Y(~0u)}, + {71113, S_028C44_BIN_SIZE_X_EXTEND(~0u)}, + {71131, S_028C44_BIN_SIZE_Y_EXTEND(~0u)}, + {71149, S_028C44_CONTEXT_STATES_PER_BIN(~0u)}, + {71172, S_028C44_PERSISTENT_STATES_PER_BIN(~0u)}, + {71198, S_028C44_DISABLE_START_OF_PRIM(~0u)}, + {71220, S_028C44_FPOVS_PER_BATCH(~0u)}, + {71236, S_028C44_OPTIMAL_BIN_SELECTION(~0u)}, /* 3008 */ - {71253, S_028C48_MAX_ALLOC_COUNT(~0u)}, - {71269, S_028C48_MAX_PRIM_PER_BATCH(~0u)}, + {71258, S_028C48_MAX_ALLOC_COUNT(~0u)}, + {71274, S_028C48_MAX_PRIM_PER_BATCH(~0u)}, /* 3010 */ - {71288, S_028C4C_OVER_RAST_ENABLE(~0u)}, - {71305, S_028C4C_OVER_RAST_SAMPLE_SELECT(~0u)}, - {71329, S_028C4C_UNDER_RAST_ENABLE(~0u)}, - {71347, S_028C4C_UNDER_RAST_SAMPLE_SELECT(~0u)}, - {71372, S_028C4C_PBB_UNCERTAINTY_REGION_ENABLE(~0u)}, - {71402, S_028C4C_ZMM_TRI_EXTENT(~0u)}, - {71417, S_028C4C_ZMM_TRI_OFFSET(~0u)}, - {71432, S_028C4C_OVERRIDE_OVER_RAST_INNER_TO_NORMAL(~0u)}, - {71467, S_028C4C_OVERRIDE_UNDER_RAST_INNER_TO_NORMAL(~0u)}, - {71503, S_028C4C_DEGENERATE_OVERRIDE_INNER_TO_NORMAL_DISABLE(~0u)}, - {71547, S_028C4C_UNCERTAINTY_REGION_MODE(~0u)}, - {71571, S_028C4C_OUTER_UNCERTAINTY_EDGERULE_OVERRIDE(~0u)}, - {71607, S_028C4C_INNER_UNCERTAINTY_EDGERULE_OVERRIDE(~0u)}, - {71643, S_028C4C_NULL_SQUAD_AA_MASK_ENABLE(~0u)}, - {71669, S_028C4C_COVERAGE_AA_MASK_ENABLE(~0u)}, - {71693, S_028C4C_PREZ_AA_MASK_ENABLE(~0u)}, - {71713, S_028C4C_POSTZ_AA_MASK_ENABLE(~0u)}, - {71734, S_028C4C_CENTROID_SAMPLE_OVERRIDE(~0u)}, + {71293, S_028C4C_OVER_RAST_ENABLE(~0u)}, + {71310, S_028C4C_OVER_RAST_SAMPLE_SELECT(~0u)}, + {71334, S_028C4C_UNDER_RAST_ENABLE(~0u)}, + {71352, S_028C4C_UNDER_RAST_SAMPLE_SELECT(~0u)}, + {71377, S_028C4C_PBB_UNCERTAINTY_REGION_ENABLE(~0u)}, + {71407, S_028C4C_ZMM_TRI_EXTENT(~0u)}, + {71422, S_028C4C_ZMM_TRI_OFFSET(~0u)}, + {71437, S_028C4C_OVERRIDE_OVER_RAST_INNER_TO_NORMAL(~0u)}, + {71472, S_028C4C_OVERRIDE_UNDER_RAST_INNER_TO_NORMAL(~0u)}, + {71508, S_028C4C_DEGENERATE_OVERRIDE_INNER_TO_NORMAL_DISABLE(~0u)}, + {71552, S_028C4C_UNCERTAINTY_REGION_MODE(~0u)}, + {71576, S_028C4C_OUTER_UNCERTAINTY_EDGERULE_OVERRIDE(~0u)}, + {71612, S_028C4C_INNER_UNCERTAINTY_EDGERULE_OVERRIDE(~0u)}, + {71648, S_028C4C_NULL_SQUAD_AA_MASK_ENABLE(~0u)}, + {71674, S_028C4C_COVERAGE_AA_MASK_ENABLE(~0u)}, + {71698, S_028C4C_PREZ_AA_MASK_ENABLE(~0u)}, + {71718, S_028C4C_POSTZ_AA_MASK_ENABLE(~0u)}, + {71739, S_028C4C_CENTROID_SAMPLE_OVERRIDE(~0u)}, /* 3028 */ - {71759, S_028C50_MAX_DEALLOCS_IN_WAVE(~0u)}, + {71764, S_028C50_MAX_DEALLOCS_IN_WAVE(~0u)}, /* 3029 */ - {71780, S_028C64_BASE_256B(~0u)}, + {71785, S_028C64_BASE_256B(~0u)}, /* 3030 */ - {71790, S_028C68_MIP0_HEIGHT(~0u)}, - {71802, S_028C68_MIP0_WIDTH(~0u)}, - {68802, S_028C68_MAX_MIP(~0u)}, + {71795, S_028C68_MIP0_HEIGHT(~0u)}, + {71807, S_028C68_MIP0_WIDTH(~0u)}, + {68807, S_028C68_MAX_MIP(~0u)}, /* 3033 */ {48842, S_028C6C_SLICE_START(~0u)}, {48854, S_028C6C_SLICE_MAX(~0u)}, - {71813, S_028C6C_MIP_LEVEL(~0u)}, + {71818, S_028C6C_MIP_LEVEL(~0u)}, /* 3036 */ - {65564, S_028C70_ENDIAN(~0u), 4, 1342}, + {65569, S_028C70_ENDIAN(~0u), 4, 1342}, {21132, S_028C70_FORMAT(~0u), 23, 1346}, - {65931, S_028C70_NUMBER_TYPE(~0u), 8, 1369}, - {65987, S_028C70_COMP_SWAP(~0u), 4, 1377}, + {65936, S_028C70_NUMBER_TYPE(~0u), 8, 1369}, + {65992, S_028C70_COMP_SWAP(~0u), 4, 1377}, {57519, S_028C70_FAST_CLEAR(~0u)}, {49428, S_028C70_COMPRESSION(~0u)}, - {65997, S_028C70_BLEND_CLAMP(~0u)}, - {66009, S_028C70_BLEND_BYPASS(~0u)}, - {66022, S_028C70_SIMPLE_FLOAT(~0u)}, - {64989, S_028C70_ROUND_MODE(~0u)}, - {66262, S_028C70_BLEND_OPT_DONT_RD_DST(~0u), 8, 1381}, - {66284, S_028C70_BLEND_OPT_DISCARD_PIXEL(~0u), 8, 1381}, - {66308, S_028C70_FMASK_COMPRESSION_DISABLE(~0u)}, - {66334, S_028C70_FMASK_COMPRESS_1FRAG_ONLY(~0u)}, - {66360, S_028C70_DCC_ENABLE(~0u)}, - {66371, S_028C70_CMASK_ADDR_TYPE(~0u)}, + {66002, S_028C70_BLEND_CLAMP(~0u)}, + {66014, S_028C70_BLEND_BYPASS(~0u)}, + {66027, S_028C70_SIMPLE_FLOAT(~0u)}, + {64994, S_028C70_ROUND_MODE(~0u)}, + {66267, S_028C70_BLEND_OPT_DONT_RD_DST(~0u), 8, 1381}, + {66289, S_028C70_BLEND_OPT_DISCARD_PIXEL(~0u), 8, 1381}, + {66313, S_028C70_FMASK_COMPRESSION_DISABLE(~0u)}, + {66339, S_028C70_FMASK_COMPRESS_1FRAG_ONLY(~0u)}, + {66365, S_028C70_DCC_ENABLE(~0u)}, + {66376, S_028C70_CMASK_ADDR_TYPE(~0u)}, /* 3052 */ - {71823, S_028C74_MIP0_DEPTH(~0u)}, - {68756, S_028C74_META_LINEAR(~0u)}, + {71828, S_028C74_MIP0_DEPTH(~0u)}, + {68761, S_028C74_META_LINEAR(~0u)}, {50010, S_028C74_NUM_SAMPLES(~0u)}, - {66427, S_028C74_NUM_FRAGMENTS(~0u)}, - {66441, S_028C74_FORCE_DST_ALPHA_1(~0u)}, - {71834, S_028C74_COLOR_SW_MODE(~0u)}, - {71848, S_028C74_FMASK_SW_MODE(~0u)}, - {71862, S_028C74_RESOURCE_TYPE(~0u), 4, 1583}, - {68791, S_028C74_RB_ALIGNED(~0u)}, - {68773, S_028C74_PIPE_ALIGNED(~0u)}, + {66432, S_028C74_NUM_FRAGMENTS(~0u)}, + {66446, S_028C74_FORCE_DST_ALPHA_1(~0u)}, + {71839, S_028C74_COLOR_SW_MODE(~0u)}, + {71853, S_028C74_FMASK_SW_MODE(~0u)}, + {71867, S_028C74_RESOURCE_TYPE(~0u), 4, 1583}, + {68796, S_028C74_RB_ALIGNED(~0u)}, + {68778, S_028C74_PIPE_ALIGNED(~0u)}, /* 3062 */ - {71780, S_028C80_BASE_256B(~0u)}, + {71785, S_028C80_BASE_256B(~0u)}, /* 3063 */ - {71780, S_028C88_BASE_256B(~0u)}, + {71785, S_028C88_BASE_256B(~0u)}, /* 3064 */ - {71780, S_028C98_BASE_256B(~0u)}, + {71785, S_028C98_BASE_256B(~0u)}, }; static const char sid_strings[] = @@ -8320,864 +8320,852 @@ "CB_RESOLVE\0" /* 57530 */ "CB_FMASK_DECOMPRESS\0" /* 57541 */ "CB_DCC_DECOMPRESS\0" /* 57561 */ - "X_0X00\0" /* 57579 */ - "X_0X05\0" /* 57586 */ - "X_0X0A\0" /* 57593 */ - "X_0X0F\0" /* 57600 */ - "X_0X11\0" /* 57607 */ - "X_0X22\0" /* 57614 */ - "X_0X33\0" /* 57621 */ - "X_0X44\0" /* 57628 */ - "X_0X50\0" /* 57635 */ - "X_0X55\0" /* 57642 */ - "X_0X5A\0" /* 57649 */ - "X_0X5F\0" /* 57656 */ - "X_0X66\0" /* 57663 */ - "X_0X77\0" /* 57670 */ - "X_0X88\0" /* 57677 */ - "X_0X99\0" /* 57684 */ - "X_0XA0\0" /* 57691 */ - "X_0XA5\0" /* 57698 */ - "X_0XAA\0" /* 57705 */ - "X_0XAF\0" /* 57712 */ - "X_0XBB\0" /* 57719 */ - "X_0XCC\0" /* 57726 */ - "X_0XDD\0" /* 57733 */ - "X_0XEE\0" /* 57740 */ - "X_0XF0\0" /* 57747 */ - "X_0XF5\0" /* 57754 */ - "X_0XFA\0" /* 57761 */ - "X_0XFF\0" /* 57768 */ - "Z_EXPORT_ENABLE\0" /* 57775 */ - "STENCIL_TEST_VAL_EXPORT_ENABLE\0" /* 57791 */ - "STENCIL_OP_VAL_EXPORT_ENABLE\0" /* 57822 */ - "LATE_Z\0" /* 57851 */ - "EARLY_Z_THEN_LATE_Z\0" /* 57858 */ - "RE_Z\0" /* 57878 */ - "EARLY_Z_THEN_RE_Z\0" /* 57883 */ - "KILL_ENABLE\0" /* 57901 */ - "COVERAGE_TO_MASK_ENABLE\0" /* 57913 */ - "MASK_EXPORT_ENABLE\0" /* 57937 */ - "EXEC_ON_HIER_FAIL\0" /* 57956 */ - "EXEC_ON_NOOP\0" /* 57974 */ - "ALPHA_TO_MASK_DISABLE\0" /* 57987 */ - "DEPTH_BEFORE_SHADER\0" /* 58009 */ - "EXPORT_ANY_Z\0" /* 58029 */ - "EXPORT_LESS_THAN_Z\0" /* 58042 */ - "EXPORT_GREATER_THAN_Z\0" /* 58061 */ - "EXPORT_RESERVED\0" /* 58083 */ - "CONSERVATIVE_Z_EXPORT\0" /* 58099 */ - "DUAL_QUAD_DISABLE\0" /* 58121 */ - "UCP_ENA_0\0" /* 58139 */ - "UCP_ENA_1\0" /* 58149 */ - "UCP_ENA_2\0" /* 58159 */ - "UCP_ENA_3\0" /* 58169 */ - "UCP_ENA_4\0" /* 58179 */ - "UCP_ENA_5\0" /* 58189 */ - "PS_UCP_Y_SCALE_NEG\0" /* 58199 */ - "PS_UCP_MODE\0" /* 58218 */ - "CLIP_DISABLE\0" /* 58230 */ - "UCP_CULL_ONLY_ENA\0" /* 58243 */ - "BOUNDARY_EDGE_FLAG_ENA\0" /* 58261 */ - "DX_CLIP_SPACE_DEF\0" /* 58284 */ - "DIS_CLIP_ERR_DETECT\0" /* 58302 */ - "VTX_KILL_OR\0" /* 58322 */ - "DX_RASTERIZATION_KILL\0" /* 58334 */ - "DX_LINEAR_ATTR_CLIP_ENA\0" /* 58356 */ - "VTE_VPORT_PROVOKE_DISABLE\0" /* 58380 */ - "ZCLIP_NEAR_DISABLE\0" /* 58406 */ - "ZCLIP_FAR_DISABLE\0" /* 58425 */ - "CULL_FRONT\0" /* 58443 */ - "CULL_BACK\0" /* 58454 */ - "X_DISABLE_POLY_MODE\0" /* 58464, 58474 */ - "X_DUAL_MODE\0" /* 58484 */ - "X_DRAW_POINTS\0" /* 58496 */ - "X_DRAW_LINES\0" /* 58510 */ - "X_DRAW_TRIANGLES\0" /* 58523 */ - "POLYMODE_FRONT_PTYPE\0" /* 58540 */ - "POLYMODE_BACK_PTYPE\0" /* 58561 */ - "POLY_OFFSET_FRONT_ENABLE\0" /* 58581 */ - "POLY_OFFSET_BACK_ENABLE\0" /* 58606 */ - "POLY_OFFSET_PARA_ENABLE\0" /* 58630 */ - "VTX_WINDOW_OFFSET_ENABLE\0" /* 58654 */ - "PROVOKING_VTX_LAST\0" /* 58679 */ - "PERSP_CORR_DIS\0" /* 58698 */ - "MULTI_PRIM_IB_ENA\0" /* 58713 */ - "VPORT_X_SCALE_ENA\0" /* 58731 */ - "VPORT_X_OFFSET_ENA\0" /* 58749 */ - "VPORT_Y_SCALE_ENA\0" /* 58768 */ - "VPORT_Y_OFFSET_ENA\0" /* 58786 */ - "VPORT_Z_SCALE_ENA\0" /* 58805 */ - "VPORT_Z_OFFSET_ENA\0" /* 58823 */ - "VTX_XY_FMT\0" /* 58842 */ - "VTX_Z_FMT\0" /* 58853 */ - "VTX_W0_FMT\0" /* 58863 */ - "CLIP_DIST_ENA_0\0" /* 58874 */ - "CLIP_DIST_ENA_1\0" /* 58890 */ - "CLIP_DIST_ENA_2\0" /* 58906 */ - "CLIP_DIST_ENA_3\0" /* 58922 */ - "CLIP_DIST_ENA_4\0" /* 58938 */ - "CLIP_DIST_ENA_5\0" /* 58954 */ - "CLIP_DIST_ENA_6\0" /* 58970 */ - "CLIP_DIST_ENA_7\0" /* 58986 */ - "CULL_DIST_ENA_0\0" /* 59002 */ - "CULL_DIST_ENA_1\0" /* 59018 */ - "CULL_DIST_ENA_2\0" /* 59034 */ - "CULL_DIST_ENA_3\0" /* 59050 */ - "CULL_DIST_ENA_4\0" /* 59066 */ - "CULL_DIST_ENA_5\0" /* 59082 */ - "CULL_DIST_ENA_6\0" /* 59098 */ - "CULL_DIST_ENA_7\0" /* 59114 */ - "USE_VTX_POINT_SIZE\0" /* 59130 */ - "USE_VTX_EDGE_FLAG\0" /* 59149 */ - "USE_VTX_RENDER_TARGET_INDX\0" /* 59167 */ - "USE_VTX_VIEWPORT_INDX\0" /* 59194 */ - "USE_VTX_KILL_FLAG\0" /* 59216 */ - "VS_OUT_MISC_VEC_ENA\0" /* 59234 */ - "VS_OUT_CCDIST0_VEC_ENA\0" /* 59254 */ - "VS_OUT_CCDIST1_VEC_ENA\0" /* 59277 */ - "VS_OUT_MISC_SIDE_BUS_ENA\0" /* 59300 */ - "USE_VTX_GS_CUT_FLAG\0" /* 59325 */ - "USE_VTX_LINE_WIDTH\0" /* 59345 */ - "VTE_XY_INF_DISCARD\0" /* 59364 */ - "VTE_Z_INF_DISCARD\0" /* 59383 */ - "VTE_W_INF_DISCARD\0" /* 59401 */ - "VTE_0XNANINF_IS_0\0" /* 59419 */ - "VTE_XY_NAN_RETAIN\0" /* 59437 */ - "VTE_Z_NAN_RETAIN\0" /* 59455 */ - "VTE_W_NAN_RETAIN\0" /* 59472 */ - "VTE_W_RECIP_NAN_IS_0\0" /* 59489 */ - "VS_XY_NAN_TO_INF\0" /* 59510 */ - "VS_XY_INF_RETAIN\0" /* 59527 */ - "VS_Z_NAN_TO_INF\0" /* 59544 */ - "VS_Z_INF_RETAIN\0" /* 59560 */ - "VS_W_NAN_TO_INF\0" /* 59576 */ - "VS_W_INF_RETAIN\0" /* 59592 */ - "VS_CLIP_DIST_INF_DISCARD\0" /* 59608 */ - "VTE_NO_OUTPUT_NEG_0\0" /* 59633 */ - "LINE_STIPPLE_RESET\0" /* 59653 */ - "EXPAND_FULL_LENGTH\0" /* 59672 */ - "FRACTIONAL_ACCUM\0" /* 59691 */ - "DIAMOND_ADJUST\0" /* 59708 */ - "TRIANGLE_FILTER_DISABLE\0" /* 59723 */ - "LINE_FILTER_DISABLE\0" /* 59747 */ - "POINT_FILTER_DISABLE\0" /* 59767 */ - "RECTANGLE_FILTER_DISABLE\0" /* 59788 */ - "TRIANGLE_EXPAND_ENA\0" /* 59813 */ - "LINE_EXPAND_ENA\0" /* 59833 */ - "POINT_EXPAND_ENA\0" /* 59849 */ - "RECTANGLE_EXPAND_ENA\0" /* 59866 */ - "PRIM_EXPAND_CONSTANT\0" /* 59887 */ - "XMAX_RIGHT_EXCLUSION\0" /* 59908 */ - "YMAX_BOTTOM_EXCLUSION\0" /* 59929 */ - "SMALL_PRIM_FILTER_ENABLE\0" /* 59951 */ - "MIN_SIZE\0" /* 59976 */ - "LINE_PATTERN\0" /* 59985 */ - "REPEAT_COUNT\0" /* 59998 */ - "PATTERN_BIT_ORDER\0" /* 60011 */ - "AUTO_RESET_CNTL\0" /* 60029 */ - "VGT_OUTPATH_VTX_REUSE\0" /* 60045 */ - "VGT_OUTPATH_TESS_EN\0" /* 60067 */ - "VGT_OUTPATH_PASSTHRU\0" /* 60087 */ - "VGT_OUTPATH_GS_BLOCK\0" /* 60108 */ - "VGT_OUTPATH_HS_BLOCK\0" /* 60129 */ - "PATH_SELECT\0" /* 60150 */ - "TESS_MODE\0" /* 60162 */ - "VGT_GRP_3D_POINT\0" /* 60172 */ - "VGT_GRP_3D_LINE\0" /* 60189 */ - "VGT_GRP_3D_TRI\0" /* 60205 */ - "VGT_GRP_3D_RECT\0" /* 60220 */ - "VGT_GRP_3D_QUAD\0" /* 60236 */ - "VGT_GRP_2D_COPY_RECT_V0\0" /* 60252 */ - "VGT_GRP_2D_COPY_RECT_V1\0" /* 60276 */ - "VGT_GRP_2D_COPY_RECT_V2\0" /* 60300 */ - "VGT_GRP_2D_COPY_RECT_V3\0" /* 60324 */ - "VGT_GRP_2D_FILL_RECT\0" /* 60348 */ - "VGT_GRP_2D_LINE\0" /* 60369 */ - "VGT_GRP_2D_TRI\0" /* 60385 */ - "VGT_GRP_PRIM_INDEX_LINE\0" /* 60400 */ - "VGT_GRP_PRIM_INDEX_TRI\0" /* 60424 */ - "VGT_GRP_PRIM_INDEX_QUAD\0" /* 60447 */ - "VGT_GRP_3D_LINE_ADJ\0" /* 60471 */ - "VGT_GRP_3D_TRI_ADJ\0" /* 60491 */ - "VGT_GRP_3D_PATCH\0" /* 60510 */ - "RETAIN_ORDER\0" /* 60527 */ - "RETAIN_QUADS\0" /* 60540 */ - "VGT_GRP_LIST\0" /* 60553 */ - "VGT_GRP_STRIP\0" /* 60566 */ - "VGT_GRP_FAN\0" /* 60580 */ - "VGT_GRP_LOOP\0" /* 60592 */ - "VGT_GRP_POLYGON\0" /* 60605 */ - "PRIM_ORDER\0" /* 60621 */ - "COMP_X_EN\0" /* 60632 */ - "COMP_Y_EN\0" /* 60642 */ - "COMP_Z_EN\0" /* 60652 */ - "COMP_W_EN\0" /* 60662 */ - "SHIFT\0" /* 60672 */ - "VGT_GRP_INDEX_16\0" /* 60678 */ - "VGT_GRP_INDEX_32\0" /* 60695 */ - "VGT_GRP_UINT_16\0" /* 60712 */ - "VGT_GRP_UINT_32\0" /* 60728 */ - "VGT_GRP_SINT_16\0" /* 60744 */ - "VGT_GRP_SINT_32\0" /* 60760 */ - "VGT_GRP_FLOAT_32\0" /* 60776 */ - "VGT_GRP_AUTO_PRIM\0" /* 60793 */ - "VGT_GRP_FIX_1_23_TO_FLOAT\0" /* 60811 */ - "X_CONV\0" /* 60841, 60837 */ - "Y_CONV\0" /* 60844 */ - "Z_CONV\0" /* 60851 */ - "Z_OFFSET\0" /* 60858 */ - "W_CONV\0" /* 60867 */ - "GS_OFF\0" /* 60874 */ - "GS_SCENARIO_A\0" /* 60881 */ - "GS_SCENARIO_B\0" /* 60895 */ - "GS_SCENARIO_G\0" /* 60909 */ - "GS_SCENARIO_C\0" /* 60923 */ - "SPRITE_EN\0" /* 60937 */ - "GS_CUT_1024\0" /* 60947 */ - "GS_CUT_512\0" /* 60959 */ - "GS_CUT_256\0" /* 60970 */ - "GS_CUT_128\0" /* 60981 */ - "CUT_MODE\0" /* 60992 */ - "GS_C_PACK_EN\0" /* 61001 */ - "RESERVED_2\0" /* 61014 */ - "ES_PASSTHRU\0" /* 61025 */ - "COMPUTE_MODE\0" /* 61037 */ - "FAST_COMPUTE_MODE\0" /* 61050 */ - "ELEMENT_INFO_EN\0" /* 61068 */ - "PARTIAL_THD_AT_EOI\0" /* 61084 */ - "SUPPRESS_CUTS\0" /* 61103 */ - "ES_WRITE_OPTIMIZE\0" /* 61117 */ - "GS_WRITE_OPTIMIZE\0" /* 61135 */ - "X_0_OFFCHIP_GS\0" /* 61153 */ - "X_3_ES_AND_GS_ARE_ONCHIP\0" /* 61168, 61186 */ - "ES_VERTS_PER_SUBGRP\0" /* 61193 */ - "GS_PRIMS_PER_SUBGRP\0" /* 61213 */ - "MSAA_ENABLE\0" /* 61233 */ - "VPORT_SCISSOR_ENABLE\0" /* 61245 */ - "LINE_STIPPLE_ENABLE\0" /* 61266 */ - "SEND_UNLIT_STILES_TO_PKR\0" /* 61286 */ - "WALK_SIZE\0" /* 61311 */ - "WALK_ALIGNMENT\0" /* 61321 */ - "WALK_ALIGN8_PRIM_FITS_ST\0" /* 61336 */ - "WALK_FENCE_ENABLE\0" /* 61361 */ - "WALK_FENCE_SIZE\0" /* 61379 */ - "SUPERTILE_WALK_ORDER_ENABLE\0" /* 61400, 61395 */ - "TILE_COVER_DISABLE\0" /* 61423 */ - "TILE_COVER_NO_SCISSOR\0" /* 61442 */ - "ZMM_LINE_EXTENT\0" /* 61464 */ - "ZMM_LINE_OFFSET\0" /* 61480 */ - "ZMM_RECT_EXTENT\0" /* 61496 */ - "KILL_PIX_POST_HI_Z\0" /* 61512 */ - "KILL_PIX_POST_DETAIL_MASK\0" /* 61531 */ - "PS_ITER_SAMPLE\0" /* 61557 */ - "MULTI_SHADER_ENGINE_PRIM_DISCARD_ENABLE\0" /* 61572 */ - "MULTI_GPU_SUPERTILE_ENABLE\0" /* 61612 */ - "GPU_ID_OVERRIDE_ENABLE\0" /* 61639 */ - "GPU_ID_OVERRIDE\0" /* 61662 */ - "MULTI_GPU_PRIM_DISCARD_ENABLE\0" /* 61678 */ - "FORCE_EOV_CNTDWN_ENABLE\0" /* 61708 */ - "FORCE_EOV_REZ_ENABLE\0" /* 61732 */ - "OUT_OF_ORDER_PRIMITIVE_ENABLE\0" /* 61753 */ - "OUT_OF_ORDER_WATER_MARK\0" /* 61783 */ - "OUTPRIM_TYPE_POINTLIST\0" /* 61807 */ - "OUTPRIM_TYPE_LINESTRIP\0" /* 61830 */ - "OUTPRIM_TYPE_TRISTRIP\0" /* 61853 */ - "OUTPRIM_TYPE\0" /* 61875 */ - "OUTPRIM_TYPE_1\0" /* 61888 */ - "OUTPRIM_TYPE_2\0" /* 61903 */ - "OUTPRIM_TYPE_3\0" /* 61918 */ - "UNIQUE_TYPE_PER_STREAM\0" /* 61933 */ - "VGT_INDEX_16\0" /* 61956 */ - "VGT_INDEX_32\0" /* 61969 */ - "VGT_INDEX_8\0" /* 61982 */ - "VGT_DMA_SWAP_NONE\0" /* 61994 */ - "VGT_DMA_SWAP_16_BIT\0" /* 62012 */ - "VGT_DMA_SWAP_32_BIT\0" /* 62032 */ - "VGT_DMA_SWAP_WORD\0" /* 62052 */ - "SWAP_MODE\0" /* 62070 */ - "VGT_DMA_BUF_MEM\0" /* 62080 */ - "VGT_DMA_BUF_RING\0" /* 62096 */ - "VGT_DMA_BUF_SETUP\0" /* 62113 */ - "BUF_TYPE\0" /* 62131 */ - "VGT_POLICY_LRU\0" /* 62140 */ - "VGT_POLICY_STREAM\0" /* 62155 */ - "RDREQ_POLICY_CIK\0" /* 62173 */ - "RDREQ_POLICY\0" /* 62190 */ - "REQ_PATH\0" /* 62203 */ - "DISABLE_RESET_ON_EOI\0" /* 62212 */ - "SAMPLE_STREAMOUTSTATS1\0" /* 62233 */ - "SAMPLE_STREAMOUTSTATS2\0" /* 62256 */ - "SAMPLE_STREAMOUTSTATS3\0" /* 62279 */ - "CACHE_FLUSH_TS\0" /* 62302 */ - "CONTEXT_DONE\0" /* 62317 */ - "CACHE_FLUSH\0" /* 62330 */ - "CS_PARTIAL_FLUSH\0" /* 62342 */ - "VGT_STREAMOUT_SYNC\0" /* 62359 */ - "VGT_STREAMOUT_RESET\0" /* 62378 */ - "END_OF_PIPE_INCR_DE\0" /* 62398 */ - "END_OF_PIPE_IB_END\0" /* 62418 */ - "RST_PIX_CNT\0" /* 62437 */ - "VS_PARTIAL_FLUSH\0" /* 62449 */ - "PS_PARTIAL_FLUSH\0" /* 62466 */ - "FLUSH_HS_OUTPUT\0" /* 62483 */ - "FLUSH_LS_OUTPUT\0" /* 62499 */ - "CACHE_FLUSH_AND_INV_TS_EVENT\0" /* 62515 */ - "ZPASS_DONE\0" /* 62544 */ - "CACHE_FLUSH_AND_INV_EVENT\0" /* 62555 */ - "PERFCOUNTER_START\0" /* 62581 */ - "PERFCOUNTER_STOP\0" /* 62599 */ - "PIPELINESTAT_START\0" /* 62616 */ - "PIPELINESTAT_STOP\0" /* 62635 */ - "PERFCOUNTER_SAMPLE\0" /* 62653 */ - "FLUSH_ES_OUTPUT\0" /* 62672 */ - "FLUSH_GS_OUTPUT\0" /* 62688 */ - "SAMPLE_PIPELINESTAT\0" /* 62704 */ - "SO_VGTSTREAMOUT_FLUSH\0" /* 62724 */ - "SAMPLE_STREAMOUTSTATS\0" /* 62746 */ - "RESET_VTX_CNT\0" /* 62768 */ - "BLOCK_CONTEXT_DONE\0" /* 62782 */ - "CS_CONTEXT_DONE\0" /* 62801 */ - "VGT_FLUSH\0" /* 62817 */ - "SC_SEND_DB_VPZ\0" /* 62827 */ - "BOTTOM_OF_PIPE_TS\0" /* 62842 */ - "DB_CACHE_FLUSH_AND_INV\0" /* 62860 */ - "FLUSH_AND_INV_DB_DATA_TS\0" /* 62883 */ - "FLUSH_AND_INV_DB_META\0" /* 62908 */ - "FLUSH_AND_INV_CB_DATA_TS\0" /* 62930 */ - "FLUSH_AND_INV_CB_META\0" /* 62955 */ - "FLUSH_AND_INV_CB_PIXEL_DATA\0" /* 62977 */ - "THREAD_TRACE_START\0" /* 63005 */ - "THREAD_TRACE_STOP\0" /* 63024 */ - "THREAD_TRACE_MARKER\0" /* 63042 */ - "THREAD_TRACE_FLUSH\0" /* 63062 */ - "THREAD_TRACE_FINISH\0" /* 63081 */ - "PIXEL_PIPE_STAT_CONTROL\0" /* 63101 */ - "PIXEL_PIPE_STAT_DUMP\0" /* 63125 */ - "PIXEL_PIPE_STAT_RESET\0" /* 63146 */ - "EVENT_TYPE\0" /* 63168 */ - "ADDRESS_HI_GFX6\0" /* 63179 */ - "EXTENDED_EVENT\0" /* 63195 */ - "PRIMGROUP_SIZE\0" /* 63210 */ - "PARTIAL_VS_WAVE_ON\0" /* 63225 */ - "SWITCH_ON_EOP\0" /* 63244 */ - "PARTIAL_ES_WAVE_ON\0" /* 63258 */ - "SWITCH_ON_EOI\0" /* 63277 */ - "WD_SWITCH_ON_EOP\0" /* 63291 */ - "MAX_PRIMGRP_IN_WAVE\0" /* 63308 */ - "FULL_CACHE\0" /* 63328 */ - "HTILE_USES_PRELOAD_WIN\0" /* 63339 */ - "PRELOAD\0" /* 63362 */ - "PREFETCH_WIDTH\0" /* 63370 */ - "PREFETCH_HEIGHT\0" /* 63385 */ - "DST_OUTSIDE_ZERO_TO_ONE\0" /* 63401 */ - "TC_COMPATIBLE\0" /* 63425 */ - "COMPAREFUNC0\0" /* 63439 */ - "COMPAREVALUE0\0" /* 63452 */ - "COMPAREMASK0\0" /* 63466 */ - "COMPAREFUNC1\0" /* 63479 */ - "COMPAREVALUE1\0" /* 63492 */ - "COMPAREMASK1\0" /* 63506 */ - "MAX_X\0" /* 63519 */ - "MAX_Y\0" /* 63525 */ - "ACCUM_ISOLINE\0" /* 63531 */ - "ACCUM_TRI\0" /* 63545 */ - "ACCUM_QUAD\0" /* 63555 */ - "DONUT_SPLIT\0" /* 63566 */ - "TRAP_SPLIT\0" /* 63578 */ - "LS_STAGE_OFF\0" /* 63589 */ - "LS_STAGE_ON\0" /* 63602 */ - "CS_STAGE_ON\0" /* 63614 */ - "ES_STAGE_OFF\0" /* 63626 */ - "ES_STAGE_DS\0" /* 63639 */ - "ES_STAGE_REAL\0" /* 63651 */ - "VS_STAGE_REAL\0" /* 63665 */ - "VS_STAGE_DS\0" /* 63679 */ - "VS_STAGE_COPY_SHADER\0" /* 63691 */ - "DYNAMIC_HS\0" /* 63712 */ - "DIS_DEALLOC_ACCUM_0\0" /* 63723 */ - "DIS_DEALLOC_ACCUM_1\0" /* 63743 */ - "VS_WAVE_ID_EN\0" /* 63763 */ - "NUM_PATCHES\0" /* 63777 */ - "HS_NUM_INPUT_CP\0" /* 63789 */ - "HS_NUM_OUTPUT_CP\0" /* 63805 */ - "TESS_ISOLINE\0" /* 63822 */ - "TESS_TRIANGLE\0" /* 63835 */ - "TESS_QUAD\0" /* 63849 */ - "PART_INTEGER\0" /* 63859 */ - "PART_POW2\0" /* 63872 */ - "PART_FRAC_ODD\0" /* 63882 */ - "PART_FRAC_EVEN\0" /* 63896 */ - "PARTITIONING\0" /* 63911 */ - "OUTPUT_POINT\0" /* 63924 */ - "OUTPUT_LINE\0" /* 63937 */ - "OUTPUT_TRIANGLE_CW\0" /* 63949 */ - "OUTPUT_TRIANGLE_CCW\0" /* 63968 */ - "TOPOLOGY\0" /* 63988 */ - "RESERVED_REDUC_AXIS\0" /* 63997 */ - "DEPRECATED\0" /* 64017 */ - "NUM_DS_WAVES_PER_SIMD\0" /* 64028 */ - "DISABLE_DONUTS\0" /* 64050 */ - "VGT_POLICY_BYPASS\0" /* 64065 */ - "DISTRIBUTION_MODE_NO_DIST\0" /* 64083 */ - "DISTRIBUTION_MODE_PATCHES\0" /* 64109 */ - "DISTRIBUTION_MODE_DONUTS\0" /* 64135 */ - "DISTRIBUTION_MODE_TRAPEZOIDS\0" /* 64160 */ - "DISTRIBUTION_MODE\0" /* 64189 */ - "ALPHA_TO_MASK_ENABLE\0" /* 64207 */ - "ALPHA_TO_MASK_OFFSET0\0" /* 64228 */ - "ALPHA_TO_MASK_OFFSET1\0" /* 64250 */ - "ALPHA_TO_MASK_OFFSET2\0" /* 64272 */ - "ALPHA_TO_MASK_OFFSET3\0" /* 64294 */ - "OFFSET_ROUND\0" /* 64316 */ - "POLY_OFFSET_NEG_NUM_DB_BITS\0" /* 64329 */ - "POLY_OFFSET_DB_IS_FLOAT_FMT\0" /* 64357 */ - "STREAMOUT_0_EN\0" /* 64385 */ - "STREAMOUT_1_EN\0" /* 64400 */ - "STREAMOUT_2_EN\0" /* 64415 */ - "STREAMOUT_3_EN\0" /* 64430 */ - "RAST_STREAM\0" /* 64445 */ - "RAST_STREAM_MASK\0" /* 64457 */ - "USE_RAST_STREAM_MASK\0" /* 64474 */ - "STREAM_0_BUFFER_EN\0" /* 64495 */ - "STREAM_1_BUFFER_EN\0" /* 64514 */ - "STREAM_2_BUFFER_EN\0" /* 64533 */ - "STREAM_3_BUFFER_EN\0" /* 64552 */ - "DISTANCE_0\0" /* 64571 */ - "DISTANCE_1\0" /* 64582 */ - "DISTANCE_2\0" /* 64593 */ - "DISTANCE_3\0" /* 64604 */ - "DISTANCE_4\0" /* 64615 */ - "DISTANCE_5\0" /* 64626 */ - "DISTANCE_6\0" /* 64637 */ - "DISTANCE_7\0" /* 64648 */ - "DISTANCE_8\0" /* 64659 */ - "DISTANCE_9\0" /* 64670 */ - "DISTANCE_10\0" /* 64681 */ - "DISTANCE_11\0" /* 64693 */ - "DISTANCE_12\0" /* 64705 */ - "DISTANCE_13\0" /* 64717 */ - "DISTANCE_14\0" /* 64729 */ - "DISTANCE_15\0" /* 64741 */ - "EXPAND_LINE_WIDTH\0" /* 64753 */ - "LAST_PIXEL\0" /* 64771 */ - "PERPENDICULAR_ENDCAP_ENA\0" /* 64782 */ - "DX10_DIAMOND_TEST_ENA\0" /* 64807 */ - "MSAA_NUM_SAMPLES\0" /* 64829 */ - "AA_MASK_CENTROID_DTMN\0" /* 64846 */ - "MAX_SAMPLE_DIST\0" /* 64868 */ - "MSAA_EXPOSED_SAMPLES\0" /* 64884 */ - "DETAIL_TO_EXPOSED_MODE\0" /* 64905 */ - "PIX_CENTER\0" /* 64928 */ - "X_TRUNCATE\0" /* 64939 */ - "X_ROUND\0" /* 64950 */ - "X_ROUND_TO_EVEN\0" /* 64958 */ - "X_ROUND_TO_ODD\0" /* 64974 */ - "ROUND_MODE\0" /* 64989 */ - "X_16_8_FIXED_POINT_1_16TH\0" /* 65000 */ - "X_16_8_FIXED_POINT_1_8TH\0" /* 65026 */ - "X_16_8_FIXED_POINT_1_4TH\0" /* 65051 */ - "X_16_8_FIXED_POINT_1_2\0" /* 65076 */ - "X_16_8_FIXED_POINT_1\0" /* 65099 */ - "X_16_8_FIXED_POINT_1_256TH\0" /* 65120 */ - "X_14_10_FIXED_POINT_1_1024TH\0" /* 65147 */ - "X_12_12_FIXED_POINT_1_4096TH\0" /* 65176 */ - "QUANT_MODE\0" /* 65205 */ - "S0_X\0" /* 65216 */ - "S0_Y\0" /* 65221 */ - "S1_X\0" /* 65226 */ - "S1_Y\0" /* 65231 */ - "S2_X\0" /* 65236 */ - "S2_Y\0" /* 65241 */ - "S3_X\0" /* 65246 */ - "S3_Y\0" /* 65251 */ - "S4_X\0" /* 65256 */ - "S4_Y\0" /* 65261 */ - "S5_X\0" /* 65266 */ - "S5_Y\0" /* 65271 */ - "S6_X\0" /* 65276 */ - "S6_Y\0" /* 65281 */ - "S7_X\0" /* 65286 */ - "S7_Y\0" /* 65291 */ - "S8_X\0" /* 65296 */ - "S8_Y\0" /* 65301 */ - "S9_X\0" /* 65306 */ - "S9_Y\0" /* 65311 */ - "S10_X\0" /* 65316 */ - "S10_Y\0" /* 65322 */ - "S11_X\0" /* 65328 */ - "S11_Y\0" /* 65334 */ - "S12_X\0" /* 65340 */ - "S12_Y\0" /* 65346 */ - "S13_X\0" /* 65352 */ - "S13_Y\0" /* 65358 */ - "S14_X\0" /* 65364 */ - "S14_Y\0" /* 65370 */ - "S15_X\0" /* 65376 */ - "S15_Y\0" /* 65382 */ - "AA_MASK_X0Y0\0" /* 65388 */ - "AA_MASK_X1Y0\0" /* 65401 */ - "AA_MASK_X0Y1\0" /* 65414 */ - "AA_MASK_X1Y1\0" /* 65427 */ - "REALIGN_DQUADS_AFTER_N_WAVES\0" /* 65440 */ - "VTX_REUSE_DEPTH\0" /* 65469 */ - "DEALLOC_DIST\0" /* 65485 */ - "FMASK_TILE_MAX\0" /* 65498 */ - "ENDIAN_NONE\0" /* 65513 */ - "ENDIAN_8IN16\0" /* 65525 */ - "ENDIAN_8IN32\0" /* 65538 */ - "ENDIAN_8IN64\0" /* 65551 */ - "ENDIAN\0" /* 65564 */ - "COLOR_INVALID\0" /* 65571 */ - "COLOR_8\0" /* 65585 */ - "COLOR_16\0" /* 65593 */ - "COLOR_8_8\0" /* 65602 */ - "COLOR_32\0" /* 65612 */ - "COLOR_16_16\0" /* 65621 */ - "COLOR_10_11_11\0" /* 65633 */ - "COLOR_11_11_10\0" /* 65648 */ - "COLOR_10_10_10_2\0" /* 65663 */ - "COLOR_2_10_10_10\0" /* 65680 */ - "COLOR_8_8_8_8\0" /* 65697 */ - "COLOR_32_32\0" /* 65711 */ - "COLOR_16_16_16_16\0" /* 65723 */ - "COLOR_32_32_32_32\0" /* 65741 */ - "COLOR_5_6_5\0" /* 65759 */ - "COLOR_1_5_5_5\0" /* 65771 */ - "COLOR_5_5_5_1\0" /* 65785 */ - "COLOR_4_4_4_4\0" /* 65799 */ - "COLOR_8_24\0" /* 65813 */ - "COLOR_24_8\0" /* 65824 */ - "COLOR_X24_8_32_FLOAT\0" /* 65835 */ - "NUMBER_UNORM\0" /* 65856 */ - "NUMBER_SNORM\0" /* 65869 */ - "NUMBER_UINT\0" /* 65882 */ - "NUMBER_SINT\0" /* 65894 */ - "NUMBER_SRGB\0" /* 65906 */ - "NUMBER_FLOAT\0" /* 65918 */ - "NUMBER_TYPE\0" /* 65931 */ - "SWAP_STD\0" /* 65943 */ - "SWAP_ALT\0" /* 65952 */ - "SWAP_STD_REV\0" /* 65961 */ - "SWAP_ALT_REV\0" /* 65974 */ - "COMP_SWAP\0" /* 65987 */ - "BLEND_CLAMP\0" /* 65997 */ - "BLEND_BYPASS\0" /* 66009 */ - "SIMPLE_FLOAT\0" /* 66022 */ - "CMASK_IS_LINEAR\0" /* 66035 */ - "FORCE_OPT_AUTO\0" /* 66051 */ - "FORCE_OPT_DISABLE\0" /* 66066 */ - "FORCE_OPT_ENABLE_IF_SRC_A_0\0" /* 66084 */ - "FORCE_OPT_ENABLE_IF_SRC_RGB_0\0" /* 66112 */ - "FORCE_OPT_ENABLE_IF_SRC_ARGB_0\0" /* 66142 */ - "FORCE_OPT_ENABLE_IF_SRC_A_1\0" /* 66173 */ - "FORCE_OPT_ENABLE_IF_SRC_RGB_1\0" /* 66201 */ - "FORCE_OPT_ENABLE_IF_SRC_ARGB_1\0" /* 66231 */ - "BLEND_OPT_DONT_RD_DST\0" /* 66262 */ - "BLEND_OPT_DISCARD_PIXEL\0" /* 66284 */ - "FMASK_COMPRESSION_DISABLE\0" /* 66308 */ - "FMASK_COMPRESS_1FRAG_ONLY\0" /* 66334 */ - "DCC_ENABLE\0" /* 66360 */ - "CMASK_ADDR_TYPE\0" /* 66371 */ - "FMASK_TILE_MODE_INDEX\0" /* 66387 */ - "FMASK_BANK_HEIGHT\0" /* 66409 */ - "NUM_FRAGMENTS\0" /* 66427 */ - "FORCE_DST_ALPHA_1\0" /* 66441 */ - "KEY_CLEAR_ENABLE\0" /* 66459 */ - "MAX_BLOCK_SIZE_64B\0" /* 66476 */ - "MAX_BLOCK_SIZE_128B\0" /* 66495 */ - "MAX_BLOCK_SIZE_256B\0" /* 66515 */ - "MAX_UNCOMPRESSED_BLOCK_SIZE\0" /* 66535 */ - "MIN_BLOCK_SIZE_32B\0" /* 66563 */ - "MIN_BLOCK_SIZE_64B\0" /* 66582 */ - "MIN_COMPRESSED_BLOCK_SIZE\0" /* 66601 */ - "MAX_COMPRESSED_BLOCK_SIZE\0" /* 66627 */ - "INDEPENDENT_64B_BLOCKS\0" /* 66653 */ - "LOSSY_RGB_PRECISION\0" /* 66676 */ - "LOSSY_ALPHA_PRECISION\0" /* 66696 */ - "UTCL2_BUSY\0" /* 66718 */ - "EA_BUSY\0" /* 66729 */ - "RMI_BUSY\0" /* 66737 */ - "UTCL2_RQ_PENDING\0" /* 66746 */ - "CPF_RQ_PENDING\0" /* 66763 */ - "EA_LINK_BUSY\0" /* 66778 */ - "CPAXI_BUSY\0" /* 66791 */ - "RSMU_RQ_PENDING\0" /* 66802 */ - "TC_WC_ACTION_ENA\0" /* 66818 */ - "TC_INV_METADATA_ACTION_ENA\0" /* 66835 */ - "UTCL2IU_BUSY\0" /* 66862 */ - "SAVE_RESTORE_BUSY\0" /* 66875 */ - "UTCL2IU_WAITING_ON_FREE\0" /* 66893 */ - "UTCL2IU_WAITING_ON_TAGS\0" /* 66917 */ - "UTCL1_WAITING_ON_TRANS\0" /* 66941 */ - "GFX_UTCL1_WAITING_ON_TRANS\0" /* 66964 */ - "CMP_UTCL1_WAITING_ON_TRANS\0" /* 66991 */ - "RCIU_WAITING_ON_FREE\0" /* 67018 */ - "PRIMGEN_EN\0" /* 67039 */ - "MATCH_ALL_BITS\0" /* 67050 */ - "EN_INST_OPT_BASIC\0" /* 67065 */ - "EN_INST_OPT_ADV\0" /* 67083 */ - "HW_USE_ONLY\0" /* 67099 */ - "TARGET_INST\0" /* 67111 */ - "TARGET_DATA\0" /* 67123 */ - "COMPLETE\0" /* 67135 */ - "DWB\0" /* 67144 */ - "GRAD_ADJ_0\0" /* 67148 */ - "GRAD_ADJ_1\0" /* 67159 */ - "GRAD_ADJ_2\0" /* 67170 */ - "GRAD_ADJ_3\0" /* 67181 */ - "USER_VM_ENABLE\0" /* 67192 */ - "USER_VM_MODE\0" /* 67207 */ - "IMG_DATA_FORMAT_6E4\0" /* 67220 */ - "IMG_DATA_FORMAT_16_AS_32_32\0" /* 67240 */ - "IMG_DATA_FORMAT_16_AS_16_16_16_16_GFX9\0" /* 67268 */ - "IMG_DATA_FORMAT_16_AS_32_32_32_32_GFX9\0" /* 67307 */ - "IMG_DATA_FORMAT_FMASK\0" /* 67346 */ - "IMG_DATA_FORMAT_ASTC_2D_LDR\0" /* 67368 */ - "IMG_DATA_FORMAT_ASTC_2D_HDR\0" /* 67396 */ - "IMG_DATA_FORMAT_ASTC_2D_LDR_SRGB\0" /* 67424 */ - "IMG_DATA_FORMAT_ASTC_3D_LDR\0" /* 67457 */ - "IMG_DATA_FORMAT_ASTC_3D_HDR\0" /* 67485 */ - "IMG_DATA_FORMAT_ASTC_3D_LDR_SRGB\0" /* 67513 */ - "IMG_DATA_FORMAT_N_IN_16\0" /* 67546 */ - "IMG_DATA_FORMAT_N_IN_16_16\0" /* 67570 */ - "IMG_DATA_FORMAT_N_IN_16_16_16_16\0" /* 67597 */ - "IMG_DATA_FORMAT_N_IN_16_AS_16_16_16_16\0" /* 67630 */ - "IMG_DATA_FORMAT_RESERVED_56\0" /* 67669 */ - "IMG_DATA_FORMAT_S8_16\0" /* 67697 */ - "IMG_DATA_FORMAT_S8_32\0" /* 67719 */ - "IMG_DATA_FORMAT_8_AS_32\0" /* 67741 */ - "IMG_DATA_FORMAT_8_AS_32_32\0" /* 67765 */ - "DATA_FORMAT_GFX9\0" /* 67792 */ - "IMG_NUM_FORMAT_RESERVED_6\0" /* 67809 */ - "IMG_NUM_FORMAT_METADATA\0" /* 67835 */ - "IMG_NUM_FORMAT_UNORM_UINT\0" /* 67859 */ - "NUM_FORMAT_GFX9\0" /* 67885 */ - "IMG_FMASK_8_2_1\0" /* 67901 */ - "IMG_FMASK_8_4_1\0" /* 67917 */ - "IMG_FMASK_8_8_1\0" /* 67933 */ - "IMG_FMASK_8_2_2\0" /* 67949 */ - "IMG_FMASK_8_4_2\0" /* 67965 */ - "IMG_FMASK_8_4_4\0" /* 67981 */ - "IMG_FMASK_16_16_1\0" /* 67997 */ - "IMG_FMASK_16_8_2\0" /* 68015 */ - "IMG_FMASK_32_16_2\0" /* 68032 */ - "IMG_FMASK_32_8_4\0" /* 68050 */ - "IMG_FMASK_32_8_8\0" /* 68067 */ - "IMG_FMASK_64_16_4\0" /* 68084 */ - "IMG_FMASK_64_16_8\0" /* 68102 */ - "NUM_FORMAT_FMASK\0" /* 68120 */ - "IMG_ASTC_2D_4x4\0" /* 68137 */ - "IMG_ASTC_2D_5x4\0" /* 68153 */ - "IMG_ASTC_2D_5x5\0" /* 68169 */ - "IMG_ASTC_2D_6x5\0" /* 68185 */ - "IMG_ASTC_2D_6x6\0" /* 68201 */ - "IMG_ASTC_2D_8x5\0" /* 68217 */ - "IMG_ASTC_2D_8x6\0" /* 68233 */ - "IMG_ASTC_2D_8x8\0" /* 68249 */ - "IMG_ASTC_2D_10x5\0" /* 68265 */ - "IMG_ASTC_2D_10x6\0" /* 68282 */ - "IMG_ASTC_2D_10x8\0" /* 68299 */ - "IMG_ASTC_2D_10x10\0" /* 68316 */ - "IMG_ASTC_2D_12x10\0" /* 68334 */ - "IMG_ASTC_2D_12x12\0" /* 68352 */ - "NUM_FORMAT_ASTC_2D\0" /* 68370 */ - "IMG_ASTC_3D_3x3x3\0" /* 68389 */ - "IMG_ASTC_3D_4x3x3\0" /* 68407 */ - "IMG_ASTC_3D_4x4x3\0" /* 68425 */ - "IMG_ASTC_3D_4x4x4\0" /* 68443 */ - "IMG_ASTC_3D_5x4x4\0" /* 68461 */ - "IMG_ASTC_3D_5x5x4\0" /* 68479 */ - "IMG_ASTC_3D_5x5x5\0" /* 68497 */ - "IMG_ASTC_3D_6x5x5\0" /* 68515 */ - "IMG_ASTC_3D_6x6x5\0" /* 68533 */ - "IMG_ASTC_3D_6x6x6\0" /* 68551 */ - "NUM_FORMAT_ASTC_3D\0" /* 68569 */ - "META_DIRECT\0" /* 68588 */ - "SW_MODE\0" /* 68600 */ - "PITCH_GFX9\0" /* 68608 */ - "BC_SWIZZLE_XYZW\0" /* 68619 */ - "BC_SWIZZLE_XWYZ\0" /* 68635 */ - "BC_SWIZZLE_WZYX\0" /* 68651 */ - "BC_SWIZZLE_WXYZ\0" /* 68667 */ - "BC_SWIZZLE_ZYXW\0" /* 68683 */ - "BC_SWIZZLE_YXWZ\0" /* 68699 */ - "BC_SWIZZLE\0" /* 68715 */ - "ARRAY_PITCH\0" /* 68726 */ - "META_DATA_ADDRESS\0" /* 68738 */ - "META_LINEAR\0" /* 68756 */ - "META_PIPE_ALIGNED\0" /* 68768, 68773 */ - "META_RB_ALIGNED\0" /* 68786, 68791 */ - "MAX_MIP\0" /* 68802 */ - "BLEND_ZERO_PRT\0" /* 68810 */ - "SKIP_DEGAMMA\0" /* 68825 */ - "TTRACE_STALL_ALL\0" /* 68838 */ - "ALLOC_ARB_LRU_ENA\0" /* 68855 */ - "EXP_ARB_LRU_ENA\0" /* 68873 */ - "PS_PKR_PRIORITY_CNTL\0" /* 68889 */ - "BATON_RESET_DISABLE\0" /* 68910 */ - "CRC_SIMD_ID_WADDR_DISABLE\0" /* 68930 */ - "LBPW_CU_CHK_MODE\0" /* 68956 */ - "LBPW_CU_CHK_CNT\0" /* 68973 */ - "CSC_PWR_SAVE_DISABLE\0" /* 68989 */ - "CSG_PWR_SAVE_DISABLE\0" /* 69010 */ - "CONTEXT_SAVE_WAIT_GDS_REQUEST_CYCLE_OVHD\0" /* 69031 */ - "CONTEXT_SAVE_WAIT_GDS_GRANT_CYCLE_OVHD\0" /* 69072 */ - "PIPE_INTERLEAVE_SIZE_GFX9\0" /* 69111 */ - "MAX_COMPRESSED_FRAGS\0" /* 69137 */ - "NUM_SHADER_ENGINES_GFX9\0" /* 69158 */ - "NUM_GPUS_GFX9\0" /* 69182 */ - "NUM_RB_PER_SE\0" /* 69196 */ - "SE_ENABLE\0" /* 69210 */ - "SIMD_DISABLE\0" /* 69220 */ - "FP16_OVFL\0" /* 69233 */ - "LOAD_COLLISION_WAVEID\0" /* 69243 */ - "LOAD_INTRAWAVE_COLLISION\0" /* 69265 */ - "SKIP_USGPR0\0" /* 69290 */ - "USER_SGPR_MSB\0" /* 69302 */ - "PC_BASE_EN\0" /* 69316 */ - "SPI_SHADER_LATE_ALLOC_GS\0" /* 69327 */ - "GS_VGPR_COMP_CNT\0" /* 69352 */ - "ES_VGPR_COMP_CNT\0" /* 69369 */ - "LS_VGPR_COMP_CNT\0" /* 69386 */ - "CNTR_SEL0\0" /* 69403 */ - "CNTR_SEL1\0" /* 69413 */ - "CNTR_MODE1\0" /* 69423 */ - "CNTR_MODE0\0" /* 69434 */ - "CNTR_SEL2\0" /* 69445 */ - "CNTR_SEL3\0" /* 69455 */ - "CNTR_MODE3\0" /* 69465 */ - "CNTR_MODE2\0" /* 69476 */ - "UTCL2_BUSY_USER_DEFINED_MASK\0" /* 69487 */ - "EA_BUSY_USER_DEFINED_MASK\0" /* 69516 */ - "RMI_BUSY_USER_DEFINED_MASK\0" /* 69542 */ - "MIPID\0" /* 69569 */ - "ALLOW_PARTIAL_RES_HIER_KILL\0" /* 69575 */ - "X_MAX\0" /* 69603 */ - "Y_MAX\0" /* 69609 */ - "PARTIALLY_RESIDENT\0" /* 69615 */ - "FAULT_BEHAVIOR\0" /* 69634 */ - "ITERATE_FLUSH\0" /* 69649 */ - "MAXMIP\0" /* 69663 */ - "FORCE_ON\0" /* 69670 */ - "PUNCHOUT_MODE\0" /* 69679 */ - "POPS_DRAIN_PS_ON_OVERLAP\0" /* 69693 */ - "DISALLOW_OVERFLOW\0" /* 69718 */ - "PS_INVOKE_MASK\0" /* 69736 */ - "DEST_BASE_HI_256B\0" /* 69751 */ - "SE_XSEL_GFX9\0" /* 69769 */ - "SE_YSEL_GFX9\0" /* 69782 */ - "SE_PAIR_XSEL_GFX9\0" /* 69795 */ - "SE_PAIR_YSEL_GFX9\0" /* 69813 */ - "NUM_SE\0" /* 69831 */ - "DISABLE_SRBSL_DB_OPTIMIZED_PACKING\0" /* 69838 */ - "PERFMON_ENABLE\0" /* 69873 */ - "LEFT_QTR\0" /* 69888 */ - "LEFT_HALF\0" /* 69897 */ - "RIGHT_HALF\0" /* 69907 */ - "RIGHT_QTR\0" /* 69918 */ - "TOP_QTR\0" /* 69928 */ - "TOP_HALF\0" /* 69936 */ - "BOT_HALF\0" /* 69945 */ - "BOT_QTR\0" /* 69954 */ - "LEFT_EYE_FOV_LEFT\0" /* 69962 */ - "LEFT_EYE_FOV_RIGHT\0" /* 69980 */ - "RIGHT_EYE_FOV_LEFT\0" /* 69999 */ - "RIGHT_EYE_FOV_RIGHT\0" /* 70018 */ - "FOV_TOP\0" /* 70038 */ - "FOV_BOT\0" /* 70046 */ - "OFFCHIP_PARAM_EN\0" /* 70054 */ - "LATE_PC_DEALLOC\0" /* 70071 */ - "BASE_ADDR_GFX9\0" /* 70087 */ - "SPRITE_EN_R6XX\0" /* 70102 */ - "UNROLLED_INST\0" /* 70117 */ - "GRBM_SKEW_NO_DEC\0" /* 70131 */ - "REG_RT_INDEX\0" /* 70148 */ - "PRIMITIVE_ORDERED_PIXEL_SHADER\0" /* 70161 */ - "EXEC_IF_OVERLAPPED\0" /* 70192 */ - "POPS_OVERLAP_NUM_SAMPLES\0" /* 70211 */ - "RIGHT_TRIANGLE_ALTERNATE_GRADIENT_REF\0" /* 70236 */ - "NEW_QUAD_DECOMPOSITION\0" /* 70274 */ - "PERFCOUNTER_REF\0" /* 70297 */ - "USE_VTX_SHD_OBJPRIM_ID\0" /* 70313 */ - "SRBSL_ENABLE\0" /* 70336 */ - "OBJ_ID_SEL\0" /* 70349 */ - "ADD_PIPED_PRIM_ID\0" /* 70360 */ - "EN_32BIT_OBJPRIMID\0" /* 70378 */ - "VERTEX_REUSE_OFF\0" /* 70397 */ - "INDEX_BUF_EDGE_FLAG_ENA\0" /* 70414 */ - "DISCARD_0_AREA_TRIANGLES\0" /* 70438 */ - "DISCARD_0_AREA_LINES\0" /* 70463 */ - "DISCARD_0_AREA_POINTS\0" /* 70484 */ - "DISCARD_0_AREA_RECTANGLES\0" /* 70506 */ - "USE_PROVOKING_ZW\0" /* 70532 */ - "RESERVED_3\0" /* 70549 */ - "RESERVED_4\0" /* 70560 */ - "RESERVED_5\0" /* 70571 */ - "GS_INST_PRIMS_IN_SUBGRP\0" /* 70582 */ - "SCALE_LINE_WIDTH_PAD\0" /* 70606 */ - "ALTERNATE_RBS_PER_TILE\0" /* 70627 */ - "COARSE_TILE_STARTS_ON_EVEN_RB\0" /* 70650 */ - "NGG_DISABLE_PROVOK_REUSE\0" /* 70680 */ - "BREAK_BATCH\0" /* 70705 */ - "FLUSH_DFSM\0" /* 70717 */ - "RESET_TO_LOWEST_VGT\0" /* 70728 */ - "TGID_ROLLOVER\0" /* 70748 */ - "ENABLE_NGG_PIPELINE\0" /* 70762 */ - "ENABLE_LEGACY_PIPELINE\0" /* 70782 */ - "ADDRESS_HI_GFX9\0" /* 70805 */ - "OBJPRIM_ID_EN\0" /* 70821 */ - "EN_REG_RT_INDEX\0" /* 70835 */ - "EN_PIPELINE_PRIMID\0" /* 70851 */ - "OBJECT_ID_INST_EN\0" /* 70870 */ - "COMPOUND_INDEX_EN\0" /* 70888 */ - "ORDERED_ID_MODE\0" /* 70906 */ - "GS_FAST_LAUNCH\0" /* 70922 */ - "EN_PRIMS_NEEDED_CNT\0" /* 70937 */ - "COVERAGE_TO_SHADER_SELECT\0" /* 70957 */ - "BINNING_ALLOWED\0" /* 70983 */ - "FORCE_BINNING_ON\0" /* 70999 */ - "DISABLE_BINNING_USE_NEW_SC\0" /* 71016 */ - "DISABLE_BINNING_USE_LEGACY_SC\0" /* 71043 */ - "BINNING_MODE\0" /* 71073 */ - "BIN_SIZE_X\0" /* 71086 */ - "BIN_SIZE_Y\0" /* 71097 */ - "BIN_SIZE_X_EXTEND\0" /* 71108 */ - "BIN_SIZE_Y_EXTEND\0" /* 71126 */ - "CONTEXT_STATES_PER_BIN\0" /* 71144 */ - "PERSISTENT_STATES_PER_BIN\0" /* 71167 */ - "DISABLE_START_OF_PRIM\0" /* 71193 */ - "FPOVS_PER_BATCH\0" /* 71215 */ - "OPTIMAL_BIN_SELECTION\0" /* 71231 */ - "MAX_ALLOC_COUNT\0" /* 71253 */ - "MAX_PRIM_PER_BATCH\0" /* 71269 */ - "OVER_RAST_ENABLE\0" /* 71288 */ - "OVER_RAST_SAMPLE_SELECT\0" /* 71305 */ - "UNDER_RAST_ENABLE\0" /* 71329 */ - "UNDER_RAST_SAMPLE_SELECT\0" /* 71347 */ - "PBB_UNCERTAINTY_REGION_ENABLE\0" /* 71372 */ - "ZMM_TRI_EXTENT\0" /* 71402 */ - "ZMM_TRI_OFFSET\0" /* 71417 */ - "OVERRIDE_OVER_RAST_INNER_TO_NORMAL\0" /* 71432 */ - "OVERRIDE_UNDER_RAST_INNER_TO_NORMAL\0" /* 71467 */ - "DEGENERATE_OVERRIDE_INNER_TO_NORMAL_DISABLE\0" /* 71503 */ - "UNCERTAINTY_REGION_MODE\0" /* 71547 */ - "OUTER_UNCERTAINTY_EDGERULE_OVERRIDE\0" /* 71571 */ - "INNER_UNCERTAINTY_EDGERULE_OVERRIDE\0" /* 71607 */ - "NULL_SQUAD_AA_MASK_ENABLE\0" /* 71643 */ - "COVERAGE_AA_MASK_ENABLE\0" /* 71669 */ - "PREZ_AA_MASK_ENABLE\0" /* 71693 */ - "POSTZ_AA_MASK_ENABLE\0" /* 71713 */ - "CENTROID_SAMPLE_OVERRIDE\0" /* 71734 */ - "MAX_DEALLOCS_IN_WAVE\0" /* 71759 */ - "BASE_256B\0" /* 71780 */ - "MIP0_HEIGHT\0" /* 71790 */ - "MIP0_WIDTH\0" /* 71802 */ - "MIP_LEVEL\0" /* 71813 */ - "MIP0_DEPTH\0" /* 71823 */ - "COLOR_SW_MODE\0" /* 71834 */ - "FMASK_SW_MODE\0" /* 71848 */ - "RESOURCE_TYPE\0" /* 71862 */; + "ROP3_CLEAR\0" /* 57579 */ + "ROP3_NOR\0" /* 57590 */ + "ROP3_AND_INVERTED\0" /* 57599 */ + "ROP3_COPY_INVERTED\0" /* 57617 */ + "ROP3_AND_REVERSE\0" /* 57636 */ + "ROP3_INVERT\0" /* 57653 */ + "ROP3_XOR\0" /* 57665 */ + "ROP3_NAND\0" /* 57674 */ + "ROP3_AND\0" /* 57684 */ + "ROP3_EQUIVALENT\0" /* 57693 */ + "ROP3_NO_OP\0" /* 57709 */ + "ROP3_OR_INVERTED\0" /* 57720 */ + "ROP3_COPY\0" /* 57737 */ + "ROP3_OR_REVERSE\0" /* 57747 */ + "ROP3_OR\0" /* 57763 */ + "ROP3_SET\0" /* 57771 */ + "Z_EXPORT_ENABLE\0" /* 57780 */ + "STENCIL_TEST_VAL_EXPORT_ENABLE\0" /* 57796 */ + "STENCIL_OP_VAL_EXPORT_ENABLE\0" /* 57827 */ + "LATE_Z\0" /* 57856 */ + "EARLY_Z_THEN_LATE_Z\0" /* 57863 */ + "RE_Z\0" /* 57883 */ + "EARLY_Z_THEN_RE_Z\0" /* 57888 */ + "KILL_ENABLE\0" /* 57906 */ + "COVERAGE_TO_MASK_ENABLE\0" /* 57918 */ + "MASK_EXPORT_ENABLE\0" /* 57942 */ + "EXEC_ON_HIER_FAIL\0" /* 57961 */ + "EXEC_ON_NOOP\0" /* 57979 */ + "ALPHA_TO_MASK_DISABLE\0" /* 57992 */ + "DEPTH_BEFORE_SHADER\0" /* 58014 */ + "EXPORT_ANY_Z\0" /* 58034 */ + "EXPORT_LESS_THAN_Z\0" /* 58047 */ + "EXPORT_GREATER_THAN_Z\0" /* 58066 */ + "EXPORT_RESERVED\0" /* 58088 */ + "CONSERVATIVE_Z_EXPORT\0" /* 58104 */ + "DUAL_QUAD_DISABLE\0" /* 58126 */ + "UCP_ENA_0\0" /* 58144 */ + "UCP_ENA_1\0" /* 58154 */ + "UCP_ENA_2\0" /* 58164 */ + "UCP_ENA_3\0" /* 58174 */ + "UCP_ENA_4\0" /* 58184 */ + "UCP_ENA_5\0" /* 58194 */ + "PS_UCP_Y_SCALE_NEG\0" /* 58204 */ + "PS_UCP_MODE\0" /* 58223 */ + "CLIP_DISABLE\0" /* 58235 */ + "UCP_CULL_ONLY_ENA\0" /* 58248 */ + "BOUNDARY_EDGE_FLAG_ENA\0" /* 58266 */ + "DX_CLIP_SPACE_DEF\0" /* 58289 */ + "DIS_CLIP_ERR_DETECT\0" /* 58307 */ + "VTX_KILL_OR\0" /* 58327 */ + "DX_RASTERIZATION_KILL\0" /* 58339 */ + "DX_LINEAR_ATTR_CLIP_ENA\0" /* 58361 */ + "VTE_VPORT_PROVOKE_DISABLE\0" /* 58385 */ + "ZCLIP_NEAR_DISABLE\0" /* 58411 */ + "ZCLIP_FAR_DISABLE\0" /* 58430 */ + "CULL_FRONT\0" /* 58448 */ + "CULL_BACK\0" /* 58459 */ + "X_DISABLE_POLY_MODE\0" /* 58469, 58479 */ + "X_DUAL_MODE\0" /* 58489 */ + "X_DRAW_POINTS\0" /* 58501 */ + "X_DRAW_LINES\0" /* 58515 */ + "X_DRAW_TRIANGLES\0" /* 58528 */ + "POLYMODE_FRONT_PTYPE\0" /* 58545 */ + "POLYMODE_BACK_PTYPE\0" /* 58566 */ + "POLY_OFFSET_FRONT_ENABLE\0" /* 58586 */ + "POLY_OFFSET_BACK_ENABLE\0" /* 58611 */ + "POLY_OFFSET_PARA_ENABLE\0" /* 58635 */ + "VTX_WINDOW_OFFSET_ENABLE\0" /* 58659 */ + "PROVOKING_VTX_LAST\0" /* 58684 */ + "PERSP_CORR_DIS\0" /* 58703 */ + "MULTI_PRIM_IB_ENA\0" /* 58718 */ + "VPORT_X_SCALE_ENA\0" /* 58736 */ + "VPORT_X_OFFSET_ENA\0" /* 58754 */ + "VPORT_Y_SCALE_ENA\0" /* 58773 */ + "VPORT_Y_OFFSET_ENA\0" /* 58791 */ + "VPORT_Z_SCALE_ENA\0" /* 58810 */ + "VPORT_Z_OFFSET_ENA\0" /* 58828 */ + "VTX_XY_FMT\0" /* 58847 */ + "VTX_Z_FMT\0" /* 58858 */ + "VTX_W0_FMT\0" /* 58868 */ + "CLIP_DIST_ENA_0\0" /* 58879 */ + "CLIP_DIST_ENA_1\0" /* 58895 */ + "CLIP_DIST_ENA_2\0" /* 58911 */ + "CLIP_DIST_ENA_3\0" /* 58927 */ + "CLIP_DIST_ENA_4\0" /* 58943 */ + "CLIP_DIST_ENA_5\0" /* 58959 */ + "CLIP_DIST_ENA_6\0" /* 58975 */ + "CLIP_DIST_ENA_7\0" /* 58991 */ + "CULL_DIST_ENA_0\0" /* 59007 */ + "CULL_DIST_ENA_1\0" /* 59023 */ + "CULL_DIST_ENA_2\0" /* 59039 */ + "CULL_DIST_ENA_3\0" /* 59055 */ + "CULL_DIST_ENA_4\0" /* 59071 */ + "CULL_DIST_ENA_5\0" /* 59087 */ + "CULL_DIST_ENA_6\0" /* 59103 */ + "CULL_DIST_ENA_7\0" /* 59119 */ + "USE_VTX_POINT_SIZE\0" /* 59135 */ + "USE_VTX_EDGE_FLAG\0" /* 59154 */ + "USE_VTX_RENDER_TARGET_INDX\0" /* 59172 */ + "USE_VTX_VIEWPORT_INDX\0" /* 59199 */ + "USE_VTX_KILL_FLAG\0" /* 59221 */ + "VS_OUT_MISC_VEC_ENA\0" /* 59239 */ + "VS_OUT_CCDIST0_VEC_ENA\0" /* 59259 */ + "VS_OUT_CCDIST1_VEC_ENA\0" /* 59282 */ + "VS_OUT_MISC_SIDE_BUS_ENA\0" /* 59305 */ + "USE_VTX_GS_CUT_FLAG\0" /* 59330 */ + "USE_VTX_LINE_WIDTH\0" /* 59350 */ + "VTE_XY_INF_DISCARD\0" /* 59369 */ + "VTE_Z_INF_DISCARD\0" /* 59388 */ + "VTE_W_INF_DISCARD\0" /* 59406 */ + "VTE_0XNANINF_IS_0\0" /* 59424 */ + "VTE_XY_NAN_RETAIN\0" /* 59442 */ + "VTE_Z_NAN_RETAIN\0" /* 59460 */ + "VTE_W_NAN_RETAIN\0" /* 59477 */ + "VTE_W_RECIP_NAN_IS_0\0" /* 59494 */ + "VS_XY_NAN_TO_INF\0" /* 59515 */ + "VS_XY_INF_RETAIN\0" /* 59532 */ + "VS_Z_NAN_TO_INF\0" /* 59549 */ + "VS_Z_INF_RETAIN\0" /* 59565 */ + "VS_W_NAN_TO_INF\0" /* 59581 */ + "VS_W_INF_RETAIN\0" /* 59597 */ + "VS_CLIP_DIST_INF_DISCARD\0" /* 59613 */ + "VTE_NO_OUTPUT_NEG_0\0" /* 59638 */ + "LINE_STIPPLE_RESET\0" /* 59658 */ + "EXPAND_FULL_LENGTH\0" /* 59677 */ + "FRACTIONAL_ACCUM\0" /* 59696 */ + "DIAMOND_ADJUST\0" /* 59713 */ + "TRIANGLE_FILTER_DISABLE\0" /* 59728 */ + "LINE_FILTER_DISABLE\0" /* 59752 */ + "POINT_FILTER_DISABLE\0" /* 59772 */ + "RECTANGLE_FILTER_DISABLE\0" /* 59793 */ + "TRIANGLE_EXPAND_ENA\0" /* 59818 */ + "LINE_EXPAND_ENA\0" /* 59838 */ + "POINT_EXPAND_ENA\0" /* 59854 */ + "RECTANGLE_EXPAND_ENA\0" /* 59871 */ + "PRIM_EXPAND_CONSTANT\0" /* 59892 */ + "XMAX_RIGHT_EXCLUSION\0" /* 59913 */ + "YMAX_BOTTOM_EXCLUSION\0" /* 59934 */ + "SMALL_PRIM_FILTER_ENABLE\0" /* 59956 */ + "MIN_SIZE\0" /* 59981 */ + "LINE_PATTERN\0" /* 59990 */ + "REPEAT_COUNT\0" /* 60003 */ + "PATTERN_BIT_ORDER\0" /* 60016 */ + "AUTO_RESET_CNTL\0" /* 60034 */ + "VGT_OUTPATH_VTX_REUSE\0" /* 60050 */ + "VGT_OUTPATH_TESS_EN\0" /* 60072 */ + "VGT_OUTPATH_PASSTHRU\0" /* 60092 */ + "VGT_OUTPATH_GS_BLOCK\0" /* 60113 */ + "VGT_OUTPATH_HS_BLOCK\0" /* 60134 */ + "PATH_SELECT\0" /* 60155 */ + "TESS_MODE\0" /* 60167 */ + "VGT_GRP_3D_POINT\0" /* 60177 */ + "VGT_GRP_3D_LINE\0" /* 60194 */ + "VGT_GRP_3D_TRI\0" /* 60210 */ + "VGT_GRP_3D_RECT\0" /* 60225 */ + "VGT_GRP_3D_QUAD\0" /* 60241 */ + "VGT_GRP_2D_COPY_RECT_V0\0" /* 60257 */ + "VGT_GRP_2D_COPY_RECT_V1\0" /* 60281 */ + "VGT_GRP_2D_COPY_RECT_V2\0" /* 60305 */ + "VGT_GRP_2D_COPY_RECT_V3\0" /* 60329 */ + "VGT_GRP_2D_FILL_RECT\0" /* 60353 */ + "VGT_GRP_2D_LINE\0" /* 60374 */ + "VGT_GRP_2D_TRI\0" /* 60390 */ + "VGT_GRP_PRIM_INDEX_LINE\0" /* 60405 */ + "VGT_GRP_PRIM_INDEX_TRI\0" /* 60429 */ + "VGT_GRP_PRIM_INDEX_QUAD\0" /* 60452 */ + "VGT_GRP_3D_LINE_ADJ\0" /* 60476 */ + "VGT_GRP_3D_TRI_ADJ\0" /* 60496 */ + "VGT_GRP_3D_PATCH\0" /* 60515 */ + "RETAIN_ORDER\0" /* 60532 */ + "RETAIN_QUADS\0" /* 60545 */ + "VGT_GRP_LIST\0" /* 60558 */ + "VGT_GRP_STRIP\0" /* 60571 */ + "VGT_GRP_FAN\0" /* 60585 */ + "VGT_GRP_LOOP\0" /* 60597 */ + "VGT_GRP_POLYGON\0" /* 60610 */ + "PRIM_ORDER\0" /* 60626 */ + "COMP_X_EN\0" /* 60637 */ + "COMP_Y_EN\0" /* 60647 */ + "COMP_Z_EN\0" /* 60657 */ + "COMP_W_EN\0" /* 60667 */ + "SHIFT\0" /* 60677 */ + "VGT_GRP_INDEX_16\0" /* 60683 */ + "VGT_GRP_INDEX_32\0" /* 60700 */ + "VGT_GRP_UINT_16\0" /* 60717 */ + "VGT_GRP_UINT_32\0" /* 60733 */ + "VGT_GRP_SINT_16\0" /* 60749 */ + "VGT_GRP_SINT_32\0" /* 60765 */ + "VGT_GRP_FLOAT_32\0" /* 60781 */ + "VGT_GRP_AUTO_PRIM\0" /* 60798 */ + "VGT_GRP_FIX_1_23_TO_FLOAT\0" /* 60816 */ + "X_CONV\0" /* 60842, 60846 */ + "Y_CONV\0" /* 60849 */ + "Z_CONV\0" /* 60856 */ + "Z_OFFSET\0" /* 60863 */ + "W_CONV\0" /* 60872 */ + "GS_OFF\0" /* 60879 */ + "GS_SCENARIO_A\0" /* 60886 */ + "GS_SCENARIO_B\0" /* 60900 */ + "GS_SCENARIO_G\0" /* 60914 */ + "GS_SCENARIO_C\0" /* 60928 */ + "SPRITE_EN\0" /* 60942 */ + "GS_CUT_1024\0" /* 60952 */ + "GS_CUT_512\0" /* 60964 */ + "GS_CUT_256\0" /* 60975 */ + "GS_CUT_128\0" /* 60986 */ + "CUT_MODE\0" /* 60997 */ + "GS_C_PACK_EN\0" /* 61006 */ + "RESERVED_2\0" /* 61019 */ + "ES_PASSTHRU\0" /* 61030 */ + "COMPUTE_MODE\0" /* 61042 */ + "FAST_COMPUTE_MODE\0" /* 61055 */ + "ELEMENT_INFO_EN\0" /* 61073 */ + "PARTIAL_THD_AT_EOI\0" /* 61089 */ + "SUPPRESS_CUTS\0" /* 61108 */ + "ES_WRITE_OPTIMIZE\0" /* 61122 */ + "GS_WRITE_OPTIMIZE\0" /* 61140 */ + "X_0_OFFCHIP_GS\0" /* 61158 */ + "X_3_ES_AND_GS_ARE_ONCHIP\0" /* 61173, 61191 */ + "ES_VERTS_PER_SUBGRP\0" /* 61198 */ + "GS_PRIMS_PER_SUBGRP\0" /* 61218 */ + "MSAA_ENABLE\0" /* 61238 */ + "VPORT_SCISSOR_ENABLE\0" /* 61250 */ + "LINE_STIPPLE_ENABLE\0" /* 61271 */ + "SEND_UNLIT_STILES_TO_PKR\0" /* 61291 */ + "WALK_SIZE\0" /* 61316 */ + "WALK_ALIGNMENT\0" /* 61326 */ + "WALK_ALIGN8_PRIM_FITS_ST\0" /* 61341 */ + "WALK_FENCE_ENABLE\0" /* 61366 */ + "WALK_FENCE_SIZE\0" /* 61384 */ + "SUPERTILE_WALK_ORDER_ENABLE\0" /* 61400, 61405 */ + "TILE_COVER_DISABLE\0" /* 61428 */ + "TILE_COVER_NO_SCISSOR\0" /* 61447 */ + "ZMM_LINE_EXTENT\0" /* 61469 */ + "ZMM_LINE_OFFSET\0" /* 61485 */ + "ZMM_RECT_EXTENT\0" /* 61501 */ + "KILL_PIX_POST_HI_Z\0" /* 61517 */ + "KILL_PIX_POST_DETAIL_MASK\0" /* 61536 */ + "PS_ITER_SAMPLE\0" /* 61562 */ + "MULTI_SHADER_ENGINE_PRIM_DISCARD_ENABLE\0" /* 61577 */ + "MULTI_GPU_SUPERTILE_ENABLE\0" /* 61617 */ + "GPU_ID_OVERRIDE_ENABLE\0" /* 61644 */ + "GPU_ID_OVERRIDE\0" /* 61667 */ + "MULTI_GPU_PRIM_DISCARD_ENABLE\0" /* 61683 */ + "FORCE_EOV_CNTDWN_ENABLE\0" /* 61713 */ + "FORCE_EOV_REZ_ENABLE\0" /* 61737 */ + "OUT_OF_ORDER_PRIMITIVE_ENABLE\0" /* 61758 */ + "OUT_OF_ORDER_WATER_MARK\0" /* 61788 */ + "OUTPRIM_TYPE_POINTLIST\0" /* 61812 */ + "OUTPRIM_TYPE_LINESTRIP\0" /* 61835 */ + "OUTPRIM_TYPE_TRISTRIP\0" /* 61858 */ + "OUTPRIM_TYPE\0" /* 61880 */ + "OUTPRIM_TYPE_1\0" /* 61893 */ + "OUTPRIM_TYPE_2\0" /* 61908 */ + "OUTPRIM_TYPE_3\0" /* 61923 */ + "UNIQUE_TYPE_PER_STREAM\0" /* 61938 */ + "VGT_INDEX_16\0" /* 61961 */ + "VGT_INDEX_32\0" /* 61974 */ + "VGT_INDEX_8\0" /* 61987 */ + "VGT_DMA_SWAP_NONE\0" /* 61999 */ + "VGT_DMA_SWAP_16_BIT\0" /* 62017 */ + "VGT_DMA_SWAP_32_BIT\0" /* 62037 */ + "VGT_DMA_SWAP_WORD\0" /* 62057 */ + "SWAP_MODE\0" /* 62075 */ + "VGT_DMA_BUF_MEM\0" /* 62085 */ + "VGT_DMA_BUF_RING\0" /* 62101 */ + "VGT_DMA_BUF_SETUP\0" /* 62118 */ + "BUF_TYPE\0" /* 62136 */ + "VGT_POLICY_LRU\0" /* 62145 */ + "VGT_POLICY_STREAM\0" /* 62160 */ + "RDREQ_POLICY_CIK\0" /* 62178 */ + "RDREQ_POLICY\0" /* 62195 */ + "REQ_PATH\0" /* 62208 */ + "DISABLE_RESET_ON_EOI\0" /* 62217 */ + "SAMPLE_STREAMOUTSTATS1\0" /* 62238 */ + "SAMPLE_STREAMOUTSTATS2\0" /* 62261 */ + "SAMPLE_STREAMOUTSTATS3\0" /* 62284 */ + "CACHE_FLUSH_TS\0" /* 62307 */ + "CONTEXT_DONE\0" /* 62322 */ + "CACHE_FLUSH\0" /* 62335 */ + "CS_PARTIAL_FLUSH\0" /* 62347 */ + "VGT_STREAMOUT_SYNC\0" /* 62364 */ + "VGT_STREAMOUT_RESET\0" /* 62383 */ + "END_OF_PIPE_INCR_DE\0" /* 62403 */ + "END_OF_PIPE_IB_END\0" /* 62423 */ + "RST_PIX_CNT\0" /* 62442 */ + "VS_PARTIAL_FLUSH\0" /* 62454 */ + "PS_PARTIAL_FLUSH\0" /* 62471 */ + "FLUSH_HS_OUTPUT\0" /* 62488 */ + "FLUSH_LS_OUTPUT\0" /* 62504 */ + "CACHE_FLUSH_AND_INV_TS_EVENT\0" /* 62520 */ + "ZPASS_DONE\0" /* 62549 */ + "CACHE_FLUSH_AND_INV_EVENT\0" /* 62560 */ + "PERFCOUNTER_START\0" /* 62586 */ + "PERFCOUNTER_STOP\0" /* 62604 */ + "PIPELINESTAT_START\0" /* 62621 */ + "PIPELINESTAT_STOP\0" /* 62640 */ + "PERFCOUNTER_SAMPLE\0" /* 62658 */ + "FLUSH_ES_OUTPUT\0" /* 62677 */ + "FLUSH_GS_OUTPUT\0" /* 62693 */ + "SAMPLE_PIPELINESTAT\0" /* 62709 */ + "SO_VGTSTREAMOUT_FLUSH\0" /* 62729 */ + "SAMPLE_STREAMOUTSTATS\0" /* 62751 */ + "RESET_VTX_CNT\0" /* 62773 */ + "BLOCK_CONTEXT_DONE\0" /* 62787 */ + "CS_CONTEXT_DONE\0" /* 62806 */ + "VGT_FLUSH\0" /* 62822 */ + "SC_SEND_DB_VPZ\0" /* 62832 */ + "BOTTOM_OF_PIPE_TS\0" /* 62847 */ + "DB_CACHE_FLUSH_AND_INV\0" /* 62865 */ + "FLUSH_AND_INV_DB_DATA_TS\0" /* 62888 */ + "FLUSH_AND_INV_DB_META\0" /* 62913 */ + "FLUSH_AND_INV_CB_DATA_TS\0" /* 62935 */ + "FLUSH_AND_INV_CB_META\0" /* 62960 */ + "FLUSH_AND_INV_CB_PIXEL_DATA\0" /* 62982 */ + "THREAD_TRACE_START\0" /* 63010 */ + "THREAD_TRACE_STOP\0" /* 63029 */ + "THREAD_TRACE_MARKER\0" /* 63047 */ + "THREAD_TRACE_FLUSH\0" /* 63067 */ + "THREAD_TRACE_FINISH\0" /* 63086 */ + "PIXEL_PIPE_STAT_CONTROL\0" /* 63106 */ + "PIXEL_PIPE_STAT_DUMP\0" /* 63130 */ + "PIXEL_PIPE_STAT_RESET\0" /* 63151 */ + "EVENT_TYPE\0" /* 63173 */ + "ADDRESS_HI_GFX6\0" /* 63184 */ + "EXTENDED_EVENT\0" /* 63200 */ + "PRIMGROUP_SIZE\0" /* 63215 */ + "PARTIAL_VS_WAVE_ON\0" /* 63230 */ + "SWITCH_ON_EOP\0" /* 63249 */ + "PARTIAL_ES_WAVE_ON\0" /* 63263 */ + "SWITCH_ON_EOI\0" /* 63282 */ + "WD_SWITCH_ON_EOP\0" /* 63296 */ + "MAX_PRIMGRP_IN_WAVE\0" /* 63313 */ + "FULL_CACHE\0" /* 63333 */ + "HTILE_USES_PRELOAD_WIN\0" /* 63344 */ + "PRELOAD\0" /* 63367 */ + "PREFETCH_WIDTH\0" /* 63375 */ + "PREFETCH_HEIGHT\0" /* 63390 */ + "DST_OUTSIDE_ZERO_TO_ONE\0" /* 63406 */ + "TC_COMPATIBLE\0" /* 63430 */ + "COMPAREFUNC0\0" /* 63444 */ + "COMPAREVALUE0\0" /* 63457 */ + "COMPAREMASK0\0" /* 63471 */ + "COMPAREFUNC1\0" /* 63484 */ + "COMPAREVALUE1\0" /* 63497 */ + "COMPAREMASK1\0" /* 63511 */ + "MAX_X\0" /* 63524 */ + "MAX_Y\0" /* 63530 */ + "ACCUM_ISOLINE\0" /* 63536 */ + "ACCUM_TRI\0" /* 63550 */ + "ACCUM_QUAD\0" /* 63560 */ + "DONUT_SPLIT\0" /* 63571 */ + "TRAP_SPLIT\0" /* 63583 */ + "LS_STAGE_OFF\0" /* 63594 */ + "LS_STAGE_ON\0" /* 63607 */ + "CS_STAGE_ON\0" /* 63619 */ + "ES_STAGE_OFF\0" /* 63631 */ + "ES_STAGE_DS\0" /* 63644 */ + "ES_STAGE_REAL\0" /* 63656 */ + "VS_STAGE_REAL\0" /* 63670 */ + "VS_STAGE_DS\0" /* 63684 */ + "VS_STAGE_COPY_SHADER\0" /* 63696 */ + "DYNAMIC_HS\0" /* 63717 */ + "DIS_DEALLOC_ACCUM_0\0" /* 63728 */ + "DIS_DEALLOC_ACCUM_1\0" /* 63748 */ + "VS_WAVE_ID_EN\0" /* 63768 */ + "NUM_PATCHES\0" /* 63782 */ + "HS_NUM_INPUT_CP\0" /* 63794 */ + "HS_NUM_OUTPUT_CP\0" /* 63810 */ + "TESS_ISOLINE\0" /* 63827 */ + "TESS_TRIANGLE\0" /* 63840 */ + "TESS_QUAD\0" /* 63854 */ + "PART_INTEGER\0" /* 63864 */ + "PART_POW2\0" /* 63877 */ + "PART_FRAC_ODD\0" /* 63887 */ + "PART_FRAC_EVEN\0" /* 63901 */ + "PARTITIONING\0" /* 63916 */ + "OUTPUT_POINT\0" /* 63929 */ + "OUTPUT_LINE\0" /* 63942 */ + "OUTPUT_TRIANGLE_CW\0" /* 63954 */ + "OUTPUT_TRIANGLE_CCW\0" /* 63973 */ + "TOPOLOGY\0" /* 63993 */ + "RESERVED_REDUC_AXIS\0" /* 64002 */ + "DEPRECATED\0" /* 64022 */ + "NUM_DS_WAVES_PER_SIMD\0" /* 64033 */ + "DISABLE_DONUTS\0" /* 64055 */ + "VGT_POLICY_BYPASS\0" /* 64070 */ + "DISTRIBUTION_MODE_NO_DIST\0" /* 64088 */ + "DISTRIBUTION_MODE_PATCHES\0" /* 64114 */ + "DISTRIBUTION_MODE_DONUTS\0" /* 64140 */ + "DISTRIBUTION_MODE_TRAPEZOIDS\0" /* 64165 */ + "DISTRIBUTION_MODE\0" /* 64194 */ + "ALPHA_TO_MASK_ENABLE\0" /* 64212 */ + "ALPHA_TO_MASK_OFFSET0\0" /* 64233 */ + "ALPHA_TO_MASK_OFFSET1\0" /* 64255 */ + "ALPHA_TO_MASK_OFFSET2\0" /* 64277 */ + "ALPHA_TO_MASK_OFFSET3\0" /* 64299 */ + "OFFSET_ROUND\0" /* 64321 */ + "POLY_OFFSET_NEG_NUM_DB_BITS\0" /* 64334 */ + "POLY_OFFSET_DB_IS_FLOAT_FMT\0" /* 64362 */ + "STREAMOUT_0_EN\0" /* 64390 */ + "STREAMOUT_1_EN\0" /* 64405 */ + "STREAMOUT_2_EN\0" /* 64420 */ + "STREAMOUT_3_EN\0" /* 64435 */ + "RAST_STREAM\0" /* 64450 */ + "RAST_STREAM_MASK\0" /* 64462 */ + "USE_RAST_STREAM_MASK\0" /* 64479 */ + "STREAM_0_BUFFER_EN\0" /* 64500 */ + "STREAM_1_BUFFER_EN\0" /* 64519 */ + "STREAM_2_BUFFER_EN\0" /* 64538 */ + "STREAM_3_BUFFER_EN\0" /* 64557 */ + "DISTANCE_0\0" /* 64576 */ + "DISTANCE_1\0" /* 64587 */ + "DISTANCE_2\0" /* 64598 */ + "DISTANCE_3\0" /* 64609 */ + "DISTANCE_4\0" /* 64620 */ + "DISTANCE_5\0" /* 64631 */ + "DISTANCE_6\0" /* 64642 */ + "DISTANCE_7\0" /* 64653 */ + "DISTANCE_8\0" /* 64664 */ + "DISTANCE_9\0" /* 64675 */ + "DISTANCE_10\0" /* 64686 */ + "DISTANCE_11\0" /* 64698 */ + "DISTANCE_12\0" /* 64710 */ + "DISTANCE_13\0" /* 64722 */ + "DISTANCE_14\0" /* 64734 */ + "DISTANCE_15\0" /* 64746 */ + "EXPAND_LINE_WIDTH\0" /* 64758 */ + "LAST_PIXEL\0" /* 64776 */ + "PERPENDICULAR_ENDCAP_ENA\0" /* 64787 */ + "DX10_DIAMOND_TEST_ENA\0" /* 64812 */ + "MSAA_NUM_SAMPLES\0" /* 64834 */ + "AA_MASK_CENTROID_DTMN\0" /* 64851 */ + "MAX_SAMPLE_DIST\0" /* 64873 */ + "MSAA_EXPOSED_SAMPLES\0" /* 64889 */ + "DETAIL_TO_EXPOSED_MODE\0" /* 64910 */ + "PIX_CENTER\0" /* 64933 */ + "X_TRUNCATE\0" /* 64944 */ + "X_ROUND\0" /* 64955 */ + "X_ROUND_TO_EVEN\0" /* 64963 */ + "X_ROUND_TO_ODD\0" /* 64979 */ + "ROUND_MODE\0" /* 64994 */ + "X_16_8_FIXED_POINT_1_16TH\0" /* 65005 */ + "X_16_8_FIXED_POINT_1_8TH\0" /* 65031 */ + "X_16_8_FIXED_POINT_1_4TH\0" /* 65056 */ + "X_16_8_FIXED_POINT_1_2\0" /* 65081 */ + "X_16_8_FIXED_POINT_1\0" /* 65104 */ + "X_16_8_FIXED_POINT_1_256TH\0" /* 65125 */ + "X_14_10_FIXED_POINT_1_1024TH\0" /* 65152 */ + "X_12_12_FIXED_POINT_1_4096TH\0" /* 65181 */ + "QUANT_MODE\0" /* 65210 */ + "S0_X\0" /* 65221 */ + "S0_Y\0" /* 65226 */ + "S1_X\0" /* 65231 */ + "S1_Y\0" /* 65236 */ + "S2_X\0" /* 65241 */ + "S2_Y\0" /* 65246 */ + "S3_X\0" /* 65251 */ + "S3_Y\0" /* 65256 */ + "S4_X\0" /* 65261 */ + "S4_Y\0" /* 65266 */ + "S5_X\0" /* 65271 */ + "S5_Y\0" /* 65276 */ + "S6_X\0" /* 65281 */ + "S6_Y\0" /* 65286 */ + "S7_X\0" /* 65291 */ + "S7_Y\0" /* 65296 */ + "S8_X\0" /* 65301 */ + "S8_Y\0" /* 65306 */ + "S9_X\0" /* 65311 */ + "S9_Y\0" /* 65316 */ + "S10_X\0" /* 65321 */ + "S10_Y\0" /* 65327 */ + "S11_X\0" /* 65333 */ + "S11_Y\0" /* 65339 */ + "S12_X\0" /* 65345 */ + "S12_Y\0" /* 65351 */ + "S13_X\0" /* 65357 */ + "S13_Y\0" /* 65363 */ + "S14_X\0" /* 65369 */ + "S14_Y\0" /* 65375 */ + "S15_X\0" /* 65381 */ + "S15_Y\0" /* 65387 */ + "AA_MASK_X0Y0\0" /* 65393 */ + "AA_MASK_X1Y0\0" /* 65406 */ + "AA_MASK_X0Y1\0" /* 65419 */ + "AA_MASK_X1Y1\0" /* 65432 */ + "REALIGN_DQUADS_AFTER_N_WAVES\0" /* 65445 */ + "VTX_REUSE_DEPTH\0" /* 65474 */ + "DEALLOC_DIST\0" /* 65490 */ + "FMASK_TILE_MAX\0" /* 65503 */ + "ENDIAN_NONE\0" /* 65518 */ + "ENDIAN_8IN16\0" /* 65530 */ + "ENDIAN_8IN32\0" /* 65543 */ + "ENDIAN_8IN64\0" /* 65556 */ + "ENDIAN\0" /* 65569 */ + "COLOR_INVALID\0" /* 65576 */ + "COLOR_8\0" /* 65590 */ + "COLOR_16\0" /* 65598 */ + "COLOR_8_8\0" /* 65607 */ + "COLOR_32\0" /* 65617 */ + "COLOR_16_16\0" /* 65626 */ + "COLOR_10_11_11\0" /* 65638 */ + "COLOR_11_11_10\0" /* 65653 */ + "COLOR_10_10_10_2\0" /* 65668 */ + "COLOR_2_10_10_10\0" /* 65685 */ + "COLOR_8_8_8_8\0" /* 65702 */ + "COLOR_32_32\0" /* 65716 */ + "COLOR_16_16_16_16\0" /* 65728 */ + "COLOR_32_32_32_32\0" /* 65746 */ + "COLOR_5_6_5\0" /* 65764 */ + "COLOR_1_5_5_5\0" /* 65776 */ + "COLOR_5_5_5_1\0" /* 65790 */ + "COLOR_4_4_4_4\0" /* 65804 */ + "COLOR_8_24\0" /* 65818 */ + "COLOR_24_8\0" /* 65829 */ + "COLOR_X24_8_32_FLOAT\0" /* 65840 */ + "NUMBER_UNORM\0" /* 65861 */ + "NUMBER_SNORM\0" /* 65874 */ + "NUMBER_UINT\0" /* 65887 */ + "NUMBER_SINT\0" /* 65899 */ + "NUMBER_SRGB\0" /* 65911 */ + "NUMBER_FLOAT\0" /* 65923 */ + "NUMBER_TYPE\0" /* 65936 */ + "SWAP_STD\0" /* 65948 */ + "SWAP_ALT\0" /* 65957 */ + "SWAP_STD_REV\0" /* 65966 */ + "SWAP_ALT_REV\0" /* 65979 */ + "COMP_SWAP\0" /* 65992 */ + "BLEND_CLAMP\0" /* 66002 */ + "BLEND_BYPASS\0" /* 66014 */ + "SIMPLE_FLOAT\0" /* 66027 */ + "CMASK_IS_LINEAR\0" /* 66040 */ + "FORCE_OPT_AUTO\0" /* 66056 */ + "FORCE_OPT_DISABLE\0" /* 66071 */ + "FORCE_OPT_ENABLE_IF_SRC_A_0\0" /* 66089 */ + "FORCE_OPT_ENABLE_IF_SRC_RGB_0\0" /* 66117 */ + "FORCE_OPT_ENABLE_IF_SRC_ARGB_0\0" /* 66147 */ + "FORCE_OPT_ENABLE_IF_SRC_A_1\0" /* 66178 */ + "FORCE_OPT_ENABLE_IF_SRC_RGB_1\0" /* 66206 */ + "FORCE_OPT_ENABLE_IF_SRC_ARGB_1\0" /* 66236 */ + "BLEND_OPT_DONT_RD_DST\0" /* 66267 */ + "BLEND_OPT_DISCARD_PIXEL\0" /* 66289 */ + "FMASK_COMPRESSION_DISABLE\0" /* 66313 */ + "FMASK_COMPRESS_1FRAG_ONLY\0" /* 66339 */ + "DCC_ENABLE\0" /* 66365 */ + "CMASK_ADDR_TYPE\0" /* 66376 */ + "FMASK_TILE_MODE_INDEX\0" /* 66392 */ + "FMASK_BANK_HEIGHT\0" /* 66414 */ + "NUM_FRAGMENTS\0" /* 66432 */ + "FORCE_DST_ALPHA_1\0" /* 66446 */ + "KEY_CLEAR_ENABLE\0" /* 66464 */ + "MAX_BLOCK_SIZE_64B\0" /* 66481 */ + "MAX_BLOCK_SIZE_128B\0" /* 66500 */ + "MAX_BLOCK_SIZE_256B\0" /* 66520 */ + "MAX_UNCOMPRESSED_BLOCK_SIZE\0" /* 66540 */ + "MIN_BLOCK_SIZE_32B\0" /* 66568 */ + "MIN_BLOCK_SIZE_64B\0" /* 66587 */ + "MIN_COMPRESSED_BLOCK_SIZE\0" /* 66606 */ + "MAX_COMPRESSED_BLOCK_SIZE\0" /* 66632 */ + "INDEPENDENT_64B_BLOCKS\0" /* 66658 */ + "LOSSY_RGB_PRECISION\0" /* 66681 */ + "LOSSY_ALPHA_PRECISION\0" /* 66701 */ + "UTCL2_BUSY\0" /* 66723 */ + "EA_BUSY\0" /* 66734 */ + "RMI_BUSY\0" /* 66742 */ + "UTCL2_RQ_PENDING\0" /* 66751 */ + "CPF_RQ_PENDING\0" /* 66768 */ + "EA_LINK_BUSY\0" /* 66783 */ + "CPAXI_BUSY\0" /* 66796 */ + "RSMU_RQ_PENDING\0" /* 66807 */ + "TC_WC_ACTION_ENA\0" /* 66823 */ + "TC_INV_METADATA_ACTION_ENA\0" /* 66840 */ + "UTCL2IU_BUSY\0" /* 66867 */ + "SAVE_RESTORE_BUSY\0" /* 66880 */ + "UTCL2IU_WAITING_ON_FREE\0" /* 66898 */ + "UTCL2IU_WAITING_ON_TAGS\0" /* 66922 */ + "UTCL1_WAITING_ON_TRANS\0" /* 66946 */ + "GFX_UTCL1_WAITING_ON_TRANS\0" /* 66969 */ + "CMP_UTCL1_WAITING_ON_TRANS\0" /* 66996 */ + "RCIU_WAITING_ON_FREE\0" /* 67023 */ + "PRIMGEN_EN\0" /* 67044 */ + "MATCH_ALL_BITS\0" /* 67055 */ + "EN_INST_OPT_BASIC\0" /* 67070 */ + "EN_INST_OPT_ADV\0" /* 67088 */ + "HW_USE_ONLY\0" /* 67104 */ + "TARGET_INST\0" /* 67116 */ + "TARGET_DATA\0" /* 67128 */ + "COMPLETE\0" /* 67140 */ + "DWB\0" /* 67149 */ + "GRAD_ADJ_0\0" /* 67153 */ + "GRAD_ADJ_1\0" /* 67164 */ + "GRAD_ADJ_2\0" /* 67175 */ + "GRAD_ADJ_3\0" /* 67186 */ + "USER_VM_ENABLE\0" /* 67197 */ + "USER_VM_MODE\0" /* 67212 */ + "IMG_DATA_FORMAT_6E4\0" /* 67225 */ + "IMG_DATA_FORMAT_16_AS_32_32\0" /* 67245 */ + "IMG_DATA_FORMAT_16_AS_16_16_16_16_GFX9\0" /* 67273 */ + "IMG_DATA_FORMAT_16_AS_32_32_32_32_GFX9\0" /* 67312 */ + "IMG_DATA_FORMAT_FMASK\0" /* 67351 */ + "IMG_DATA_FORMAT_ASTC_2D_LDR\0" /* 67373 */ + "IMG_DATA_FORMAT_ASTC_2D_HDR\0" /* 67401 */ + "IMG_DATA_FORMAT_ASTC_2D_LDR_SRGB\0" /* 67429 */ + "IMG_DATA_FORMAT_ASTC_3D_LDR\0" /* 67462 */ + "IMG_DATA_FORMAT_ASTC_3D_HDR\0" /* 67490 */ + "IMG_DATA_FORMAT_ASTC_3D_LDR_SRGB\0" /* 67518 */ + "IMG_DATA_FORMAT_N_IN_16\0" /* 67551 */ + "IMG_DATA_FORMAT_N_IN_16_16\0" /* 67575 */ + "IMG_DATA_FORMAT_N_IN_16_16_16_16\0" /* 67602 */ + "IMG_DATA_FORMAT_N_IN_16_AS_16_16_16_16\0" /* 67635 */ + "IMG_DATA_FORMAT_RESERVED_56\0" /* 67674 */ + "IMG_DATA_FORMAT_S8_16\0" /* 67702 */ + "IMG_DATA_FORMAT_S8_32\0" /* 67724 */ + "IMG_DATA_FORMAT_8_AS_32\0" /* 67746 */ + "IMG_DATA_FORMAT_8_AS_32_32\0" /* 67770 */ + "DATA_FORMAT_GFX9\0" /* 67797 */ + "IMG_NUM_FORMAT_RESERVED_6\0" /* 67814 */ + "IMG_NUM_FORMAT_METADATA\0" /* 67840 */ + "IMG_NUM_FORMAT_UNORM_UINT\0" /* 67864 */ + "NUM_FORMAT_GFX9\0" /* 67890 */ + "IMG_FMASK_8_2_1\0" /* 67906 */ + "IMG_FMASK_8_4_1\0" /* 67922 */ + "IMG_FMASK_8_8_1\0" /* 67938 */ + "IMG_FMASK_8_2_2\0" /* 67954 */ + "IMG_FMASK_8_4_2\0" /* 67970 */ + "IMG_FMASK_8_4_4\0" /* 67986 */ + "IMG_FMASK_16_16_1\0" /* 68002 */ + "IMG_FMASK_16_8_2\0" /* 68020 */ + "IMG_FMASK_32_16_2\0" /* 68037 */ + "IMG_FMASK_32_8_4\0" /* 68055 */ + "IMG_FMASK_32_8_8\0" /* 68072 */ + "IMG_FMASK_64_16_4\0" /* 68089 */ + "IMG_FMASK_64_16_8\0" /* 68107 */ + "NUM_FORMAT_FMASK\0" /* 68125 */ + "IMG_ASTC_2D_4x4\0" /* 68142 */ + "IMG_ASTC_2D_5x4\0" /* 68158 */ + "IMG_ASTC_2D_5x5\0" /* 68174 */ + "IMG_ASTC_2D_6x5\0" /* 68190 */ + "IMG_ASTC_2D_6x6\0" /* 68206 */ + "IMG_ASTC_2D_8x5\0" /* 68222 */ + "IMG_ASTC_2D_8x6\0" /* 68238 */ + "IMG_ASTC_2D_8x8\0" /* 68254 */ + "IMG_ASTC_2D_10x5\0" /* 68270 */ + "IMG_ASTC_2D_10x6\0" /* 68287 */ + "IMG_ASTC_2D_10x8\0" /* 68304 */ + "IMG_ASTC_2D_10x10\0" /* 68321 */ + "IMG_ASTC_2D_12x10\0" /* 68339 */ + "IMG_ASTC_2D_12x12\0" /* 68357 */ + "NUM_FORMAT_ASTC_2D\0" /* 68375 */ + "IMG_ASTC_3D_3x3x3\0" /* 68394 */ + "IMG_ASTC_3D_4x3x3\0" /* 68412 */ + "IMG_ASTC_3D_4x4x3\0" /* 68430 */ + "IMG_ASTC_3D_4x4x4\0" /* 68448 */ + "IMG_ASTC_3D_5x4x4\0" /* 68466 */ + "IMG_ASTC_3D_5x5x4\0" /* 68484 */ + "IMG_ASTC_3D_5x5x5\0" /* 68502 */ + "IMG_ASTC_3D_6x5x5\0" /* 68520 */ + "IMG_ASTC_3D_6x6x5\0" /* 68538 */ + "IMG_ASTC_3D_6x6x6\0" /* 68556 */ + "NUM_FORMAT_ASTC_3D\0" /* 68574 */ + "META_DIRECT\0" /* 68593 */ + "SW_MODE\0" /* 68605 */ + "PITCH_GFX9\0" /* 68613 */ + "BC_SWIZZLE_XYZW\0" /* 68624 */ + "BC_SWIZZLE_XWYZ\0" /* 68640 */ + "BC_SWIZZLE_WZYX\0" /* 68656 */ + "BC_SWIZZLE_WXYZ\0" /* 68672 */ + "BC_SWIZZLE_ZYXW\0" /* 68688 */ + "BC_SWIZZLE_YXWZ\0" /* 68704 */ + "BC_SWIZZLE\0" /* 68720 */ + "ARRAY_PITCH\0" /* 68731 */ + "META_DATA_ADDRESS\0" /* 68743 */ + "META_LINEAR\0" /* 68761 */ + "META_PIPE_ALIGNED\0" /* 68778, 68773 */ + "META_RB_ALIGNED\0" /* 68796, 68791 */ + "MAX_MIP\0" /* 68807 */ + "BLEND_ZERO_PRT\0" /* 68815 */ + "SKIP_DEGAMMA\0" /* 68830 */ + "TTRACE_STALL_ALL\0" /* 68843 */ + "ALLOC_ARB_LRU_ENA\0" /* 68860 */ + "EXP_ARB_LRU_ENA\0" /* 68878 */ + "PS_PKR_PRIORITY_CNTL\0" /* 68894 */ + "BATON_RESET_DISABLE\0" /* 68915 */ + "CRC_SIMD_ID_WADDR_DISABLE\0" /* 68935 */ + "LBPW_CU_CHK_MODE\0" /* 68961 */ + "LBPW_CU_CHK_CNT\0" /* 68978 */ + "CSC_PWR_SAVE_DISABLE\0" /* 68994 */ + "CSG_PWR_SAVE_DISABLE\0" /* 69015 */ + "CONTEXT_SAVE_WAIT_GDS_REQUEST_CYCLE_OVHD\0" /* 69036 */ + "CONTEXT_SAVE_WAIT_GDS_GRANT_CYCLE_OVHD\0" /* 69077 */ + "PIPE_INTERLEAVE_SIZE_GFX9\0" /* 69116 */ + "MAX_COMPRESSED_FRAGS\0" /* 69142 */ + "NUM_SHADER_ENGINES_GFX9\0" /* 69163 */ + "NUM_GPUS_GFX9\0" /* 69187 */ + "NUM_RB_PER_SE\0" /* 69201 */ + "SE_ENABLE\0" /* 69215 */ + "SIMD_DISABLE\0" /* 69225 */ + "FP16_OVFL\0" /* 69238 */ + "LOAD_COLLISION_WAVEID\0" /* 69248 */ + "LOAD_INTRAWAVE_COLLISION\0" /* 69270 */ + "SKIP_USGPR0\0" /* 69295 */ + "USER_SGPR_MSB\0" /* 69307 */ + "PC_BASE_EN\0" /* 69321 */ + "SPI_SHADER_LATE_ALLOC_GS\0" /* 69332 */ + "GS_VGPR_COMP_CNT\0" /* 69357 */ + "ES_VGPR_COMP_CNT\0" /* 69374 */ + "LS_VGPR_COMP_CNT\0" /* 69391 */ + "CNTR_SEL0\0" /* 69408 */ + "CNTR_SEL1\0" /* 69418 */ + "CNTR_MODE1\0" /* 69428 */ + "CNTR_MODE0\0" /* 69439 */ + "CNTR_SEL2\0" /* 69450 */ + "CNTR_SEL3\0" /* 69460 */ + "CNTR_MODE3\0" /* 69470 */ + "CNTR_MODE2\0" /* 69481 */ + "UTCL2_BUSY_USER_DEFINED_MASK\0" /* 69492 */ + "EA_BUSY_USER_DEFINED_MASK\0" /* 69521 */ + "RMI_BUSY_USER_DEFINED_MASK\0" /* 69547 */ + "MIPID\0" /* 69574 */ + "ALLOW_PARTIAL_RES_HIER_KILL\0" /* 69580 */ + "X_MAX\0" /* 69608 */ + "Y_MAX\0" /* 69614 */ + "PARTIALLY_RESIDENT\0" /* 69620 */ + "FAULT_BEHAVIOR\0" /* 69639 */ + "ITERATE_FLUSH\0" /* 69654 */ + "MAXMIP\0" /* 69668 */ + "FORCE_ON\0" /* 69675 */ + "PUNCHOUT_MODE\0" /* 69684 */ + "POPS_DRAIN_PS_ON_OVERLAP\0" /* 69698 */ + "DISALLOW_OVERFLOW\0" /* 69723 */ + "PS_INVOKE_MASK\0" /* 69741 */ + "DEST_BASE_HI_256B\0" /* 69756 */ + "SE_XSEL_GFX9\0" /* 69774 */ + "SE_YSEL_GFX9\0" /* 69787 */ + "SE_PAIR_XSEL_GFX9\0" /* 69800 */ + "SE_PAIR_YSEL_GFX9\0" /* 69818 */ + "NUM_SE\0" /* 69836 */ + "DISABLE_SRBSL_DB_OPTIMIZED_PACKING\0" /* 69843 */ + "PERFMON_ENABLE\0" /* 69878 */ + "LEFT_QTR\0" /* 69893 */ + "LEFT_HALF\0" /* 69902 */ + "RIGHT_HALF\0" /* 69912 */ + "RIGHT_QTR\0" /* 69923 */ + "TOP_QTR\0" /* 69933 */ + "TOP_HALF\0" /* 69941 */ + "BOT_HALF\0" /* 69950 */ + "BOT_QTR\0" /* 69959 */ + "LEFT_EYE_FOV_LEFT\0" /* 69967 */ + "LEFT_EYE_FOV_RIGHT\0" /* 69985 */ + "RIGHT_EYE_FOV_LEFT\0" /* 70004 */ + "RIGHT_EYE_FOV_RIGHT\0" /* 70023 */ + "FOV_TOP\0" /* 70043 */ + "FOV_BOT\0" /* 70051 */ + "OFFCHIP_PARAM_EN\0" /* 70059 */ + "LATE_PC_DEALLOC\0" /* 70076 */ + "BASE_ADDR_GFX9\0" /* 70092 */ + "SPRITE_EN_R6XX\0" /* 70107 */ + "UNROLLED_INST\0" /* 70122 */ + "GRBM_SKEW_NO_DEC\0" /* 70136 */ + "REG_RT_INDEX\0" /* 70153 */ + "PRIMITIVE_ORDERED_PIXEL_SHADER\0" /* 70166 */ + "EXEC_IF_OVERLAPPED\0" /* 70197 */ + "POPS_OVERLAP_NUM_SAMPLES\0" /* 70216 */ + "RIGHT_TRIANGLE_ALTERNATE_GRADIENT_REF\0" /* 70241 */ + "NEW_QUAD_DECOMPOSITION\0" /* 70279 */ + "PERFCOUNTER_REF\0" /* 70302 */ + "USE_VTX_SHD_OBJPRIM_ID\0" /* 70318 */ + "SRBSL_ENABLE\0" /* 70341 */ + "OBJ_ID_SEL\0" /* 70354 */ + "ADD_PIPED_PRIM_ID\0" /* 70365 */ + "EN_32BIT_OBJPRIMID\0" /* 70383 */ + "VERTEX_REUSE_OFF\0" /* 70402 */ + "INDEX_BUF_EDGE_FLAG_ENA\0" /* 70419 */ + "DISCARD_0_AREA_TRIANGLES\0" /* 70443 */ + "DISCARD_0_AREA_LINES\0" /* 70468 */ + "DISCARD_0_AREA_POINTS\0" /* 70489 */ + "DISCARD_0_AREA_RECTANGLES\0" /* 70511 */ + "USE_PROVOKING_ZW\0" /* 70537 */ + "RESERVED_3\0" /* 70554 */ + "RESERVED_4\0" /* 70565 */ + "RESERVED_5\0" /* 70576 */ + "GS_INST_PRIMS_IN_SUBGRP\0" /* 70587 */ + "SCALE_LINE_WIDTH_PAD\0" /* 70611 */ + "ALTERNATE_RBS_PER_TILE\0" /* 70632 */ + "COARSE_TILE_STARTS_ON_EVEN_RB\0" /* 70655 */ + "NGG_DISABLE_PROVOK_REUSE\0" /* 70685 */ + "BREAK_BATCH\0" /* 70710 */ + "FLUSH_DFSM\0" /* 70722 */ + "RESET_TO_LOWEST_VGT\0" /* 70733 */ + "TGID_ROLLOVER\0" /* 70753 */ + "ENABLE_NGG_PIPELINE\0" /* 70767 */ + "ENABLE_LEGACY_PIPELINE\0" /* 70787 */ + "ADDRESS_HI_GFX9\0" /* 70810 */ + "OBJPRIM_ID_EN\0" /* 70826 */ + "EN_REG_RT_INDEX\0" /* 70840 */ + "EN_PIPELINE_PRIMID\0" /* 70856 */ + "OBJECT_ID_INST_EN\0" /* 70875 */ + "COMPOUND_INDEX_EN\0" /* 70893 */ + "ORDERED_ID_MODE\0" /* 70911 */ + "GS_FAST_LAUNCH\0" /* 70927 */ + "EN_PRIMS_NEEDED_CNT\0" /* 70942 */ + "COVERAGE_TO_SHADER_SELECT\0" /* 70962 */ + "BINNING_ALLOWED\0" /* 70988 */ + "FORCE_BINNING_ON\0" /* 71004 */ + "DISABLE_BINNING_USE_NEW_SC\0" /* 71021 */ + "DISABLE_BINNING_USE_LEGACY_SC\0" /* 71048 */ + "BINNING_MODE\0" /* 71078 */ + "BIN_SIZE_X\0" /* 71091 */ + "BIN_SIZE_Y\0" /* 71102 */ + "BIN_SIZE_X_EXTEND\0" /* 71113 */ + "BIN_SIZE_Y_EXTEND\0" /* 71131 */ + "CONTEXT_STATES_PER_BIN\0" /* 71149 */ + "PERSISTENT_STATES_PER_BIN\0" /* 71172 */ + "DISABLE_START_OF_PRIM\0" /* 71198 */ + "FPOVS_PER_BATCH\0" /* 71220 */ + "OPTIMAL_BIN_SELECTION\0" /* 71236 */ + "MAX_ALLOC_COUNT\0" /* 71258 */ + "MAX_PRIM_PER_BATCH\0" /* 71274 */ + "OVER_RAST_ENABLE\0" /* 71293 */ + "OVER_RAST_SAMPLE_SELECT\0" /* 71310 */ + "UNDER_RAST_ENABLE\0" /* 71334 */ + "UNDER_RAST_SAMPLE_SELECT\0" /* 71352 */ + "PBB_UNCERTAINTY_REGION_ENABLE\0" /* 71377 */ + "ZMM_TRI_EXTENT\0" /* 71407 */ + "ZMM_TRI_OFFSET\0" /* 71422 */ + "OVERRIDE_OVER_RAST_INNER_TO_NORMAL\0" /* 71437 */ + "OVERRIDE_UNDER_RAST_INNER_TO_NORMAL\0" /* 71472 */ + "DEGENERATE_OVERRIDE_INNER_TO_NORMAL_DISABLE\0" /* 71508 */ + "UNCERTAINTY_REGION_MODE\0" /* 71552 */ + "OUTER_UNCERTAINTY_EDGERULE_OVERRIDE\0" /* 71576 */ + "INNER_UNCERTAINTY_EDGERULE_OVERRIDE\0" /* 71612 */ + "NULL_SQUAD_AA_MASK_ENABLE\0" /* 71648 */ + "COVERAGE_AA_MASK_ENABLE\0" /* 71674 */ + "PREZ_AA_MASK_ENABLE\0" /* 71698 */ + "POSTZ_AA_MASK_ENABLE\0" /* 71718 */ + "CENTROID_SAMPLE_OVERRIDE\0" /* 71739 */ + "MAX_DEALLOCS_IN_WAVE\0" /* 71764 */ + "BASE_256B\0" /* 71785 */ + "MIP0_HEIGHT\0" /* 71795 */ + "MIP0_WIDTH\0" /* 71807 */ + "MIP_LEVEL\0" /* 71818 */ + "MIP0_DEPTH\0" /* 71828 */ + "COLOR_SW_MODE\0" /* 71839 */ + "FMASK_SW_MODE\0" /* 71853 */ + "RESOURCE_TYPE\0" /* 71867 */; static const int sid_strings_offsets[] = { /* 0 */ 509, 31780, 1768, 15296, @@ -9258,50 +9246,50 @@ /* 886 */ 56877, 56888, 56898, 56909, 56921, 56934, 56948, 56960, /* 894 */ 56988, 56998, 57007, 57017, 57028, 57040, 57053, 57064, /* 902 */ 57485, 57496, 57506, 57530, -1, 57541, 57561, - /* 909 */ 57579, -1, -1, -1, -1, 57586, -1, -1, -1, -1, 57593, -1, -1, -1, -1, 57600, -1, 57607, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57614, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57621, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57628, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57635, -1, -1, -1, -1, 57642, -1, -1, -1, -1, 57649, -1, -1, -1, -1, 57656, -1, -1, -1, -1, -1, -1, 57663, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57670, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57677, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57684, -1, -1, -1, -1, -1, -1, 57691, -1, -1, -1, -1, 57698, -1, -1, -1, -1, 57705, -1, -1, -1, -1, 57712, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57719, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57726, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57733, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57740, -1, 57747, -1, -1, -1, -1, 57754, -1, -1, -1, -1, 57761, -1, -1, -1, -1, 57768, - /* 1165 */ 57851, 57858, 57878, 57883, - /* 1169 */ 58029, 58042, 58061, 58083, - /* 1173 */ 58464, 58484, - /* 1175 */ 58496, 58510, 58523, - /* 1178 */ 60045, 60067, 60087, 60108, 60129, - /* 1183 */ 60172, 60189, 60205, 60220, 60236, 60252, 60276, 60300, 60324, 60348, 60369, 60385, 60400, 60424, 60447, 60471, 60491, 60510, - /* 1201 */ 60553, 60566, 60580, 60592, 60605, - /* 1206 */ 60678, 60695, 60712, 60728, 60744, 60760, 60776, 60793, 60811, - /* 1215 */ 60874, 60881, 60895, 60909, 60923, 60937, - /* 1221 */ 60947, 60959, 60970, 60981, - /* 1225 */ 61153, -1, -1, 61168, - /* 1229 */ 61807, 61830, 61853, - /* 1232 */ 61956, 61969, 61982, - /* 1235 */ 61994, 62012, 62032, 62052, - /* 1239 */ 62080, 62096, 62113, - /* 1242 */ 62140, 62155, - /* 1244 */ -1, 62233, 62256, 62279, 62302, 62317, 62330, 62342, 62359, -1, 62378, 62398, 62418, 62437, -1, 62449, 62466, 62483, 62499, -1, 62515, 62544, 62555, 62581, 62599, 62616, 62635, 62653, 62672, 62688, 62704, 62724, 62746, 62768, 62782, 62801, 62817, -1, -1, 62827, 62842, -1, 62860, 62883, 62908, 62930, 62955, 38562, 38589, 62977, -1, 63005, 63024, 63042, 63062, 63081, 63101, 63125, 63146, - /* 1303 */ 63589, 63602, 63614, - /* 1306 */ 63626, 63639, 63651, - /* 1309 */ 63665, 63679, 63691, - /* 1312 */ 63822, 63835, 63849, - /* 1315 */ 63859, 63872, 63882, 63896, - /* 1319 */ 63924, 63937, 63949, 63968, - /* 1323 */ 62140, 62155, 64065, - /* 1326 */ 64083, 64109, 64135, 64160, - /* 1330 */ 64939, 64950, 64958, 64974, - /* 1334 */ 65000, 65026, 65051, 65076, 65099, 65120, 65147, 65176, - /* 1342 */ 65513, 65525, 65538, 65551, - /* 1346 */ 65571, 65585, 65593, 65602, 65612, 65621, 65633, 65648, 65663, 65680, 65697, 65711, 65723, -1, 65741, -1, 65759, 65771, 65785, 65799, 65813, 65824, 65835, - /* 1369 */ 65856, 65869, -1, -1, 65882, 65894, 65906, 65918, - /* 1377 */ 65943, 65952, 65961, 65974, - /* 1381 */ 66051, 66066, 66084, 66112, 66142, 66173, 66201, 66231, - /* 1389 */ 66476, 66495, 66515, - /* 1392 */ 66563, 66582, - /* 1394 */ 40211, 40235, 40253, 40272, 40292, 40311, 40333, 40358, 40383, 40410, 40437, 40461, 40483, 40511, 40536, 40564, 40592, 40614, 40638, 40662, 40686, 40707, 40728, 40753, 40782, 40807, 40833, 40856, 40880, 40907, 40935, 67220, 40991, 41013, 41035, 41059, 41079, 41099, 41119, 41139, 41159, 41179, 67240, 67268, 67307, 67346, 67368, 67396, 67424, 67457, 67485, 67513, 67546, 67570, 67597, 67630, 67669, 41665, 41685, 67697, 67719, 67741, 67765, 41802, - /* 1458 */ 41853, 41874, 41895, 41918, 41941, 41961, 67809, 42006, 67835, 42053, 67859, - /* 1469 */ 67901, 67917, 67933, 67949, 67965, 67981, 67997, 68015, 68032, 68050, 68067, 68084, 68102, - /* 1482 */ 68137, 68153, 68169, 68185, 68201, 68217, 68233, 68249, 68265, 68282, 68299, 68316, 68334, 68352, - /* 1496 */ 68389, 68407, 68425, 68443, 68461, 68479, 68497, 68515, 68533, 68551, - /* 1506 */ 68619, 68635, 68651, 68667, 68683, 68699, - /* 1512 */ 245, 69670, 48894, 8050, - /* 1516 */ -1, 62233, 62256, 62279, 62302, 62317, 62330, 62342, 62359, -1, 62378, 62398, 62418, 62437, 70705, 62449, 62466, 62483, 70717, 70728, 62515, 62544, 62555, 62581, 62599, 62616, 62635, 62653, -1, -1, 62704, 62724, 62746, 62768, 62782, 62801, 62817, 70748, -1, 62827, 62842, -1, 62860, 62883, 62908, 62930, 62955, 38562, 38589, 62977, -1, 63005, 63024, 63042, 63062, 63081, 63101, 63125, 63146, -1, -1, 70762, 70782, - /* 1579 */ 70983, 70999, 71016, 71043, + /* 909 */ 57579, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57590, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57599, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57617, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57636, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57653, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57665, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57674, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57684, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57693, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57709, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57720, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57737, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57747, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57763, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 57771, + /* 1165 */ 57856, 57863, 57883, 57888, + /* 1169 */ 58034, 58047, 58066, 58088, + /* 1173 */ 58469, 58489, + /* 1175 */ 58501, 58515, 58528, + /* 1178 */ 60050, 60072, 60092, 60113, 60134, + /* 1183 */ 60177, 60194, 60210, 60225, 60241, 60257, 60281, 60305, 60329, 60353, 60374, 60390, 60405, 60429, 60452, 60476, 60496, 60515, + /* 1201 */ 60558, 60571, 60585, 60597, 60610, + /* 1206 */ 60683, 60700, 60717, 60733, 60749, 60765, 60781, 60798, 60816, + /* 1215 */ 60879, 60886, 60900, 60914, 60928, 60942, + /* 1221 */ 60952, 60964, 60975, 60986, + /* 1225 */ 61158, -1, -1, 61173, + /* 1229 */ 61812, 61835, 61858, + /* 1232 */ 61961, 61974, 61987, + /* 1235 */ 61999, 62017, 62037, 62057, + /* 1239 */ 62085, 62101, 62118, + /* 1242 */ 62145, 62160, + /* 1244 */ -1, 62238, 62261, 62284, 62307, 62322, 62335, 62347, 62364, -1, 62383, 62403, 62423, 62442, -1, 62454, 62471, 62488, 62504, -1, 62520, 62549, 62560, 62586, 62604, 62621, 62640, 62658, 62677, 62693, 62709, 62729, 62751, 62773, 62787, 62806, 62822, -1, -1, 62832, 62847, -1, 62865, 62888, 62913, 62935, 62960, 38562, 38589, 62982, -1, 63010, 63029, 63047, 63067, 63086, 63106, 63130, 63151, + /* 1303 */ 63594, 63607, 63619, + /* 1306 */ 63631, 63644, 63656, + /* 1309 */ 63670, 63684, 63696, + /* 1312 */ 63827, 63840, 63854, + /* 1315 */ 63864, 63877, 63887, 63901, + /* 1319 */ 63929, 63942, 63954, 63973, + /* 1323 */ 62145, 62160, 64070, + /* 1326 */ 64088, 64114, 64140, 64165, + /* 1330 */ 64944, 64955, 64963, 64979, + /* 1334 */ 65005, 65031, 65056, 65081, 65104, 65125, 65152, 65181, + /* 1342 */ 65518, 65530, 65543, 65556, + /* 1346 */ 65576, 65590, 65598, 65607, 65617, 65626, 65638, 65653, 65668, 65685, 65702, 65716, 65728, -1, 65746, -1, 65764, 65776, 65790, 65804, 65818, 65829, 65840, + /* 1369 */ 65861, 65874, -1, -1, 65887, 65899, 65911, 65923, + /* 1377 */ 65948, 65957, 65966, 65979, + /* 1381 */ 66056, 66071, 66089, 66117, 66147, 66178, 66206, 66236, + /* 1389 */ 66481, 66500, 66520, + /* 1392 */ 66568, 66587, + /* 1394 */ 40211, 40235, 40253, 40272, 40292, 40311, 40333, 40358, 40383, 40410, 40437, 40461, 40483, 40511, 40536, 40564, 40592, 40614, 40638, 40662, 40686, 40707, 40728, 40753, 40782, 40807, 40833, 40856, 40880, 40907, 40935, 67225, 40991, 41013, 41035, 41059, 41079, 41099, 41119, 41139, 41159, 41179, 67245, 67273, 67312, 67351, 67373, 67401, 67429, 67462, 67490, 67518, 67551, 67575, 67602, 67635, 67674, 41665, 41685, 67702, 67724, 67746, 67770, 41802, + /* 1458 */ 41853, 41874, 41895, 41918, 41941, 41961, 67814, 42006, 67840, 42053, 67864, + /* 1469 */ 67906, 67922, 67938, 67954, 67970, 67986, 68002, 68020, 68037, 68055, 68072, 68089, 68107, + /* 1482 */ 68142, 68158, 68174, 68190, 68206, 68222, 68238, 68254, 68270, 68287, 68304, 68321, 68339, 68357, + /* 1496 */ 68394, 68412, 68430, 68448, 68466, 68484, 68502, 68520, 68538, 68556, + /* 1506 */ 68624, 68640, 68656, 68672, 68688, 68704, + /* 1512 */ 245, 69675, 48894, 8050, + /* 1516 */ -1, 62238, 62261, 62284, 62307, 62322, 62335, 62347, 62364, -1, 62383, 62403, 62423, 62442, 70710, 62454, 62471, 62488, 70722, 70733, 62520, 62549, 62560, 62586, 62604, 62621, 62640, 62658, -1, -1, 62709, 62729, 62751, 62773, 62787, 62806, 62822, 70753, -1, 62832, 62847, -1, 62865, 62888, 62913, 62935, 62960, 38562, 38589, 62982, -1, 63010, 63029, 63047, 63067, 63086, 63106, 63130, 63151, -1, -1, 70767, 70787, + /* 1579 */ 70988, 71004, 71021, 71048, /* 1583 */ 42477, 42492, 42507, 8050, }; diff -Nru mesa-18.1.0/src/amd/Makefile.addrlib.am mesa-18.1.1/src/amd/Makefile.addrlib.am --- mesa-18.1.0/src/amd/Makefile.addrlib.am 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/amd/Makefile.addrlib.am 2018-06-01 15:18:20.000000000 +0000 @@ -22,6 +22,7 @@ ADDRLIB_LIBS = addrlib/libamdgpu_addrlib.la addrlib_libamdgpu_addrlib_la_CPPFLAGS = \ + $(DEFINES) \ -I$(top_srcdir)/src/ \ -I$(srcdir)/common \ -I$(srcdir)/addrlib \ diff -Nru mesa-18.1.0/src/amd/Makefile.in mesa-18.1.1/src/amd/Makefile.in --- mesa-18.1.0/src/amd/Makefile.in 2018-05-18 23:28:50.000000000 +0000 +++ mesa-18.1.1/src/amd/Makefile.in 2018-06-01 15:18:29.000000000 +0000 @@ -689,6 +689,7 @@ noinst_LTLIBRARIES = $(ADDRLIB_LIBS) $(am__append_1) ADDRLIB_LIBS = addrlib/libamdgpu_addrlib.la addrlib_libamdgpu_addrlib_la_CPPFLAGS = \ + $(DEFINES) \ -I$(top_srcdir)/src/ \ -I$(srcdir)/common \ -I$(srcdir)/addrlib \ diff -Nru mesa-18.1.0/src/amd/vulkan/radv_device.c mesa-18.1.1/src/amd/vulkan/radv_device.c --- mesa-18.1.0/src/amd/vulkan/radv_device.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/amd/vulkan/radv_device.c 2018-06-01 15:18:21.000000000 +0000 @@ -736,7 +736,7 @@ } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: { VkPhysicalDeviceDescriptorIndexingFeaturesEXT *features = - (VkPhysicalDeviceDescriptorIndexingFeaturesEXT*)features; + (VkPhysicalDeviceDescriptorIndexingFeaturesEXT*)ext; features->shaderInputAttachmentArrayDynamicIndexing = true; features->shaderUniformTexelBufferArrayDynamicIndexing = true; features->shaderStorageTexelBufferArrayDynamicIndexing = true; @@ -968,9 +968,12 @@ VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT | - VK_SUBGROUP_FEATURE_SHUFFLE_BIT | - VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT; + if (pdevice->rad_info.chip_class >= VI) { + properties->supportedOperations |= + VK_SUBGROUP_FEATURE_SHUFFLE_BIT | + VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT; + } properties->quadOperationsInAllStages = true; break; } diff -Nru mesa-18.1.0/src/amd/vulkan/radv_formats.c mesa-18.1.1/src/amd/vulkan/radv_formats.c --- mesa-18.1.0/src/amd/vulkan/radv_formats.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/amd/vulkan/radv_formats.c 2018-06-01 15:18:21.000000000 +0000 @@ -655,6 +655,25 @@ tiled |= VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT; } + switch(format) { + case VK_FORMAT_A2R10G10B10_SNORM_PACK32: + case VK_FORMAT_A2B10G10R10_SNORM_PACK32: + case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: + case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: + case VK_FORMAT_A2R10G10B10_SINT_PACK32: + case VK_FORMAT_A2B10G10R10_SINT_PACK32: + if (physical_device->rad_info.chip_class <= VI && + physical_device->rad_info.family != CHIP_STONEY) { + buffer &= ~(VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT); + linear = 0; + tiled = 0; + } + break; + default: + break; + } + out_properties->linearTilingFeatures = linear; out_properties->optimalTilingFeatures = tiled; out_properties->bufferFeatures = buffer; diff -Nru mesa-18.1.0/src/amd/vulkan/radv_meta_copy.c mesa-18.1.1/src/amd/vulkan/radv_meta_copy.c --- mesa-18.1.0/src/amd/vulkan/radv_meta_copy.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/amd/vulkan/radv_meta_copy.c 2018-06-01 15:18:21.000000000 +0000 @@ -93,6 +93,8 @@ !(radv_image_is_tc_compat_htile(image))) format = vk_format_for_size(vk_format_get_blocksize(format)); + format = vk_format_no_srgb(format); + return (struct radv_meta_blit2d_surf) { .format = format, .bs = vk_format_get_blocksize(format), diff -Nru mesa-18.1.0/src/amd/vulkan/radv_meta_resolve.c mesa-18.1.1/src/amd/vulkan/radv_meta_resolve.c --- mesa-18.1.0/src/amd/vulkan/radv_meta_resolve.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/amd/vulkan/radv_meta_resolve.c 2018-06-01 15:18:21.000000000 +0000 @@ -358,6 +358,8 @@ *method = RESOLVE_COMPUTE; else if (vk_format_is_int(src_image->vk_format)) *method = RESOLVE_COMPUTE; + else if (src_image->info.array_size > 1) + *method = RESOLVE_COMPUTE; if (radv_layout_dcc_compressed(dest_image, dest_image_layout, queue_mask)) { *method = RESOLVE_FRAGMENT; @@ -695,7 +697,7 @@ VkImageResolve region = {}; region.srcSubresource.baseArrayLayer = 0; region.srcSubresource.mipLevel = 0; - region.srcSubresource.layerCount = 1; + region.srcSubresource.layerCount = src_image->info.array_size; radv_decompress_resolve_src(cmd_buffer, src_image, src_att.layout, 1, ®ion); diff -Nru mesa-18.1.0/src/amd/vulkan/radv_meta_resolve_cs.c mesa-18.1.1/src/amd/vulkan/radv_meta_resolve_cs.c --- mesa-18.1.0/src/amd/vulkan/radv_meta_resolve_cs.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/amd/vulkan/radv_meta_resolve_cs.c 2018-06-01 15:18:21.000000000 +0000 @@ -508,12 +508,48 @@ if (dest_att.attachment == VK_ATTACHMENT_UNUSED) continue; - emit_resolve(cmd_buffer, - src_iview, - dst_iview, - &(VkOffset2D) { 0, 0 }, - &(VkOffset2D) { 0, 0 }, - &(VkExtent2D) { fb->width, fb->height }); + struct radv_image *src_image = src_iview->image; + struct radv_image *dst_image = dst_iview->image; + for (uint32_t layer = 0; layer < src_image->info.array_size; layer++) { + + struct radv_image_view tsrc_iview; + radv_image_view_init(&tsrc_iview, cmd_buffer->device, + &(VkImageViewCreateInfo) { + .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, + .image = radv_image_to_handle(src_image), + .viewType = radv_meta_get_view_type(src_image), + .format = src_image->vk_format, + .subresourceRange = { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = src_iview->base_mip, + .levelCount = 1, + .baseArrayLayer = layer, + .layerCount = 1, + }, + }); + + struct radv_image_view tdst_iview; + radv_image_view_init(&tdst_iview, cmd_buffer->device, + &(VkImageViewCreateInfo) { + .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, + .image = radv_image_to_handle(dst_image), + .viewType = radv_meta_get_view_type(dst_image), + .format = vk_to_non_srgb_format(dst_image->vk_format), + .subresourceRange = { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = dst_iview->base_mip, + .levelCount = 1, + .baseArrayLayer = layer, + .layerCount = 1, + }, + }); + emit_resolve(cmd_buffer, + &tsrc_iview, + &tdst_iview, + &(VkOffset2D) { 0, 0 }, + &(VkOffset2D) { 0, 0 }, + &(VkExtent2D) { fb->width, fb->height }); + } } cmd_buffer->state.flush_bits |= RADV_CMD_FLAG_CS_PARTIAL_FLUSH | diff -Nru mesa-18.1.0/src/amd/vulkan/radv_nir_to_llvm.c mesa-18.1.1/src/amd/vulkan/radv_nir_to_llvm.c --- mesa-18.1.0/src/amd/vulkan/radv_nir_to_llvm.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/amd/vulkan/radv_nir_to_llvm.c 2018-06-01 15:18:21.000000000 +0000 @@ -1773,6 +1773,47 @@ return ac_build_load_to_sgpr(&ctx->ac, list, index); } +/* For 2_10_10_10 formats the alpha is handled as unsigned by pre-vega HW. + * so we may need to fix it up. */ +static LLVMValueRef +adjust_vertex_fetch_alpha(struct radv_shader_context *ctx, + unsigned adjustment, + LLVMValueRef alpha) +{ + if (adjustment == RADV_ALPHA_ADJUST_NONE) + return alpha; + + LLVMValueRef c30 = LLVMConstInt(ctx->ac.i32, 30, 0); + + if (adjustment == RADV_ALPHA_ADJUST_SSCALED) + alpha = LLVMBuildFPToUI(ctx->ac.builder, alpha, ctx->ac.i32, ""); + else + alpha = ac_to_integer(&ctx->ac, alpha); + + /* For the integer-like cases, do a natural sign extension. + * + * For the SNORM case, the values are 0.0, 0.333, 0.666, 1.0 + * and happen to contain 0, 1, 2, 3 as the two LSBs of the + * exponent. + */ + alpha = LLVMBuildShl(ctx->ac.builder, alpha, + adjustment == RADV_ALPHA_ADJUST_SNORM ? + LLVMConstInt(ctx->ac.i32, 7, 0) : c30, ""); + alpha = LLVMBuildAShr(ctx->ac.builder, alpha, c30, ""); + + /* Convert back to the right type. */ + if (adjustment == RADV_ALPHA_ADJUST_SNORM) { + LLVMValueRef clamp; + LLVMValueRef neg_one = LLVMConstReal(ctx->ac.f32, -1.0); + alpha = LLVMBuildSIToFP(ctx->ac.builder, alpha, ctx->ac.f32, ""); + clamp = LLVMBuildFCmp(ctx->ac.builder, LLVMRealULT, alpha, neg_one, ""); + alpha = LLVMBuildSelect(ctx->ac.builder, clamp, neg_one, alpha, ""); + } else if (adjustment == RADV_ALPHA_ADJUST_SSCALED) { + alpha = LLVMBuildSIToFP(ctx->ac.builder, alpha, ctx->ac.f32, ""); + } + + return alpha; +} static void handle_vs_input_decl(struct radv_shader_context *ctx, @@ -1783,18 +1824,19 @@ LLVMValueRef t_list; LLVMValueRef input; LLVMValueRef buffer_index; - int index = variable->data.location - VERT_ATTRIB_GENERIC0; - int idx = variable->data.location; unsigned attrib_count = glsl_count_attribute_slots(variable->type, true); uint8_t input_usage_mask = ctx->shader_info->info.vs.input_usage_mask[variable->data.location]; unsigned num_channels = util_last_bit(input_usage_mask); - variable->data.driver_location = idx * 4; + variable->data.driver_location = variable->data.location * 4; - for (unsigned i = 0; i < attrib_count; ++i, ++idx) { - if (ctx->options->key.vs.instance_rate_inputs & (1u << (index + i))) { - uint32_t divisor = ctx->options->key.vs.instance_rate_divisors[index + i]; + for (unsigned i = 0; i < attrib_count; ++i) { + LLVMValueRef output[4]; + unsigned attrib_index = variable->data.location + i - VERT_ATTRIB_GENERIC0; + + if (ctx->options->key.vs.instance_rate_inputs & (1u << attrib_index)) { + uint32_t divisor = ctx->options->key.vs.instance_rate_divisors[attrib_index]; if (divisor) { buffer_index = LLVMBuildAdd(ctx->ac.builder, ctx->abi.instance_id, @@ -1818,7 +1860,7 @@ } else buffer_index = LLVMBuildAdd(ctx->ac.builder, ctx->abi.vertex_id, ctx->abi.base_vertex, ""); - t_offset = LLVMConstInt(ctx->ac.i32, index + i, false); + t_offset = LLVMConstInt(ctx->ac.i32, attrib_index, false); t_list = ac_build_load_to_sgpr(&ctx->ac, t_list_ptr, t_offset); @@ -1831,9 +1873,15 @@ for (unsigned chan = 0; chan < 4; chan++) { LLVMValueRef llvm_chan = LLVMConstInt(ctx->ac.i32, chan, false); - ctx->inputs[ac_llvm_reg_index_soa(idx, chan)] = - ac_to_integer(&ctx->ac, LLVMBuildExtractElement(ctx->ac.builder, - input, llvm_chan, "")); + output[chan] = LLVMBuildExtractElement(ctx->ac.builder, input, llvm_chan, ""); + } + + unsigned alpha_adjust = (ctx->options->key.vs.alpha_adjust >> (attrib_index * 2)) & 3; + output[3] = adjust_vertex_fetch_alpha(ctx, alpha_adjust, output[3]); + + for (unsigned chan = 0; chan < 4; chan++) { + ctx->inputs[ac_llvm_reg_index_soa(variable->data.location + i, chan)] = + ac_to_integer(&ctx->ac, output[chan]); } } } @@ -1929,9 +1977,6 @@ prepare_interp_optimize(struct radv_shader_context *ctx, struct nir_shader *nir) { - if (!ctx->options->key.fs.multisample) - return; - bool uses_center = false; bool uses_centroid = false; nir_foreach_variable(variable, &nir->inputs) { diff -Nru mesa-18.1.0/src/amd/vulkan/radv_pipeline.c mesa-18.1.1/src/amd/vulkan/radv_pipeline.c --- mesa-18.1.0/src/amd/vulkan/radv_pipeline.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/amd/vulkan/radv_pipeline.c 2018-06-01 15:18:21.000000000 +0000 @@ -181,6 +181,47 @@ return VK_SUCCESS; } +static uint32_t si_translate_blend_logic_op(VkLogicOp op) +{ + switch (op) { + case VK_LOGIC_OP_CLEAR: + return V_028808_ROP3_CLEAR; + case VK_LOGIC_OP_AND: + return V_028808_ROP3_AND; + case VK_LOGIC_OP_AND_REVERSE: + return V_028808_ROP3_AND_REVERSE; + case VK_LOGIC_OP_COPY: + return V_028808_ROP3_COPY; + case VK_LOGIC_OP_AND_INVERTED: + return V_028808_ROP3_AND_INVERTED; + case VK_LOGIC_OP_NO_OP: + return V_028808_ROP3_NO_OP; + case VK_LOGIC_OP_XOR: + return V_028808_ROP3_XOR; + case VK_LOGIC_OP_OR: + return V_028808_ROP3_OR; + case VK_LOGIC_OP_NOR: + return V_028808_ROP3_NOR; + case VK_LOGIC_OP_EQUIVALENT: + return V_028808_ROP3_EQUIVALENT; + case VK_LOGIC_OP_INVERT: + return V_028808_ROP3_INVERT; + case VK_LOGIC_OP_OR_REVERSE: + return V_028808_ROP3_OR_REVERSE; + case VK_LOGIC_OP_COPY_INVERTED: + return V_028808_ROP3_COPY_INVERTED; + case VK_LOGIC_OP_OR_INVERTED: + return V_028808_ROP3_OR_INVERTED; + case VK_LOGIC_OP_NAND: + return V_028808_ROP3_NAND; + case VK_LOGIC_OP_SET: + return V_028808_ROP3_SET; + default: + unreachable("Unhandled logic op"); + } +} + + static uint32_t si_translate_blend_function(VkBlendOp op) { switch (op) { @@ -600,9 +641,9 @@ } blend.cb_color_control = 0; if (vkblend->logicOpEnable) - blend.cb_color_control |= S_028808_ROP3(vkblend->logicOp | (vkblend->logicOp << 4)); + blend.cb_color_control |= S_028808_ROP3(si_translate_blend_logic_op(vkblend->logicOp)); else - blend.cb_color_control |= S_028808_ROP3(0xcc); + blend.cb_color_control |= S_028808_ROP3(V_028808_ROP3_COPY); blend.db_alpha_to_mask = S_028B70_ALPHA_TO_MASK_OFFSET0(2) | S_028B70_ALPHA_TO_MASK_OFFSET1(2) | @@ -1769,13 +1810,36 @@ } for (unsigned i = 0; i < input_state->vertexAttributeDescriptionCount; ++i) { - unsigned binding; - binding = input_state->pVertexAttributeDescriptions[i].binding; + unsigned location = input_state->pVertexAttributeDescriptions[i].location; + unsigned binding = input_state->pVertexAttributeDescriptions[i].binding; if (binding_input_rate & (1u << binding)) { - unsigned location = input_state->pVertexAttributeDescriptions[i].location; key.instance_rate_inputs |= 1u << location; key.instance_rate_divisors[location] = instance_rate_divisors[binding]; } + + if (pipeline->device->physical_device->rad_info.chip_class <= VI && + pipeline->device->physical_device->rad_info.family != CHIP_STONEY) { + VkFormat format = input_state->pVertexAttributeDescriptions[i].format; + uint64_t adjust; + switch(format) { + case VK_FORMAT_A2R10G10B10_SNORM_PACK32: + case VK_FORMAT_A2B10G10R10_SNORM_PACK32: + adjust = RADV_ALPHA_ADJUST_SNORM; + break; + case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: + case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: + adjust = RADV_ALPHA_ADJUST_SSCALED; + break; + case VK_FORMAT_A2R10G10B10_SINT_PACK32: + case VK_FORMAT_A2B10G10R10_SINT_PACK32: + adjust = RADV_ALPHA_ADJUST_SINT; + break; + default: + adjust = 0; + break; + } + key.vertex_alpha_adjust |= adjust << (2 * location); + } } if (pCreateInfo->pTessellationState) @@ -1804,6 +1868,7 @@ nir_shader **nir) { keys[MESA_SHADER_VERTEX].vs.instance_rate_inputs = key->instance_rate_inputs; + keys[MESA_SHADER_VERTEX].vs.alpha_adjust = key->vertex_alpha_adjust; for (unsigned i = 0; i < MAX_VERTEX_ATTRIBS; ++i) keys[MESA_SHADER_VERTEX].vs.instance_rate_divisors[i] = key->instance_rate_divisors[i]; diff -Nru mesa-18.1.0/src/amd/vulkan/radv_private.h mesa-18.1.1/src/amd/vulkan/radv_private.h --- mesa-18.1.0/src/amd/vulkan/radv_private.h 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/amd/vulkan/radv_private.h 2018-06-01 15:18:21.000000000 +0000 @@ -352,6 +352,7 @@ struct radv_pipeline_key { uint32_t instance_rate_inputs; uint32_t instance_rate_divisors[MAX_VERTEX_ATTRIBS]; + uint64_t vertex_alpha_adjust; unsigned tess_input_vertices; uint32_t col_format; uint32_t is_int8; diff -Nru mesa-18.1.0/src/amd/vulkan/radv_query.c mesa-18.1.1/src/amd/vulkan/radv_query.c --- mesa-18.1.0/src/amd/vulkan/radv_query.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/amd/vulkan/radv_query.c 2018-06-01 15:18:21.000000000 +0000 @@ -1204,25 +1204,6 @@ va += pool->stride * query; emit_begin_query(cmd_buffer, va, pool->type, flags); - - /* - * For multiview we have to emit a query for each bit in the mask, - * however the first query we emit will get the totals for all the - * operations, so we don't want to get a real value in the other - * queries. This emits a fake begin/end sequence so the waiting - * code gets a completed query value and doesn't hang, but the - * query returns 0. - */ - if (cmd_buffer->state.subpass && cmd_buffer->state.subpass->view_mask) { - uint64_t avail_va = va + pool->availability_offset + 4 * query; - - for (unsigned i = 0; i < util_bitcount(cmd_buffer->state.subpass->view_mask); i++) { - va += pool->stride; - avail_va += 4; - emit_begin_query(cmd_buffer, va, pool->type, flags); - emit_end_query(cmd_buffer, va, avail_va, pool->type); - } - } } @@ -1241,6 +1222,26 @@ * currently be active, which means the BO is already in the list. */ emit_end_query(cmd_buffer, va, avail_va, pool->type); + + /* + * For multiview we have to emit a query for each bit in the mask, + * however the first query we emit will get the totals for all the + * operations, so we don't want to get a real value in the other + * queries. This emits a fake begin/end sequence so the waiting + * code gets a completed query value and doesn't hang, but the + * query returns 0. + */ + if (cmd_buffer->state.subpass && cmd_buffer->state.subpass->view_mask) { + uint64_t avail_va = va + pool->availability_offset + 4 * query; + + + for (unsigned i = 1; i < util_bitcount(cmd_buffer->state.subpass->view_mask); i++) { + va += pool->stride; + avail_va += 4; + emit_begin_query(cmd_buffer, va, pool->type, 0); + emit_end_query(cmd_buffer, va, avail_va, pool->type); + } + } } void radv_CmdWriteTimestamp( diff -Nru mesa-18.1.0/src/amd/vulkan/radv_shader.h mesa-18.1.1/src/amd/vulkan/radv_shader.h --- mesa-18.1.0/src/amd/vulkan/radv_shader.h 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/amd/vulkan/radv_shader.h 2018-06-01 15:18:21.000000000 +0000 @@ -55,9 +55,21 @@ char data[0]; }; +enum { + RADV_ALPHA_ADJUST_NONE = 0, + RADV_ALPHA_ADJUST_SNORM = 1, + RADV_ALPHA_ADJUST_SINT = 2, + RADV_ALPHA_ADJUST_SSCALED = 3, +}; + struct radv_vs_variant_key { uint32_t instance_rate_inputs; uint32_t instance_rate_divisors[MAX_VERTEX_ATTRIBS]; + + /* For 2_10_10_10 formats the alpha is handled as unsigned by pre-vega HW. + * so we may need to fix it up. */ + uint64_t alpha_adjust; + uint32_t as_es:1; uint32_t as_ls:1; uint32_t export_prim_id:1; diff -Nru mesa-18.1.0/src/amd/vulkan/vk_format.h mesa-18.1.1/src/amd/vulkan/vk_format.h --- mesa-18.1.0/src/amd/vulkan/vk_format.h 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/amd/vulkan/vk_format.h 2018-06-01 15:18:21.000000000 +0000 @@ -417,6 +417,46 @@ } static inline VkFormat +vk_format_no_srgb(VkFormat format) +{ + switch(format) { + case VK_FORMAT_R8_SRGB: + return VK_FORMAT_R8_UNORM; + case VK_FORMAT_R8G8_SRGB: + return VK_FORMAT_R8G8_UNORM; + case VK_FORMAT_R8G8B8_SRGB: + return VK_FORMAT_R8G8B8_UNORM; + case VK_FORMAT_B8G8R8_SRGB: + return VK_FORMAT_B8G8R8_UNORM; + case VK_FORMAT_R8G8B8A8_SRGB: + return VK_FORMAT_R8G8B8A8_UNORM; + case VK_FORMAT_B8G8R8A8_SRGB: + return VK_FORMAT_B8G8R8A8_UNORM; + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: + return VK_FORMAT_A8B8G8R8_UNORM_PACK32; + case VK_FORMAT_BC1_RGB_SRGB_BLOCK: + return VK_FORMAT_BC1_RGB_UNORM_BLOCK; + case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: + return VK_FORMAT_BC1_RGBA_UNORM_BLOCK; + case VK_FORMAT_BC2_SRGB_BLOCK: + return VK_FORMAT_BC2_UNORM_BLOCK; + case VK_FORMAT_BC3_SRGB_BLOCK: + return VK_FORMAT_BC3_UNORM_BLOCK; + case VK_FORMAT_BC7_SRGB_BLOCK: + return VK_FORMAT_BC7_UNORM_BLOCK; + case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: + return VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; + case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: + return VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK; + case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: + return VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; + default: + assert(!vk_format_is_srgb(format)); + return format; + } +} + +static inline VkFormat vk_format_stencil_only(VkFormat format) { return VK_FORMAT_S8_UINT; diff -Nru mesa-18.1.0/src/compiler/spirv/vtn_cfg.c mesa-18.1.1/src/compiler/spirv/vtn_cfg.c --- mesa-18.1.0/src/compiler/spirv/vtn_cfg.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/compiler/spirv/vtn_cfg.c 2018-06-01 15:18:21.000000000 +0000 @@ -374,6 +374,19 @@ vtn_cfg_walk_blocks(b, &loop->cont_body, new_loop_cont, NULL, NULL, new_loop_break, NULL, block); + enum vtn_branch_type branch_type = + vtn_get_branch_type(b, new_loop_break, switch_case, switch_break, + loop_break, loop_cont); + + if (branch_type != vtn_branch_type_none) { + /* Stop walking through the CFG when this inner loop's break block + * ends up as the same block as the outer loop's continue block + * because we are already going to visit it. + */ + vtn_assert(branch_type == vtn_branch_type_loop_continue); + return; + } + block = new_loop_break; continue; } diff -Nru mesa-18.1.0/src/gallium/auxiliary/tgsi/tgsi_scan.c mesa-18.1.1/src/gallium/auxiliary/tgsi/tgsi_scan.c --- mesa-18.1.0/src/gallium/auxiliary/tgsi/tgsi_scan.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/gallium/auxiliary/tgsi/tgsi_scan.c 2018-06-01 15:18:21.000000000 +0000 @@ -50,7 +50,8 @@ return file == TGSI_FILE_SAMPLER || file == TGSI_FILE_SAMPLER_VIEW || file == TGSI_FILE_IMAGE || - file == TGSI_FILE_BUFFER; + file == TGSI_FILE_BUFFER || + file == TGSI_FILE_HW_ATOMIC; } diff -Nru mesa-18.1.0/src/gallium/drivers/etnaviv/Makefile.in mesa-18.1.1/src/gallium/drivers/etnaviv/Makefile.in --- mesa-18.1.0/src/gallium/drivers/etnaviv/Makefile.in 2018-05-18 23:28:51.000000000 +0000 +++ mesa-18.1.1/src/gallium/drivers/etnaviv/Makefile.in 2018-06-01 15:18:30.000000000 +0000 @@ -549,6 +549,7 @@ hw/state_3d.xml.h \ hw/state_blt.xml.h \ hw/state.xml.h \ + hw/texdesc_3d.xml.h \ \ etnaviv_asm.c \ etnaviv_asm.h \ diff -Nru mesa-18.1.0/src/gallium/drivers/etnaviv/Makefile.sources mesa-18.1.1/src/gallium/drivers/etnaviv/Makefile.sources --- mesa-18.1.0/src/gallium/drivers/etnaviv/Makefile.sources 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/gallium/drivers/etnaviv/Makefile.sources 2018-06-01 15:18:21.000000000 +0000 @@ -6,6 +6,7 @@ hw/state_3d.xml.h \ hw/state_blt.xml.h \ hw/state.xml.h \ + hw/texdesc_3d.xml.h \ \ etnaviv_asm.c \ etnaviv_asm.h \ diff -Nru mesa-18.1.0/src/gallium/drivers/etnaviv/meson.build mesa-18.1.1/src/gallium/drivers/etnaviv/meson.build --- mesa-18.1.0/src/gallium/drivers/etnaviv/meson.build 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/gallium/drivers/etnaviv/meson.build 2018-06-01 15:18:21.000000000 +0000 @@ -26,6 +26,7 @@ 'hw/state_3d.xml.h', 'hw/state_blt.xml.h', 'hw/state.xml.h', + 'hw/texdesc_3d.xml.h', 'etnaviv_asm.c', 'etnaviv_asm.h', 'etnaviv_blend.c', diff -Nru mesa-18.1.0/src/gallium/drivers/nouveau/nv30/nv30_format.c mesa-18.1.1/src/gallium/drivers/nouveau/nv30/nv30_format.c --- mesa-18.1.0/src/gallium/drivers/nouveau/nv30/nv30_format.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/gallium/drivers/nouveau/nv30/nv30_format.c 2018-06-01 15:18:21.000000000 +0000 @@ -50,10 +50,12 @@ #define S___ PIPE_BIND_SAMPLER_VIEW #define _R__ PIPE_BIND_RENDER_TARGET #define _B__ PIPE_BIND_RENDER_TARGET | PIPE_BIND_BLENDABLE +#define _D__ PIPE_BIND_SCANOUT | PIPE_BIND_DISPLAY_TARGET | _B__ #define _Z__ PIPE_BIND_DEPTH_STENCIL #define __V_ PIPE_BIND_VERTEX_BUFFER #define SR__ (S___ | _R__) #define SB__ (S___ | _B__) +#define SD__ (S___ | _D__) #define SZ__ (S___ | _Z__) #define S_V_ (S___ | __V_) #define SRV_ (SR__ | __V_) @@ -73,14 +75,14 @@ _(A8_SNORM , S___), _(R8_UNORM , S_V_), _(R8_SNORM , S___), - _(B5G5R5X1_UNORM , SB__), + _(B5G5R5X1_UNORM , SD__), _(B5G5R5A1_UNORM , S___), _(B4G4R4X4_UNORM , S___), _(B4G4R4A4_UNORM , S___), - _(B5G6R5_UNORM , SB__), - _(BGRX8888_UNORM , SB__), + _(B5G6R5_UNORM , SD__), + _(BGRX8888_UNORM , SD__), _(BGRX8888_SRGB , S___), - _(BGRA8888_UNORM , SB__), + _(BGRA8888_UNORM , SD__), _(BGRA8888_SRGB , S___), _(R8G8B8A8_UNORM , __V_), _(RGBA8888_SNORM , S___), diff -Nru mesa-18.1.0/src/gallium/drivers/r600/compute_memory_pool.c mesa-18.1.1/src/gallium/drivers/r600/compute_memory_pool.c --- mesa-18.1.0/src/gallium/drivers/r600/compute_memory_pool.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/gallium/drivers/r600/compute_memory_pool.c 2018-06-01 15:18:21.000000000 +0000 @@ -91,10 +91,7 @@ { COMPUTE_DBG(pool->screen, "* compute_memory_pool_delete()\n"); free(pool->shadow); - if (pool->bo) { - pool->screen->b.b.resource_destroy((struct pipe_screen *) - pool->screen, (struct pipe_resource *)pool->bo); - } + pipe_resource_reference(&pool->bo, NULL); /* In theory, all of the items were freed in compute_memory_free. * Just delete the list heads */ @@ -213,10 +210,8 @@ compute_memory_defrag(pool, src, dst, pipe); - pool->screen->b.b.resource_destroy( - (struct pipe_screen *)pool->screen, - src); - + /* Release the old buffer */ + pipe_resource_reference(&pool->bo, NULL); pool->bo = temp; pool->size_in_dw = new_size_in_dw; } @@ -230,9 +225,8 @@ return -1; pool->size_in_dw = new_size_in_dw; - pool->screen->b.b.resource_destroy( - (struct pipe_screen *)pool->screen, - (struct pipe_resource *)pool->bo); + /* Release the old buffer */ + pipe_resource_reference(&pool->bo, NULL); pool->bo = r600_compute_buffer_alloc_vram(pool->screen, pool->size_in_dw * 4); compute_memory_shadow(pool, pipe, 0); diff -Nru mesa-18.1.0/src/gallium/drivers/r600/evergreen_compute.c mesa-18.1.1/src/gallium/drivers/r600/evergreen_compute.c --- mesa-18.1.0/src/gallium/drivers/r600/evergreen_compute.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/gallium/drivers/r600/evergreen_compute.c 2018-06-01 15:18:21.000000000 +0000 @@ -122,7 +122,8 @@ rat_templ.u.tex.first_layer = 0; rat_templ.u.tex.last_layer = 0; - /* Add the RAT the list of color buffers */ + /* Add the RAT the list of color buffers. Drop the old buffer first. */ + pipe_surface_reference(&pipe->ctx->framebuffer.state.cbufs[id], NULL); pipe->ctx->framebuffer.state.cbufs[id] = pipe->ctx->b.b.create_surface( (struct pipe_context *)pipe->ctx, (struct pipe_resource *)bo, &rat_templ); diff -Nru mesa-18.1.0/src/gallium/drivers/radeonsi/si_state_shaders.c mesa-18.1.1/src/gallium/drivers/radeonsi/si_state_shaders.c --- mesa-18.1.0/src/gallium/drivers/radeonsi/si_state_shaders.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/gallium/drivers/radeonsi/si_state_shaders.c 2018-06-01 15:18:21.000000000 +0000 @@ -1227,8 +1227,8 @@ uint64_t inputs_read = 0; /* ignore POSITION, PSIZE */ - outputs_written &= ~((1ull << si_shader_io_get_unique_index(TGSI_SEMANTIC_POSITION, 0) | - (1ull << si_shader_io_get_unique_index(TGSI_SEMANTIC_PSIZE, 0)))); + outputs_written &= ~((1ull << si_shader_io_get_unique_index(TGSI_SEMANTIC_POSITION, 0)) | + (1ull << si_shader_io_get_unique_index(TGSI_SEMANTIC_PSIZE, 0))); if (!ps_disabled) { inputs_read = ps->inputs_read; diff -Nru mesa-18.1.0/src/gallium/drivers/swr/rasterizer/jitter/gen_builder.hpp mesa-18.1.1/src/gallium/drivers/swr/rasterizer/jitter/gen_builder.hpp --- mesa-18.1.0/src/gallium/drivers/swr/rasterizer/jitter/gen_builder.hpp 2018-05-18 23:29:54.000000000 +0000 +++ mesa-18.1.1/src/gallium/drivers/swr/rasterizer/jitter/gen_builder.hpp 2018-06-01 15:19:23.000000000 +0000 @@ -29,7 +29,7 @@ // Generation Command Line: // ./rasterizer/codegen/gen_llvm_ir_macros.py // --input -// /home/dylan/llvm-install/include/llvm/IR/IRBuilder.h +// /home/dylan/tigraine/llvm-install/include/llvm/IR/IRBuilder.h // --output // rasterizer/jitter // --gen_h diff -Nru mesa-18.1.0/src/gallium/drivers/tegra/tegra_screen.c mesa-18.1.1/src/gallium/drivers/tegra/tegra_screen.c --- mesa-18.1.0/src/gallium/drivers/tegra/tegra_screen.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/gallium/drivers/tegra/tegra_screen.c 2018-06-01 15:18:21.000000000 +0000 @@ -219,11 +219,9 @@ } static int tegra_screen_import_resource(struct tegra_screen *screen, - struct tegra_resource *resource, - bool has_modifiers) + struct tegra_resource *resource) { unsigned usage = PIPE_HANDLE_USAGE_READ; - struct drm_tegra_gem_set_tiling args; struct winsys_handle handle; boolean status; int fd, err; @@ -254,67 +252,6 @@ close(fd); - if (!has_modifiers) { - memset(&args, 0, sizeof(args)); - args.handle = resource->handle; - - switch (handle.modifier) { - case DRM_FORMAT_MOD_NVIDIA_TEGRA_TILED: - args.mode = DRM_TEGRA_GEM_TILING_MODE_TILED; - break; - - case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_ONE_GOB: - args.mode = DRM_TEGRA_GEM_TILING_MODE_BLOCK; - args.value = 0; - break; - - case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_TWO_GOB: - args.mode = DRM_TEGRA_GEM_TILING_MODE_BLOCK; - args.value = 1; - break; - - case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_FOUR_GOB: - args.mode = DRM_TEGRA_GEM_TILING_MODE_BLOCK; - args.value = 2; - break; - - case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_EIGHT_GOB: - args.mode = DRM_TEGRA_GEM_TILING_MODE_BLOCK; - args.value = 3; - break; - - case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_SIXTEEN_GOB: - args.mode = DRM_TEGRA_GEM_TILING_MODE_BLOCK; - args.value = 4; - break; - - case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK_THIRTYTWO_GOB: - args.mode = DRM_TEGRA_GEM_TILING_MODE_BLOCK; - args.value = 5; - break; - - default: - debug_printf("unsupported modifier %" PRIx64 ", assuming linear\n", - handle.modifier); - /* fall-through */ - - case DRM_FORMAT_MOD_LINEAR: - args.mode = DRM_TEGRA_GEM_TILING_MODE_PITCH; - break; - } - - err = drmIoctl(screen->fd, DRM_IOCTL_TEGRA_GEM_SET_TILING, &args); - if (err < 0) { - fprintf(stderr, "failed to set tiling parameters: %s\n", - strerror(errno)); - err = -errno; - goto out; - } - } - - return 0; - -out: return err; } @@ -323,6 +260,7 @@ const struct pipe_resource *template) { struct tegra_screen *screen = to_tegra_screen(pscreen); + uint64_t modifier = DRM_FORMAT_MOD_INVALID; struct tegra_resource *resource; int err; @@ -330,13 +268,29 @@ if (!resource) return NULL; - resource->gpu = screen->gpu->resource_create(screen->gpu, template); + /* + * Applications that create scanout resources without modifiers are very + * unlikely to support modifiers at all. In that case the resources need + * to be created with a pitch-linear layout so that they can be properly + * shared with scanout hardware. + * + * Technically it is possible for applications to create resources without + * specifying a modifier but still query the modifier associated with the + * resource (e.g. using gbm_bo_get_modifier()) before handing it to the + * framebuffer creation API (such as the DRM_IOCTL_MODE_ADDFB2 IOCTL). + */ + if (template->bind & PIPE_BIND_SCANOUT) + modifier = DRM_FORMAT_MOD_LINEAR; + + resource->gpu = screen->gpu->resource_create_with_modifiers(screen->gpu, + template, + &modifier, 1); if (!resource->gpu) goto free; /* import scanout buffers for display */ if (template->bind & PIPE_BIND_SCANOUT) { - err = tegra_screen_import_resource(screen, resource, false); + err = tegra_screen_import_resource(screen, resource); if (err < 0) goto destroy; } @@ -561,6 +515,7 @@ int count) { struct tegra_screen *screen = to_tegra_screen(pscreen); + struct pipe_resource tmpl = *template; struct tegra_resource *resource; int err; @@ -568,14 +523,24 @@ if (!resource) return NULL; + /* + * Assume that resources created with modifiers will always be used for + * scanout. This is necessary because some of the APIs that are used to + * create resources with modifiers (e.g. gbm_bo_create_with_modifiers()) + * can't pass along usage information. Adding that capability might be + * worth adding to remove this ambiguity. Not all future use-cases that + * involve modifiers may always be targetting scanout hardware. + */ + tmpl.bind |= PIPE_BIND_SCANOUT; + resource->gpu = screen->gpu->resource_create_with_modifiers(screen->gpu, - template, + &tmpl, modifiers, count); if (!resource->gpu) goto free; - err = tegra_screen_import_resource(screen, resource, true); + err = tegra_screen_import_resource(screen, resource); if (err < 0) goto destroy; diff -Nru mesa-18.1.0/src/gallium/drivers/virgl/virgl_winsys.h mesa-18.1.1/src/gallium/drivers/virgl/virgl_winsys.h --- mesa-18.1.0/src/gallium/drivers/virgl/virgl_winsys.h 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/gallium/drivers/virgl/virgl_winsys.h 2018-06-01 15:18:21.000000000 +0000 @@ -132,7 +132,7 @@ caps->caps.v2.max_texel_offset = 7; caps->caps.v2.min_texture_gather_offset = -8; caps->caps.v2.max_texture_gather_offset = 7; - caps->caps.v2.texture_buffer_offset_alignment = 32; + caps->caps.v2.texture_buffer_offset_alignment = 0; caps->caps.v2.uniform_buffer_offset_alignment = 256; } #endif diff -Nru mesa-18.1.0/src/gallium/targets/opencl/Makefile.am mesa-18.1.1/src/gallium/targets/opencl/Makefile.am --- mesa-18.1.0/src/gallium/targets/opencl/Makefile.am 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/gallium/targets/opencl/Makefile.am 2018-06-01 15:18:21.000000000 +0000 @@ -23,11 +23,10 @@ $(LIBELF_LIBS) \ $(DLOPEN_LIBS) \ -lclangCodeGen \ - -lclangFrontendTool \ -lclangFrontend \ + -lclangFrontendTool \ -lclangDriver \ -lclangSerialization \ - -lclangCodeGen \ -lclangParse \ -lclangSema \ -lclangAnalysis \ diff -Nru mesa-18.1.0/src/gallium/targets/opencl/Makefile.in mesa-18.1.1/src/gallium/targets/opencl/Makefile.in --- mesa-18.1.0/src/gallium/targets/opencl/Makefile.in 2018-05-18 23:28:53.000000000 +0000 +++ mesa-18.1.1/src/gallium/targets/opencl/Makefile.in 2018-06-01 15:18:31.000000000 +0000 @@ -602,11 +602,10 @@ $(LIBELF_LIBS) \ $(DLOPEN_LIBS) \ -lclangCodeGen \ - -lclangFrontendTool \ -lclangFrontend \ + -lclangFrontendTool \ -lclangDriver \ -lclangSerialization \ - -lclangCodeGen \ -lclangParse \ -lclangSema \ -lclangAnalysis \ diff -Nru mesa-18.1.0/src/glx/indirect.c mesa-18.1.1/src/glx/indirect.c --- mesa-18.1.0/src/glx/indirect.c 2018-05-18 23:29:27.000000000 +0000 +++ mesa-18.1.1/src/glx/indirect.c 2018-06-01 15:19:00.000000000 +0000 @@ -37,52 +37,40 @@ #include #include -#if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__) -#define FASTCALL __attribute__((fastcall)) -#else -#define FASTCALL -#endif -#if defined(__GNUC__) -#define NOINLINE __attribute__((noinline)) -#else -#define NOINLINE -#endif +# if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__) +# define FASTCALL __attribute__((fastcall)) +# else +# define FASTCALL +# endif +# if defined(__GNUC__) +# define NOINLINE __attribute__((noinline)) +# else +# define NOINLINE +# endif -static _X_INLINE int -safe_add(int a, int b) +static _X_INLINE int safe_add(int a, int b) { - if (a < 0 || b < 0) - return -1; - if (INT_MAX - a < b) - return -1; + if (a < 0 || b < 0) return -1; + if (INT_MAX - a < b) return -1; return a + b; } - -static _X_INLINE int -safe_mul(int a, int b) +static _X_INLINE int safe_mul(int a, int b) { - if (a < 0 || b < 0) - return -1; - if (a == 0 || b == 0) - return 0; - if (a > INT_MAX / b) - return -1; + if (a < 0 || b < 0) return -1; + if (a == 0 || b == 0) return 0; + if (a > INT_MAX / b) return -1; return a * b; } - -static _X_INLINE int -safe_pad(int a) +static _X_INLINE int safe_pad(int a) { int ret; - if (a < 0) - return -1; - if ((ret = safe_add(a, 3)) < 0) - return -1; - return ret & (GLuint) ~ 3; + if (a < 0) return -1; + if ((ret = safe_add(a, 3)) < 0) return -1; + return ret & (GLuint)~3; } #ifndef __GNUC__ -#define __builtin_expect(x, y) x +# define __builtin_expect(x, y) x #endif /* If the size and opcode values are known at compile-time, this will, on @@ -94,24 +82,24 @@ *((int *)(dest)) = temp.i; } while(0) NOINLINE CARD32 -__glXReadReply(Display * dpy, size_t size, void *dest, - GLboolean reply_is_always_array) +__glXReadReply( Display *dpy, size_t size, void * dest, GLboolean reply_is_always_array ) { xGLXSingleReply reply; - + (void) _XReply(dpy, (xReply *) & reply, 0, False); if (size != 0) { if ((reply.length > 0) || reply_is_always_array) { - const GLint bytes = (reply_is_always_array) - ? (4 * reply.length) : (reply.size * size); + const GLint bytes = (reply_is_always_array) + ? (4 * reply.length) : (reply.size * size); const GLint extra = 4 - (bytes & 3); _XRead(dpy, dest, bytes); - if (extra < 4) { + if ( extra < 4 ) { _XEatData(dpy, extra); } - } else { - (void) memcpy(dest, &(reply.pad3), size); + } + else { + (void) memcpy( dest, &(reply.pad3), size); } } @@ -119,40 +107,37 @@ } NOINLINE void -__glXReadPixelReply(Display * dpy, struct glx_context *gc, unsigned max_dim, - GLint width, GLint height, GLint depth, GLenum format, - GLenum type, void *dest, GLboolean dimensions_in_reply) +__glXReadPixelReply( Display *dpy, struct glx_context * gc, unsigned max_dim, + GLint width, GLint height, GLint depth, GLenum format, GLenum type, + void * dest, GLboolean dimensions_in_reply ) { xGLXSingleReply reply; GLint size; - + (void) _XReply(dpy, (xReply *) & reply, 0, False); - if (dimensions_in_reply) { - width = reply.pad3; + if ( dimensions_in_reply ) { + width = reply.pad3; height = reply.pad4; - depth = reply.pad5; - - if ((height == 0) || (max_dim < 2)) { - height = 1; - } - if ((depth == 0) || (max_dim < 3)) { - depth = 1; - } + depth = reply.pad5; + + if ((height == 0) || (max_dim < 2)) { height = 1; } + if ((depth == 0) || (max_dim < 3)) { depth = 1; } } size = reply.length * 4; if (size != 0) { - void *buf = malloc(size); + void * buf = malloc( size ); - if (buf == NULL) { + if ( buf == NULL ) { _XEatData(dpy, size); __glXSetError(gc, GL_OUT_OF_MEMORY); - } else { + } + else { const GLint extra = 4 - (size & 3); _XRead(dpy, buf, size); - if (extra < 4) { + if ( extra < 4 ) { _XEatData(dpy, extra); } @@ -166,10 +151,10 @@ #define X_GLXSingle 0 NOINLINE FASTCALL GLubyte * -__glXSetupSingleRequest(struct glx_context *gc, GLint sop, GLint cmdlen) +__glXSetupSingleRequest( struct glx_context * gc, GLint sop, GLint cmdlen ) { - xGLXSingleReq *req; - Display *const dpy = gc->currentDpy; + xGLXSingleReq * req; + Display * const dpy = gc->currentDpy; (void) __glXFlushRenderBuffer(gc, gc->pc); LockDisplay(dpy); @@ -177,15 +162,14 @@ req->reqType = gc->majorOpcode; req->contextTag = gc->currentContextTag; req->glxCode = sop; - return (GLubyte *) (req) + sz_xGLXSingleReq; + return (GLubyte *)(req) + sz_xGLXSingleReq; } NOINLINE FASTCALL GLubyte * -__glXSetupVendorRequest(struct glx_context *gc, GLint code, GLint vop, - GLint cmdlen) +__glXSetupVendorRequest( struct glx_context * gc, GLint code, GLint vop, GLint cmdlen ) { - xGLXVendorPrivateReq *req; - Display *const dpy = gc->currentDpy; + xGLXVendorPrivateReq * req; + Display * const dpy = gc->currentDpy; (void) __glXFlushRenderBuffer(gc, gc->pc); LockDisplay(dpy); @@ -194,7 +178,7 @@ req->glxCode = code; req->vendorCode = vop; req->contextTag = gc->currentContextTag; - return (GLubyte *) (req) + sz_xGLXVendorPrivateReq; + return (GLubyte *)(req) + sz_xGLXVendorPrivateReq; } const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 }; @@ -211,123 +195,106 @@ #define default_pixel_store_4D_size 36 static FASTCALL NOINLINE void -generic_3_byte(GLint rop, const void *ptr) +generic_3_byte( GLint rop, const void * ptr ) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; emit_header(gc->pc, rop, cmdlen); - (void) memcpy((void *) (gc->pc + 4), ptr, 4); + (void) memcpy((void *)(gc->pc + 4), ptr, 4); gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } + if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } static FASTCALL NOINLINE void -generic_4_byte(GLint rop, const void *ptr) +generic_4_byte( GLint rop, const void * ptr ) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; emit_header(gc->pc, rop, cmdlen); - (void) memcpy((void *) (gc->pc + 4), ptr, 4); + (void) memcpy((void *)(gc->pc + 4), ptr, 4); gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } + if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } static FASTCALL NOINLINE void -generic_6_byte(GLint rop, const void *ptr) +generic_6_byte( GLint rop, const void * ptr ) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; emit_header(gc->pc, rop, cmdlen); - (void) memcpy((void *) (gc->pc + 4), ptr, 8); + (void) memcpy((void *)(gc->pc + 4), ptr, 8); gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } + if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } static FASTCALL NOINLINE void -generic_8_byte(GLint rop, const void *ptr) +generic_8_byte( GLint rop, const void * ptr ) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; emit_header(gc->pc, rop, cmdlen); - (void) memcpy((void *) (gc->pc + 4), ptr, 8); + (void) memcpy((void *)(gc->pc + 4), ptr, 8); gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } + if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } static FASTCALL NOINLINE void -generic_12_byte(GLint rop, const void *ptr) +generic_12_byte( GLint rop, const void * ptr ) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; emit_header(gc->pc, rop, cmdlen); - (void) memcpy((void *) (gc->pc + 4), ptr, 12); + (void) memcpy((void *)(gc->pc + 4), ptr, 12); gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } + if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } static FASTCALL NOINLINE void -generic_16_byte(GLint rop, const void *ptr) +generic_16_byte( GLint rop, const void * ptr ) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; emit_header(gc->pc, rop, cmdlen); - (void) memcpy((void *) (gc->pc + 4), ptr, 16); + (void) memcpy((void *)(gc->pc + 4), ptr, 16); gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } + if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } static FASTCALL NOINLINE void -generic_24_byte(GLint rop, const void *ptr) +generic_24_byte( GLint rop, const void * ptr ) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; emit_header(gc->pc, rop, cmdlen); - (void) memcpy((void *) (gc->pc + 4), ptr, 24); + (void) memcpy((void *)(gc->pc + 4), ptr, 24); gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } + if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } static FASTCALL NOINLINE void -generic_32_byte(GLint rop, const void *ptr) +generic_32_byte( GLint rop, const void * ptr ) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 36; emit_header(gc->pc, rop, cmdlen); - (void) memcpy((void *) (gc->pc + 4), ptr, 32); + (void) memcpy((void *)(gc->pc + 4), ptr, 32); gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } + if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLsop_NewList 101 -void -__indirect_glNewList(GLuint list, GLenum mode) +void __indirect_glNewList(GLuint list, GLenum mode) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -337,23 +304,20 @@ (void) __glXFlushRenderBuffer(gc, gc->pc); xcb_glx_new_list(c, gc->currentContextTag, list, mode); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_NewList, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&list), 4); - (void) memcpy((void *) (pc + 4), (void *) (&mode), 4); - UnlockDisplay(dpy); - SyncHandle(); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_NewList, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&list), 4); +(void) memcpy((void *)(pc + 4), (void *)(&mode), 4); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_EndList 102 -void -__indirect_glEndList(void) +void __indirect_glEndList(void) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 0; #endif @@ -364,32 +328,27 @@ xcb_glx_end_list(c, gc->currentContextTag); #else (void) __glXSetupSingleRequest(gc, X_GLsop_EndList, cmdlen); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLrop_CallList 1 -void -__indirect_glCallList(GLuint list) +void __indirect_glCallList(GLuint list) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_CallList, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&list), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_CallList, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&list), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_CallLists 2 -void -__indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists) +void __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glCallLists_size(type); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, n)); if (0 + safe_pad(safe_mul(compsize, n)) < 0) { @@ -401,38 +360,35 @@ return; } if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, X_GLrop_CallLists, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&type), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (lists), - safe_mul(compsize, n)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = X_GLrop_CallLists; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 8), (void *) (&n), 4); - (void) memcpy((void *) (pc + 12), (void *) (&type), 4); - __glXSendLargeCommand(gc, pc, 16, lists, safe_mul(compsize, n)); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, X_GLrop_CallLists, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&type), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(lists), safe_mul(compsize, n)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = X_GLrop_CallLists; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 8), (void *)(&n), 4); +(void) memcpy((void *)(pc + 12), (void *)(&type), 4); + __glXSendLargeCommand(gc, pc, 16, lists, safe_mul(compsize, n)); +} } } #define X_GLsop_DeleteLists 103 -void -__indirect_glDeleteLists(GLuint list, GLsizei range) +void __indirect_glDeleteLists(GLuint list, GLsizei range) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -442,23 +398,20 @@ (void) __glXFlushRenderBuffer(gc, gc->pc); xcb_glx_delete_lists(c, gc->currentContextTag, list, range); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_DeleteLists, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&list), 4); - (void) memcpy((void *) (pc + 4), (void *) (&range), 4); - UnlockDisplay(dpy); - SyncHandle(); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteLists, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&list), 4); +(void) memcpy((void *)(pc + 4), (void *)(&range), 4); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GenLists 104 -GLuint -__indirect_glGenLists(GLsizei range) +GLuint __indirect_glGenLists(GLsizei range) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; GLuint retval = (GLuint) 0; #ifndef USE_XCB const GLuint cmdlen = 4; @@ -467,3251 +420,2637 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_gen_lists_reply_t *reply = - xcb_glx_gen_lists_reply(c, - xcb_glx_gen_lists(c, - gc->currentContextTag, - range), NULL); + xcb_glx_gen_lists_reply_t *reply = xcb_glx_gen_lists_reply(c, xcb_glx_gen_lists(c, gc->currentContextTag, range), NULL); retval = reply->ret_val; free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GenLists, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&range), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenLists, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&range), 4); retval = (GLuint) __glXReadReply(dpy, 0, NULL, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return retval; } #define X_GLrop_ListBase 3 -void -__indirect_glListBase(GLuint base) +void __indirect_glListBase(GLuint base) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_ListBase, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&base), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ListBase, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&base), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Begin 4 -void -__indirect_glBegin(GLenum mode) +void __indirect_glBegin(GLenum mode) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_Begin, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Begin, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Bitmap 5 -void -__indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, - GLfloat yorig, GLfloat xmove, GLfloat ymove, - const GLubyte *bitmap) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint compsize = - (bitmap != NULL) ? __glImageSize(width, height, 1, GL_COLOR_INDEX, - GL_BITMAP, 0) : 0; +void __indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint compsize = (bitmap != NULL) ? __glImageSize(width, height, 1, GL_COLOR_INDEX, GL_BITMAP, 0) : 0; const GLuint cmdlen = 48 + safe_pad(compsize); if (0 + safe_pad(compsize) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } if (__builtin_expect(gc->currentDpy != NULL, 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, X_GLrop_Bitmap, cmdlen); - (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4); - (void) memcpy((void *) (gc->pc + 32), (void *) (&xorig), 4); - (void) memcpy((void *) (gc->pc + 36), (void *) (&yorig), 4); - (void) memcpy((void *) (gc->pc + 40), (void *) (&xmove), 4); - (void) memcpy((void *) (gc->pc + 44), (void *) (&ymove), 4); - if (compsize > 0) { - gc->fillImage(gc, 2, width, height, 1, GL_COLOR_INDEX, - GL_BITMAP, bitmap, gc->pc + 48, gc->pc + 4); - } else { - (void) memcpy(gc->pc + 4, default_pixel_store_2D, - default_pixel_store_2D_size); - } - gc->pc += cmdlen; - if (gc->pc > gc->limit) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = X_GLrop_Bitmap; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 28), (void *) (&width), 4); - (void) memcpy((void *) (pc + 32), (void *) (&height), 4); - (void) memcpy((void *) (pc + 36), (void *) (&xorig), 4); - (void) memcpy((void *) (pc + 40), (void *) (&yorig), 4); - (void) memcpy((void *) (pc + 44), (void *) (&xmove), 4); - (void) memcpy((void *) (pc + 48), (void *) (&ymove), 4); - __glXSendLargeImage(gc, compsize, 2, width, height, 1, - GL_COLOR_INDEX, GL_BITMAP, bitmap, pc + 52, - pc + 8); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, X_GLrop_Bitmap, cmdlen); +(void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4); +(void) memcpy((void *)(gc->pc + 32), (void *)(&xorig), 4); +(void) memcpy((void *)(gc->pc + 36), (void *)(&yorig), 4); +(void) memcpy((void *)(gc->pc + 40), (void *)(&xmove), 4); +(void) memcpy((void *)(gc->pc + 44), (void *)(&ymove), 4); +if (compsize > 0) { + gc->fillImage(gc, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, gc->pc + 48, gc->pc + 4); +} else { + (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size ); +} +gc->pc += cmdlen; +if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = X_GLrop_Bitmap; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 28), (void *)(&width), 4); +(void) memcpy((void *)(pc + 32), (void *)(&height), 4); +(void) memcpy((void *)(pc + 36), (void *)(&xorig), 4); +(void) memcpy((void *)(pc + 40), (void *)(&yorig), 4); +(void) memcpy((void *)(pc + 44), (void *)(&xmove), 4); +(void) memcpy((void *)(pc + 48), (void *)(&ymove), 4); +__glXSendLargeImage(gc, compsize, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, pc + 52, pc + 8); +} } } #define X_GLrop_Color3bv 6 -void -__indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue) +void __indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_Color3bv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1); - (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1); - (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color3bv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1); +(void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1); +(void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color3bv 6 -void -__indirect_glColor3bv(const GLbyte *v) +void __indirect_glColor3bv(const GLbyte * v) { - generic_3_byte(X_GLrop_Color3bv, v); + generic_3_byte( X_GLrop_Color3bv, v ); } #define X_GLrop_Color3dv 7 -void -__indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue) +void __indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_Color3dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color3dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color3dv 7 -void -__indirect_glColor3dv(const GLdouble * v) +void __indirect_glColor3dv(const GLdouble * v) { - generic_24_byte(X_GLrop_Color3dv, v); + generic_24_byte( X_GLrop_Color3dv, v ); } #define X_GLrop_Color3fv 8 -void -__indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue) +void __indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_Color3fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color3fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color3fv 8 -void -__indirect_glColor3fv(const GLfloat * v) +void __indirect_glColor3fv(const GLfloat * v) { - generic_12_byte(X_GLrop_Color3fv, v); + generic_12_byte( X_GLrop_Color3fv, v ); } #define X_GLrop_Color3iv 9 -void -__indirect_glColor3i(GLint red, GLint green, GLint blue) +void __indirect_glColor3i(GLint red, GLint green, GLint blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_Color3iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color3iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color3iv 9 -void -__indirect_glColor3iv(const GLint * v) +void __indirect_glColor3iv(const GLint * v) { - generic_12_byte(X_GLrop_Color3iv, v); + generic_12_byte( X_GLrop_Color3iv, v ); } #define X_GLrop_Color3sv 10 -void -__indirect_glColor3s(GLshort red, GLshort green, GLshort blue) +void __indirect_glColor3s(GLshort red, GLshort green, GLshort blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Color3sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2); - (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color3sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2); +(void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color3sv 10 -void -__indirect_glColor3sv(const GLshort * v) +void __indirect_glColor3sv(const GLshort * v) { - generic_6_byte(X_GLrop_Color3sv, v); + generic_6_byte( X_GLrop_Color3sv, v ); } #define X_GLrop_Color3ubv 11 -void -__indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue) +void __indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_Color3ubv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1); - (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1); - (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color3ubv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1); +(void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1); +(void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color3ubv 11 -void -__indirect_glColor3ubv(const GLubyte *v) +void __indirect_glColor3ubv(const GLubyte * v) { - generic_3_byte(X_GLrop_Color3ubv, v); + generic_3_byte( X_GLrop_Color3ubv, v ); } #define X_GLrop_Color3uiv 12 -void -__indirect_glColor3ui(GLuint red, GLuint green, GLuint blue) +void __indirect_glColor3ui(GLuint red, GLuint green, GLuint blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_Color3uiv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color3uiv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color3uiv 12 -void -__indirect_glColor3uiv(const GLuint * v) +void __indirect_glColor3uiv(const GLuint * v) { - generic_12_byte(X_GLrop_Color3uiv, v); + generic_12_byte( X_GLrop_Color3uiv, v ); } #define X_GLrop_Color3usv 13 -void -__indirect_glColor3us(GLushort red, GLushort green, GLushort blue) +void __indirect_glColor3us(GLushort red, GLushort green, GLushort blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Color3usv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2); - (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color3usv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2); +(void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color3usv 13 -void -__indirect_glColor3usv(const GLushort * v) +void __indirect_glColor3usv(const GLushort * v) { - generic_6_byte(X_GLrop_Color3usv, v); + generic_6_byte( X_GLrop_Color3usv, v ); } #define X_GLrop_Color4bv 14 -void -__indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +void __indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_Color4bv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1); - (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1); - (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1); - (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color4bv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1); +(void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1); +(void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1); +(void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color4bv 14 -void -__indirect_glColor4bv(const GLbyte *v) +void __indirect_glColor4bv(const GLbyte * v) { - generic_4_byte(X_GLrop_Color4bv, v); + generic_4_byte( X_GLrop_Color4bv, v ); } #define X_GLrop_Color4dv 15 -void -__indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue, - GLdouble alpha) +void __indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 36; - emit_header(gc->pc, X_GLrop_Color4dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8); - (void) memcpy((void *) (gc->pc + 28), (void *) (&alpha), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color4dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8); +(void) memcpy((void *)(gc->pc + 28), (void *)(&alpha), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color4dv 15 -void -__indirect_glColor4dv(const GLdouble * v) +void __indirect_glColor4dv(const GLdouble * v) { - generic_32_byte(X_GLrop_Color4dv, v); + generic_32_byte( X_GLrop_Color4dv, v ); } #define X_GLrop_Color4fv 16 -void -__indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +void __indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_Color4fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color4fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color4fv 16 -void -__indirect_glColor4fv(const GLfloat * v) +void __indirect_glColor4fv(const GLfloat * v) { - generic_16_byte(X_GLrop_Color4fv, v); + generic_16_byte( X_GLrop_Color4fv, v ); } #define X_GLrop_Color4iv 17 -void -__indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha) +void __indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_Color4iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color4iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color4iv 17 -void -__indirect_glColor4iv(const GLint * v) +void __indirect_glColor4iv(const GLint * v) { - generic_16_byte(X_GLrop_Color4iv, v); + generic_16_byte( X_GLrop_Color4iv, v ); } #define X_GLrop_Color4sv 18 -void -__indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha) +void __indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Color4sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2); - (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&alpha), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color4sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2); +(void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color4sv 18 -void -__indirect_glColor4sv(const GLshort * v) +void __indirect_glColor4sv(const GLshort * v) { - generic_8_byte(X_GLrop_Color4sv, v); + generic_8_byte( X_GLrop_Color4sv, v ); } #define X_GLrop_Color4ubv 19 -void -__indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +void __indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_Color4ubv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1); - (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1); - (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1); - (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color4ubv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1); +(void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1); +(void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1); +(void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color4ubv 19 -void -__indirect_glColor4ubv(const GLubyte *v) +void __indirect_glColor4ubv(const GLubyte * v) { - generic_4_byte(X_GLrop_Color4ubv, v); + generic_4_byte( X_GLrop_Color4ubv, v ); } #define X_GLrop_Color4uiv 20 -void -__indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) +void __indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color4uiv 20 -void -__indirect_glColor4uiv(const GLuint * v) +void __indirect_glColor4uiv(const GLuint * v) { - generic_16_byte(X_GLrop_Color4uiv, v); + generic_16_byte( X_GLrop_Color4uiv, v ); } #define X_GLrop_Color4usv 21 -void -__indirect_glColor4us(GLushort red, GLushort green, GLushort blue, - GLushort alpha) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Color4usv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2); - (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&alpha), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +void __indirect_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint cmdlen = 12; +emit_header(gc->pc, X_GLrop_Color4usv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2); +(void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Color4usv 21 -void -__indirect_glColor4usv(const GLushort * v) +void __indirect_glColor4usv(const GLushort * v) { - generic_8_byte(X_GLrop_Color4usv, v); + generic_8_byte( X_GLrop_Color4usv, v ); } #define X_GLrop_EdgeFlagv 22 -void -__indirect_glEdgeFlag(GLboolean flag) +void __indirect_glEdgeFlag(GLboolean flag) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&flag), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_EdgeFlagv 22 -void -__indirect_glEdgeFlagv(const GLboolean * flag) +void __indirect_glEdgeFlagv(const GLboolean * flag) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (flag), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(flag), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_End 23 -void -__indirect_glEnd(void) +void __indirect_glEnd(void) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 4; - emit_header(gc->pc, X_GLrop_End, cmdlen); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_End, cmdlen); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Indexdv 24 -void -__indirect_glIndexd(GLdouble c) +void __indirect_glIndexd(GLdouble c) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Indexdv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Indexdv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&c), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Indexdv 24 -void -__indirect_glIndexdv(const GLdouble * c) +void __indirect_glIndexdv(const GLdouble * c) { - generic_8_byte(X_GLrop_Indexdv, c); + generic_8_byte( X_GLrop_Indexdv, c ); } #define X_GLrop_Indexfv 25 -void -__indirect_glIndexf(GLfloat c) +void __indirect_glIndexf(GLfloat c) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_Indexfv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Indexfv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Indexfv 25 -void -__indirect_glIndexfv(const GLfloat * c) +void __indirect_glIndexfv(const GLfloat * c) { - generic_4_byte(X_GLrop_Indexfv, c); + generic_4_byte( X_GLrop_Indexfv, c ); } #define X_GLrop_Indexiv 26 -void -__indirect_glIndexi(GLint c) +void __indirect_glIndexi(GLint c) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_Indexiv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Indexiv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Indexiv 26 -void -__indirect_glIndexiv(const GLint * c) +void __indirect_glIndexiv(const GLint * c) { - generic_4_byte(X_GLrop_Indexiv, c); + generic_4_byte( X_GLrop_Indexiv, c ); } #define X_GLrop_Indexsv 27 -void -__indirect_glIndexs(GLshort c) +void __indirect_glIndexs(GLshort c) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_Indexsv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Indexsv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&c), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Indexsv 27 -void -__indirect_glIndexsv(const GLshort * c) +void __indirect_glIndexsv(const GLshort * c) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_Indexsv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (c), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Indexsv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(c), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Normal3bv 28 -void -__indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) +void __indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 1); - (void) memcpy((void *) (gc->pc + 5), (void *) (&ny), 1); - (void) memcpy((void *) (gc->pc + 6), (void *) (&nz), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 1); +(void) memcpy((void *)(gc->pc + 5), (void *)(&ny), 1); +(void) memcpy((void *)(gc->pc + 6), (void *)(&nz), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Normal3bv 28 -void -__indirect_glNormal3bv(const GLbyte *v) +void __indirect_glNormal3bv(const GLbyte * v) { - generic_3_byte(X_GLrop_Normal3bv, v); + generic_3_byte( X_GLrop_Normal3bv, v ); } #define X_GLrop_Normal3dv 29 -void -__indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) +void __indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&ny), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&nz), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&ny), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&nz), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Normal3dv 29 -void -__indirect_glNormal3dv(const GLdouble * v) +void __indirect_glNormal3dv(const GLdouble * v) { - generic_24_byte(X_GLrop_Normal3dv, v); + generic_24_byte( X_GLrop_Normal3dv, v ); } #define X_GLrop_Normal3fv 30 -void -__indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) +void __indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&ny), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&nz), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Normal3fv 30 -void -__indirect_glNormal3fv(const GLfloat * v) +void __indirect_glNormal3fv(const GLfloat * v) { - generic_12_byte(X_GLrop_Normal3fv, v); + generic_12_byte( X_GLrop_Normal3fv, v ); } #define X_GLrop_Normal3iv 31 -void -__indirect_glNormal3i(GLint nx, GLint ny, GLint nz) +void __indirect_glNormal3i(GLint nx, GLint ny, GLint nz) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&ny), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&nz), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Normal3iv 31 -void -__indirect_glNormal3iv(const GLint * v) +void __indirect_glNormal3iv(const GLint * v) { - generic_12_byte(X_GLrop_Normal3iv, v); + generic_12_byte( X_GLrop_Normal3iv, v ); } #define X_GLrop_Normal3sv 32 -void -__indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz) +void __indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&ny), 2); - (void) memcpy((void *) (gc->pc + 8), (void *) (&nz), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&ny), 2); +(void) memcpy((void *)(gc->pc + 8), (void *)(&nz), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Normal3sv 32 -void -__indirect_glNormal3sv(const GLshort * v) +void __indirect_glNormal3sv(const GLshort * v) { - generic_6_byte(X_GLrop_Normal3sv, v); + generic_6_byte( X_GLrop_Normal3sv, v ); } #define X_GLrop_RasterPos2dv 33 -void -__indirect_glRasterPos2d(GLdouble x, GLdouble y) +void __indirect_glRasterPos2d(GLdouble x, GLdouble y) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_RasterPos2dv 33 -void -__indirect_glRasterPos2dv(const GLdouble * v) +void __indirect_glRasterPos2dv(const GLdouble * v) { - generic_16_byte(X_GLrop_RasterPos2dv, v); + generic_16_byte( X_GLrop_RasterPos2dv, v ); } #define X_GLrop_RasterPos2fv 34 -void -__indirect_glRasterPos2f(GLfloat x, GLfloat y) +void __indirect_glRasterPos2f(GLfloat x, GLfloat y) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_RasterPos2fv 34 -void -__indirect_glRasterPos2fv(const GLfloat * v) +void __indirect_glRasterPos2fv(const GLfloat * v) { - generic_8_byte(X_GLrop_RasterPos2fv, v); + generic_8_byte( X_GLrop_RasterPos2fv, v ); } #define X_GLrop_RasterPos2iv 35 -void -__indirect_glRasterPos2i(GLint x, GLint y) +void __indirect_glRasterPos2i(GLint x, GLint y) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_RasterPos2iv 35 -void -__indirect_glRasterPos2iv(const GLint * v) +void __indirect_glRasterPos2iv(const GLint * v) { - generic_8_byte(X_GLrop_RasterPos2iv, v); + generic_8_byte( X_GLrop_RasterPos2iv, v ); } #define X_GLrop_RasterPos2sv 36 -void -__indirect_glRasterPos2s(GLshort x, GLshort y) +void __indirect_glRasterPos2s(GLshort x, GLshort y) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_RasterPos2sv 36 -void -__indirect_glRasterPos2sv(const GLshort * v) +void __indirect_glRasterPos2sv(const GLshort * v) { - generic_4_byte(X_GLrop_RasterPos2sv, v); + generic_4_byte( X_GLrop_RasterPos2sv, v ); } #define X_GLrop_RasterPos3dv 37 -void -__indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z) +void __indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_RasterPos3dv 37 -void -__indirect_glRasterPos3dv(const GLdouble * v) +void __indirect_glRasterPos3dv(const GLdouble * v) { - generic_24_byte(X_GLrop_RasterPos3dv, v); + generic_24_byte( X_GLrop_RasterPos3dv, v ); } #define X_GLrop_RasterPos3fv 38 -void -__indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z) +void __indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_RasterPos3fv 38 -void -__indirect_glRasterPos3fv(const GLfloat * v) +void __indirect_glRasterPos3fv(const GLfloat * v) { - generic_12_byte(X_GLrop_RasterPos3fv, v); + generic_12_byte( X_GLrop_RasterPos3fv, v ); } #define X_GLrop_RasterPos3iv 39 -void -__indirect_glRasterPos3i(GLint x, GLint y, GLint z) +void __indirect_glRasterPos3i(GLint x, GLint y, GLint z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_RasterPos3iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RasterPos3iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_RasterPos3iv 39 -void -__indirect_glRasterPos3iv(const GLint * v) +void __indirect_glRasterPos3iv(const GLint * v) { - generic_12_byte(X_GLrop_RasterPos3iv, v); + generic_12_byte( X_GLrop_RasterPos3iv, v ); } #define X_GLrop_RasterPos3sv 40 -void -__indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z) +void __indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_RasterPos3sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2); - (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RasterPos3sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2); +(void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_RasterPos3sv 40 -void -__indirect_glRasterPos3sv(const GLshort * v) +void __indirect_glRasterPos3sv(const GLshort * v) { - generic_6_byte(X_GLrop_RasterPos3sv, v); + generic_6_byte( X_GLrop_RasterPos3sv, v ); } #define X_GLrop_RasterPos4dv 41 -void -__indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) +void __indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 36; - emit_header(gc->pc, X_GLrop_RasterPos4dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8); - (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RasterPos4dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8); +(void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_RasterPos4dv 41 -void -__indirect_glRasterPos4dv(const GLdouble * v) +void __indirect_glRasterPos4dv(const GLdouble * v) { - generic_32_byte(X_GLrop_RasterPos4dv, v); + generic_32_byte( X_GLrop_RasterPos4dv, v ); } #define X_GLrop_RasterPos4fv 42 -void -__indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) +void __indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_RasterPos4fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RasterPos4fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_RasterPos4fv 42 -void -__indirect_glRasterPos4fv(const GLfloat * v) +void __indirect_glRasterPos4fv(const GLfloat * v) { - generic_16_byte(X_GLrop_RasterPos4fv, v); + generic_16_byte( X_GLrop_RasterPos4fv, v ); } #define X_GLrop_RasterPos4iv 43 -void -__indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w) +void __indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_RasterPos4iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RasterPos4iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_RasterPos4iv 43 -void -__indirect_glRasterPos4iv(const GLint * v) +void __indirect_glRasterPos4iv(const GLint * v) { - generic_16_byte(X_GLrop_RasterPos4iv, v); + generic_16_byte( X_GLrop_RasterPos4iv, v ); } #define X_GLrop_RasterPos4sv 44 -void -__indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) +void __indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_RasterPos4sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2); - (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&w), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RasterPos4sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2); +(void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_RasterPos4sv 44 -void -__indirect_glRasterPos4sv(const GLshort * v) +void __indirect_glRasterPos4sv(const GLshort * v) { - generic_8_byte(X_GLrop_RasterPos4sv, v); + generic_8_byte( X_GLrop_RasterPos4sv, v ); } #define X_GLrop_Rectdv 45 -void -__indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +void __indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 36; - emit_header(gc->pc, X_GLrop_Rectdv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y1), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&x2), 8); - (void) memcpy((void *) (gc->pc + 28), (void *) (&y2), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Rectdv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y1), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&x2), 8); +(void) memcpy((void *)(gc->pc + 28), (void *)(&y2), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Rectdv 45 -void -__indirect_glRectdv(const GLdouble * v1, const GLdouble * v2) +void __indirect_glRectdv(const GLdouble * v1, const GLdouble * v2) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 36; - emit_header(gc->pc, X_GLrop_Rectdv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 16); - (void) memcpy((void *) (gc->pc + 20), (void *) (v2), 16); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Rectdv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(v1), 16); +(void) memcpy((void *)(gc->pc + 20), (void *)(v2), 16); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Rectfv 46 -void -__indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +void __indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_Rectfv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y1), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&x2), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y2), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Rectfv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Rectfv 46 -void -__indirect_glRectfv(const GLfloat * v1, const GLfloat * v2) +void __indirect_glRectfv(const GLfloat * v1, const GLfloat * v2) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_Rectfv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (v2), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Rectfv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Rectiv 47 -void -__indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2) +void __indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_Rectiv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y1), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&x2), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y2), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Rectiv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Rectiv 47 -void -__indirect_glRectiv(const GLint * v1, const GLint * v2) +void __indirect_glRectiv(const GLint * v1, const GLint * v2) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_Rectiv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (v2), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Rectiv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Rectsv 48 -void -__indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) +void __indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Rectsv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&y1), 2); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x2), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&y2), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Rectsv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&y1), 2); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x2), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&y2), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Rectsv 48 -void -__indirect_glRectsv(const GLshort * v1, const GLshort * v2) +void __indirect_glRectsv(const GLshort * v1, const GLshort * v2) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Rectsv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v2), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Rectsv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(v1), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v2), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord1dv 49 -void -__indirect_glTexCoord1d(GLdouble s) +void __indirect_glTexCoord1d(GLdouble s) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_TexCoord1dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord1dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord1dv 49 -void -__indirect_glTexCoord1dv(const GLdouble * v) +void __indirect_glTexCoord1dv(const GLdouble * v) { - generic_8_byte(X_GLrop_TexCoord1dv, v); + generic_8_byte( X_GLrop_TexCoord1dv, v ); } #define X_GLrop_TexCoord1fv 50 -void -__indirect_glTexCoord1f(GLfloat s) +void __indirect_glTexCoord1f(GLfloat s) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_TexCoord1fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord1fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord1fv 50 -void -__indirect_glTexCoord1fv(const GLfloat * v) +void __indirect_glTexCoord1fv(const GLfloat * v) { - generic_4_byte(X_GLrop_TexCoord1fv, v); + generic_4_byte( X_GLrop_TexCoord1fv, v ); } #define X_GLrop_TexCoord1iv 51 -void -__indirect_glTexCoord1i(GLint s) +void __indirect_glTexCoord1i(GLint s) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_TexCoord1iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord1iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord1iv 51 -void -__indirect_glTexCoord1iv(const GLint * v) +void __indirect_glTexCoord1iv(const GLint * v) { - generic_4_byte(X_GLrop_TexCoord1iv, v); + generic_4_byte( X_GLrop_TexCoord1iv, v ); } #define X_GLrop_TexCoord1sv 52 -void -__indirect_glTexCoord1s(GLshort s) +void __indirect_glTexCoord1s(GLshort s) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord1sv 52 -void -__indirect_glTexCoord1sv(const GLshort * v) +void __indirect_glTexCoord1sv(const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (v), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(v), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord2dv 53 -void -__indirect_glTexCoord2d(GLdouble s, GLdouble t) +void __indirect_glTexCoord2d(GLdouble s, GLdouble t) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_TexCoord2dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord2dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord2dv 53 -void -__indirect_glTexCoord2dv(const GLdouble * v) +void __indirect_glTexCoord2dv(const GLdouble * v) { - generic_16_byte(X_GLrop_TexCoord2dv, v); + generic_16_byte( X_GLrop_TexCoord2dv, v ); } #define X_GLrop_TexCoord2fv 54 -void -__indirect_glTexCoord2f(GLfloat s, GLfloat t) +void __indirect_glTexCoord2f(GLfloat s, GLfloat t) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_TexCoord2fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord2fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord2fv 54 -void -__indirect_glTexCoord2fv(const GLfloat * v) +void __indirect_glTexCoord2fv(const GLfloat * v) { - generic_8_byte(X_GLrop_TexCoord2fv, v); + generic_8_byte( X_GLrop_TexCoord2fv, v ); } #define X_GLrop_TexCoord2iv 55 -void -__indirect_glTexCoord2i(GLint s, GLint t) +void __indirect_glTexCoord2i(GLint s, GLint t) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_TexCoord2iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord2iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord2iv 55 -void -__indirect_glTexCoord2iv(const GLint * v) +void __indirect_glTexCoord2iv(const GLint * v) { - generic_8_byte(X_GLrop_TexCoord2iv, v); + generic_8_byte( X_GLrop_TexCoord2iv, v ); } #define X_GLrop_TexCoord2sv 56 -void -__indirect_glTexCoord2s(GLshort s, GLshort t) +void __indirect_glTexCoord2s(GLshort s, GLshort t) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_TexCoord2sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord2sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord2sv 56 -void -__indirect_glTexCoord2sv(const GLshort * v) +void __indirect_glTexCoord2sv(const GLshort * v) { - generic_4_byte(X_GLrop_TexCoord2sv, v); + generic_4_byte( X_GLrop_TexCoord2sv, v ); } #define X_GLrop_TexCoord3dv 57 -void -__indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r) +void __indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_TexCoord3dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord3dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord3dv 57 -void -__indirect_glTexCoord3dv(const GLdouble * v) +void __indirect_glTexCoord3dv(const GLdouble * v) { - generic_24_byte(X_GLrop_TexCoord3dv, v); + generic_24_byte( X_GLrop_TexCoord3dv, v ); } #define X_GLrop_TexCoord3fv 58 -void -__indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r) +void __indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_TexCoord3fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord3fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord3fv 58 -void -__indirect_glTexCoord3fv(const GLfloat * v) +void __indirect_glTexCoord3fv(const GLfloat * v) { - generic_12_byte(X_GLrop_TexCoord3fv, v); + generic_12_byte( X_GLrop_TexCoord3fv, v ); } #define X_GLrop_TexCoord3iv 59 -void -__indirect_glTexCoord3i(GLint s, GLint t, GLint r) +void __indirect_glTexCoord3i(GLint s, GLint t, GLint r) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord3iv 59 -void -__indirect_glTexCoord3iv(const GLint * v) +void __indirect_glTexCoord3iv(const GLint * v) { - generic_12_byte(X_GLrop_TexCoord3iv, v); + generic_12_byte( X_GLrop_TexCoord3iv, v ); } #define X_GLrop_TexCoord3sv 60 -void -__indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r) +void __indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2); - (void) memcpy((void *) (gc->pc + 8), (void *) (&r), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2); +(void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord3sv 60 -void -__indirect_glTexCoord3sv(const GLshort * v) +void __indirect_glTexCoord3sv(const GLshort * v) { - generic_6_byte(X_GLrop_TexCoord3sv, v); + generic_6_byte( X_GLrop_TexCoord3sv, v ); } #define X_GLrop_TexCoord4dv 61 -void -__indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) +void __indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 36; - emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8); - (void) memcpy((void *) (gc->pc + 28), (void *) (&q), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8); +(void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord4dv 61 -void -__indirect_glTexCoord4dv(const GLdouble * v) +void __indirect_glTexCoord4dv(const GLdouble * v) { - generic_32_byte(X_GLrop_TexCoord4dv, v); + generic_32_byte( X_GLrop_TexCoord4dv, v ); } #define X_GLrop_TexCoord4fv 62 -void -__indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) +void __indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&q), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord4fv 62 -void -__indirect_glTexCoord4fv(const GLfloat * v) +void __indirect_glTexCoord4fv(const GLfloat * v) { - generic_16_byte(X_GLrop_TexCoord4fv, v); + generic_16_byte( X_GLrop_TexCoord4fv, v ); } #define X_GLrop_TexCoord4iv 63 -void -__indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q) +void __indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&q), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord4iv 63 -void -__indirect_glTexCoord4iv(const GLint * v) +void __indirect_glTexCoord4iv(const GLint * v) { - generic_16_byte(X_GLrop_TexCoord4iv, v); + generic_16_byte( X_GLrop_TexCoord4iv, v ); } #define X_GLrop_TexCoord4sv 64 -void -__indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) +void __indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2); - (void) memcpy((void *) (gc->pc + 8), (void *) (&r), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&q), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2); +(void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&q), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexCoord4sv 64 -void -__indirect_glTexCoord4sv(const GLshort * v) +void __indirect_glTexCoord4sv(const GLshort * v) { - generic_8_byte(X_GLrop_TexCoord4sv, v); + generic_8_byte( X_GLrop_TexCoord4sv, v ); } #define X_GLrop_Vertex2dv 65 -void -__indirect_glVertex2d(GLdouble x, GLdouble y) +void __indirect_glVertex2d(GLdouble x, GLdouble y) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_Vertex2dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Vertex2dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Vertex2dv 65 -void -__indirect_glVertex2dv(const GLdouble * v) +void __indirect_glVertex2dv(const GLdouble * v) { - generic_16_byte(X_GLrop_Vertex2dv, v); + generic_16_byte( X_GLrop_Vertex2dv, v ); } #define X_GLrop_Vertex2fv 66 -void -__indirect_glVertex2f(GLfloat x, GLfloat y) +void __indirect_glVertex2f(GLfloat x, GLfloat y) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Vertex2fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Vertex2fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Vertex2fv 66 -void -__indirect_glVertex2fv(const GLfloat * v) +void __indirect_glVertex2fv(const GLfloat * v) { - generic_8_byte(X_GLrop_Vertex2fv, v); + generic_8_byte( X_GLrop_Vertex2fv, v ); } #define X_GLrop_Vertex2iv 67 -void -__indirect_glVertex2i(GLint x, GLint y) +void __indirect_glVertex2i(GLint x, GLint y) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Vertex2iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Vertex2iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Vertex2iv 67 -void -__indirect_glVertex2iv(const GLint * v) +void __indirect_glVertex2iv(const GLint * v) { - generic_8_byte(X_GLrop_Vertex2iv, v); + generic_8_byte( X_GLrop_Vertex2iv, v ); } #define X_GLrop_Vertex2sv 68 -void -__indirect_glVertex2s(GLshort x, GLshort y) +void __indirect_glVertex2s(GLshort x, GLshort y) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_Vertex2sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Vertex2sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Vertex2sv 68 -void -__indirect_glVertex2sv(const GLshort * v) +void __indirect_glVertex2sv(const GLshort * v) { - generic_4_byte(X_GLrop_Vertex2sv, v); + generic_4_byte( X_GLrop_Vertex2sv, v ); } #define X_GLrop_Vertex3dv 69 -void -__indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z) +void __indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_Vertex3dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Vertex3dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Vertex3dv 69 -void -__indirect_glVertex3dv(const GLdouble * v) +void __indirect_glVertex3dv(const GLdouble * v) { - generic_24_byte(X_GLrop_Vertex3dv, v); + generic_24_byte( X_GLrop_Vertex3dv, v ); } #define X_GLrop_Vertex3fv 70 -void -__indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z) +void __indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_Vertex3fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Vertex3fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Vertex3fv 70 -void -__indirect_glVertex3fv(const GLfloat * v) +void __indirect_glVertex3fv(const GLfloat * v) { - generic_12_byte(X_GLrop_Vertex3fv, v); + generic_12_byte( X_GLrop_Vertex3fv, v ); } #define X_GLrop_Vertex3iv 71 -void -__indirect_glVertex3i(GLint x, GLint y, GLint z) +void __indirect_glVertex3i(GLint x, GLint y, GLint z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_Vertex3iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Vertex3iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Vertex3iv 71 -void -__indirect_glVertex3iv(const GLint * v) +void __indirect_glVertex3iv(const GLint * v) { - generic_12_byte(X_GLrop_Vertex3iv, v); + generic_12_byte( X_GLrop_Vertex3iv, v ); } #define X_GLrop_Vertex3sv 72 -void -__indirect_glVertex3s(GLshort x, GLshort y, GLshort z) +void __indirect_glVertex3s(GLshort x, GLshort y, GLshort z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Vertex3sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2); - (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Vertex3sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2); +(void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Vertex3sv 72 -void -__indirect_glVertex3sv(const GLshort * v) +void __indirect_glVertex3sv(const GLshort * v) { - generic_6_byte(X_GLrop_Vertex3sv, v); + generic_6_byte( X_GLrop_Vertex3sv, v ); } #define X_GLrop_Vertex4dv 73 -void -__indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) +void __indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 36; - emit_header(gc->pc, X_GLrop_Vertex4dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8); - (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Vertex4dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8); +(void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Vertex4dv 73 -void -__indirect_glVertex4dv(const GLdouble * v) +void __indirect_glVertex4dv(const GLdouble * v) { - generic_32_byte(X_GLrop_Vertex4dv, v); + generic_32_byte( X_GLrop_Vertex4dv, v ); } #define X_GLrop_Vertex4fv 74 -void -__indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) +void __indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_Vertex4fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Vertex4fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Vertex4fv 74 -void -__indirect_glVertex4fv(const GLfloat * v) +void __indirect_glVertex4fv(const GLfloat * v) { - generic_16_byte(X_GLrop_Vertex4fv, v); + generic_16_byte( X_GLrop_Vertex4fv, v ); } #define X_GLrop_Vertex4iv 75 -void -__indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w) +void __indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_Vertex4iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Vertex4iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Vertex4iv 75 -void -__indirect_glVertex4iv(const GLint * v) +void __indirect_glVertex4iv(const GLint * v) { - generic_16_byte(X_GLrop_Vertex4iv, v); + generic_16_byte( X_GLrop_Vertex4iv, v ); } #define X_GLrop_Vertex4sv 76 -void -__indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) +void __indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2); - (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&w), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2); +(void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Vertex4sv 76 -void -__indirect_glVertex4sv(const GLshort * v) +void __indirect_glVertex4sv(const GLshort * v) { - generic_8_byte(X_GLrop_Vertex4sv, v); + generic_8_byte( X_GLrop_Vertex4sv, v ); } #define X_GLrop_ClipPlane 77 -void -__indirect_glClipPlane(GLenum plane, const GLdouble * equation) +void __indirect_glClipPlane(GLenum plane, const GLdouble * equation) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 40; - emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (equation), 32); - (void) memcpy((void *) (gc->pc + 36), (void *) (&plane), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(equation), 32); +(void) memcpy((void *)(gc->pc + 36), (void *)(&plane), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ColorMaterial 78 -void -__indirect_glColorMaterial(GLenum face, GLenum mode) +void __indirect_glColorMaterial(GLenum face, GLenum mode) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_CullFace 79 -void -__indirect_glCullFace(GLenum mode) +void __indirect_glCullFace(GLenum mode) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_CullFace, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_CullFace, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Fogf 80 -void -__indirect_glFogf(GLenum pname, GLfloat param) +void __indirect_glFogf(GLenum pname, GLfloat param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Fogf, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Fogf, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Fogfv 81 -void -__indirect_glFogfv(GLenum pname, const GLfloat * params) +void __indirect_glFogfv(GLenum pname, const GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glFogfv_size(pname); const GLuint cmdlen = 8 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_Fogfv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Fogfv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Fogi 82 -void -__indirect_glFogi(GLenum pname, GLint param) +void __indirect_glFogi(GLenum pname, GLint param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Fogi, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Fogi, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Fogiv 83 -void -__indirect_glFogiv(GLenum pname, const GLint * params) +void __indirect_glFogiv(GLenum pname, const GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glFogiv_size(pname); const GLuint cmdlen = 8 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_Fogiv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Fogiv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_FrontFace 84 -void -__indirect_glFrontFace(GLenum mode) +void __indirect_glFrontFace(GLenum mode) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_FrontFace, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_FrontFace, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Hint 85 -void -__indirect_glHint(GLenum target, GLenum mode) +void __indirect_glHint(GLenum target, GLenum mode) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Hint, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Hint, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Lightf 86 -void -__indirect_glLightf(GLenum light, GLenum pname, GLfloat param) +void __indirect_glLightf(GLenum light, GLenum pname, GLfloat param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_Lightf, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Lightf, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Lightfv 87 -void -__indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params) +void __indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glLightfv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_Lightfv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Lightfv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Lighti 88 -void -__indirect_glLighti(GLenum light, GLenum pname, GLint param) +void __indirect_glLighti(GLenum light, GLenum pname, GLint param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_Lighti, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Lighti, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Lightiv 89 -void -__indirect_glLightiv(GLenum light, GLenum pname, const GLint * params) +void __indirect_glLightiv(GLenum light, GLenum pname, const GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glLightiv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_Lightiv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Lightiv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_LightModelf 90 -void -__indirect_glLightModelf(GLenum pname, GLfloat param) +void __indirect_glLightModelf(GLenum pname, GLfloat param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_LightModelf, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_LightModelf, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_LightModelfv 91 -void -__indirect_glLightModelfv(GLenum pname, const GLfloat * params) +void __indirect_glLightModelfv(GLenum pname, const GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glLightModelfv_size(pname); const GLuint cmdlen = 8 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_LightModelfv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_LightModelfv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_LightModeli 92 -void -__indirect_glLightModeli(GLenum pname, GLint param) +void __indirect_glLightModeli(GLenum pname, GLint param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_LightModeli, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_LightModeli, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_LightModeliv 93 -void -__indirect_glLightModeliv(GLenum pname, const GLint * params) +void __indirect_glLightModeliv(GLenum pname, const GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glLightModeliv_size(pname); const GLuint cmdlen = 8 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_LightModeliv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_LightModeliv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_LineStipple 94 -void -__indirect_glLineStipple(GLint factor, GLushort pattern) +void __indirect_glLineStipple(GLint factor, GLushort pattern) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_LineStipple, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&factor), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pattern), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_LineStipple, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pattern), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_LineWidth 95 -void -__indirect_glLineWidth(GLfloat width) +void __indirect_glLineWidth(GLfloat width) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_LineWidth, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&width), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_LineWidth, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&width), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Materialf 96 -void -__indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param) +void __indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_Materialf, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Materialf, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Materialfv 97 -void -__indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params) +void __indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glMaterialfv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_Materialfv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Materialfv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Materiali 98 -void -__indirect_glMateriali(GLenum face, GLenum pname, GLint param) +void __indirect_glMateriali(GLenum face, GLenum pname, GLint param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_Materiali, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Materiali, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Materialiv 99 -void -__indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params) +void __indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glMaterialiv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_Materialiv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Materialiv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PointSize 100 -void -__indirect_glPointSize(GLfloat size) +void __indirect_glPointSize(GLfloat size) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_PointSize, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&size), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PointSize, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&size), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PolygonMode 101 -void -__indirect_glPolygonMode(GLenum face, GLenum mode) +void __indirect_glPolygonMode(GLenum face, GLenum mode) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_PolygonMode, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PolygonMode, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PolygonStipple 102 -void -__indirect_glPolygonStipple(const GLubyte *mask) +void __indirect_glPolygonStipple(const GLubyte * mask) { - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint compsize = - (mask != NULL) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, - 0) : 0; + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint compsize = (mask != NULL) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, 0) : 0; const GLuint cmdlen = 24 + safe_pad(compsize); if (0 + safe_pad(compsize) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_PolygonStipple, cmdlen); - if (compsize > 0) { - gc->fillImage(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, - gc->pc + 24, gc->pc + 4); - } else { - (void) memcpy(gc->pc + 4, default_pixel_store_2D, - default_pixel_store_2D_size); - } - gc->pc += cmdlen; - if (gc->pc > gc->limit) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PolygonStipple, cmdlen); +if (compsize > 0) { + gc->fillImage(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, gc->pc + 24, gc->pc + 4); +} else { + (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size ); +} +gc->pc += cmdlen; +if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Scissor 103 -void -__indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height) +void __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_Scissor, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Scissor, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ShadeModel 104 -void -__indirect_glShadeModel(GLenum mode) +void __indirect_glShadeModel(GLenum mode) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_ShadeModel, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ShadeModel, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexParameterf 105 -void -__indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param) +void __indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_TexParameterf, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexParameterf, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexParameterfv 106 -void -__indirect_glTexParameterfv(GLenum target, GLenum pname, - const GLfloat * params) +void __indirect_glTexParameterfv(GLenum target, GLenum pname, const GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glTexParameterfv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_TexParameterfv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexParameterfv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexParameteri 107 -void -__indirect_glTexParameteri(GLenum target, GLenum pname, GLint param) +void __indirect_glTexParameteri(GLenum target, GLenum pname, GLint param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_TexParameteri, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexParameteri, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexParameteriv 108 -void -__indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * params) +void __indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glTexParameteriv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_TexParameteriv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexParameteriv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } static void -__glx_TexImage_1D2D(unsigned opcode, unsigned dim, GLenum target, GLint level, - GLint internalformat, GLsizei width, GLsizei height, - GLint border, GLenum format, GLenum type, - const GLvoid * pixels) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint compsize = - __glImageSize(width, height, 1, format, type, target); +__glx_TexImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels ) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint compsize = __glImageSize(width, height, 1, format, type, target); const GLuint cmdlen = 56 + safe_pad(compsize); if (0 + safe_pad(compsize) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } if (__builtin_expect(gc->currentDpy != NULL, 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, opcode, cmdlen); - (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 28), (void *) (&level), 4); - (void) memcpy((void *) (gc->pc + 32), (void *) (&internalformat), - 4); - (void) memcpy((void *) (gc->pc + 36), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 40), (void *) (&height), 4); - (void) memcpy((void *) (gc->pc + 44), (void *) (&border), 4); - (void) memcpy((void *) (gc->pc + 48), (void *) (&format), 4); - (void) memcpy((void *) (gc->pc + 52), (void *) (&type), 4); - if ((compsize > 0) && (pixels != NULL)) { - gc->fillImage(gc, dim, width, height, 1, format, type, pixels, - gc->pc + 56, gc->pc + 4); - } else { - (void) memcpy(gc->pc + 4, default_pixel_store_2D, - default_pixel_store_2D_size); - } - gc->pc += cmdlen; - if (gc->pc > gc->limit) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = opcode; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 28), (void *) (&target), 4); - (void) memcpy((void *) (pc + 32), (void *) (&level), 4); - (void) memcpy((void *) (pc + 36), (void *) (&internalformat), 4); - (void) memcpy((void *) (pc + 40), (void *) (&width), 4); - (void) memcpy((void *) (pc + 44), (void *) (&height), 4); - (void) memcpy((void *) (pc + 48), (void *) (&border), 4); - (void) memcpy((void *) (pc + 52), (void *) (&format), 4); - (void) memcpy((void *) (pc + 56), (void *) (&type), 4); - __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, - type, pixels, pc + 60, pc + 8); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, opcode, cmdlen); +(void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4); +(void) memcpy((void *)(gc->pc + 32), (void *)(&internalformat), 4); +(void) memcpy((void *)(gc->pc + 36), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 40), (void *)(&height), 4); +(void) memcpy((void *)(gc->pc + 44), (void *)(&border), 4); +(void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4); +(void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4); +if ((compsize > 0) && (pixels != NULL)) { + gc->fillImage(gc, dim, width, height, 1, format, type, pixels, gc->pc + 56, gc->pc + 4); +} else { + (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size ); +} +gc->pc += cmdlen; +if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = opcode; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 28), (void *)(&target), 4); +(void) memcpy((void *)(pc + 32), (void *)(&level), 4); +(void) memcpy((void *)(pc + 36), (void *)(&internalformat), 4); +(void) memcpy((void *)(pc + 40), (void *)(&width), 4); +(void) memcpy((void *)(pc + 44), (void *)(&height), 4); +(void) memcpy((void *)(pc + 48), (void *)(&border), 4); +(void) memcpy((void *)(pc + 52), (void *)(&format), 4); +(void) memcpy((void *)(pc + 56), (void *)(&type), 4); +__glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, pc + 60, pc + 8); +} } } #define X_GLrop_TexImage1D 109 -void -__indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat, - GLsizei width, GLint border, GLenum format, - GLenum type, const GLvoid * pixels) +void __indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels) { - __glx_TexImage_1D2D(X_GLrop_TexImage1D, 1, target, level, internalformat, - width, 1, border, format, type, pixels); + __glx_TexImage_1D2D(X_GLrop_TexImage1D, 1, target, level, internalformat, width, 1, border, format, type, pixels ); } #define X_GLrop_TexImage2D 110 -void -__indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat, - GLsizei width, GLsizei height, GLint border, - GLenum format, GLenum type, const GLvoid * pixels) +void __indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels) { - __glx_TexImage_1D2D(X_GLrop_TexImage2D, 2, target, level, internalformat, - width, height, border, format, type, pixels); + __glx_TexImage_1D2D(X_GLrop_TexImage2D, 2, target, level, internalformat, width, height, border, format, type, pixels ); } #define X_GLrop_TexEnvf 111 -void -__indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param) +void __indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_TexEnvf, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexEnvf, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexEnvfv 112 -void -__indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params) +void __indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glTexEnvfv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_TexEnvfv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexEnvfv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexEnvi 113 -void -__indirect_glTexEnvi(GLenum target, GLenum pname, GLint param) +void __indirect_glTexEnvi(GLenum target, GLenum pname, GLint param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_TexEnvi, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexEnvi, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexEnviv 114 -void -__indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params) +void __indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glTexEnviv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_TexEnviv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexEnviv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexGend 115 -void -__indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param) +void __indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_TexGend, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (¶m), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&coord), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&pname), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexGend, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(¶m), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&coord), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&pname), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexGendv 116 -void -__indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params) +void __indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glTexGendv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 8)); if (0 + safe_pad(safe_mul(compsize, 8)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_TexGendv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 8)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexGendv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 8)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexGenf 117 -void -__indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param) +void __indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_TexGenf, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexGenf, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexGenfv 118 -void -__indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params) +void __indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glTexGenfv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_TexGenfv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexGenfv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexGeni 119 -void -__indirect_glTexGeni(GLenum coord, GLenum pname, GLint param) +void __indirect_glTexGeni(GLenum coord, GLenum pname, GLint param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_TexGeni, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexGeni, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_TexGeniv 120 -void -__indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params) +void __indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glTexGeniv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_TexGeniv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TexGeniv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_InitNames 121 -void -__indirect_glInitNames(void) +void __indirect_glInitNames(void) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 4; - emit_header(gc->pc, X_GLrop_InitNames, cmdlen); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_InitNames, cmdlen); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_LoadName 122 -void -__indirect_glLoadName(GLuint name) +void __indirect_glLoadName(GLuint name) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_LoadName, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&name), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_LoadName, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PassThrough 123 -void -__indirect_glPassThrough(GLfloat token) +void __indirect_glPassThrough(GLfloat token) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_PassThrough, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&token), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PassThrough, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&token), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PopName 124 -void -__indirect_glPopName(void) +void __indirect_glPopName(void) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 4; - emit_header(gc->pc, X_GLrop_PopName, cmdlen); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PopName, cmdlen); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PushName 125 -void -__indirect_glPushName(GLuint name) +void __indirect_glPushName(GLuint name) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_PushName, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&name), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PushName, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_DrawBuffer 126 -void -__indirect_glDrawBuffer(GLenum mode) +void __indirect_glDrawBuffer(GLenum mode) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_DrawBuffer, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_DrawBuffer, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Clear 127 -void -__indirect_glClear(GLbitfield mask) +void __indirect_glClear(GLbitfield mask) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_Clear, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Clear, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ClearAccum 128 -void -__indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, - GLfloat alpha) +void __indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_ClearAccum, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ClearAccum, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ClearIndex 129 -void -__indirect_glClearIndex(GLfloat c) +void __indirect_glClearIndex(GLfloat c) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_ClearIndex, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ClearIndex, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ClearColor 130 -void -__indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue, - GLclampf alpha) +void __indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_ClearColor, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ClearColor, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ClearStencil 131 -void -__indirect_glClearStencil(GLint s) +void __indirect_glClearStencil(GLint s) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_ClearStencil, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ClearStencil, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ClearDepth 132 -void -__indirect_glClearDepth(GLclampd depth) +void __indirect_glClearDepth(GLclampd depth) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_ClearDepth, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&depth), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ClearDepth, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&depth), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_StencilMask 133 -void -__indirect_glStencilMask(GLuint mask) +void __indirect_glStencilMask(GLuint mask) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_StencilMask, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_StencilMask, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ColorMask 134 -void -__indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue, - GLboolean alpha) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_ColorMask, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1); - (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1); - (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1); - (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +void __indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint cmdlen = 8; +emit_header(gc->pc, X_GLrop_ColorMask, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1); +(void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1); +(void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1); +(void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_DepthMask 135 -void -__indirect_glDepthMask(GLboolean flag) +void __indirect_glDepthMask(GLboolean flag) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_DepthMask, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&flag), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_DepthMask, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_IndexMask 136 -void -__indirect_glIndexMask(GLuint mask) +void __indirect_glIndexMask(GLuint mask) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_IndexMask, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_IndexMask, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Accum 137 -void -__indirect_glAccum(GLenum op, GLfloat value) +void __indirect_glAccum(GLenum op, GLfloat value) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_Accum, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&value), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Accum, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&value), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PopAttrib 141 -void -__indirect_glPopAttrib(void) +void __indirect_glPopAttrib(void) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 4; - emit_header(gc->pc, X_GLrop_PopAttrib, cmdlen); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PopAttrib, cmdlen); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PushAttrib 142 -void -__indirect_glPushAttrib(GLbitfield mask) +void __indirect_glPushAttrib(GLbitfield mask) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_PushAttrib, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PushAttrib, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MapGrid1d 147 -void -__indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2) +void __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_MapGrid1d, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&u1), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&un), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MapGrid1d, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&un), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MapGrid1f 148 -void -__indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2) +void __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_MapGrid1f, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&un), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&u1), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MapGrid1f, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MapGrid2d 149 -void -__indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, - GLdouble v1, GLdouble v2) +void __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 44; - emit_header(gc->pc, X_GLrop_MapGrid2d, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&u1), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&v1), 8); - (void) memcpy((void *) (gc->pc + 28), (void *) (&v2), 8); - (void) memcpy((void *) (gc->pc + 36), (void *) (&un), 4); - (void) memcpy((void *) (gc->pc + 40), (void *) (&vn), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MapGrid2d, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 8); +(void) memcpy((void *)(gc->pc + 28), (void *)(&v2), 8); +(void) memcpy((void *)(gc->pc + 36), (void *)(&un), 4); +(void) memcpy((void *)(gc->pc + 40), (void *)(&vn), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MapGrid2f 150 -void -__indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, - GLfloat v2) +void __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_MapGrid2f, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&un), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&u1), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&vn), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&v1), 4); - (void) memcpy((void *) (gc->pc + 24), (void *) (&v2), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MapGrid2f, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&vn), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 4); +(void) memcpy((void *)(gc->pc + 24), (void *)(&v2), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_EvalCoord1dv 151 -void -__indirect_glEvalCoord1d(GLdouble u) +void __indirect_glEvalCoord1d(GLdouble u) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_EvalCoord1dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_EvalCoord1dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_EvalCoord1dv 151 -void -__indirect_glEvalCoord1dv(const GLdouble * u) +void __indirect_glEvalCoord1dv(const GLdouble * u) { - generic_8_byte(X_GLrop_EvalCoord1dv, u); + generic_8_byte( X_GLrop_EvalCoord1dv, u ); } #define X_GLrop_EvalCoord1fv 152 -void -__indirect_glEvalCoord1f(GLfloat u) +void __indirect_glEvalCoord1f(GLfloat u) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_EvalCoord1fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_EvalCoord1fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_EvalCoord1fv 152 -void -__indirect_glEvalCoord1fv(const GLfloat * u) +void __indirect_glEvalCoord1fv(const GLfloat * u) { - generic_4_byte(X_GLrop_EvalCoord1fv, u); + generic_4_byte( X_GLrop_EvalCoord1fv, u ); } #define X_GLrop_EvalCoord2dv 153 -void -__indirect_glEvalCoord2d(GLdouble u, GLdouble v) +void __indirect_glEvalCoord2d(GLdouble u, GLdouble v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_EvalCoord2dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&v), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_EvalCoord2dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&v), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_EvalCoord2dv 153 -void -__indirect_glEvalCoord2dv(const GLdouble * u) +void __indirect_glEvalCoord2dv(const GLdouble * u) { - generic_16_byte(X_GLrop_EvalCoord2dv, u); + generic_16_byte( X_GLrop_EvalCoord2dv, u ); } #define X_GLrop_EvalCoord2fv 154 -void -__indirect_glEvalCoord2f(GLfloat u, GLfloat v) +void __indirect_glEvalCoord2f(GLfloat u, GLfloat v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_EvalCoord2fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&v), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_EvalCoord2fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&v), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_EvalCoord2fv 154 -void -__indirect_glEvalCoord2fv(const GLfloat * u) +void __indirect_glEvalCoord2fv(const GLfloat * u) { - generic_8_byte(X_GLrop_EvalCoord2fv, u); + generic_8_byte( X_GLrop_EvalCoord2fv, u ); } #define X_GLrop_EvalMesh1 155 -void -__indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2) +void __indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_EvalMesh1, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&i1), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&i2), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_EvalMesh1, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_EvalPoint1 156 -void -__indirect_glEvalPoint1(GLint i) +void __indirect_glEvalPoint1(GLint i) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_EvalPoint1, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&i), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_EvalPoint1, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_EvalMesh2 157 -void -__indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +void __indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_EvalMesh2, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&i1), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&i2), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&j1), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&j2), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_EvalMesh2, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&j1), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&j2), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_EvalPoint2 158 -void -__indirect_glEvalPoint2(GLint i, GLint j) +void __indirect_glEvalPoint2(GLint i, GLint j) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_EvalPoint2, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&i), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&j), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_EvalPoint2, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&j), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_AlphaFunc 159 -void -__indirect_glAlphaFunc(GLenum func, GLclampf ref) +void __indirect_glAlphaFunc(GLenum func, GLclampf ref) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_AlphaFunc, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&ref), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_AlphaFunc, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_BlendFunc 160 -void -__indirect_glBlendFunc(GLenum sfactor, GLenum dfactor) +void __indirect_glBlendFunc(GLenum sfactor, GLenum dfactor) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_BlendFunc, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&sfactor), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&dfactor), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_BlendFunc, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&sfactor), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&dfactor), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_LogicOp 161 -void -__indirect_glLogicOp(GLenum opcode) +void __indirect_glLogicOp(GLenum opcode) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_LogicOp, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&opcode), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_LogicOp, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&opcode), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_StencilFunc 162 -void -__indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask) +void __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_StencilFunc, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&ref), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&mask), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_StencilFunc, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&mask), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_StencilOp 163 -void -__indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) +void __indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_StencilOp, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&fail), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&zfail), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&zpass), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_StencilOp, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&fail), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&zfail), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&zpass), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_DepthFunc 164 -void -__indirect_glDepthFunc(GLenum func) +void __indirect_glDepthFunc(GLenum func) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_DepthFunc, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_DepthFunc, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PixelZoom 165 -void -__indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor) +void __indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_PixelZoom, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&xfactor), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&yfactor), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PixelZoom, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&xfactor), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&yfactor), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PixelTransferf 166 -void -__indirect_glPixelTransferf(GLenum pname, GLfloat param) +void __indirect_glPixelTransferf(GLenum pname, GLfloat param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_PixelTransferf, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PixelTransferf, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PixelTransferi 167 -void -__indirect_glPixelTransferi(GLenum pname, GLint param) +void __indirect_glPixelTransferi(GLenum pname, GLint param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_PixelTransferi, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PixelTransferi, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PixelMapfv 168 -void -__indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values) +void __indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(mapsize, 4)); if (0 + safe_pad(safe_mul(mapsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -3722,37 +3061,34 @@ return; } if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (values), - safe_mul(mapsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = X_GLrop_PixelMapfv; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 8), (void *) (&map), 4); - (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4); - __glXSendLargeCommand(gc, pc, 16, values, safe_mul(mapsize, 4)); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(values), safe_mul(mapsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = X_GLrop_PixelMapfv; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 8), (void *)(&map), 4); +(void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4); + __glXSendLargeCommand(gc, pc, 16, values, safe_mul(mapsize, 4)); +} } } #define X_GLrop_PixelMapuiv 169 -void -__indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values) +void __indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(mapsize, 4)); if (0 + safe_pad(safe_mul(mapsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -3763,37 +3099,34 @@ return; } if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (values), - safe_mul(mapsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = X_GLrop_PixelMapuiv; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 8), (void *) (&map), 4); - (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4); - __glXSendLargeCommand(gc, pc, 16, values, safe_mul(mapsize, 4)); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(values), safe_mul(mapsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = X_GLrop_PixelMapuiv; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 8), (void *)(&map), 4); +(void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4); + __glXSendLargeCommand(gc, pc, 16, values, safe_mul(mapsize, 4)); +} } } #define X_GLrop_PixelMapusv 170 -void -__indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values) +void __indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(mapsize, 2)); if (0 + safe_pad(safe_mul(mapsize, 2)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -3804,73 +3137,62 @@ return; } if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (values), - safe_mul(mapsize, 2)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = X_GLrop_PixelMapusv; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 8), (void *) (&map), 4); - (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4); - __glXSendLargeCommand(gc, pc, 16, values, safe_mul(mapsize, 2)); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(values), safe_mul(mapsize, 2)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = X_GLrop_PixelMapusv; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 8), (void *)(&map), 4); +(void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4); + __glXSendLargeCommand(gc, pc, 16, values, safe_mul(mapsize, 2)); +} } } #define X_GLrop_ReadBuffer 171 -void -__indirect_glReadBuffer(GLenum mode) +void __indirect_glReadBuffer(GLenum mode) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_ReadBuffer, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ReadBuffer, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_CopyPixels 172 -void -__indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, - GLenum type) +void __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_CopyPixels, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&type), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_CopyPixels, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&type), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLsop_ReadPixels 111 -void -__indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, - GLenum format, GLenum type, GLvoid * pixels) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const __GLXattribute *const state = gc->client_state_private; - Display *const dpy = gc->currentDpy; +void __indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const __GLXattribute * const state = gc->client_state_private; + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 28; #endif @@ -3878,96 +3200,74 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_read_pixels_reply_t *reply = - xcb_glx_read_pixels_reply(c, - xcb_glx_read_pixels(c, - gc-> - currentContextTag, - x, y, width, height, - format, type, - state->storePack. - swapEndian, 0), - NULL); - __glEmptyImage(gc, 3, width, height, 1, format, type, - xcb_glx_read_pixels_data(reply), pixels); - free(reply); -#else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_ReadPixels, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&x), 4); - (void) memcpy((void *) (pc + 4), (void *) (&y), 4); - (void) memcpy((void *) (pc + 8), (void *) (&width), 4); - (void) memcpy((void *) (pc + 12), (void *) (&height), 4); - (void) memcpy((void *) (pc + 16), (void *) (&format), 4); - (void) memcpy((void *) (pc + 20), (void *) (&type), 4); - *(int32_t *) (pc + 24) = 0; - *(int8_t *) (pc + 24) = state->storePack.swapEndian; - __glXReadPixelReply(dpy, gc, 2, width, height, 1, format, type, - pixels, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + xcb_glx_read_pixels_reply_t *reply = xcb_glx_read_pixels_reply(c, xcb_glx_read_pixels(c, gc->currentContextTag, x, y, width, height, format, type, state->storePack.swapEndian, 0), NULL); + __glEmptyImage(gc, 3, width, height, 1, format, type, xcb_glx_read_pixels_data(reply), pixels); + free(reply); +#else + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_ReadPixels, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&x), 4); +(void) memcpy((void *)(pc + 4), (void *)(&y), 4); +(void) memcpy((void *)(pc + 8), (void *)(&width), 4); +(void) memcpy((void *)(pc + 12), (void *)(&height), 4); +(void) memcpy((void *)(pc + 16), (void *)(&format), 4); +(void) memcpy((void *)(pc + 20), (void *)(&type), 4); + *(int32_t *)(pc + 24) = 0; + * (int8_t *)(pc + 24) = state->storePack.swapEndian; + __glXReadPixelReply(dpy, gc, 2, width, height, 1, format, type, pixels, GL_FALSE); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLrop_DrawPixels 173 -void -__indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, - GLenum type, const GLvoid * pixels) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint compsize = - (pixels != NULL) ? __glImageSize(width, height, 1, format, type, - 0) : 0; +void __indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, format, type, 0) : 0; const GLuint cmdlen = 40 + safe_pad(compsize); if (0 + safe_pad(compsize) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } if (__builtin_expect(gc->currentDpy != NULL, 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, X_GLrop_DrawPixels, cmdlen); - (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4); - (void) memcpy((void *) (gc->pc + 32), (void *) (&format), 4); - (void) memcpy((void *) (gc->pc + 36), (void *) (&type), 4); - if (compsize > 0) { - gc->fillImage(gc, 2, width, height, 1, format, type, pixels, - gc->pc + 40, gc->pc + 4); - } else { - (void) memcpy(gc->pc + 4, default_pixel_store_2D, - default_pixel_store_2D_size); - } - gc->pc += cmdlen; - if (gc->pc > gc->limit) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = X_GLrop_DrawPixels; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 28), (void *) (&width), 4); - (void) memcpy((void *) (pc + 32), (void *) (&height), 4); - (void) memcpy((void *) (pc + 36), (void *) (&format), 4); - (void) memcpy((void *) (pc + 40), (void *) (&type), 4); - __glXSendLargeImage(gc, compsize, 2, width, height, 1, format, - type, pixels, pc + 44, pc + 8); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, X_GLrop_DrawPixels, cmdlen); +(void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4); +(void) memcpy((void *)(gc->pc + 32), (void *)(&format), 4); +(void) memcpy((void *)(gc->pc + 36), (void *)(&type), 4); +if (compsize > 0) { + gc->fillImage(gc, 2, width, height, 1, format, type, pixels, gc->pc + 40, gc->pc + 4); +} else { + (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size ); +} +gc->pc += cmdlen; +if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = X_GLrop_DrawPixels; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 28), (void *)(&width), 4); +(void) memcpy((void *)(pc + 32), (void *)(&height), 4); +(void) memcpy((void *)(pc + 36), (void *)(&format), 4); +(void) memcpy((void *)(pc + 40), (void *)(&type), 4); +__glXSendLargeImage(gc, compsize, 2, width, height, 1, format, type, pixels, pc + 44, pc + 8); +} } } #define X_GLsop_GetClipPlane 113 -void -__indirect_glGetClipPlane(GLenum plane, GLdouble * equation) +void __indirect_glGetClipPlane(GLenum plane, GLdouble * equation) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 4; #endif @@ -3975,34 +3275,24 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_clip_plane_reply_t *reply = - xcb_glx_get_clip_plane_reply(c, - xcb_glx_get_clip_plane(c, - gc-> - currentContextTag, - plane), NULL); - (void) memcpy(equation, xcb_glx_get_clip_plane_data(reply), - xcb_glx_get_clip_plane_data_length(reply) * - sizeof(GLdouble)); + xcb_glx_get_clip_plane_reply_t *reply = xcb_glx_get_clip_plane_reply(c, xcb_glx_get_clip_plane(c, gc->currentContextTag, plane), NULL); + (void)memcpy(equation, xcb_glx_get_clip_plane_data(reply), xcb_glx_get_clip_plane_data_length(reply) * sizeof(GLdouble)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetClipPlane, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&plane), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetClipPlane, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&plane), 4); (void) __glXReadReply(dpy, 8, equation, GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetLightfv 118 -void -__indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params) +void __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -4010,41 +3300,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_lightfv_reply_t *reply = - xcb_glx_get_lightfv_reply(c, - xcb_glx_get_lightfv(c, - gc-> - currentContextTag, - light, pname), - NULL); + xcb_glx_get_lightfv_reply_t *reply = xcb_glx_get_lightfv_reply(c, xcb_glx_get_lightfv(c, gc->currentContextTag, light, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_lightfv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_lightfv_data(reply), - xcb_glx_get_lightfv_data_length(reply) * - sizeof(GLfloat)); + (void)memcpy(params, xcb_glx_get_lightfv_data(reply), xcb_glx_get_lightfv_data_length(reply) * sizeof(GLfloat)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetLightfv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&light), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetLightfv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&light), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetLightiv 119 -void -__indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params) +void __indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -4052,41 +3331,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_lightiv_reply_t *reply = - xcb_glx_get_lightiv_reply(c, - xcb_glx_get_lightiv(c, - gc-> - currentContextTag, - light, pname), - NULL); + xcb_glx_get_lightiv_reply_t *reply = xcb_glx_get_lightiv_reply(c, xcb_glx_get_lightiv(c, gc->currentContextTag, light, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_lightiv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_lightiv_data(reply), - xcb_glx_get_lightiv_data_length(reply) * - sizeof(GLint)); + (void)memcpy(params, xcb_glx_get_lightiv_data(reply), xcb_glx_get_lightiv_data_length(reply) * sizeof(GLint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetLightiv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&light), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetLightiv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&light), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetMapdv 120 -void -__indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v) +void __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -4094,39 +3362,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_mapdv_reply_t *reply = - xcb_glx_get_mapdv_reply(c, - xcb_glx_get_mapdv(c, - gc->currentContextTag, - target, query), NULL); + xcb_glx_get_mapdv_reply_t *reply = xcb_glx_get_mapdv_reply(c, xcb_glx_get_mapdv(c, gc->currentContextTag, target, query), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_mapdv_data_length(reply) == 1) - (void) memcpy(v, &reply->datum, sizeof(reply->datum)); + (void)memcpy(v, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(v, xcb_glx_get_mapdv_data(reply), - xcb_glx_get_mapdv_data_length(reply) * - sizeof(GLdouble)); + (void)memcpy(v, xcb_glx_get_mapdv_data(reply), xcb_glx_get_mapdv_data_length(reply) * sizeof(GLdouble)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetMapdv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&query), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapdv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&query), 4); (void) __glXReadReply(dpy, 8, v, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetMapfv 121 -void -__indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v) +void __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -4134,39 +3393,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_mapfv_reply_t *reply = - xcb_glx_get_mapfv_reply(c, - xcb_glx_get_mapfv(c, - gc->currentContextTag, - target, query), NULL); + xcb_glx_get_mapfv_reply_t *reply = xcb_glx_get_mapfv_reply(c, xcb_glx_get_mapfv(c, gc->currentContextTag, target, query), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_mapfv_data_length(reply) == 1) - (void) memcpy(v, &reply->datum, sizeof(reply->datum)); + (void)memcpy(v, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(v, xcb_glx_get_mapfv_data(reply), - xcb_glx_get_mapfv_data_length(reply) * - sizeof(GLfloat)); + (void)memcpy(v, xcb_glx_get_mapfv_data(reply), xcb_glx_get_mapfv_data_length(reply) * sizeof(GLfloat)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetMapfv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&query), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapfv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&query), 4); (void) __glXReadReply(dpy, 4, v, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetMapiv 122 -void -__indirect_glGetMapiv(GLenum target, GLenum query, GLint * v) +void __indirect_glGetMapiv(GLenum target, GLenum query, GLint * v) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -4174,39 +3424,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_mapiv_reply_t *reply = - xcb_glx_get_mapiv_reply(c, - xcb_glx_get_mapiv(c, - gc->currentContextTag, - target, query), NULL); + xcb_glx_get_mapiv_reply_t *reply = xcb_glx_get_mapiv_reply(c, xcb_glx_get_mapiv(c, gc->currentContextTag, target, query), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_mapiv_data_length(reply) == 1) - (void) memcpy(v, &reply->datum, sizeof(reply->datum)); + (void)memcpy(v, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(v, xcb_glx_get_mapiv_data(reply), - xcb_glx_get_mapiv_data_length(reply) * - sizeof(GLint)); + (void)memcpy(v, xcb_glx_get_mapiv_data(reply), xcb_glx_get_mapiv_data_length(reply) * sizeof(GLint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetMapiv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&query), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapiv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&query), 4); (void) __glXReadReply(dpy, 4, v, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetMaterialfv 123 -void -__indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params) +void __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -4214,41 +3455,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_materialfv_reply_t *reply = - xcb_glx_get_materialfv_reply(c, - xcb_glx_get_materialfv(c, - gc-> - currentContextTag, - face, pname), - NULL); + xcb_glx_get_materialfv_reply_t *reply = xcb_glx_get_materialfv_reply(c, xcb_glx_get_materialfv(c, gc->currentContextTag, face, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_materialfv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_materialfv_data(reply), - xcb_glx_get_materialfv_data_length(reply) * - sizeof(GLfloat)); + (void)memcpy(params, xcb_glx_get_materialfv_data(reply), xcb_glx_get_materialfv_data_length(reply) * sizeof(GLfloat)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetMaterialfv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&face), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMaterialfv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&face), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetMaterialiv 124 -void -__indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params) +void __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -4256,41 +3486,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_materialiv_reply_t *reply = - xcb_glx_get_materialiv_reply(c, - xcb_glx_get_materialiv(c, - gc-> - currentContextTag, - face, pname), - NULL); + xcb_glx_get_materialiv_reply_t *reply = xcb_glx_get_materialiv_reply(c, xcb_glx_get_materialiv(c, gc->currentContextTag, face, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_materialiv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_materialiv_data(reply), - xcb_glx_get_materialiv_data_length(reply) * - sizeof(GLint)); + (void)memcpy(params, xcb_glx_get_materialiv_data(reply), xcb_glx_get_materialiv_data_length(reply) * sizeof(GLint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetMaterialiv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&face), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMaterialiv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&face), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetPixelMapfv 125 -void -__indirect_glGetPixelMapfv(GLenum map, GLfloat * values) +void __indirect_glGetPixelMapfv(GLenum map, GLfloat * values) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 4; #endif @@ -4298,39 +3517,29 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_pixel_mapfv_reply_t *reply = - xcb_glx_get_pixel_mapfv_reply(c, - xcb_glx_get_pixel_mapfv(c, - gc-> - currentContextTag, - map), NULL); + xcb_glx_get_pixel_mapfv_reply_t *reply = xcb_glx_get_pixel_mapfv_reply(c, xcb_glx_get_pixel_mapfv(c, gc->currentContextTag, map), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_pixel_mapfv_data_length(reply) == 1) - (void) memcpy(values, &reply->datum, sizeof(reply->datum)); + (void)memcpy(values, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(values, xcb_glx_get_pixel_mapfv_data(reply), - xcb_glx_get_pixel_mapfv_data_length(reply) * - sizeof(GLfloat)); + (void)memcpy(values, xcb_glx_get_pixel_mapfv_data(reply), xcb_glx_get_pixel_mapfv_data_length(reply) * sizeof(GLfloat)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapfv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&map), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapfv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&map), 4); (void) __glXReadReply(dpy, 4, values, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetPixelMapuiv 126 -void -__indirect_glGetPixelMapuiv(GLenum map, GLuint * values) +void __indirect_glGetPixelMapuiv(GLenum map, GLuint * values) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 4; #endif @@ -4338,40 +3547,29 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_pixel_mapuiv_reply_t *reply = - xcb_glx_get_pixel_mapuiv_reply(c, - xcb_glx_get_pixel_mapuiv(c, - gc-> - currentContextTag, - map), - NULL); + xcb_glx_get_pixel_mapuiv_reply_t *reply = xcb_glx_get_pixel_mapuiv_reply(c, xcb_glx_get_pixel_mapuiv(c, gc->currentContextTag, map), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_pixel_mapuiv_data_length(reply) == 1) - (void) memcpy(values, &reply->datum, sizeof(reply->datum)); + (void)memcpy(values, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(values, xcb_glx_get_pixel_mapuiv_data(reply), - xcb_glx_get_pixel_mapuiv_data_length(reply) * - sizeof(GLuint)); + (void)memcpy(values, xcb_glx_get_pixel_mapuiv_data(reply), xcb_glx_get_pixel_mapuiv_data_length(reply) * sizeof(GLuint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapuiv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&map), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapuiv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&map), 4); (void) __glXReadReply(dpy, 4, values, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetPixelMapusv 127 -void -__indirect_glGetPixelMapusv(GLenum map, GLushort * values) +void __indirect_glGetPixelMapusv(GLenum map, GLushort * values) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 4; #endif @@ -4379,40 +3577,29 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_pixel_mapusv_reply_t *reply = - xcb_glx_get_pixel_mapusv_reply(c, - xcb_glx_get_pixel_mapusv(c, - gc-> - currentContextTag, - map), - NULL); + xcb_glx_get_pixel_mapusv_reply_t *reply = xcb_glx_get_pixel_mapusv_reply(c, xcb_glx_get_pixel_mapusv(c, gc->currentContextTag, map), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_pixel_mapusv_data_length(reply) == 1) - (void) memcpy(values, &reply->datum, sizeof(reply->datum)); + (void)memcpy(values, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(values, xcb_glx_get_pixel_mapusv_data(reply), - xcb_glx_get_pixel_mapusv_data_length(reply) * - sizeof(GLushort)); + (void)memcpy(values, xcb_glx_get_pixel_mapusv_data(reply), xcb_glx_get_pixel_mapusv_data_length(reply) * sizeof(GLushort)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapusv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&map), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapusv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&map), 4); (void) __glXReadReply(dpy, 2, values, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetPolygonStipple 128 -void -__indirect_glGetPolygonStipple(GLubyte *mask) +void __indirect_glGetPolygonStipple(GLubyte * mask) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 4; #endif @@ -4420,35 +3607,24 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_polygon_stipple_reply_t *reply = - xcb_glx_get_polygon_stipple_reply(c, - xcb_glx_get_polygon_stipple(c, - gc-> - currentContextTag, - 0), - NULL); - __glEmptyImage(gc, 3, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, - xcb_glx_get_polygon_stipple_data(reply), mask); - free(reply); -#else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetPolygonStipple, cmdlen); - *(int32_t *) (pc + 0) = 0; - __glXReadPixelReply(dpy, gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, - mask, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + xcb_glx_get_polygon_stipple_reply_t *reply = xcb_glx_get_polygon_stipple_reply(c, xcb_glx_get_polygon_stipple(c, gc->currentContextTag, 0), NULL); + __glEmptyImage(gc, 3, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, xcb_glx_get_polygon_stipple_data(reply), mask); + free(reply); +#else + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPolygonStipple, cmdlen); + *(int32_t *)(pc + 0) = 0; + __glXReadPixelReply(dpy, gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, GL_FALSE); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetTexEnvfv 130 -void -__indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params) +void __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -4456,41 +3632,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_tex_envfv_reply_t *reply = - xcb_glx_get_tex_envfv_reply(c, - xcb_glx_get_tex_envfv(c, - gc-> - currentContextTag, - target, pname), - NULL); + xcb_glx_get_tex_envfv_reply_t *reply = xcb_glx_get_tex_envfv_reply(c, xcb_glx_get_tex_envfv(c, gc->currentContextTag, target, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_tex_envfv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_tex_envfv_data(reply), - xcb_glx_get_tex_envfv_data_length(reply) * - sizeof(GLfloat)); + (void)memcpy(params, xcb_glx_get_tex_envfv_data(reply), xcb_glx_get_tex_envfv_data_length(reply) * sizeof(GLfloat)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetTexEnvfv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexEnvfv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetTexEnviv 131 -void -__indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params) +void __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -4498,41 +3663,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_tex_enviv_reply_t *reply = - xcb_glx_get_tex_enviv_reply(c, - xcb_glx_get_tex_enviv(c, - gc-> - currentContextTag, - target, pname), - NULL); + xcb_glx_get_tex_enviv_reply_t *reply = xcb_glx_get_tex_enviv_reply(c, xcb_glx_get_tex_enviv(c, gc->currentContextTag, target, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_tex_enviv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_tex_enviv_data(reply), - xcb_glx_get_tex_enviv_data_length(reply) * - sizeof(GLint)); + (void)memcpy(params, xcb_glx_get_tex_enviv_data(reply), xcb_glx_get_tex_enviv_data_length(reply) * sizeof(GLint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetTexEnviv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexEnviv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetTexGendv 132 -void -__indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params) +void __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -4540,41 +3694,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_tex_gendv_reply_t *reply = - xcb_glx_get_tex_gendv_reply(c, - xcb_glx_get_tex_gendv(c, - gc-> - currentContextTag, - coord, pname), - NULL); + xcb_glx_get_tex_gendv_reply_t *reply = xcb_glx_get_tex_gendv_reply(c, xcb_glx_get_tex_gendv(c, gc->currentContextTag, coord, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_tex_gendv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_tex_gendv_data(reply), - xcb_glx_get_tex_gendv_data_length(reply) * - sizeof(GLdouble)); + (void)memcpy(params, xcb_glx_get_tex_gendv_data(reply), xcb_glx_get_tex_gendv_data_length(reply) * sizeof(GLdouble)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetTexGendv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&coord), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGendv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&coord), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 8, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetTexGenfv 133 -void -__indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params) +void __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -4582,41 +3725,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_tex_genfv_reply_t *reply = - xcb_glx_get_tex_genfv_reply(c, - xcb_glx_get_tex_genfv(c, - gc-> - currentContextTag, - coord, pname), - NULL); + xcb_glx_get_tex_genfv_reply_t *reply = xcb_glx_get_tex_genfv_reply(c, xcb_glx_get_tex_genfv(c, gc->currentContextTag, coord, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_tex_genfv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_tex_genfv_data(reply), - xcb_glx_get_tex_genfv_data_length(reply) * - sizeof(GLfloat)); + (void)memcpy(params, xcb_glx_get_tex_genfv_data(reply), xcb_glx_get_tex_genfv_data_length(reply) * sizeof(GLfloat)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetTexGenfv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&coord), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGenfv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&coord), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetTexGeniv 134 -void -__indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params) +void __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -4624,43 +3756,31 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_tex_geniv_reply_t *reply = - xcb_glx_get_tex_geniv_reply(c, - xcb_glx_get_tex_geniv(c, - gc-> - currentContextTag, - coord, pname), - NULL); + xcb_glx_get_tex_geniv_reply_t *reply = xcb_glx_get_tex_geniv_reply(c, xcb_glx_get_tex_geniv(c, gc->currentContextTag, coord, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_tex_geniv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_tex_geniv_data(reply), - xcb_glx_get_tex_geniv_data_length(reply) * - sizeof(GLint)); + (void)memcpy(params, xcb_glx_get_tex_geniv_data(reply), xcb_glx_get_tex_geniv_data_length(reply) * sizeof(GLint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetTexGeniv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&coord), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGeniv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&coord), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetTexImage 135 -void -__indirect_glGetTexImage(GLenum target, GLint level, GLenum format, - GLenum type, GLvoid * pixels) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const __GLXattribute *const state = gc->client_state_private; - Display *const dpy = gc->currentDpy; +void __indirect_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const __GLXattribute * const state = gc->client_state_private; + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 20; #endif @@ -4668,51 +3788,31 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_tex_image_reply_t *reply = - xcb_glx_get_tex_image_reply(c, - xcb_glx_get_tex_image(c, - gc-> - currentContextTag, - target, level, - format, type, - state-> - storePack. - swapEndian), - NULL); - if (reply->height == 0) { - reply->height = 1; - } - if (reply->depth == 0) { - reply->depth = 1; - } - __glEmptyImage(gc, 3, reply->width, reply->height, reply->depth, - format, type, xcb_glx_get_tex_image_data(reply), - pixels); - free(reply); -#else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetTexImage, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&level), 4); - (void) memcpy((void *) (pc + 8), (void *) (&format), 4); - (void) memcpy((void *) (pc + 12), (void *) (&type), 4); - *(int32_t *) (pc + 16) = 0; - *(int8_t *) (pc + 16) = state->storePack.swapEndian; - __glXReadPixelReply(dpy, gc, 3, 0, 0, 0, format, type, pixels, - GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); + xcb_glx_get_tex_image_reply_t *reply = xcb_glx_get_tex_image_reply(c, xcb_glx_get_tex_image(c, gc->currentContextTag, target, level, format, type, state->storePack.swapEndian), NULL); + if (reply->height == 0) { reply->height = 1; } + if (reply->depth == 0) { reply->depth = 1; } + __glEmptyImage(gc, 3, reply->width, reply->height, reply->depth, format, type, xcb_glx_get_tex_image_data(reply), pixels); + free(reply); +#else + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexImage, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&level), 4); +(void) memcpy((void *)(pc + 8), (void *)(&format), 4); +(void) memcpy((void *)(pc + 12), (void *)(&type), 4); + *(int32_t *)(pc + 16) = 0; + * (int8_t *)(pc + 16) = state->storePack.swapEndian; + __glXReadPixelReply(dpy, gc, 3, 0, 0, 0, format, type, pixels, GL_TRUE); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetTexParameterfv 136 -void -__indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params) +void __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -4720,42 +3820,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_tex_parameterfv_reply_t *reply = - xcb_glx_get_tex_parameterfv_reply(c, - xcb_glx_get_tex_parameterfv(c, - gc-> - currentContextTag, - target, - pname), - NULL); + xcb_glx_get_tex_parameterfv_reply_t *reply = xcb_glx_get_tex_parameterfv_reply(c, xcb_glx_get_tex_parameterfv(c, gc->currentContextTag, target, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_tex_parameterfv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_tex_parameterfv_data(reply), - xcb_glx_get_tex_parameterfv_data_length(reply) * - sizeof(GLfloat)); + (void)memcpy(params, xcb_glx_get_tex_parameterfv_data(reply), xcb_glx_get_tex_parameterfv_data_length(reply) * sizeof(GLfloat)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetTexParameterfv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexParameterfv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetTexParameteriv 137 -void -__indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params) +void __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -4763,43 +3851,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_tex_parameteriv_reply_t *reply = - xcb_glx_get_tex_parameteriv_reply(c, - xcb_glx_get_tex_parameteriv(c, - gc-> - currentContextTag, - target, - pname), - NULL); + xcb_glx_get_tex_parameteriv_reply_t *reply = xcb_glx_get_tex_parameteriv_reply(c, xcb_glx_get_tex_parameteriv(c, gc->currentContextTag, target, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_tex_parameteriv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_tex_parameteriv_data(reply), - xcb_glx_get_tex_parameteriv_data_length(reply) * - sizeof(GLint)); + (void)memcpy(params, xcb_glx_get_tex_parameteriv_data(reply), xcb_glx_get_tex_parameteriv_data_length(reply) * sizeof(GLint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetTexParameteriv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexParameteriv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetTexLevelParameterfv 138 -void -__indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, - GLfloat * params) +void __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 12; #endif @@ -4807,44 +3882,31 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_tex_level_parameterfv_reply_t *reply = - xcb_glx_get_tex_level_parameterfv_reply(c, - xcb_glx_get_tex_level_parameterfv - (c, gc->currentContextTag, - target, level, pname), - NULL); + xcb_glx_get_tex_level_parameterfv_reply_t *reply = xcb_glx_get_tex_level_parameterfv_reply(c, xcb_glx_get_tex_level_parameterfv(c, gc->currentContextTag, target, level, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_tex_level_parameterfv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, - xcb_glx_get_tex_level_parameterfv_data(reply), - xcb_glx_get_tex_level_parameterfv_data_length(reply) - * sizeof(GLfloat)); + (void)memcpy(params, xcb_glx_get_tex_level_parameterfv_data(reply), xcb_glx_get_tex_level_parameterfv_data_length(reply) * sizeof(GLfloat)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameterfv, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&level), 4); - (void) memcpy((void *) (pc + 8), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameterfv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&level), 4); +(void) memcpy((void *)(pc + 8), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetTexLevelParameteriv 139 -void -__indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, - GLint * params) +void __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 12; #endif @@ -4852,43 +3914,31 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_tex_level_parameteriv_reply_t *reply = - xcb_glx_get_tex_level_parameteriv_reply(c, - xcb_glx_get_tex_level_parameteriv - (c, gc->currentContextTag, - target, level, pname), - NULL); + xcb_glx_get_tex_level_parameteriv_reply_t *reply = xcb_glx_get_tex_level_parameteriv_reply(c, xcb_glx_get_tex_level_parameteriv(c, gc->currentContextTag, target, level, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_tex_level_parameteriv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, - xcb_glx_get_tex_level_parameteriv_data(reply), - xcb_glx_get_tex_level_parameteriv_data_length(reply) - * sizeof(GLint)); + (void)memcpy(params, xcb_glx_get_tex_level_parameteriv_data(reply), xcb_glx_get_tex_level_parameteriv_data_length(reply) * sizeof(GLint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameteriv, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&level), 4); - (void) memcpy((void *) (pc + 8), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameteriv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&level), 4); +(void) memcpy((void *)(pc + 8), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_IsList 141 -GLboolean -__indirect_glIsList(GLuint list) +GLboolean __indirect_glIsList(GLuint list) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; GLboolean retval = (GLboolean) 0; #ifndef USE_XCB const GLuint cmdlen = 4; @@ -4897,454 +3947,362 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_is_list_reply_t *reply = - xcb_glx_is_list_reply(c, - xcb_glx_is_list(c, gc->currentContextTag, - list), NULL); + xcb_glx_is_list_reply_t *reply = xcb_glx_is_list_reply(c, xcb_glx_is_list(c, gc->currentContextTag, list), NULL); retval = reply->ret_val; free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_IsList, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&list), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsList, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&list), 4); retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return retval; } #define X_GLrop_DepthRange 174 -void -__indirect_glDepthRange(GLclampd zNear, GLclampd zFar) +void __indirect_glDepthRange(GLclampd zNear, GLclampd zFar) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_DepthRange, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&zNear), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&zFar), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_DepthRange, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&zNear), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&zFar), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Frustum 175 -void -__indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, - GLdouble top, GLdouble zNear, GLdouble zFar) +void __indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 52; - emit_header(gc->pc, X_GLrop_Frustum, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&left), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&right), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&bottom), 8); - (void) memcpy((void *) (gc->pc + 28), (void *) (&top), 8); - (void) memcpy((void *) (gc->pc + 36), (void *) (&zNear), 8); - (void) memcpy((void *) (gc->pc + 44), (void *) (&zFar), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Frustum, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8); +(void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8); +(void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8); +(void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_LoadIdentity 176 -void -__indirect_glLoadIdentity(void) +void __indirect_glLoadIdentity(void) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 4; - emit_header(gc->pc, X_GLrop_LoadIdentity, cmdlen); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_LoadIdentity, cmdlen); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_LoadMatrixf 177 -void -__indirect_glLoadMatrixf(const GLfloat * m) +void __indirect_glLoadMatrixf(const GLfloat * m) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 68; - emit_header(gc->pc, X_GLrop_LoadMatrixf, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (m), 64); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_LoadMatrixf, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(m), 64); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_LoadMatrixd 178 -void -__indirect_glLoadMatrixd(const GLdouble * m) +void __indirect_glLoadMatrixd(const GLdouble * m) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 132; - emit_header(gc->pc, X_GLrop_LoadMatrixd, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (m), 128); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_LoadMatrixd, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(m), 128); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MatrixMode 179 -void -__indirect_glMatrixMode(GLenum mode) +void __indirect_glMatrixMode(GLenum mode) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_MatrixMode, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MatrixMode, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultMatrixf 180 -void -__indirect_glMultMatrixf(const GLfloat * m) +void __indirect_glMultMatrixf(const GLfloat * m) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 68; - emit_header(gc->pc, X_GLrop_MultMatrixf, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (m), 64); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultMatrixf, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(m), 64); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultMatrixd 181 -void -__indirect_glMultMatrixd(const GLdouble * m) +void __indirect_glMultMatrixd(const GLdouble * m) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 132; - emit_header(gc->pc, X_GLrop_MultMatrixd, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (m), 128); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultMatrixd, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(m), 128); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Ortho 182 -void -__indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, - GLdouble top, GLdouble zNear, GLdouble zFar) +void __indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 52; - emit_header(gc->pc, X_GLrop_Ortho, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&left), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&right), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&bottom), 8); - (void) memcpy((void *) (gc->pc + 28), (void *) (&top), 8); - (void) memcpy((void *) (gc->pc + 36), (void *) (&zNear), 8); - (void) memcpy((void *) (gc->pc + 44), (void *) (&zFar), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Ortho, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8); +(void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8); +(void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8); +(void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PopMatrix 183 -void -__indirect_glPopMatrix(void) +void __indirect_glPopMatrix(void) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 4; - emit_header(gc->pc, X_GLrop_PopMatrix, cmdlen); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PopMatrix, cmdlen); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PushMatrix 184 -void -__indirect_glPushMatrix(void) +void __indirect_glPushMatrix(void) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 4; - emit_header(gc->pc, X_GLrop_PushMatrix, cmdlen); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PushMatrix, cmdlen); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Rotated 185 -void -__indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +void __indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 36; - emit_header(gc->pc, X_GLrop_Rotated, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&angle), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8); - (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Rotated, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8); +(void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Rotatef 186 -void -__indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +void __indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_Rotatef, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&angle), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Rotatef, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Scaled 187 -void -__indirect_glScaled(GLdouble x, GLdouble y, GLdouble z) +void __indirect_glScaled(GLdouble x, GLdouble y, GLdouble z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_Scaled, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Scaled, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Scalef 188 -void -__indirect_glScalef(GLfloat x, GLfloat y, GLfloat z) +void __indirect_glScalef(GLfloat x, GLfloat y, GLfloat z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_Scalef, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Scalef, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Translated 189 -void -__indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z) +void __indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_Translated, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Translated, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Translatef 190 -void -__indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z) +void __indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_Translatef, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Translatef, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Viewport 191 -void -__indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height) +void __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_Viewport, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Viewport, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_BindTexture 4117 -void -__indirect_glBindTexture(GLenum target, GLuint texture) +void __indirect_glBindTexture(GLenum target, GLuint texture) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_BindTexture, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&texture), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_BindTexture, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&texture), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Indexubv 194 -void -__indirect_glIndexub(GLubyte c) +void __indirect_glIndexub(GLubyte c) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_Indexubv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Indexubv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&c), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Indexubv 194 -void -__indirect_glIndexubv(const GLubyte *c) +void __indirect_glIndexubv(const GLubyte * c) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_Indexubv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (c), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Indexubv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(c), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PolygonOffset 192 -void -__indirect_glPolygonOffset(GLfloat factor, GLfloat units) +void __indirect_glPolygonOffset(GLfloat factor, GLfloat units) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_PolygonOffset, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&factor), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&units), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PolygonOffset, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&units), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_CopyTexImage1D 4119 -void -__indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, - GLint x, GLint y, GLsizei width, GLint border) +void __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 32; - emit_header(gc->pc, X_GLrop_CopyTexImage1D, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 28), (void *) (&border), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_CopyTexImage1D, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 28), (void *)(&border), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_CopyTexImage2D 4120 -void -__indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, - GLint x, GLint y, GLsizei width, GLsizei height, - GLint border) +void __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 36; - emit_header(gc->pc, X_GLrop_CopyTexImage2D, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4); - (void) memcpy((void *) (gc->pc + 32), (void *) (&border), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_CopyTexImage2D, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4); +(void) memcpy((void *)(gc->pc + 32), (void *)(&border), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_CopyTexSubImage1D 4121 -void -__indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, - GLint x, GLint y, GLsizei width) +void __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_CopyTexSubImage1D, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_CopyTexSubImage1D, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_CopyTexSubImage2D 4122 -void -__indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, - GLint yoffset, GLint x, GLint y, GLsizei width, - GLsizei height) +void __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 36; - emit_header(gc->pc, X_GLrop_CopyTexSubImage2D, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&yoffset), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 24), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 28), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 32), (void *) (&height), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_CopyTexSubImage2D, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 24), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 28), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 32), (void *)(&height), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLsop_DeleteTextures 144 -void -__indirect_glDeleteTextures(GLsizei n, const GLuint * textures) +void __indirect_glDeleteTextures(GLsizei n, const GLuint * textures) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 4 + safe_pad(safe_mul(n, 4)); #endif @@ -5362,63 +4320,55 @@ (void) __glXFlushRenderBuffer(gc, gc->pc); xcb_glx_delete_textures(c, gc->currentContextTag, n, textures); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_DeleteTextures, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&n), 4); - (void) memcpy((void *) (pc + 4), (void *) (textures), safe_mul(n, 4)); - UnlockDisplay(dpy); - SyncHandle(); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteTextures, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&n), 4); +(void) memcpy((void *)(pc + 4), (void *)(textures), safe_mul(n, 4)); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLvop_DeleteTexturesEXT 12 -void -glDeleteTexturesEXT(GLsizei n, const GLuint * textures) +void glDeleteTexturesEXT(GLsizei n, const GLuint * textures) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); PFNGLDELETETEXTURESEXTPROC p = (PFNGLDELETETEXTURESEXTPROC) disp_table[327]; - p(n, textures); + p(n, textures); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 4 + safe_pad(safe_mul(n, 4)); - if (0 + safe_pad(safe_mul(n, 4)) < 0) { - __glXSetError(gc, GL_INVALID_VALUE); - return; - } - if (n < 0) { - __glXSetError(gc, GL_INVALID_VALUE); - return; - } - if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivate, - X_GLvop_DeleteTexturesEXT, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&n), 4); - (void) memcpy((void *) (pc + 4), (void *) (textures), - safe_mul(n, 4)); - UnlockDisplay(dpy); - SyncHandle(); - } + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 4 + safe_pad(safe_mul(n, 4)); + if (0 + safe_pad(safe_mul(n, 4)) < 0) { + __glXSetError(gc, GL_INVALID_VALUE); + return; + } + if (n < 0) { + __glXSetError(gc, GL_INVALID_VALUE); return; } + if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_GLvop_DeleteTexturesEXT, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&n), 4); +(void) memcpy((void *)(pc + 4), (void *)(textures), safe_mul(n, 4)); + UnlockDisplay(dpy); SyncHandle(); + } + return; +} } #define X_GLsop_GenTextures 145 -void -__indirect_glGenTextures(GLsizei n, GLuint * textures) +void __indirect_glGenTextures(GLsizei n, GLuint * textures) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 4; #endif @@ -5430,68 +4380,55 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_gen_textures_reply_t *reply = - xcb_glx_gen_textures_reply(c, - xcb_glx_gen_textures(c, - gc-> - currentContextTag, - n), NULL); - (void) memcpy(textures, xcb_glx_gen_textures_data(reply), - xcb_glx_gen_textures_data_length(reply) * - sizeof(GLuint)); + xcb_glx_gen_textures_reply_t *reply = xcb_glx_gen_textures_reply(c, xcb_glx_gen_textures(c, gc->currentContextTag, n), NULL); + (void)memcpy(textures, xcb_glx_gen_textures_data(reply), xcb_glx_gen_textures_data_length(reply) * sizeof(GLuint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GenTextures, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&n), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenTextures, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&n), 4); (void) __glXReadReply(dpy, 4, textures, GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLvop_GenTexturesEXT 13 -void -glGenTexturesEXT(GLsizei n, GLuint * textures) +void glGenTexturesEXT(GLsizei n, GLuint * textures) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); - PFNGLGENTEXTURESEXTPROC p = (PFNGLGENTEXTURESEXTPROC) disp_table[328]; - p(n, textures); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); + PFNGLGENTEXTURESEXTPROC p = + (PFNGLGENTEXTURESEXTPROC) disp_table[328]; + p(n, textures); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 4; - if (n < 0) { - __glXSetError(gc, GL_INVALID_VALUE); - return; - } - if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GenTexturesEXT, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&n), 4); - (void) __glXReadReply(dpy, 4, textures, GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); - } + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 4; + if (n < 0) { + __glXSetError(gc, GL_INVALID_VALUE); return; } + if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenTexturesEXT, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&n), 4); + (void) __glXReadReply(dpy, 4, textures, GL_TRUE); + UnlockDisplay(dpy); SyncHandle(); + } + return; +} } #define X_GLsop_IsTexture 146 -GLboolean -__indirect_glIsTexture(GLuint texture) +GLboolean __indirect_glIsTexture(GLuint texture) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; GLboolean retval = (GLboolean) 0; #ifndef USE_XCB const GLuint cmdlen = 4; @@ -5500,64 +4437,52 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_is_texture_reply_t *reply = - xcb_glx_is_texture_reply(c, - xcb_glx_is_texture(c, - gc->currentContextTag, - texture), NULL); + xcb_glx_is_texture_reply_t *reply = xcb_glx_is_texture_reply(c, xcb_glx_is_texture(c, gc->currentContextTag, texture), NULL); retval = reply->ret_val; free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_IsTexture, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&texture), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsTexture, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&texture), 4); retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return retval; } #define X_GLvop_IsTextureEXT 14 -GLboolean -glIsTextureEXT(GLuint texture) +GLboolean glIsTextureEXT(GLuint texture) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); - PFNGLISTEXTUREEXTPROC p = (PFNGLISTEXTUREEXTPROC) disp_table[330]; - return p(texture); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); + PFNGLISTEXTUREEXTPROC p = + (PFNGLISTEXTUREEXTPROC) disp_table[330]; + return p(texture); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; - GLboolean retval = (GLboolean) 0; - const GLuint cmdlen = 4; - if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_IsTextureEXT, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&texture), 4); - retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); - } - return retval; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; + GLboolean retval = (GLboolean) 0; + const GLuint cmdlen = 4; + if (__builtin_expect(dpy != NULL, 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsTextureEXT, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&texture), 4); + retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); + UnlockDisplay(dpy); SyncHandle(); } + return retval; +} } #define X_GLrop_PrioritizeTextures 4118 -void -__indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures, - const GLclampf * priorities) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint cmdlen = - 8 + safe_pad(safe_mul(n, 4)) + safe_pad(safe_mul(n, 4)); +void __indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures, const GLclampf * priorities) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint cmdlen = 8 + safe_pad(safe_mul(n, 4)) + safe_pad(safe_mul(n, 4)); if (0 + safe_pad(safe_mul(n, 4)) + safe_pad(safe_mul(n, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; @@ -5567,260 +4492,207 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (textures), - safe_mul(n, 4)); - (void) memcpy((void *) (gc->pc + 8 + safe_mul(n, 4)), - (void *) (priorities), safe_mul(n, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(textures), safe_mul(n, 4)); +(void) memcpy((void *)(gc->pc + 8 + safe_mul(n, 4)), (void *)(priorities), safe_mul(n, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } static void -__glx_TexSubImage_1D2D(unsigned opcode, unsigned dim, GLenum target, - GLint level, GLint xoffset, GLint yoffset, - GLsizei width, GLsizei height, GLenum format, - GLenum type, const GLvoid * pixels) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint compsize = - (pixels != NULL) ? __glImageSize(width, height, 1, format, type, - target) : 0; +__glx_TexSubImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels ) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, format, type, target) : 0; const GLuint cmdlen = 60 + safe_pad(compsize); if (0 + safe_pad(compsize) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } if (__builtin_expect(gc->currentDpy != NULL, 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, opcode, cmdlen); - (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 28), (void *) (&level), 4); - (void) memcpy((void *) (gc->pc + 32), (void *) (&xoffset), 4); - (void) memcpy((void *) (gc->pc + 36), (void *) (&yoffset), 4); - (void) memcpy((void *) (gc->pc + 40), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 44), (void *) (&height), 4); - (void) memcpy((void *) (gc->pc + 48), (void *) (&format), 4); - (void) memcpy((void *) (gc->pc + 52), (void *) (&type), 4); - (void) memset((void *) (gc->pc + 56), 0, 4); - if (compsize > 0) { - gc->fillImage(gc, dim, width, height, 1, format, type, pixels, - gc->pc + 60, gc->pc + 4); - } else { - (void) memcpy(gc->pc + 4, default_pixel_store_2D, - default_pixel_store_2D_size); - } - gc->pc += cmdlen; - if (gc->pc > gc->limit) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = opcode; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 28), (void *) (&target), 4); - (void) memcpy((void *) (pc + 32), (void *) (&level), 4); - (void) memcpy((void *) (pc + 36), (void *) (&xoffset), 4); - (void) memcpy((void *) (pc + 40), (void *) (&yoffset), 4); - (void) memcpy((void *) (pc + 44), (void *) (&width), 4); - (void) memcpy((void *) (pc + 48), (void *) (&height), 4); - (void) memcpy((void *) (pc + 52), (void *) (&format), 4); - (void) memcpy((void *) (pc + 56), (void *) (&type), 4); - (void) memset((void *) (pc + 60), 0, 4); - __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, - type, pixels, pc + 64, pc + 8); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, opcode, cmdlen); +(void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4); +(void) memcpy((void *)(gc->pc + 32), (void *)(&xoffset), 4); +(void) memcpy((void *)(gc->pc + 36), (void *)(&yoffset), 4); +(void) memcpy((void *)(gc->pc + 40), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 44), (void *)(&height), 4); +(void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4); +(void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4); +(void) memset((void *)(gc->pc + 56), 0, 4); +if (compsize > 0) { + gc->fillImage(gc, dim, width, height, 1, format, type, pixels, gc->pc + 60, gc->pc + 4); +} else { + (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size ); +} +gc->pc += cmdlen; +if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = opcode; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 28), (void *)(&target), 4); +(void) memcpy((void *)(pc + 32), (void *)(&level), 4); +(void) memcpy((void *)(pc + 36), (void *)(&xoffset), 4); +(void) memcpy((void *)(pc + 40), (void *)(&yoffset), 4); +(void) memcpy((void *)(pc + 44), (void *)(&width), 4); +(void) memcpy((void *)(pc + 48), (void *)(&height), 4); +(void) memcpy((void *)(pc + 52), (void *)(&format), 4); +(void) memcpy((void *)(pc + 56), (void *)(&type), 4); +(void) memset((void *)(pc + 60), 0, 4); +__glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, pc + 64, pc + 8); +} } } #define X_GLrop_TexSubImage1D 4099 -void -__indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, - GLsizei width, GLenum format, GLenum type, - const GLvoid * pixels) +void __indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels) { - __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D, 1, target, level, xoffset, - 1, width, 1, format, type, pixels); + __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D, 1, target, level, xoffset, 1, width, 1, format, type, pixels ); } #define X_GLrop_TexSubImage2D 4100 -void -__indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, - GLint yoffset, GLsizei width, GLsizei height, - GLenum format, GLenum type, const GLvoid * pixels) +void __indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) { - __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D, 2, target, level, xoffset, - yoffset, width, height, format, type, pixels); + __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D, 2, target, level, xoffset, yoffset, width, height, format, type, pixels ); } #define X_GLrop_BlendColor 4096 -void -__indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, - GLclampf alpha) +void __indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_BlendColor, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_BlendColor, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_BlendEquation 4097 -void -__indirect_glBlendEquation(GLenum mode) +void __indirect_glBlendEquation(GLenum mode) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_BlendEquation, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_BlendEquation, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ColorTable 2053 -void -__indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width, - GLenum format, GLenum type, const GLvoid * table) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint compsize = - (table != NULL) ? __glImageSize(width, 1, 1, format, type, - target) : 0; +void __indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint compsize = (table != NULL) ? __glImageSize(width, 1, 1, format, type, target) : 0; const GLuint cmdlen = 44 + safe_pad(compsize); if (0 + safe_pad(compsize) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } if (__builtin_expect(gc->currentDpy != NULL, 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, X_GLrop_ColorTable, cmdlen); - (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 28), (void *) (&internalformat), - 4); - (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 36), (void *) (&format), 4); - (void) memcpy((void *) (gc->pc + 40), (void *) (&type), 4); - if (compsize > 0) { - gc->fillImage(gc, 1, width, 1, 1, format, type, table, - gc->pc + 44, gc->pc + 4); - } else { - (void) memcpy(gc->pc + 4, default_pixel_store_1D, - default_pixel_store_1D_size); - } - gc->pc += cmdlen; - if (gc->pc > gc->limit) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = X_GLrop_ColorTable; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 28), (void *) (&target), 4); - (void) memcpy((void *) (pc + 32), (void *) (&internalformat), 4); - (void) memcpy((void *) (pc + 36), (void *) (&width), 4); - (void) memcpy((void *) (pc + 40), (void *) (&format), 4); - (void) memcpy((void *) (pc + 44), (void *) (&type), 4); - __glXSendLargeImage(gc, compsize, 1, width, 1, 1, format, type, - table, pc + 48, pc + 8); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, X_GLrop_ColorTable, cmdlen); +(void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4); +(void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4); +(void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4); +if (compsize > 0) { + gc->fillImage(gc, 1, width, 1, 1, format, type, table, gc->pc + 44, gc->pc + 4); +} else { + (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_size ); +} +gc->pc += cmdlen; +if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = X_GLrop_ColorTable; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 28), (void *)(&target), 4); +(void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4); +(void) memcpy((void *)(pc + 36), (void *)(&width), 4); +(void) memcpy((void *)(pc + 40), (void *)(&format), 4); +(void) memcpy((void *)(pc + 44), (void *)(&type), 4); +__glXSendLargeImage(gc, compsize, 1, width, 1, 1, format, type, table, pc + 48, pc + 8); +} } } #define X_GLrop_ColorTableParameterfv 2054 -void -__indirect_glColorTableParameterfv(GLenum target, GLenum pname, - const GLfloat * params) +void __indirect_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glColorTableParameterfv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_ColorTableParameterfv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ColorTableParameterfv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ColorTableParameteriv 2055 -void -__indirect_glColorTableParameteriv(GLenum target, GLenum pname, - const GLint * params) +void __indirect_glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glColorTableParameteriv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_ColorTableParameteriv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ColorTableParameteriv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_CopyColorTable 2056 -void -__indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, - GLint y, GLsizei width) +void __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_CopyColorTable, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_CopyColorTable, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLsop_GetColorTable 147 -void -__indirect_glGetColorTable(GLenum target, GLenum format, GLenum type, - GLvoid * table) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const __GLXattribute *const state = gc->client_state_private; - Display *const dpy = gc->currentDpy; +void __indirect_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * table) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const __GLXattribute * const state = gc->client_state_private; + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 16; #endif @@ -5828,83 +4700,60 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_color_table_reply_t *reply = - xcb_glx_get_color_table_reply(c, - xcb_glx_get_color_table(c, - gc-> - currentContextTag, - target, - format, - type, - state-> - storePack. - swapEndian), - NULL); - __glEmptyImage(gc, 3, reply->width, 1, 1, format, type, - xcb_glx_get_color_table_data(reply), table); - free(reply); -#else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetColorTable, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&format), 4); - (void) memcpy((void *) (pc + 8), (void *) (&type), 4); - *(int32_t *) (pc + 12) = 0; - *(int8_t *) (pc + 12) = state->storePack.swapEndian; - __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table, - GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); + xcb_glx_get_color_table_reply_t *reply = xcb_glx_get_color_table_reply(c, xcb_glx_get_color_table(c, gc->currentContextTag, target, format, type, state->storePack.swapEndian), NULL); + __glEmptyImage(gc, 3, reply->width, 1, 1, format, type, xcb_glx_get_color_table_data(reply), table); + free(reply); +#else + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTable, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&format), 4); +(void) memcpy((void *)(pc + 8), (void *)(&type), 4); + *(int32_t *)(pc + 12) = 0; + * (int8_t *)(pc + 12) = state->storePack.swapEndian; + __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table, GL_TRUE); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLvop_GetColorTableSGI 4098 -void -gl_dispatch_stub_343(GLenum target, GLenum format, GLenum type, - GLvoid * table) +void gl_dispatch_stub_343(GLenum target, GLenum format, GLenum type, GLvoid * table) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); PFNGLGETCOLORTABLESGIPROC p = (PFNGLGETCOLORTABLESGIPROC) disp_table[343]; - p(target, format, type, table); + p(target, format, type, table); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - const __GLXattribute *const state = gc->client_state_private; - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 16; - if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetColorTableSGI, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&format), 4); - (void) memcpy((void *) (pc + 8), (void *) (&type), 4); - *(int32_t *) (pc + 12) = 0; - *(int8_t *) (pc + 12) = state->storePack.swapEndian; - __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table, - GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); - } - return; + struct glx_context * const gc = __glXGetCurrentContext(); + const __GLXattribute * const state = gc->client_state_private; + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 16; + if (__builtin_expect(dpy != NULL, 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetColorTableSGI, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&format), 4); +(void) memcpy((void *)(pc + 8), (void *)(&type), 4); + *(int32_t *)(pc + 12) = 0; + * (int8_t *)(pc + 12) = state->storePack.swapEndian; + __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table, GL_TRUE); + UnlockDisplay(dpy); SyncHandle(); } + return; +} } #define X_GLsop_GetColorTableParameterfv 148 -void -__indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, - GLfloat * params) +void __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -5912,76 +4761,58 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_color_table_parameterfv_reply_t *reply = - xcb_glx_get_color_table_parameterfv_reply(c, - xcb_glx_get_color_table_parameterfv - (c, - gc->currentContextTag, - target, pname), NULL); + xcb_glx_get_color_table_parameterfv_reply_t *reply = xcb_glx_get_color_table_parameterfv_reply(c, xcb_glx_get_color_table_parameterfv(c, gc->currentContextTag, target, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_color_table_parameterfv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, - xcb_glx_get_color_table_parameterfv_data(reply), - xcb_glx_get_color_table_parameterfv_data_length - (reply) * sizeof(GLfloat)); + (void)memcpy(params, xcb_glx_get_color_table_parameterfv_data(reply), xcb_glx_get_color_table_parameterfv_data_length(reply) * sizeof(GLfloat)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameterfv, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameterfv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLvop_GetColorTableParameterfvSGI 4099 -void -gl_dispatch_stub_344(GLenum target, GLenum pname, GLfloat * params) +void gl_dispatch_stub_344(GLenum target, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); PFNGLGETCOLORTABLEPARAMETERFVSGIPROC p = (PFNGLGETCOLORTABLEPARAMETERFVSGIPROC) disp_table[344]; - p(target, pname, params); + p(target, pname, params); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 8; - if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetColorTableParameterfvSGI, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); - (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); - } - return; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 8; + if (__builtin_expect(dpy != NULL, 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetColorTableParameterfvSGI, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); + (void) __glXReadReply(dpy, 4, params, GL_FALSE); + UnlockDisplay(dpy); SyncHandle(); } + return; +} } #define X_GLsop_GetColorTableParameteriv 149 -void -__indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, - GLint * params) +void __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -5989,346 +4820,271 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_color_table_parameteriv_reply_t *reply = - xcb_glx_get_color_table_parameteriv_reply(c, - xcb_glx_get_color_table_parameteriv - (c, - gc->currentContextTag, - target, pname), NULL); + xcb_glx_get_color_table_parameteriv_reply_t *reply = xcb_glx_get_color_table_parameteriv_reply(c, xcb_glx_get_color_table_parameteriv(c, gc->currentContextTag, target, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_color_table_parameteriv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, - xcb_glx_get_color_table_parameteriv_data(reply), - xcb_glx_get_color_table_parameteriv_data_length - (reply) * sizeof(GLint)); + (void)memcpy(params, xcb_glx_get_color_table_parameteriv_data(reply), xcb_glx_get_color_table_parameteriv_data_length(reply) * sizeof(GLint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameteriv, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameteriv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLvop_GetColorTableParameterivSGI 4100 -void -gl_dispatch_stub_345(GLenum target, GLenum pname, GLint * params) +void gl_dispatch_stub_345(GLenum target, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); PFNGLGETCOLORTABLEPARAMETERIVSGIPROC p = (PFNGLGETCOLORTABLEPARAMETERIVSGIPROC) disp_table[345]; - p(target, pname, params); + p(target, pname, params); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 8; - if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetColorTableParameterivSGI, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); - (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); - } - return; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 8; + if (__builtin_expect(dpy != NULL, 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetColorTableParameterivSGI, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); + (void) __glXReadReply(dpy, 4, params, GL_FALSE); + UnlockDisplay(dpy); SyncHandle(); } + return; +} } #define X_GLrop_ColorSubTable 195 -void -__indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count, - GLenum format, GLenum type, const GLvoid * data) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint compsize = - (data != NULL) ? __glImageSize(count, 1, 1, format, type, target) : 0; +void __indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint compsize = (data != NULL) ? __glImageSize(count, 1, 1, format, type, target) : 0; const GLuint cmdlen = 44 + safe_pad(compsize); if (0 + safe_pad(compsize) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } if (__builtin_expect(gc->currentDpy != NULL, 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, X_GLrop_ColorSubTable, cmdlen); - (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 28), (void *) (&start), 4); - (void) memcpy((void *) (gc->pc + 32), (void *) (&count), 4); - (void) memcpy((void *) (gc->pc + 36), (void *) (&format), 4); - (void) memcpy((void *) (gc->pc + 40), (void *) (&type), 4); - if (compsize > 0) { - gc->fillImage(gc, 1, count, 1, 1, format, type, data, - gc->pc + 44, gc->pc + 4); - } else { - (void) memcpy(gc->pc + 4, default_pixel_store_1D, - default_pixel_store_1D_size); - } - gc->pc += cmdlen; - if (gc->pc > gc->limit) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = X_GLrop_ColorSubTable; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 28), (void *) (&target), 4); - (void) memcpy((void *) (pc + 32), (void *) (&start), 4); - (void) memcpy((void *) (pc + 36), (void *) (&count), 4); - (void) memcpy((void *) (pc + 40), (void *) (&format), 4); - (void) memcpy((void *) (pc + 44), (void *) (&type), 4); - __glXSendLargeImage(gc, compsize, 1, count, 1, 1, format, type, - data, pc + 48, pc + 8); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, X_GLrop_ColorSubTable, cmdlen); +(void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 28), (void *)(&start), 4); +(void) memcpy((void *)(gc->pc + 32), (void *)(&count), 4); +(void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4); +(void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4); +if (compsize > 0) { + gc->fillImage(gc, 1, count, 1, 1, format, type, data, gc->pc + 44, gc->pc + 4); +} else { + (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_size ); +} +gc->pc += cmdlen; +if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = X_GLrop_ColorSubTable; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 28), (void *)(&target), 4); +(void) memcpy((void *)(pc + 32), (void *)(&start), 4); +(void) memcpy((void *)(pc + 36), (void *)(&count), 4); +(void) memcpy((void *)(pc + 40), (void *)(&format), 4); +(void) memcpy((void *)(pc + 44), (void *)(&type), 4); +__glXSendLargeImage(gc, compsize, 1, count, 1, 1, format, type, data, pc + 48, pc + 8); +} } } #define X_GLrop_CopyColorSubTable 196 -void -__indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, - GLsizei width) +void __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_CopyColorSubTable, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&start), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_CopyColorSubTable, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&start), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } static void -__glx_ConvolutionFilter_1D2D(unsigned opcode, unsigned dim, GLenum target, - GLenum internalformat, GLsizei width, - GLsizei height, GLenum format, GLenum type, - const GLvoid * image) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint compsize = - (image != NULL) ? __glImageSize(width, height, 1, format, type, - target) : 0; +__glx_ConvolutionFilter_1D2D( unsigned opcode, unsigned dim, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image ) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint compsize = (image != NULL) ? __glImageSize(width, height, 1, format, type, target) : 0; const GLuint cmdlen = 48 + safe_pad(compsize); if (0 + safe_pad(compsize) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } if (__builtin_expect(gc->currentDpy != NULL, 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, opcode, cmdlen); - (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 28), (void *) (&internalformat), - 4); - (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 36), (void *) (&height), 4); - (void) memcpy((void *) (gc->pc + 40), (void *) (&format), 4); - (void) memcpy((void *) (gc->pc + 44), (void *) (&type), 4); - if (compsize > 0) { - gc->fillImage(gc, dim, width, height, 1, format, type, image, - gc->pc + 48, gc->pc + 4); - } else { - (void) memcpy(gc->pc + 4, default_pixel_store_2D, - default_pixel_store_2D_size); - } - gc->pc += cmdlen; - if (gc->pc > gc->limit) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = opcode; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 28), (void *) (&target), 4); - (void) memcpy((void *) (pc + 32), (void *) (&internalformat), 4); - (void) memcpy((void *) (pc + 36), (void *) (&width), 4); - (void) memcpy((void *) (pc + 40), (void *) (&height), 4); - (void) memcpy((void *) (pc + 44), (void *) (&format), 4); - (void) memcpy((void *) (pc + 48), (void *) (&type), 4); - __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, - type, image, pc + 52, pc + 8); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, opcode, cmdlen); +(void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4); +(void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4); +(void) memcpy((void *)(gc->pc + 40), (void *)(&format), 4); +(void) memcpy((void *)(gc->pc + 44), (void *)(&type), 4); +if (compsize > 0) { + gc->fillImage(gc, dim, width, height, 1, format, type, image, gc->pc + 48, gc->pc + 4); +} else { + (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size ); +} +gc->pc += cmdlen; +if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = opcode; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 28), (void *)(&target), 4); +(void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4); +(void) memcpy((void *)(pc + 36), (void *)(&width), 4); +(void) memcpy((void *)(pc + 40), (void *)(&height), 4); +(void) memcpy((void *)(pc + 44), (void *)(&format), 4); +(void) memcpy((void *)(pc + 48), (void *)(&type), 4); +__glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, image, pc + 52, pc + 8); +} } } #define X_GLrop_ConvolutionFilter1D 4101 -void -__indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat, - GLsizei width, GLenum format, GLenum type, - const GLvoid * image) -{ - __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D, 1, target, - internalformat, width, 1, format, type, - image); +void __indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image) +{ + __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D, 1, target, internalformat, width, 1, format, type, image ); } #define X_GLrop_ConvolutionFilter2D 4102 -void -__indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat, - GLsizei width, GLsizei height, GLenum format, - GLenum type, const GLvoid * image) -{ - __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D, 2, target, - internalformat, width, height, format, type, - image); +void __indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image) +{ + __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D, 2, target, internalformat, width, height, format, type, image ); } #define X_GLrop_ConvolutionParameterf 4103 -void -__indirect_glConvolutionParameterf(GLenum target, GLenum pname, - GLfloat params) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_ConvolutionParameterf, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (¶ms), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +void __indirect_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint cmdlen = 16; +emit_header(gc->pc, X_GLrop_ConvolutionParameterf, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(¶ms), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ConvolutionParameterfv 4104 -void -__indirect_glConvolutionParameterfv(GLenum target, GLenum pname, - const GLfloat * params) +void __indirect_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glConvolutionParameterfv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_ConvolutionParameterfv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ConvolutionParameterfv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ConvolutionParameteri 4105 -void -__indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint params) +void __indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_ConvolutionParameteri, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (¶ms), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ConvolutionParameteri, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(¶ms), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ConvolutionParameteriv 4106 -void -__indirect_glConvolutionParameteriv(GLenum target, GLenum pname, - const GLint * params) +void __indirect_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glConvolutionParameteriv_size(pname); const GLuint cmdlen = 12 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_ConvolutionParameteriv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ConvolutionParameteriv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_CopyConvolutionFilter1D 4107 -void -__indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, - GLint x, GLint y, GLsizei width) +void __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_CopyConvolutionFilter1D, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_CopyConvolutionFilter1D, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_CopyConvolutionFilter2D 4108 -void -__indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, - GLint x, GLint y, GLsizei width, - GLsizei height) +void __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_CopyConvolutionFilter2D, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 24), (void *) (&height), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_CopyConvolutionFilter2D, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 24), (void *)(&height), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLsop_GetConvolutionFilter 150 -void -__indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, - GLvoid * image) +void __indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid * image) { - struct glx_context *const gc = __glXGetCurrentContext(); - const __GLXattribute *const state = gc->client_state_private; - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + const __GLXattribute * const state = gc->client_state_private; + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 16; #endif @@ -6336,82 +5092,61 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_convolution_filter_reply_t *reply = - xcb_glx_get_convolution_filter_reply(c, - xcb_glx_get_convolution_filter - (c, gc->currentContextTag, - target, format, type, - state->storePack. - swapEndian), NULL); - if (reply->height == 0) { - reply->height = 1; - } - __glEmptyImage(gc, 3, reply->width, reply->height, 1, format, type, - xcb_glx_get_convolution_filter_data(reply), image); + xcb_glx_get_convolution_filter_reply_t *reply = xcb_glx_get_convolution_filter_reply(c, xcb_glx_get_convolution_filter(c, gc->currentContextTag, target, format, type, state->storePack.swapEndian), NULL); + if (reply->height == 0) { reply->height = 1; } + __glEmptyImage(gc, 3, reply->width, reply->height, 1, format, type, xcb_glx_get_convolution_filter_data(reply), image); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionFilter, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&format), 4); - (void) memcpy((void *) (pc + 8), (void *) (&type), 4); - *(int32_t *) (pc + 12) = 0; - *(int8_t *) (pc + 12) = state->storePack.swapEndian; - __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image, - GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionFilter, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&format), 4); +(void) memcpy((void *)(pc + 8), (void *)(&type), 4); + *(int32_t *)(pc + 12) = 0; + * (int8_t *)(pc + 12) = state->storePack.swapEndian; + __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image, GL_TRUE); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLvop_GetConvolutionFilterEXT 1 -void -gl_dispatch_stub_356(GLenum target, GLenum format, GLenum type, - GLvoid * image) +void gl_dispatch_stub_356(GLenum target, GLenum format, GLenum type, GLvoid * image) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); PFNGLGETCONVOLUTIONFILTEREXTPROC p = (PFNGLGETCONVOLUTIONFILTEREXTPROC) disp_table[356]; - p(target, format, type, image); + p(target, format, type, image); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - const __GLXattribute *const state = gc->client_state_private; - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 16; - if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetConvolutionFilterEXT, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&format), 4); - (void) memcpy((void *) (pc + 8), (void *) (&type), 4); - *(int32_t *) (pc + 12) = 0; - *(int8_t *) (pc + 12) = state->storePack.swapEndian; - __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image, - GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); - } - return; + struct glx_context * const gc = __glXGetCurrentContext(); + const __GLXattribute * const state = gc->client_state_private; + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 16; + if (__builtin_expect(dpy != NULL, 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetConvolutionFilterEXT, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&format), 4); +(void) memcpy((void *)(pc + 8), (void *)(&type), 4); + *(int32_t *)(pc + 12) = 0; + * (int8_t *)(pc + 12) = state->storePack.swapEndian; + __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image, GL_TRUE); + UnlockDisplay(dpy); SyncHandle(); } + return; +} } #define X_GLsop_GetConvolutionParameterfv 151 -void -__indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, - GLfloat * params) +void __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -6419,76 +5154,58 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_convolution_parameterfv_reply_t *reply = - xcb_glx_get_convolution_parameterfv_reply(c, - xcb_glx_get_convolution_parameterfv - (c, - gc->currentContextTag, - target, pname), NULL); + xcb_glx_get_convolution_parameterfv_reply_t *reply = xcb_glx_get_convolution_parameterfv_reply(c, xcb_glx_get_convolution_parameterfv(c, gc->currentContextTag, target, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_convolution_parameterfv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, - xcb_glx_get_convolution_parameterfv_data(reply), - xcb_glx_get_convolution_parameterfv_data_length - (reply) * sizeof(GLfloat)); + (void)memcpy(params, xcb_glx_get_convolution_parameterfv_data(reply), xcb_glx_get_convolution_parameterfv_data_length(reply) * sizeof(GLfloat)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameterfv, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameterfv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLvop_GetConvolutionParameterfvEXT 2 -void -gl_dispatch_stub_357(GLenum target, GLenum pname, GLfloat * params) +void gl_dispatch_stub_357(GLenum target, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC p = (PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) disp_table[357]; - p(target, pname, params); + p(target, pname, params); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 8; - if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetConvolutionParameterfvEXT, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); - (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); - } - return; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 8; + if (__builtin_expect(dpy != NULL, 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetConvolutionParameterfvEXT, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); + (void) __glXReadReply(dpy, 4, params, GL_FALSE); + UnlockDisplay(dpy); SyncHandle(); } + return; +} } #define X_GLsop_GetConvolutionParameteriv 152 -void -__indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, - GLint * params) +void __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -6496,77 +5213,59 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_convolution_parameteriv_reply_t *reply = - xcb_glx_get_convolution_parameteriv_reply(c, - xcb_glx_get_convolution_parameteriv - (c, - gc->currentContextTag, - target, pname), NULL); + xcb_glx_get_convolution_parameteriv_reply_t *reply = xcb_glx_get_convolution_parameteriv_reply(c, xcb_glx_get_convolution_parameteriv(c, gc->currentContextTag, target, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_convolution_parameteriv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, - xcb_glx_get_convolution_parameteriv_data(reply), - xcb_glx_get_convolution_parameteriv_data_length - (reply) * sizeof(GLint)); + (void)memcpy(params, xcb_glx_get_convolution_parameteriv_data(reply), xcb_glx_get_convolution_parameteriv_data_length(reply) * sizeof(GLint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameteriv, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameteriv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLvop_GetConvolutionParameterivEXT 3 -void -gl_dispatch_stub_358(GLenum target, GLenum pname, GLint * params) +void gl_dispatch_stub_358(GLenum target, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC p = (PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) disp_table[358]; - p(target, pname, params); + p(target, pname, params); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 8; - if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetConvolutionParameterivEXT, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); - (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); - } - return; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 8; + if (__builtin_expect(dpy != NULL, 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetConvolutionParameterivEXT, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); + (void) __glXReadReply(dpy, 4, params, GL_FALSE); + UnlockDisplay(dpy); SyncHandle(); } + return; +} } #define X_GLsop_GetHistogram 154 -void -__indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format, - GLenum type, GLvoid * values) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const __GLXattribute *const state = gc->client_state_private; - Display *const dpy = gc->currentDpy; +void __indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const __GLXattribute * const state = gc->client_state_private; + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 16; #endif @@ -6574,84 +5273,62 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_histogram_reply_t *reply = - xcb_glx_get_histogram_reply(c, - xcb_glx_get_histogram(c, - gc-> - currentContextTag, - target, reset, - format, type, - state-> - storePack. - swapEndian), - NULL); - __glEmptyImage(gc, 3, reply->width, 1, 1, format, type, - xcb_glx_get_histogram_data(reply), values); - free(reply); -#else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetHistogram, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&format), 4); - (void) memcpy((void *) (pc + 8), (void *) (&type), 4); - *(int32_t *) (pc + 12) = 0; - *(int8_t *) (pc + 12) = state->storePack.swapEndian; - *(int8_t *) (pc + 13) = reset; - __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values, - GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); + xcb_glx_get_histogram_reply_t *reply = xcb_glx_get_histogram_reply(c, xcb_glx_get_histogram(c, gc->currentContextTag, target, reset, format, type, state->storePack.swapEndian), NULL); + __glEmptyImage(gc, 3, reply->width, 1, 1, format, type, xcb_glx_get_histogram_data(reply), values); + free(reply); +#else + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogram, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&format), 4); +(void) memcpy((void *)(pc + 8), (void *)(&type), 4); + *(int32_t *)(pc + 12) = 0; + * (int8_t *)(pc + 12) = state->storePack.swapEndian; + * (int8_t *)(pc + 13) = reset; + __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values, GL_TRUE); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLvop_GetHistogramEXT 5 -void -gl_dispatch_stub_361(GLenum target, GLboolean reset, GLenum format, - GLenum type, GLvoid * values) +void gl_dispatch_stub_361(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); PFNGLGETHISTOGRAMEXTPROC p = (PFNGLGETHISTOGRAMEXTPROC) disp_table[361]; - p(target, reset, format, type, values); + p(target, reset, format, type, values); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - const __GLXattribute *const state = gc->client_state_private; - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 16; - if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetHistogramEXT, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&format), 4); - (void) memcpy((void *) (pc + 8), (void *) (&type), 4); - *(int32_t *) (pc + 12) = 0; - *(int8_t *) (pc + 12) = state->storePack.swapEndian; - *(int8_t *) (pc + 13) = reset; - __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values, - GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); - } - return; + struct glx_context * const gc = __glXGetCurrentContext(); + const __GLXattribute * const state = gc->client_state_private; + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 16; + if (__builtin_expect(dpy != NULL, 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetHistogramEXT, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&format), 4); +(void) memcpy((void *)(pc + 8), (void *)(&type), 4); + *(int32_t *)(pc + 12) = 0; + * (int8_t *)(pc + 12) = state->storePack.swapEndian; + * (int8_t *)(pc + 13) = reset; + __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values, GL_TRUE); + UnlockDisplay(dpy); SyncHandle(); } + return; +} } #define X_GLsop_GetHistogramParameterfv 155 -void -__indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, - GLfloat * params) +void __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -6659,75 +5336,58 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_histogram_parameterfv_reply_t *reply = - xcb_glx_get_histogram_parameterfv_reply(c, - xcb_glx_get_histogram_parameterfv - (c, gc->currentContextTag, - target, pname), NULL); + xcb_glx_get_histogram_parameterfv_reply_t *reply = xcb_glx_get_histogram_parameterfv_reply(c, xcb_glx_get_histogram_parameterfv(c, gc->currentContextTag, target, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_histogram_parameterfv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, - xcb_glx_get_histogram_parameterfv_data(reply), - xcb_glx_get_histogram_parameterfv_data_length(reply) - * sizeof(GLfloat)); + (void)memcpy(params, xcb_glx_get_histogram_parameterfv_data(reply), xcb_glx_get_histogram_parameterfv_data_length(reply) * sizeof(GLfloat)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameterfv, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameterfv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLvop_GetHistogramParameterfvEXT 6 -void -gl_dispatch_stub_362(GLenum target, GLenum pname, GLfloat * params) +void gl_dispatch_stub_362(GLenum target, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); PFNGLGETHISTOGRAMPARAMETERFVEXTPROC p = (PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) disp_table[362]; - p(target, pname, params); + p(target, pname, params); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 8; - if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetHistogramParameterfvEXT, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); - (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); - } - return; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 8; + if (__builtin_expect(dpy != NULL, 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetHistogramParameterfvEXT, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); + (void) __glXReadReply(dpy, 4, params, GL_FALSE); + UnlockDisplay(dpy); SyncHandle(); } + return; +} } #define X_GLsop_GetHistogramParameteriv 156 -void -__indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, - GLint * params) +void __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -6735,76 +5395,59 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_histogram_parameteriv_reply_t *reply = - xcb_glx_get_histogram_parameteriv_reply(c, - xcb_glx_get_histogram_parameteriv - (c, gc->currentContextTag, - target, pname), NULL); + xcb_glx_get_histogram_parameteriv_reply_t *reply = xcb_glx_get_histogram_parameteriv_reply(c, xcb_glx_get_histogram_parameteriv(c, gc->currentContextTag, target, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_histogram_parameteriv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, - xcb_glx_get_histogram_parameteriv_data(reply), - xcb_glx_get_histogram_parameteriv_data_length(reply) - * sizeof(GLint)); + (void)memcpy(params, xcb_glx_get_histogram_parameteriv_data(reply), xcb_glx_get_histogram_parameteriv_data_length(reply) * sizeof(GLint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameteriv, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameteriv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLvop_GetHistogramParameterivEXT 7 -void -gl_dispatch_stub_363(GLenum target, GLenum pname, GLint * params) +void gl_dispatch_stub_363(GLenum target, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); PFNGLGETHISTOGRAMPARAMETERIVEXTPROC p = (PFNGLGETHISTOGRAMPARAMETERIVEXTPROC) disp_table[363]; - p(target, pname, params); + p(target, pname, params); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 8; - if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetHistogramParameterivEXT, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); - (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); - } - return; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 8; + if (__builtin_expect(dpy != NULL, 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetHistogramParameterivEXT, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); + (void) __glXReadReply(dpy, 4, params, GL_FALSE); + UnlockDisplay(dpy); SyncHandle(); } + return; +} } #define X_GLsop_GetMinmax 157 -void -__indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format, - GLenum type, GLvoid * values) +void __indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) { - struct glx_context *const gc = __glXGetCurrentContext(); - const __GLXattribute *const state = gc->client_state_private; - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + const __GLXattribute * const state = gc->client_state_private; + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 16; #endif @@ -6812,80 +5455,62 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_minmax_reply_t *reply = - xcb_glx_get_minmax_reply(c, - xcb_glx_get_minmax(c, - gc->currentContextTag, - target, reset, format, - type, - state->storePack. - swapEndian), NULL); - __glEmptyImage(gc, 3, 2, 1, 1, format, type, - xcb_glx_get_minmax_data(reply), values); + xcb_glx_get_minmax_reply_t *reply = xcb_glx_get_minmax_reply(c, xcb_glx_get_minmax(c, gc->currentContextTag, target, reset, format, type, state->storePack.swapEndian), NULL); + __glEmptyImage(gc, 3, 2, 1, 1, format, type, xcb_glx_get_minmax_data(reply), values); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetMinmax, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&format), 4); - (void) memcpy((void *) (pc + 8), (void *) (&type), 4); - *(int32_t *) (pc + 12) = 0; - *(int8_t *) (pc + 12) = state->storePack.swapEndian; - *(int8_t *) (pc + 13) = reset; - __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values, - GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmax, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&format), 4); +(void) memcpy((void *)(pc + 8), (void *)(&type), 4); + *(int32_t *)(pc + 12) = 0; + * (int8_t *)(pc + 12) = state->storePack.swapEndian; + * (int8_t *)(pc + 13) = reset; + __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values, GL_FALSE); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLvop_GetMinmaxEXT 8 -void -gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format, - GLenum type, GLvoid * values) +void gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); - PFNGLGETMINMAXEXTPROC p = (PFNGLGETMINMAXEXTPROC) disp_table[364]; - p(target, reset, format, type, values); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); + PFNGLGETMINMAXEXTPROC p = + (PFNGLGETMINMAXEXTPROC) disp_table[364]; + p(target, reset, format, type, values); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - const __GLXattribute *const state = gc->client_state_private; - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 16; - if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetMinmaxEXT, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&format), 4); - (void) memcpy((void *) (pc + 8), (void *) (&type), 4); - *(int32_t *) (pc + 12) = 0; - *(int8_t *) (pc + 12) = state->storePack.swapEndian; - *(int8_t *) (pc + 13) = reset; - __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values, - GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); - } - return; + struct glx_context * const gc = __glXGetCurrentContext(); + const __GLXattribute * const state = gc->client_state_private; + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 16; + if (__builtin_expect(dpy != NULL, 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetMinmaxEXT, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&format), 4); +(void) memcpy((void *)(pc + 8), (void *)(&type), 4); + *(int32_t *)(pc + 12) = 0; + * (int8_t *)(pc + 12) = state->storePack.swapEndian; + * (int8_t *)(pc + 13) = reset; + __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values, GL_FALSE); + UnlockDisplay(dpy); SyncHandle(); } + return; +} } #define X_GLsop_GetMinmaxParameterfv 158 -void -__indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, - GLfloat * params) +void __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -6893,72 +5518,58 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_minmax_parameterfv_reply_t *reply = - xcb_glx_get_minmax_parameterfv_reply(c, - xcb_glx_get_minmax_parameterfv - (c, gc->currentContextTag, - target, pname), NULL); + xcb_glx_get_minmax_parameterfv_reply_t *reply = xcb_glx_get_minmax_parameterfv_reply(c, xcb_glx_get_minmax_parameterfv(c, gc->currentContextTag, target, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_minmax_parameterfv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_minmax_parameterfv_data(reply), - xcb_glx_get_minmax_parameterfv_data_length(reply) * - sizeof(GLfloat)); + (void)memcpy(params, xcb_glx_get_minmax_parameterfv_data(reply), xcb_glx_get_minmax_parameterfv_data_length(reply) * sizeof(GLfloat)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameterfv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameterfv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLvop_GetMinmaxParameterfvEXT 9 -void -gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params) +void gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); PFNGLGETMINMAXPARAMETERFVEXTPROC p = (PFNGLGETMINMAXPARAMETERFVEXTPROC) disp_table[365]; - p(target, pname, params); + p(target, pname, params); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 8; - if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetMinmaxParameterfvEXT, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); - (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); - } - return; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 8; + if (__builtin_expect(dpy != NULL, 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetMinmaxParameterfvEXT, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); + (void) __glXReadReply(dpy, 4, params, GL_FALSE); + UnlockDisplay(dpy); SyncHandle(); } + return; +} } #define X_GLsop_GetMinmaxParameteriv 159 -void -__indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params) +void __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -6966,1170 +5577,940 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_minmax_parameteriv_reply_t *reply = - xcb_glx_get_minmax_parameteriv_reply(c, - xcb_glx_get_minmax_parameteriv - (c, gc->currentContextTag, - target, pname), NULL); + xcb_glx_get_minmax_parameteriv_reply_t *reply = xcb_glx_get_minmax_parameteriv_reply(c, xcb_glx_get_minmax_parameteriv(c, gc->currentContextTag, target, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_minmax_parameteriv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_minmax_parameteriv_data(reply), - xcb_glx_get_minmax_parameteriv_data_length(reply) * - sizeof(GLint)); + (void)memcpy(params, xcb_glx_get_minmax_parameteriv_data(reply), xcb_glx_get_minmax_parameteriv_data_length(reply) * sizeof(GLint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameteriv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameteriv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLvop_GetMinmaxParameterivEXT 10 -void -gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params) +void gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (gc->isDirect) { - const _glapi_proc *const disp_table = (_glapi_proc *) GET_DISPATCH(); + const _glapi_proc *const disp_table = (_glapi_proc *)GET_DISPATCH(); PFNGLGETMINMAXPARAMETERIVEXTPROC p = (PFNGLGETMINMAXPARAMETERIVEXTPROC) disp_table[366]; - p(target, pname, params); + p(target, pname, params); } else #endif { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 8; - if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetMinmaxParameterivEXT, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); - (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); - } - return; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 8; + if (__builtin_expect(dpy != NULL, 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetMinmaxParameterivEXT, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); + (void) __glXReadReply(dpy, 4, params, GL_FALSE); + UnlockDisplay(dpy); SyncHandle(); } + return; +} } #define X_GLrop_Histogram 4110 -void -__indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, - GLboolean sink) +void __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_Histogram, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&sink), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Histogram, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&sink), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_Minmax 4111 -void -__indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink) +void __indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_Minmax, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&sink), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_Minmax, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&sink), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ResetHistogram 4112 -void -__indirect_glResetHistogram(GLenum target) +void __indirect_glResetHistogram(GLenum target) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_ResetHistogram, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ResetHistogram, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ResetMinmax 4113 -void -__indirect_glResetMinmax(GLenum target) +void __indirect_glResetMinmax(GLenum target) { - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_ResetMinmax, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint cmdlen = 8; +emit_header(gc->pc, X_GLrop_ResetMinmax, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } static void -__glx_TexImage_3D4D(unsigned opcode, unsigned dim, GLenum target, GLint level, - GLint internalformat, GLsizei width, GLsizei height, - GLsizei depth, GLsizei extent, GLint border, - GLenum format, GLenum type, const GLvoid * pixels) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint compsize = - (pixels != NULL) ? __glImageSize(width, height, depth, format, type, - target) : 0; +__glx_TexImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const GLvoid * pixels ) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, depth, format, type, target) : 0; const GLuint cmdlen = 84 + safe_pad(compsize); if (0 + safe_pad(compsize) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } if (__builtin_expect(gc->currentDpy != NULL, 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, opcode, cmdlen); - (void) memcpy((void *) (gc->pc + 40), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 44), (void *) (&level), 4); - (void) memcpy((void *) (gc->pc + 48), (void *) (&internalformat), - 4); - (void) memcpy((void *) (gc->pc + 52), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 56), (void *) (&height), 4); - (void) memcpy((void *) (gc->pc + 60), (void *) (&depth), 4); - (void) memcpy((void *) (gc->pc + 64), (void *) (&extent), 4); - (void) memcpy((void *) (gc->pc + 68), (void *) (&border), 4); - (void) memcpy((void *) (gc->pc + 72), (void *) (&format), 4); - (void) memcpy((void *) (gc->pc + 76), (void *) (&type), 4); - (void) memcpy((void *) (gc->pc + 80), - (void *) ((pixels == NULL) ? one : zero), 4); - if (compsize > 0) { - gc->fillImage(gc, dim, width, height, depth, format, type, - pixels, gc->pc + 84, gc->pc + 4); - } else { - (void) memcpy(gc->pc + 4, default_pixel_store_4D, - default_pixel_store_4D_size); - } - gc->pc += cmdlen; - if (gc->pc > gc->limit) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = opcode; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 44), (void *) (&target), 4); - (void) memcpy((void *) (pc + 48), (void *) (&level), 4); - (void) memcpy((void *) (pc + 52), (void *) (&internalformat), 4); - (void) memcpy((void *) (pc + 56), (void *) (&width), 4); - (void) memcpy((void *) (pc + 60), (void *) (&height), 4); - (void) memcpy((void *) (pc + 64), (void *) (&depth), 4); - (void) memcpy((void *) (pc + 68), (void *) (&extent), 4); - (void) memcpy((void *) (pc + 72), (void *) (&border), 4); - (void) memcpy((void *) (pc + 76), (void *) (&format), 4); - (void) memcpy((void *) (pc + 80), (void *) (&type), 4); - (void) memcpy((void *) (pc + 84), zero, 4); - __glXSendLargeImage(gc, compsize, dim, width, height, depth, - format, type, pixels, pc + 88, pc + 8); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, opcode, cmdlen); +(void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4); +(void) memcpy((void *)(gc->pc + 48), (void *)(&internalformat), 4); +(void) memcpy((void *)(gc->pc + 52), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 56), (void *)(&height), 4); +(void) memcpy((void *)(gc->pc + 60), (void *)(&depth), 4); +(void) memcpy((void *)(gc->pc + 64), (void *)(&extent), 4); +(void) memcpy((void *)(gc->pc + 68), (void *)(&border), 4); +(void) memcpy((void *)(gc->pc + 72), (void *)(&format), 4); +(void) memcpy((void *)(gc->pc + 76), (void *)(&type), 4); +(void) memcpy((void *)(gc->pc + 80), (void *)((pixels == NULL) ? one : zero), 4); +if (compsize > 0) { + gc->fillImage(gc, dim, width, height, depth, format, type, pixels, gc->pc + 84, gc->pc + 4); +} else { + (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_size ); +} +gc->pc += cmdlen; +if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = opcode; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 44), (void *)(&target), 4); +(void) memcpy((void *)(pc + 48), (void *)(&level), 4); +(void) memcpy((void *)(pc + 52), (void *)(&internalformat), 4); +(void) memcpy((void *)(pc + 56), (void *)(&width), 4); +(void) memcpy((void *)(pc + 60), (void *)(&height), 4); +(void) memcpy((void *)(pc + 64), (void *)(&depth), 4); +(void) memcpy((void *)(pc + 68), (void *)(&extent), 4); +(void) memcpy((void *)(pc + 72), (void *)(&border), 4); +(void) memcpy((void *)(pc + 76), (void *)(&format), 4); +(void) memcpy((void *)(pc + 80), (void *)(&type), 4); +(void) memcpy((void *)(pc + 84), zero, 4); +__glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixels, pc + 88, pc + 8); +} } } #define X_GLrop_TexImage3D 4114 -void -__indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat, - GLsizei width, GLsizei height, GLsizei depth, - GLint border, GLenum format, GLenum type, - const GLvoid * pixels) -{ - __glx_TexImage_3D4D(X_GLrop_TexImage3D, 3, target, level, internalformat, - width, height, depth, 1, border, format, type, - pixels); +void __indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) +{ + __glx_TexImage_3D4D(X_GLrop_TexImage3D, 3, target, level, internalformat, width, height, depth, 1, border, format, type, pixels ); } static void -__glx_TexSubImage_3D4D(unsigned opcode, unsigned dim, GLenum target, - GLint level, GLint xoffset, GLint yoffset, - GLint zoffset, GLint woffset, GLsizei width, - GLsizei height, GLsizei depth, GLsizei extent, - GLenum format, GLenum type, const GLvoid * pixels) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint compsize = - (pixels != NULL) ? __glImageSize(width, height, depth, format, type, - target) : 0; +__glx_TexSubImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLenum format, GLenum type, const GLvoid * pixels ) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, depth, format, type, target) : 0; const GLuint cmdlen = 92 + safe_pad(compsize); if (0 + safe_pad(compsize) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } if (__builtin_expect(gc->currentDpy != NULL, 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, opcode, cmdlen); - (void) memcpy((void *) (gc->pc + 40), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 44), (void *) (&level), 4); - (void) memcpy((void *) (gc->pc + 48), (void *) (&xoffset), 4); - (void) memcpy((void *) (gc->pc + 52), (void *) (&yoffset), 4); - (void) memcpy((void *) (gc->pc + 56), (void *) (&zoffset), 4); - (void) memcpy((void *) (gc->pc + 60), (void *) (&woffset), 4); - (void) memcpy((void *) (gc->pc + 64), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 68), (void *) (&height), 4); - (void) memcpy((void *) (gc->pc + 72), (void *) (&depth), 4); - (void) memcpy((void *) (gc->pc + 76), (void *) (&extent), 4); - (void) memcpy((void *) (gc->pc + 80), (void *) (&format), 4); - (void) memcpy((void *) (gc->pc + 84), (void *) (&type), 4); - (void) memset((void *) (gc->pc + 88), 0, 4); - if (compsize > 0) { - gc->fillImage(gc, dim, width, height, depth, format, type, - pixels, gc->pc + 92, gc->pc + 4); - } else { - (void) memcpy(gc->pc + 4, default_pixel_store_4D, - default_pixel_store_4D_size); - } - gc->pc += cmdlen; - if (gc->pc > gc->limit) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = opcode; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 44), (void *) (&target), 4); - (void) memcpy((void *) (pc + 48), (void *) (&level), 4); - (void) memcpy((void *) (pc + 52), (void *) (&xoffset), 4); - (void) memcpy((void *) (pc + 56), (void *) (&yoffset), 4); - (void) memcpy((void *) (pc + 60), (void *) (&zoffset), 4); - (void) memcpy((void *) (pc + 64), (void *) (&woffset), 4); - (void) memcpy((void *) (pc + 68), (void *) (&width), 4); - (void) memcpy((void *) (pc + 72), (void *) (&height), 4); - (void) memcpy((void *) (pc + 76), (void *) (&depth), 4); - (void) memcpy((void *) (pc + 80), (void *) (&extent), 4); - (void) memcpy((void *) (pc + 84), (void *) (&format), 4); - (void) memcpy((void *) (pc + 88), (void *) (&type), 4); - (void) memset((void *) (pc + 92), 0, 4); - __glXSendLargeImage(gc, compsize, dim, width, height, depth, - format, type, pixels, pc + 96, pc + 8); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, opcode, cmdlen); +(void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4); +(void) memcpy((void *)(gc->pc + 48), (void *)(&xoffset), 4); +(void) memcpy((void *)(gc->pc + 52), (void *)(&yoffset), 4); +(void) memcpy((void *)(gc->pc + 56), (void *)(&zoffset), 4); +(void) memcpy((void *)(gc->pc + 60), (void *)(&woffset), 4); +(void) memcpy((void *)(gc->pc + 64), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 68), (void *)(&height), 4); +(void) memcpy((void *)(gc->pc + 72), (void *)(&depth), 4); +(void) memcpy((void *)(gc->pc + 76), (void *)(&extent), 4); +(void) memcpy((void *)(gc->pc + 80), (void *)(&format), 4); +(void) memcpy((void *)(gc->pc + 84), (void *)(&type), 4); +(void) memset((void *)(gc->pc + 88), 0, 4); +if (compsize > 0) { + gc->fillImage(gc, dim, width, height, depth, format, type, pixels, gc->pc + 92, gc->pc + 4); +} else { + (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_size ); +} +gc->pc += cmdlen; +if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = opcode; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 44), (void *)(&target), 4); +(void) memcpy((void *)(pc + 48), (void *)(&level), 4); +(void) memcpy((void *)(pc + 52), (void *)(&xoffset), 4); +(void) memcpy((void *)(pc + 56), (void *)(&yoffset), 4); +(void) memcpy((void *)(pc + 60), (void *)(&zoffset), 4); +(void) memcpy((void *)(pc + 64), (void *)(&woffset), 4); +(void) memcpy((void *)(pc + 68), (void *)(&width), 4); +(void) memcpy((void *)(pc + 72), (void *)(&height), 4); +(void) memcpy((void *)(pc + 76), (void *)(&depth), 4); +(void) memcpy((void *)(pc + 80), (void *)(&extent), 4); +(void) memcpy((void *)(pc + 84), (void *)(&format), 4); +(void) memcpy((void *)(pc + 88), (void *)(&type), 4); +(void) memset((void *)(pc + 92), 0, 4); +__glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixels, pc + 96, pc + 8); +} } } #define X_GLrop_TexSubImage3D 4115 -void -__indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, - GLint yoffset, GLint zoffset, GLsizei width, - GLsizei height, GLsizei depth, GLenum format, - GLenum type, const GLvoid * pixels) -{ - __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D, 3, target, level, xoffset, - yoffset, zoffset, 1, width, height, depth, 1, - format, type, pixels); +void __indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels) +{ + __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D, 3, target, level, xoffset, yoffset, zoffset, 1, width, height, depth, 1, format, type, pixels ); } #define X_GLrop_CopyTexSubImage3D 4123 -void -__indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, - GLint yoffset, GLint zoffset, GLint x, GLint y, - GLsizei width, GLsizei height) +void __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 40; - emit_header(gc->pc, X_GLrop_CopyTexSubImage3D, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&yoffset), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&zoffset), 4); - (void) memcpy((void *) (gc->pc + 24), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 28), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 36), (void *) (&height), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_CopyTexSubImage3D, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&zoffset), 4); +(void) memcpy((void *)(gc->pc + 24), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 28), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ActiveTexture 197 -void -__indirect_glActiveTexture(GLenum texture) +void __indirect_glActiveTexture(GLenum texture) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_ActiveTexture, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&texture), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ActiveTexture, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&texture), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord1dv 198 -void -__indirect_glMultiTexCoord1d(GLenum target, GLdouble s) +void __indirect_glMultiTexCoord1d(GLenum target, GLdouble s) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_MultiTexCoord1dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&target), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord1dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord1dv 198 -void -__indirect_glMultiTexCoord1dv(GLenum target, const GLdouble * v) +void __indirect_glMultiTexCoord1dv(GLenum target, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_MultiTexCoord1dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (v), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&target), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord1dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(v), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord1fvARB 199 -void -__indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s) +void __indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord1fvARB 199 -void -__indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v) +void __indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord1iv 200 -void -__indirect_glMultiTexCoord1i(GLenum target, GLint s) +void __indirect_glMultiTexCoord1i(GLenum target, GLint s) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_MultiTexCoord1iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord1iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord1iv 200 -void -__indirect_glMultiTexCoord1iv(GLenum target, const GLint * v) +void __indirect_glMultiTexCoord1iv(GLenum target, const GLint * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_MultiTexCoord1iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord1iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord1sv 201 -void -__indirect_glMultiTexCoord1s(GLenum target, GLshort s) +void __indirect_glMultiTexCoord1s(GLenum target, GLshort s) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_MultiTexCoord1sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord1sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord1sv 201 -void -__indirect_glMultiTexCoord1sv(GLenum target, const GLshort * v) +void __indirect_glMultiTexCoord1sv(GLenum target, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_MultiTexCoord1sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord1sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord2dv 202 -void -__indirect_glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t) +void __indirect_glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_MultiTexCoord2dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&target), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord2dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord2dv 202 -void -__indirect_glMultiTexCoord2dv(GLenum target, const GLdouble * v) +void __indirect_glMultiTexCoord2dv(GLenum target, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_MultiTexCoord2dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (v), 16); - (void) memcpy((void *) (gc->pc + 20), (void *) (&target), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord2dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(v), 16); +(void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord2fvARB 203 -void -__indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t) +void __indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord2fvARB 203 -void -__indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v) +void __indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord2iv 204 -void -__indirect_glMultiTexCoord2i(GLenum target, GLint s, GLint t) +void __indirect_glMultiTexCoord2i(GLenum target, GLint s, GLint t) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_MultiTexCoord2iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord2iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord2iv 204 -void -__indirect_glMultiTexCoord2iv(GLenum target, const GLint * v) +void __indirect_glMultiTexCoord2iv(GLenum target, const GLint * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_MultiTexCoord2iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord2iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord2sv 205 -void -__indirect_glMultiTexCoord2s(GLenum target, GLshort s, GLshort t) +void __indirect_glMultiTexCoord2s(GLenum target, GLshort s, GLshort t) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_MultiTexCoord2sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord2sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord2sv 205 -void -__indirect_glMultiTexCoord2sv(GLenum target, const GLshort * v) +void __indirect_glMultiTexCoord2sv(GLenum target, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_MultiTexCoord2sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord2sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord3dv 206 -void -__indirect_glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, - GLdouble r) +void __indirect_glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 32; - emit_header(gc->pc, X_GLrop_MultiTexCoord3dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8); - (void) memcpy((void *) (gc->pc + 28), (void *) (&target), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord3dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8); +(void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord3dv 206 -void -__indirect_glMultiTexCoord3dv(GLenum target, const GLdouble * v) +void __indirect_glMultiTexCoord3dv(GLenum target, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 32; - emit_header(gc->pc, X_GLrop_MultiTexCoord3dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (v), 24); - (void) memcpy((void *) (gc->pc + 28), (void *) (&target), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord3dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(v), 24); +(void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord3fvARB 207 -void -__indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, - GLfloat r) +void __indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord3fvARB 207 -void -__indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v) +void __indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 12); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord3iv 208 -void -__indirect_glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r) +void __indirect_glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_MultiTexCoord3iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord3iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord3iv 208 -void -__indirect_glMultiTexCoord3iv(GLenum target, const GLint * v) +void __indirect_glMultiTexCoord3iv(GLenum target, const GLint * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_MultiTexCoord3iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord3iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 12); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord3sv 209 -void -__indirect_glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r) +void __indirect_glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_MultiTexCoord3sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2); - (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord3sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2); +(void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord3sv 209 -void -__indirect_glMultiTexCoord3sv(GLenum target, const GLshort * v) +void __indirect_glMultiTexCoord3sv(GLenum target, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_MultiTexCoord3sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord3sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 6); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord4dv 210 -void -__indirect_glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, - GLdouble r, GLdouble q) +void __indirect_glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 40; - emit_header(gc->pc, X_GLrop_MultiTexCoord4dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8); - (void) memcpy((void *) (gc->pc + 28), (void *) (&q), 8); - (void) memcpy((void *) (gc->pc + 36), (void *) (&target), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord4dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8); +(void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8); +(void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord4dv 210 -void -__indirect_glMultiTexCoord4dv(GLenum target, const GLdouble * v) +void __indirect_glMultiTexCoord4dv(GLenum target, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 40; - emit_header(gc->pc, X_GLrop_MultiTexCoord4dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (v), 32); - (void) memcpy((void *) (gc->pc + 36), (void *) (&target), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord4dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(v), 32); +(void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord4fvARB 211 -void -__indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, - GLfloat r, GLfloat q) +void __indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&q), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord4fvARB 211 -void -__indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v) +void __indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord4iv 212 -void -__indirect_glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, - GLint q) +void __indirect_glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_MultiTexCoord4iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&q), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord4iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord4iv 212 -void -__indirect_glMultiTexCoord4iv(GLenum target, const GLint * v) +void __indirect_glMultiTexCoord4iv(GLenum target, const GLint * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_MultiTexCoord4iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord4iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord4sv 213 -void -__indirect_glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, - GLshort q) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_MultiTexCoord4sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2); - (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 2); - (void) memcpy((void *) (gc->pc + 14), (void *) (&q), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +void __indirect_glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint cmdlen = 16; +emit_header(gc->pc, X_GLrop_MultiTexCoord4sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2); +(void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2); +(void) memcpy((void *)(gc->pc + 14), (void *)(&q), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_MultiTexCoord4sv 213 -void -__indirect_glMultiTexCoord4sv(GLenum target, const GLshort * v) +void __indirect_glMultiTexCoord4sv(GLenum target, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_MultiTexCoord4sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_MultiTexCoord4sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_SampleCoverage 229 -void -__indirect_glSampleCoverage(GLclampf value, GLboolean invert) +void __indirect_glSampleCoverage(GLclampf value, GLboolean invert) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_SampleCoverage, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&value), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&invert), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_SampleCoverage, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_BlendFuncSeparate 4134 -void -__indirect_glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, - GLenum sfactorAlpha, GLenum dfactorAlpha) +void __indirect_glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_BlendFuncSeparate, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&sfactorRGB), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&dfactorRGB), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&sfactorAlpha), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&dfactorAlpha), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_BlendFuncSeparate, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&sfactorRGB), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&dfactorRGB), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&sfactorAlpha), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&dfactorAlpha), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_FogCoorddv 4125 -void -__indirect_glFogCoordd(GLdouble coord) +void __indirect_glFogCoordd(GLdouble coord) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_FogCoorddv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_FogCoorddv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_FogCoorddv 4125 -void -__indirect_glFogCoorddv(const GLdouble * coord) +void __indirect_glFogCoorddv(const GLdouble * coord) { - generic_8_byte(X_GLrop_FogCoorddv, coord); + generic_8_byte( X_GLrop_FogCoorddv, coord ); } #define X_GLrop_PointParameterf 2065 -void -__indirect_glPointParameterf(GLenum pname, GLfloat param) +void __indirect_glPointParameterf(GLenum pname, GLfloat param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_PointParameterf, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PointParameterf, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PointParameterfv 2066 -void -__indirect_glPointParameterfv(GLenum pname, const GLfloat * params) +void __indirect_glPointParameterfv(GLenum pname, const GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glPointParameterfv_size(pname); const GLuint cmdlen = 8 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_PointParameterfv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PointParameterfv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PointParameteri 4221 -void -__indirect_glPointParameteri(GLenum pname, GLint param) +void __indirect_glPointParameteri(GLenum pname, GLint param) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_PointParameteri, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (¶m), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PointParameteri, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_PointParameteriv 4222 -void -__indirect_glPointParameteriv(GLenum pname, const GLint * params) +void __indirect_glPointParameteriv(GLenum pname, const GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint compsize = __glPointParameteriv_size(pname); const GLuint cmdlen = 8 + safe_pad(safe_mul(compsize, 4)); if (0 + safe_pad(safe_mul(compsize, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } - emit_header(gc->pc, X_GLrop_PointParameteriv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (params), - safe_mul(compsize, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_PointParameteriv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(params), safe_mul(compsize, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_SecondaryColor3bv 4126 -void -__indirect_glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue) +void __indirect_glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_SecondaryColor3bv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1); - (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1); - (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_SecondaryColor3bv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1); +(void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1); +(void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_SecondaryColor3bv 4126 -void -__indirect_glSecondaryColor3bv(const GLbyte *v) +void __indirect_glSecondaryColor3bv(const GLbyte * v) { - generic_3_byte(X_GLrop_SecondaryColor3bv, v); + generic_3_byte( X_GLrop_SecondaryColor3bv, v ); } #define X_GLrop_SecondaryColor3dv 4130 -void -__indirect_glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue) +void __indirect_glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_SecondaryColor3dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_SecondaryColor3dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_SecondaryColor3dv 4130 -void -__indirect_glSecondaryColor3dv(const GLdouble * v) +void __indirect_glSecondaryColor3dv(const GLdouble * v) { - generic_24_byte(X_GLrop_SecondaryColor3dv, v); + generic_24_byte( X_GLrop_SecondaryColor3dv, v ); } #define X_GLrop_SecondaryColor3iv 4128 -void -__indirect_glSecondaryColor3i(GLint red, GLint green, GLint blue) +void __indirect_glSecondaryColor3i(GLint red, GLint green, GLint blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_SecondaryColor3iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_SecondaryColor3iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_SecondaryColor3iv 4128 -void -__indirect_glSecondaryColor3iv(const GLint * v) +void __indirect_glSecondaryColor3iv(const GLint * v) { - generic_12_byte(X_GLrop_SecondaryColor3iv, v); + generic_12_byte( X_GLrop_SecondaryColor3iv, v ); } #define X_GLrop_SecondaryColor3sv 4127 -void -__indirect_glSecondaryColor3s(GLshort red, GLshort green, GLshort blue) +void __indirect_glSecondaryColor3s(GLshort red, GLshort green, GLshort blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_SecondaryColor3sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2); - (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_SecondaryColor3sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2); +(void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_SecondaryColor3sv 4127 -void -__indirect_glSecondaryColor3sv(const GLshort * v) +void __indirect_glSecondaryColor3sv(const GLshort * v) { - generic_6_byte(X_GLrop_SecondaryColor3sv, v); + generic_6_byte( X_GLrop_SecondaryColor3sv, v ); } #define X_GLrop_SecondaryColor3ubv 4131 -void -__indirect_glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue) +void __indirect_glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_SecondaryColor3ubv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1); - (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1); - (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_SecondaryColor3ubv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1); +(void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1); +(void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_SecondaryColor3ubv 4131 -void -__indirect_glSecondaryColor3ubv(const GLubyte *v) +void __indirect_glSecondaryColor3ubv(const GLubyte * v) { - generic_3_byte(X_GLrop_SecondaryColor3ubv, v); + generic_3_byte( X_GLrop_SecondaryColor3ubv, v ); } #define X_GLrop_SecondaryColor3uiv 4133 -void -__indirect_glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue) +void __indirect_glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_SecondaryColor3uiv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_SecondaryColor3uiv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_SecondaryColor3uiv 4133 -void -__indirect_glSecondaryColor3uiv(const GLuint * v) +void __indirect_glSecondaryColor3uiv(const GLuint * v) { - generic_12_byte(X_GLrop_SecondaryColor3uiv, v); + generic_12_byte( X_GLrop_SecondaryColor3uiv, v ); } #define X_GLrop_SecondaryColor3usv 4132 -void -__indirect_glSecondaryColor3us(GLushort red, GLushort green, GLushort blue) +void __indirect_glSecondaryColor3us(GLushort red, GLushort green, GLushort blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_SecondaryColor3usv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2); - (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2); - (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_SecondaryColor3usv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2); +(void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2); +(void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_SecondaryColor3usv 4132 -void -__indirect_glSecondaryColor3usv(const GLushort * v) +void __indirect_glSecondaryColor3usv(const GLushort * v) { - generic_6_byte(X_GLrop_SecondaryColor3usv, v); + generic_6_byte( X_GLrop_SecondaryColor3usv, v ); } #define X_GLrop_WindowPos3fv 230 -void -__indirect_glWindowPos3f(GLfloat x, GLfloat y, GLfloat z) +void __indirect_glWindowPos3f(GLfloat x, GLfloat y, GLfloat z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_WindowPos3fv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_WindowPos3fv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_WindowPos3fv 230 -void -__indirect_glWindowPos3fv(const GLfloat * v) +void __indirect_glWindowPos3fv(const GLfloat * v) { - generic_12_byte(X_GLrop_WindowPos3fv, v); + generic_12_byte( X_GLrop_WindowPos3fv, v ); } #define X_GLrop_BeginQuery 231 -void -__indirect_glBeginQuery(GLenum target, GLuint id) +void __indirect_glBeginQuery(GLenum target, GLuint id) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_BeginQuery, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_BeginQuery, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLsop_DeleteQueries 161 -void -__indirect_glDeleteQueries(GLsizei n, const GLuint * ids) +void __indirect_glDeleteQueries(GLsizei n, const GLuint * ids) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 4 + safe_pad(safe_mul(n, 4)); #endif @@ -8147,37 +6528,31 @@ (void) __glXFlushRenderBuffer(gc, gc->pc); xcb_glx_delete_queries(c, gc->currentContextTag, n, ids); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_DeleteQueries, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&n), 4); - (void) memcpy((void *) (pc + 4), (void *) (ids), safe_mul(n, 4)); - UnlockDisplay(dpy); - SyncHandle(); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteQueries, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&n), 4); +(void) memcpy((void *)(pc + 4), (void *)(ids), safe_mul(n, 4)); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLrop_EndQuery 232 -void -__indirect_glEndQuery(GLenum target) +void __indirect_glEndQuery(GLenum target) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_EndQuery, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_EndQuery, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLsop_GenQueries 162 -void -__indirect_glGenQueries(GLsizei n, GLuint * ids) +void __indirect_glGenQueries(GLsizei n, GLuint * ids) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 4; #endif @@ -8189,34 +6564,24 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_gen_queries_reply_t *reply = - xcb_glx_gen_queries_reply(c, - xcb_glx_gen_queries(c, - gc-> - currentContextTag, - n), NULL); - (void) memcpy(ids, xcb_glx_gen_queries_data(reply), - xcb_glx_gen_queries_data_length(reply) * - sizeof(GLuint)); + xcb_glx_gen_queries_reply_t *reply = xcb_glx_gen_queries_reply(c, xcb_glx_gen_queries(c, gc->currentContextTag, n), NULL); + (void)memcpy(ids, xcb_glx_gen_queries_data(reply), xcb_glx_gen_queries_data_length(reply) * sizeof(GLuint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GenQueries, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&n), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenQueries, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&n), 4); (void) __glXReadReply(dpy, 4, ids, GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetQueryObjectiv 165 -void -__indirect_glGetQueryObjectiv(GLuint id, GLenum pname, GLint * params) +void __indirect_glGetQueryObjectiv(GLuint id, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -8224,42 +6589,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_query_objectiv_reply_t *reply = - xcb_glx_get_query_objectiv_reply(c, - xcb_glx_get_query_objectiv(c, - gc-> - currentContextTag, - id, - pname), - NULL); + xcb_glx_get_query_objectiv_reply_t *reply = xcb_glx_get_query_objectiv_reply(c, xcb_glx_get_query_objectiv(c, gc->currentContextTag, id, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_query_objectiv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_query_objectiv_data(reply), - xcb_glx_get_query_objectiv_data_length(reply) * - sizeof(GLint)); + (void)memcpy(params, xcb_glx_get_query_objectiv_data(reply), xcb_glx_get_query_objectiv_data_length(reply) * sizeof(GLint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectiv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&id), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectiv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&id), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetQueryObjectuiv 166 -void -__indirect_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint * params) +void __indirect_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -8267,42 +6620,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_query_objectuiv_reply_t *reply = - xcb_glx_get_query_objectuiv_reply(c, - xcb_glx_get_query_objectuiv(c, - gc-> - currentContextTag, - id, - pname), - NULL); + xcb_glx_get_query_objectuiv_reply_t *reply = xcb_glx_get_query_objectuiv_reply(c, xcb_glx_get_query_objectuiv(c, gc->currentContextTag, id, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_query_objectuiv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_query_objectuiv_data(reply), - xcb_glx_get_query_objectuiv_data_length(reply) * - sizeof(GLuint)); + (void)memcpy(params, xcb_glx_get_query_objectuiv_data(reply), xcb_glx_get_query_objectuiv_data_length(reply) * sizeof(GLuint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectuiv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&id), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectuiv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&id), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_GetQueryiv 164 -void -__indirect_glGetQueryiv(GLenum target, GLenum pname, GLint * params) +void __indirect_glGetQueryiv(GLenum target, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; #ifndef USE_XCB const GLuint cmdlen = 8; #endif @@ -8310,41 +6651,30 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_get_queryiv_reply_t *reply = - xcb_glx_get_queryiv_reply(c, - xcb_glx_get_queryiv(c, - gc-> - currentContextTag, - target, pname), - NULL); + xcb_glx_get_queryiv_reply_t *reply = xcb_glx_get_queryiv_reply(c, xcb_glx_get_queryiv(c, gc->currentContextTag, target, pname), NULL); /* the XXX_data_length() xcb function name is misleading, it returns the number */ /* of elements, not the length of the data part. A single element is embedded. */ if (xcb_glx_get_queryiv_data_length(reply) == 1) - (void) memcpy(params, &reply->datum, sizeof(reply->datum)); + (void)memcpy(params, &reply->datum, sizeof(reply->datum)); else - (void) memcpy(params, xcb_glx_get_queryiv_data(reply), - xcb_glx_get_queryiv_data_length(reply) * - sizeof(GLint)); + (void)memcpy(params, xcb_glx_get_queryiv_data(reply), xcb_glx_get_queryiv_data_length(reply) * sizeof(GLint)); free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_GetQueryiv, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryiv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return; } #define X_GLsop_IsQuery 163 -GLboolean -__indirect_glIsQuery(GLuint id) +GLboolean __indirect_glIsQuery(GLuint id) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; GLboolean retval = (GLboolean) 0; #ifndef USE_XCB const GLuint cmdlen = 4; @@ -8353,44 +6683,35 @@ #ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); (void) __glXFlushRenderBuffer(gc, gc->pc); - xcb_glx_is_query_reply_t *reply = - xcb_glx_is_query_reply(c, - xcb_glx_is_query(c, gc->currentContextTag, - id), NULL); + xcb_glx_is_query_reply_t *reply = xcb_glx_is_query_reply(c, xcb_glx_is_query(c, gc->currentContextTag, id), NULL); retval = reply->ret_val; free(reply); #else - GLubyte const *pc = - __glXSetupSingleRequest(gc, X_GLsop_IsQuery, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&id), 4); + GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsQuery, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&id), 4); retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); #endif /* USE_XCB */ } return retval; } #define X_GLrop_BlendEquationSeparate 4228 -void -__indirect_glBlendEquationSeparate(GLenum modeRGB, GLenum modeA) +void __indirect_glBlendEquationSeparate(GLenum modeRGB, GLenum modeA) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_BlendEquationSeparate, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&modeRGB), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&modeA), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_BlendEquationSeparate, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&modeRGB), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&modeA), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_DrawBuffers 233 -void -__indirect_glDrawBuffers(GLsizei n, const GLenum * bufs) +void __indirect_glDrawBuffers(GLsizei n, const GLenum * bufs) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8 + safe_pad(safe_mul(n, 4)); if (0 + safe_pad(safe_mul(n, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -8401,504 +6722,408 @@ return; } if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, X_GLrop_DrawBuffers, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (bufs), - safe_mul(n, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = X_GLrop_DrawBuffers; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 8), (void *) (&n), 4); - __glXSendLargeCommand(gc, pc, 12, bufs, safe_mul(n, 4)); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, X_GLrop_DrawBuffers, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(bufs), safe_mul(n, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = X_GLrop_DrawBuffers; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 8), (void *)(&n), 4); + __glXSendLargeCommand(gc, pc, 12, bufs, safe_mul(n, 4)); +} } } #define X_GLrop_VertexAttrib1dv 4197 -void -__indirect_glVertexAttrib1d(GLuint index, GLdouble x) +void __indirect_glVertexAttrib1d(GLuint index, GLdouble x) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib1dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib1dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib1dv 4197 -void -__indirect_glVertexAttrib1dv(GLuint index, const GLdouble * v) +void __indirect_glVertexAttrib1dv(GLuint index, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib1dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib1dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib1sv 4189 -void -__indirect_glVertexAttrib1s(GLuint index, GLshort x) +void __indirect_glVertexAttrib1s(GLuint index, GLshort x) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib1sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib1sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib1sv 4189 -void -__indirect_glVertexAttrib1sv(GLuint index, const GLshort * v) +void __indirect_glVertexAttrib1sv(GLuint index, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib1sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib1sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib2dv 4198 -void -__indirect_glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y) +void __indirect_glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_VertexAttrib2dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib2dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib2dv 4198 -void -__indirect_glVertexAttrib2dv(GLuint index, const GLdouble * v) +void __indirect_glVertexAttrib2dv(GLuint index, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_VertexAttrib2dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib2dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib2sv 4190 -void -__indirect_glVertexAttrib2s(GLuint index, GLshort x, GLshort y) +void __indirect_glVertexAttrib2s(GLuint index, GLshort x, GLshort y) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib2sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib2sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib2sv 4190 -void -__indirect_glVertexAttrib2sv(GLuint index, const GLshort * v) +void __indirect_glVertexAttrib2sv(GLuint index, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib2sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib2sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib3dv 4199 -void -__indirect_glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z) +void __indirect_glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 32; - emit_header(gc->pc, X_GLrop_VertexAttrib3dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8); - (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib3dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8); +(void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib3dv 4199 -void -__indirect_glVertexAttrib3dv(GLuint index, const GLdouble * v) +void __indirect_glVertexAttrib3dv(GLuint index, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 32; - emit_header(gc->pc, X_GLrop_VertexAttrib3dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 24); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib3dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 24); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib3sv 4191 -void -__indirect_glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z) +void __indirect_glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib3sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib3sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib3sv 4191 -void -__indirect_glVertexAttrib3sv(GLuint index, const GLshort * v) +void __indirect_glVertexAttrib3sv(GLuint index, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib3sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib3sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 6); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4Nbv 4235 -void -__indirect_glVertexAttrib4Nbv(GLuint index, const GLbyte *v) +void __indirect_glVertexAttrib4Nbv(GLuint index, const GLbyte * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib4Nbv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4Nbv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4Niv 4237 -void -__indirect_glVertexAttrib4Niv(GLuint index, const GLint * v) +void __indirect_glVertexAttrib4Niv(GLuint index, const GLint * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_VertexAttrib4Niv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4Niv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4Nsv 4236 -void -__indirect_glVertexAttrib4Nsv(GLuint index, const GLshort * v) +void __indirect_glVertexAttrib4Nsv(GLuint index, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib4Nsv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4Nsv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4Nubv 4201 -void -__indirect_glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, - GLubyte w) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib4Nubv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 1); - (void) memcpy((void *) (gc->pc + 9), (void *) (&y), 1); - (void) memcpy((void *) (gc->pc + 10), (void *) (&z), 1); - (void) memcpy((void *) (gc->pc + 11), (void *) (&w), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +void __indirect_glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint cmdlen = 12; +emit_header(gc->pc, X_GLrop_VertexAttrib4Nubv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1); +(void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1); +(void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1); +(void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4Nubv 4201 -void -__indirect_glVertexAttrib4Nubv(GLuint index, const GLubyte *v) +void __indirect_glVertexAttrib4Nubv(GLuint index, const GLubyte * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib4Nubv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4Nubv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4Nuiv 4239 -void -__indirect_glVertexAttrib4Nuiv(GLuint index, const GLuint * v) +void __indirect_glVertexAttrib4Nuiv(GLuint index, const GLuint * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_VertexAttrib4Nuiv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4Nuiv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4Nusv 4238 -void -__indirect_glVertexAttrib4Nusv(GLuint index, const GLushort * v) +void __indirect_glVertexAttrib4Nusv(GLuint index, const GLushort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib4Nusv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4Nusv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4bv 4230 -void -__indirect_glVertexAttrib4bv(GLuint index, const GLbyte *v) +void __indirect_glVertexAttrib4bv(GLuint index, const GLbyte * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib4bv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4bv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4dv 4200 -void -__indirect_glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, - GLdouble w) +void __indirect_glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 40; - emit_header(gc->pc, X_GLrop_VertexAttrib4dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8); - (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8); - (void) memcpy((void *) (gc->pc + 32), (void *) (&w), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8); +(void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8); +(void) memcpy((void *)(gc->pc + 32), (void *)(&w), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4dv 4200 -void -__indirect_glVertexAttrib4dv(GLuint index, const GLdouble * v) +void __indirect_glVertexAttrib4dv(GLuint index, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 40; - emit_header(gc->pc, X_GLrop_VertexAttrib4dv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 32); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4dv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 32); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4iv 4231 -void -__indirect_glVertexAttrib4iv(GLuint index, const GLint * v) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_VertexAttrib4iv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +void __indirect_glVertexAttrib4iv(GLuint index, const GLint * v) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint cmdlen = 24; +emit_header(gc->pc, X_GLrop_VertexAttrib4iv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4sv 4192 -void -__indirect_glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, - GLshort w) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib4sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2); - (void) memcpy((void *) (gc->pc + 14), (void *) (&w), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +void __indirect_glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint cmdlen = 16; +emit_header(gc->pc, X_GLrop_VertexAttrib4sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2); +(void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4sv 4192 -void -__indirect_glVertexAttrib4sv(GLuint index, const GLshort * v) +void __indirect_glVertexAttrib4sv(GLuint index, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib4sv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4sv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4ubv 4232 -void -__indirect_glVertexAttrib4ubv(GLuint index, const GLubyte *v) +void __indirect_glVertexAttrib4ubv(GLuint index, const GLubyte * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib4ubv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4ubv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4uiv 4234 -void -__indirect_glVertexAttrib4uiv(GLuint index, const GLuint * v) +void __indirect_glVertexAttrib4uiv(GLuint index, const GLuint * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_VertexAttrib4uiv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4uiv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4usv 4233 -void -__indirect_glVertexAttrib4usv(GLuint index, const GLushort * v) +void __indirect_glVertexAttrib4usv(GLuint index, const GLushort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib4usv, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4usv, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ClampColor 234 -void -__indirect_glClampColor(GLenum target, GLenum clamp) +void __indirect_glClampColor(GLenum target, GLenum clamp) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_ClampColor, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&clamp), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ClampColor, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&clamp), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_BindProgramARB 4180 -void -__indirect_glBindProgramARB(GLenum target, GLuint program) +void __indirect_glBindProgramARB(GLenum target, GLuint program) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_BindProgramARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&program), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_BindProgramARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&program), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLvop_DeleteProgramsARB 1294 -void -__indirect_glDeleteProgramsARB(GLsizei n, const GLuint * programs) +void __indirect_glDeleteProgramsARB(GLsizei n, const GLuint * programs) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 4 + safe_pad(safe_mul(n, 4)); if (0 + safe_pad(safe_mul(n, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -8909,256 +7134,201 @@ return; } if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivate, - X_GLvop_DeleteProgramsARB, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&n), 4); - (void) memcpy((void *) (pc + 4), (void *) (programs), safe_mul(n, 4)); - UnlockDisplay(dpy); - SyncHandle(); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_GLvop_DeleteProgramsARB, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&n), 4); +(void) memcpy((void *)(pc + 4), (void *)(programs), safe_mul(n, 4)); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_GenProgramsARB 1295 -void -__indirect_glGenProgramsARB(GLsizei n, GLuint * programs) +void __indirect_glGenProgramsARB(GLsizei n, GLuint * programs) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 4; if (n < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GenProgramsARB, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&n), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenProgramsARB, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&n), 4); (void) __glXReadReply(dpy, 4, programs, GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_GetProgramStringARB 1308 -void -__indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string) +void __indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 8; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetProgramStringARB, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringARB, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 1, string, GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_GetProgramivARB 1307 -void -__indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params) +void __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 8; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetProgramivARB, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivARB, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_IsProgramARB 1304 -GLboolean -__indirect_glIsProgramARB(GLuint program) +GLboolean __indirect_glIsProgramARB(GLuint program) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; GLboolean retval = (GLboolean) 0; const GLuint cmdlen = 4; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_IsProgramARB, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&program), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsProgramARB, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&program), 4); retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return retval; } #define X_GLrop_ProgramEnvParameter4dvARB 4185 -void -__indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, - GLdouble y, GLdouble z, GLdouble w) +void __indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 44; - emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8); - (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8); - (void) memcpy((void *) (gc->pc + 36), (void *) (&w), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8); +(void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8); +(void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ProgramEnvParameter4dvARB 4185 -void -__indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, - const GLdouble * params) +void __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 44; - emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), 32); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), 32); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ProgramEnvParameter4fvARB 4184 -void -__indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, - GLfloat y, GLfloat z, GLfloat w) +void __indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4); - (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4); +(void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ProgramEnvParameter4fvARB 4184 -void -__indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, - const GLfloat * params) +void __indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), 16); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ProgramLocalParameter4dvARB 4216 -void -__indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, - GLdouble x, GLdouble y, GLdouble z, - GLdouble w) +void __indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 44; - emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8); - (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8); - (void) memcpy((void *) (gc->pc + 36), (void *) (&w), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8); +(void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8); +(void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ProgramLocalParameter4dvARB 4216 -void -__indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, - const GLdouble * params) +void __indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 44; - emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), 32); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), 32); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ProgramLocalParameter4fvARB 4215 -void -__indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, - GLfloat x, GLfloat y, GLfloat z, - GLfloat w) +void __indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4); - (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4); +(void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ProgramLocalParameter4fvARB 4215 -void -__indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, - const GLfloat * params) +void __indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), 16); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_ProgramStringARB 4217 -void -__indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, - const GLvoid * string) +void __indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16 + safe_pad(len); if (0 + safe_pad(len) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -9169,241 +7339,198 @@ return; } if (__builtin_expect((len >= 0) && (gc->currentDpy != NULL), 1)) { - if (cmdlen <= gc->maxSmallRenderCommandSize) { - if ((gc->pc + cmdlen) > gc->bufEnd) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - emit_header(gc->pc, X_GLrop_ProgramStringARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&format), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&len), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (string), len); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } - } else { - const GLint op = X_GLrop_ProgramStringARB; - const GLuint cmdlenLarge = cmdlen + 4; - GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc); - (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4); - (void) memcpy((void *) (pc + 4), (void *) (&op), 4); - (void) memcpy((void *) (pc + 8), (void *) (&target), 4); - (void) memcpy((void *) (pc + 12), (void *) (&format), 4); - (void) memcpy((void *) (pc + 16), (void *) (&len), 4); - __glXSendLargeCommand(gc, pc, 20, string, len); - } +if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } +emit_header(gc->pc, X_GLrop_ProgramStringARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&format), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(string), len); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} +else { +const GLint op = X_GLrop_ProgramStringARB; +const GLuint cmdlenLarge = cmdlen + 4; +GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); +(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); +(void) memcpy((void *)(pc + 4), (void *)(&op), 4); +(void) memcpy((void *)(pc + 8), (void *)(&target), 4); +(void) memcpy((void *)(pc + 12), (void *)(&format), 4); +(void) memcpy((void *)(pc + 16), (void *)(&len), 4); + __glXSendLargeCommand(gc, pc, 20, string, len); +} } } #define X_GLrop_VertexAttrib1fvARB 4193 -void -__indirect_glVertexAttrib1fARB(GLuint index, GLfloat x) +void __indirect_glVertexAttrib1fARB(GLuint index, GLfloat x) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib1fvARB 4193 -void -__indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v) +void __indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib2fvARB 4194 -void -__indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y) +void __indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib2fvARB 4194 -void -__indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v) +void __indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib3fvARB 4195 -void -__indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z) +void __indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib3fvARB 4195 -void -__indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v) +void __indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 12); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4fvARB 4196 -void -__indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, - GLfloat w) +void __indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&w), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4fvARB 4196 -void -__indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v) +void __indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_BindFramebuffer 236 -void -__indirect_glBindFramebuffer(GLenum target, GLuint framebuffer) +void __indirect_glBindFramebuffer(GLenum target, GLuint framebuffer) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_BindFramebuffer, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&framebuffer), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_BindFramebuffer, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&framebuffer), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_BindRenderbuffer 235 -void -__indirect_glBindRenderbuffer(GLenum target, GLuint renderbuffer) +void __indirect_glBindRenderbuffer(GLenum target, GLuint renderbuffer) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_BindRenderbuffer, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&renderbuffer), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_BindRenderbuffer, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&renderbuffer), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_BlitFramebuffer 4330 -void -__indirect_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, - GLint srcY1, GLint dstX0, GLint dstY0, - GLint dstX1, GLint dstY1, GLbitfield mask, - GLenum filter) +void __indirect_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 44; - emit_header(gc->pc, X_GLrop_BlitFramebuffer, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&srcX0), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&srcY0), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&srcX1), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&srcY1), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&dstX0), 4); - (void) memcpy((void *) (gc->pc + 24), (void *) (&dstY0), 4); - (void) memcpy((void *) (gc->pc + 28), (void *) (&dstX1), 4); - (void) memcpy((void *) (gc->pc + 32), (void *) (&dstY1), 4); - (void) memcpy((void *) (gc->pc + 36), (void *) (&mask), 4); - (void) memcpy((void *) (gc->pc + 40), (void *) (&filter), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_BlitFramebuffer, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&srcX0), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&srcY0), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&srcX1), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&srcY1), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&dstX0), 4); +(void) memcpy((void *)(gc->pc + 24), (void *)(&dstY0), 4); +(void) memcpy((void *)(gc->pc + 28), (void *)(&dstX1), 4); +(void) memcpy((void *)(gc->pc + 32), (void *)(&dstY1), 4); +(void) memcpy((void *)(gc->pc + 36), (void *)(&mask), 4); +(void) memcpy((void *)(gc->pc + 40), (void *)(&filter), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLvop_CheckFramebufferStatus 1427 -GLenum -__indirect_glCheckFramebufferStatus(GLenum target) +GLenum __indirect_glCheckFramebufferStatus(GLenum target) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; GLenum retval = (GLenum) 0; const GLuint cmdlen = 4; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_CheckFramebufferStatus, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_CheckFramebufferStatus, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); retval = (GLenum) __glXReadReply(dpy, 0, NULL, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return retval; } #define X_GLrop_DeleteFramebuffers 4320 -void -__indirect_glDeleteFramebuffers(GLsizei n, const GLuint * framebuffers) +void __indirect_glDeleteFramebuffers(GLsizei n, const GLuint * framebuffers) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8 + safe_pad(safe_mul(n, 4)); if (0 + safe_pad(safe_mul(n, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -9414,22 +7541,18 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_DeleteFramebuffers, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (framebuffers), - safe_mul(n, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_DeleteFramebuffers, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(framebuffers), safe_mul(n, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_DeleteRenderbuffers 4317 -void -__indirect_glDeleteRenderbuffers(GLsizei n, const GLuint * renderbuffers) +void __indirect_glDeleteRenderbuffers(GLsizei n, const GLuint * renderbuffers) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8 + safe_pad(safe_mul(n, 4)); if (0 + safe_pad(safe_mul(n, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -9440,380 +7563,296 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_DeleteRenderbuffers, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (renderbuffers), - safe_mul(n, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_DeleteRenderbuffers, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(renderbuffers), safe_mul(n, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_FramebufferRenderbuffer 4324 -void -__indirect_glFramebufferRenderbuffer(GLenum target, GLenum attachment, - GLenum renderbuffertarget, - GLuint renderbuffer) +void __indirect_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_FramebufferRenderbuffer, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&renderbuffertarget), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&renderbuffer), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_FramebufferRenderbuffer, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&renderbuffertarget), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&renderbuffer), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_FramebufferTexture1D 4321 -void -__indirect_glFramebufferTexture1D(GLenum target, GLenum attachment, - GLenum textarget, GLuint texture, - GLint level) +void __indirect_glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_FramebufferTexture1D, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_FramebufferTexture1D, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_FramebufferTexture2D 4322 -void -__indirect_glFramebufferTexture2D(GLenum target, GLenum attachment, - GLenum textarget, GLuint texture, - GLint level) +void __indirect_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_FramebufferTexture2D, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_FramebufferTexture2D, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_FramebufferTexture3D 4323 -void -__indirect_glFramebufferTexture3D(GLenum target, GLenum attachment, - GLenum textarget, GLuint texture, - GLint level, GLint layer) +void __indirect_glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_FramebufferTexture3D, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4); - (void) memcpy((void *) (gc->pc + 24), (void *) (&layer), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_FramebufferTexture3D, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4); +(void) memcpy((void *)(gc->pc + 24), (void *)(&layer), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_FramebufferTextureLayer 237 -void -__indirect_glFramebufferTextureLayer(GLenum target, GLenum attachment, - GLuint texture, GLint level, GLint layer) +void __indirect_glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_FramebufferTextureLayer, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&texture), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&level), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&layer), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_FramebufferTextureLayer, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&texture), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&level), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&layer), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLvop_GenFramebuffers 1426 -void -__indirect_glGenFramebuffers(GLsizei n, GLuint * framebuffers) +void __indirect_glGenFramebuffers(GLsizei n, GLuint * framebuffers) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 4; if (n < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GenFramebuffers, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&n), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenFramebuffers, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&n), 4); (void) __glXReadReply(dpy, 4, framebuffers, GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_GenRenderbuffers 1423 -void -__indirect_glGenRenderbuffers(GLsizei n, GLuint * renderbuffers) +void __indirect_glGenRenderbuffers(GLsizei n, GLuint * renderbuffers) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 4; if (n < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GenRenderbuffers, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&n), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenRenderbuffers, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&n), 4); (void) __glXReadReply(dpy, 4, renderbuffers, GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLrop_GenerateMipmap 4325 -void -__indirect_glGenerateMipmap(GLenum target) +void __indirect_glGenerateMipmap(GLenum target) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_GenerateMipmap, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_GenerateMipmap, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLvop_GetFramebufferAttachmentParameteriv 1428 -void -__indirect_glGetFramebufferAttachmentParameteriv(GLenum target, - GLenum attachment, - GLenum pname, GLint * params) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; - const GLuint cmdlen = 12; - if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetFramebufferAttachmentParameteriv, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&attachment), 4); - (void) memcpy((void *) (pc + 8), (void *) (&pname), 4); +void __indirect_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint * params) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; + const GLuint cmdlen = 12; + if (__builtin_expect(dpy != NULL, 1)) { + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetFramebufferAttachmentParameteriv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&attachment), 4); +(void) memcpy((void *)(pc + 8), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_GetRenderbufferParameteriv 1424 -void -__indirect_glGetRenderbufferParameteriv(GLenum target, GLenum pname, - GLint * params) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; +void __indirect_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint * params) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 8; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetRenderbufferParameteriv, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetRenderbufferParameteriv, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_IsFramebuffer 1425 -GLboolean -__indirect_glIsFramebuffer(GLuint framebuffer) +GLboolean __indirect_glIsFramebuffer(GLuint framebuffer) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; GLboolean retval = (GLboolean) 0; const GLuint cmdlen = 4; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_IsFramebuffer, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&framebuffer), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsFramebuffer, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&framebuffer), 4); retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return retval; } #define X_GLvop_IsRenderbuffer 1422 -GLboolean -__indirect_glIsRenderbuffer(GLuint renderbuffer) +GLboolean __indirect_glIsRenderbuffer(GLuint renderbuffer) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; GLboolean retval = (GLboolean) 0; const GLuint cmdlen = 4; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_IsRenderbuffer, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&renderbuffer), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsRenderbuffer, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&renderbuffer), 4); retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return retval; } #define X_GLrop_RenderbufferStorage 4318 -void -__indirect_glRenderbufferStorage(GLenum target, GLenum internalformat, - GLsizei width, GLsizei height) +void __indirect_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_RenderbufferStorage, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RenderbufferStorage, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_RenderbufferStorageMultisample 4331 -void -__indirect_glRenderbufferStorageMultisample(GLenum target, GLsizei samples, - GLenum internalformat, - GLsizei width, GLsizei height) +void __indirect_glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_RenderbufferStorageMultisample, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&samples), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&width), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&height), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RenderbufferStorageMultisample, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&samples), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&width), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&height), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_SampleMaskSGIS 2048 -void -__indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert) +void __indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&value), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&invert), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_SamplePatternSGIS 2049 -void -__indirect_glSamplePatternSGIS(GLenum pattern) +void __indirect_glSamplePatternSGIS(GLenum pattern) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&pattern), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&pattern), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_SecondaryColor3fvEXT 4129 -void -__indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue) +void __indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_SecondaryColor3fvEXT 4129 -void -__indirect_glSecondaryColor3fvEXT(const GLfloat * v) +void __indirect_glSecondaryColor3fvEXT(const GLfloat * v) { - generic_12_byte(X_GLrop_SecondaryColor3fvEXT, v); + generic_12_byte( X_GLrop_SecondaryColor3fvEXT, v ); } #define X_GLrop_FogCoordfvEXT 4124 -void -__indirect_glFogCoordfEXT(GLfloat coord) +void __indirect_glFogCoordfEXT(GLfloat coord) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_FogCoordfvEXT 4124 -void -__indirect_glFogCoordfvEXT(const GLfloat * coord) +void __indirect_glFogCoordfvEXT(const GLfloat * coord) { - generic_4_byte(X_GLrop_FogCoordfvEXT, coord); + generic_4_byte( X_GLrop_FogCoordfvEXT, coord ); } #define X_GLvop_AreProgramsResidentNV 1293 -GLboolean -__indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, - GLboolean * residences) +GLboolean __indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, GLboolean * residences) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; GLboolean retval = (GLboolean) 0; const GLuint cmdlen = 4 + safe_pad(safe_mul(n, 4)); if (0 + safe_pad(safe_mul(n, 4)) < 0) { @@ -9825,208 +7864,163 @@ return 0; } if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_AreProgramsResidentNV, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&n), 4); - (void) memcpy((void *) (pc + 4), (void *) (ids), safe_mul(n, 4)); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreProgramsResidentNV, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&n), 4); +(void) memcpy((void *)(pc + 4), (void *)(ids), safe_mul(n, 4)); retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return retval; } #define X_GLrop_ExecuteProgramNV 4181 -void -__indirect_glExecuteProgramNV(GLenum target, GLuint id, - const GLfloat * params) +void __indirect_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28; - emit_header(gc->pc, X_GLrop_ExecuteProgramNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ExecuteProgramNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(params), 16); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLvop_GetProgramParameterdvNV 1297 -void -__indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, - GLenum pname, GLdouble * params) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; +void __indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 12; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetProgramParameterdvNV, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (pc + 8), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterdvNV, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(pc + 8), (void *)(&pname), 4); (void) __glXReadReply(dpy, 8, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_GetProgramParameterfvNV 1296 -void -__indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, - GLenum pname, GLfloat * params) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; +void __indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 12; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetProgramParameterfvNV, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (pc + 8), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterfvNV, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(pc + 8), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_GetProgramStringNV 1299 -void -__indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte *program) +void __indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 8; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetProgramStringNV, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&id), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringNV, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&id), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 1, program, GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_GetProgramivNV 1298 -void -__indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params) +void __indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 8; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetProgramivNV, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&id), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivNV, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&id), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_GetTrackMatrixivNV 1300 -void -__indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, - GLint * params) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; +void __indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 12; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetTrackMatrixivNV, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&target), 4); - (void) memcpy((void *) (pc + 4), (void *) (&address), 4); - (void) memcpy((void *) (pc + 8), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetTrackMatrixivNV, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&target), 4); +(void) memcpy((void *)(pc + 4), (void *)(&address), 4); +(void) memcpy((void *)(pc + 8), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_GetVertexAttribdvNV 1301 -void -__indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, - GLdouble * params) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; +void __indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 8; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetVertexAttribdvNV, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&index), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribdvNV, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&index), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 8, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_GetVertexAttribfvNV 1302 -void -__indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params) +void __indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 8; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetVertexAttribfvNV, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&index), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribfvNV, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&index), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_GetVertexAttribivNV 1303 -void -__indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params) +void __indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 8; if (__builtin_expect(dpy != NULL, 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetVertexAttribivNV, cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&index), 4); - (void) memcpy((void *) (pc + 4), (void *) (&pname), 4); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribivNV, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&index), 4); +(void) memcpy((void *)(pc + 4), (void *)(&pname), 4); (void) __glXReadReply(dpy, 4, params, GL_FALSE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLrop_LoadProgramNV 4183 -void -__indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, - const GLubyte *program) +void __indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16 + safe_pad(len); if (0 + safe_pad(len) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10037,24 +8031,20 @@ return; } if (__builtin_expect(len >= 0, 1)) { - emit_header(gc->pc, X_GLrop_LoadProgramNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&len), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (program), len); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_LoadProgramNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(program), len); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_ProgramParameters4dvNV 4187 -void -__indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLsizei num, - const GLdouble * params) +void __indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLsizei num, const GLdouble * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16 + safe_pad(safe_mul(num, 32)); if (0 + safe_pad(safe_mul(num, 32)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10065,25 +8055,20 @@ return; } if (__builtin_expect(num >= 0, 1)) { - emit_header(gc->pc, X_GLrop_ProgramParameters4dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&num), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (params), - safe_mul(num, 32)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ProgramParameters4dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(params), safe_mul(num, 32)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_ProgramParameters4fvNV 4186 -void -__indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLsizei num, - const GLfloat * params) +void __indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLsizei num, const GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16 + safe_pad(safe_mul(num, 16)); if (0 + safe_pad(safe_mul(num, 16)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10094,24 +8079,20 @@ return; } if (__builtin_expect(num >= 0, 1)) { - emit_header(gc->pc, X_GLrop_ProgramParameters4fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&num), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (params), - safe_mul(num, 16)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ProgramParameters4fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(params), safe_mul(num, 16)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_RequestResidentProgramsNV 4182 -void -__indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids) +void __indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8 + safe_pad(safe_mul(n, 4)); if (0 + safe_pad(safe_mul(n, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10122,455 +8103,365 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_RequestResidentProgramsNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (ids), safe_mul(n, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_RequestResidentProgramsNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(ids), safe_mul(n, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_TrackMatrixNV 4188 -void -__indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, - GLenum transform) +void __indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_TrackMatrixNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&address), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&matrix), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&transform), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_TrackMatrixNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&address), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&matrix), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&transform), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib1dvNV 4273 -void -__indirect_glVertexAttrib1dNV(GLuint index, GLdouble x) +void __indirect_glVertexAttrib1dNV(GLuint index, GLdouble x) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib1dvNV 4273 -void -__indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v) +void __indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib1fvNV 4269 -void -__indirect_glVertexAttrib1fNV(GLuint index, GLfloat x) +void __indirect_glVertexAttrib1fNV(GLuint index, GLfloat x) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib1fvNV 4269 -void -__indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v) +void __indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib1svNV 4265 -void -__indirect_glVertexAttrib1sNV(GLuint index, GLshort x) +void __indirect_glVertexAttrib1sNV(GLuint index, GLshort x) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib1svNV 4265 -void -__indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v) +void __indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib2dvNV 4274 -void -__indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y) +void __indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib2dvNV 4274 -void -__indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v) +void __indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib2fvNV 4270 -void -__indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y) +void __indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib2fvNV 4270 -void -__indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v) +void __indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib2svNV 4266 -void -__indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y) +void __indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib2svNV 4266 -void -__indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v) +void __indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib3dvNV 4275 -void -__indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, - GLdouble z) +void __indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 32; - emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8); - (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8); +(void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib3dvNV 4275 -void -__indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v) +void __indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 32; - emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 24); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 24); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib3fvNV 4271 -void -__indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z) +void __indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib3fvNV 4271 -void -__indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v) +void __indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 20; - emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 12); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib3svNV 4267 -void -__indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z) +void __indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib3svNV 4267 -void -__indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v) +void __indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 6); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4dvNV 4276 -void -__indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, - GLdouble z, GLdouble w) +void __indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 40; - emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8); - (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8); - (void) memcpy((void *) (gc->pc + 32), (void *) (&w), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8); +(void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8); +(void) memcpy((void *)(gc->pc + 32), (void *)(&w), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4dvNV 4276 -void -__indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v) +void __indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 40; - emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 32); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 32); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4fvNV 4272 -void -__indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, - GLfloat w) +void __indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&w), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4fvNV 4272 -void -__indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v) +void __indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 24; - emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 16); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4svNV 4268 -void -__indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, - GLshort w) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2); - (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2); - (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2); - (void) memcpy((void *) (gc->pc + 14), (void *) (&w), 2); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +void __indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint cmdlen = 16; +emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2); +(void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2); +(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2); +(void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4svNV 4268 -void -__indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v) +void __indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 16; - emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4ubvNV 4277 -void -__indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, - GLubyte w) -{ - struct glx_context *const gc = __glXGetCurrentContext(); - const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 1); - (void) memcpy((void *) (gc->pc + 9), (void *) (&y), 1); - (void) memcpy((void *) (gc->pc + 10), (void *) (&z), 1); - (void) memcpy((void *) (gc->pc + 11), (void *) (&w), 1); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +void __indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +{ + struct glx_context * const gc = __glXGetCurrentContext(); + const GLuint cmdlen = 12; +emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1); +(void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1); +(void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1); +(void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttrib4ubvNV 4277 -void -__indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte *v) +void __indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_VertexAttribs1dvNV 4210 -void -__indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v) +void __indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(n, 8)); if (0 + safe_pad(safe_mul(n, 8)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10581,22 +8472,19 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_VertexAttribs1dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (v), safe_mul(n, 8)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttribs1dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(v), safe_mul(n, 8)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_VertexAttribs1fvNV 4206 -void -__indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v) +void __indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(n, 4)); if (0 + safe_pad(safe_mul(n, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10607,22 +8495,19 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_VertexAttribs1fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (v), safe_mul(n, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttribs1fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(v), safe_mul(n, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_VertexAttribs1svNV 4202 -void -__indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v) +void __indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(n, 2)); if (0 + safe_pad(safe_mul(n, 2)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10633,22 +8518,19 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_VertexAttribs1svNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (v), safe_mul(n, 2)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttribs1svNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(v), safe_mul(n, 2)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_VertexAttribs2dvNV 4211 -void -__indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v) +void __indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(n, 16)); if (0 + safe_pad(safe_mul(n, 16)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10659,22 +8541,19 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_VertexAttribs2dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (v), safe_mul(n, 16)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttribs2dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(v), safe_mul(n, 16)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_VertexAttribs2fvNV 4207 -void -__indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v) +void __indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(n, 8)); if (0 + safe_pad(safe_mul(n, 8)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10685,22 +8564,19 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_VertexAttribs2fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (v), safe_mul(n, 8)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttribs2fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(v), safe_mul(n, 8)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_VertexAttribs2svNV 4203 -void -__indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v) +void __indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(n, 4)); if (0 + safe_pad(safe_mul(n, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10711,22 +8587,19 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_VertexAttribs2svNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (v), safe_mul(n, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttribs2svNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(v), safe_mul(n, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_VertexAttribs3dvNV 4212 -void -__indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v) +void __indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(n, 24)); if (0 + safe_pad(safe_mul(n, 24)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10737,22 +8610,19 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_VertexAttribs3dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (v), safe_mul(n, 24)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttribs3dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(v), safe_mul(n, 24)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_VertexAttribs3fvNV 4208 -void -__indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v) +void __indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(n, 12)); if (0 + safe_pad(safe_mul(n, 12)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10763,22 +8633,19 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_VertexAttribs3fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (v), safe_mul(n, 12)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttribs3fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(v), safe_mul(n, 12)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_VertexAttribs3svNV 4204 -void -__indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v) +void __indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(n, 6)); if (0 + safe_pad(safe_mul(n, 6)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10789,22 +8656,19 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_VertexAttribs3svNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (v), safe_mul(n, 6)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttribs3svNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(v), safe_mul(n, 6)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_VertexAttribs4dvNV 4213 -void -__indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v) +void __indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(n, 32)); if (0 + safe_pad(safe_mul(n, 32)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10815,22 +8679,19 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_VertexAttribs4dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (v), safe_mul(n, 32)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttribs4dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(v), safe_mul(n, 32)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_VertexAttribs4fvNV 4209 -void -__indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v) +void __indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(n, 16)); if (0 + safe_pad(safe_mul(n, 16)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10841,22 +8702,19 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_VertexAttribs4fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (v), safe_mul(n, 16)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttribs4fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(v), safe_mul(n, 16)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_VertexAttribs4svNV 4205 -void -__indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v) +void __indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(n, 8)); if (0 + safe_pad(safe_mul(n, 8)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10867,22 +8725,19 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_VertexAttribs4svNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (v), safe_mul(n, 8)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttribs4svNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(v), safe_mul(n, 8)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_VertexAttribs4ubvNV 4214 -void -__indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte *v) +void __indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12 + safe_pad(safe_mul(n, 4)); if (0 + safe_pad(safe_mul(n, 4)) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10893,39 +8748,31 @@ return; } if (__builtin_expect(n >= 0, 1)) { - emit_header(gc->pc, X_GLrop_VertexAttribs4ubvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (v), safe_mul(n, 4)); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_VertexAttribs4ubvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(v), safe_mul(n, 4)); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_ActiveStencilFaceEXT 4220 -void -__indirect_glActiveStencilFaceEXT(GLenum face) +void __indirect_glActiveStencilFaceEXT(GLenum face) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 8; - emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLvop_GetProgramNamedParameterdvNV 1311 -void -__indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, - const GLubyte *name, - GLdouble * params) +void __indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 8 + safe_pad(len); if (0 + safe_pad(len) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10936,28 +8783,21 @@ return; } if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetProgramNamedParameterdvNV, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&id), 4); - (void) memcpy((void *) (pc + 4), (void *) (&len), 4); - (void) memcpy((void *) (pc + 8), (void *) (name), len); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterdvNV, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&id), 4); +(void) memcpy((void *)(pc + 4), (void *)(&len), 4); +(void) memcpy((void *)(pc + 8), (void *)(name), len); (void) __glXReadReply(dpy, 8, params, GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLvop_GetProgramNamedParameterfvNV 1310 -void -__indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, - const GLubyte *name, - GLfloat * params) +void __indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params) { - struct glx_context *const gc = __glXGetCurrentContext(); - Display *const dpy = gc->currentDpy; + struct glx_context * const gc = __glXGetCurrentContext(); + Display * const dpy = gc->currentDpy; const GLuint cmdlen = 8 + safe_pad(len); if (0 + safe_pad(len) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10968,27 +8808,20 @@ return; } if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) { - GLubyte const *pc = - __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, - X_GLvop_GetProgramNamedParameterfvNV, - cmdlen); - (void) memcpy((void *) (pc + 0), (void *) (&id), 4); - (void) memcpy((void *) (pc + 4), (void *) (&len), 4); - (void) memcpy((void *) (pc + 8), (void *) (name), len); + GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterfvNV, cmdlen); +(void) memcpy((void *)(pc + 0), (void *)(&id), 4); +(void) memcpy((void *)(pc + 4), (void *)(&len), 4); +(void) memcpy((void *)(pc + 8), (void *)(name), len); (void) __glXReadReply(dpy, 4, params, GL_TRUE); - UnlockDisplay(dpy); - SyncHandle(); + UnlockDisplay(dpy); SyncHandle(); } return; } #define X_GLrop_ProgramNamedParameter4dvNV 4219 -void -__indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, - const GLubyte *name, GLdouble x, - GLdouble y, GLdouble z, GLdouble w) +void __indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 44 + safe_pad(len); if (0 + safe_pad(len) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -10999,28 +8832,23 @@ return; } if (__builtin_expect(len >= 0, 1)) { - emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8); - (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8); - (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8); - (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8); - (void) memcpy((void *) (gc->pc + 36), (void *) (&id), 4); - (void) memcpy((void *) (gc->pc + 40), (void *) (&len), 4); - (void) memcpy((void *) (gc->pc + 44), (void *) (name), len); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8); +(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8); +(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8); +(void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8); +(void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4); +(void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4); +(void) memcpy((void *)(gc->pc + 44), (void *)(name), len); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_ProgramNamedParameter4dvNV 4219 -void -__indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, - const GLubyte *name, - const GLdouble * v) +void __indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 44 + safe_pad(len); if (0 + safe_pad(len) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -11031,25 +8859,20 @@ return; } if (__builtin_expect(len >= 0, 1)) { - emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (v), 32); - (void) memcpy((void *) (gc->pc + 36), (void *) (&id), 4); - (void) memcpy((void *) (gc->pc + 40), (void *) (&len), 4); - (void) memcpy((void *) (gc->pc + 44), (void *) (name), len); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(v), 32); +(void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4); +(void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4); +(void) memcpy((void *)(gc->pc + 44), (void *)(name), len); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_ProgramNamedParameter4fvNV 4218 -void -__indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, - const GLubyte *name, GLfloat x, - GLfloat y, GLfloat z, GLfloat w) +void __indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28 + safe_pad(len); if (0 + safe_pad(len) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -11060,28 +8883,23 @@ return; } if (__builtin_expect(len >= 0, 1)) { - emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&id), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&len), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4); - (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4); - (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4); - (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4); - (void) memcpy((void *) (gc->pc + 28), (void *) (name), len); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4); +(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4); +(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4); +(void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4); +(void) memcpy((void *)(gc->pc + 28), (void *)(name), len); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_ProgramNamedParameter4fvNV 4218 -void -__indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, - const GLubyte *name, - const GLfloat * v) +void __indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 28 + safe_pad(len); if (0 + safe_pad(len) < 0) { __glXSetError(gc, GL_INVALID_VALUE); @@ -11092,104 +8910,94 @@ return; } if (__builtin_expect(len >= 0, 1)) { - emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&id), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&len), 4); - (void) memcpy((void *) (gc->pc + 12), (void *) (v), 16); - (void) memcpy((void *) (gc->pc + 28), (void *) (name), len); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4); +(void) memcpy((void *)(gc->pc + 12), (void *)(v), 16); +(void) memcpy((void *)(gc->pc + 28), (void *)(name), len); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } } #define X_GLrop_BindFramebufferEXT 4319 -void -__indirect_glBindFramebufferEXT(GLenum target, GLuint framebuffer) +void __indirect_glBindFramebufferEXT(GLenum target, GLuint framebuffer) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_BindFramebufferEXT, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&framebuffer), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_BindFramebufferEXT, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&framebuffer), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #define X_GLrop_BindRenderbufferEXT 4316 -void -__indirect_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer) +void __indirect_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer) { - struct glx_context *const gc = __glXGetCurrentContext(); + struct glx_context * const gc = __glXGetCurrentContext(); const GLuint cmdlen = 12; - emit_header(gc->pc, X_GLrop_BindRenderbufferEXT, cmdlen); - (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4); - (void) memcpy((void *) (gc->pc + 8), (void *) (&renderbuffer), 4); - gc->pc += cmdlen; - if (__builtin_expect(gc->pc > gc->limit, 0)) { - (void) __glXFlushRenderBuffer(gc, gc->pc); - } +emit_header(gc->pc, X_GLrop_BindRenderbufferEXT, cmdlen); +(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4); +(void) memcpy((void *)(gc->pc + 8), (void *)(&renderbuffer), 4); +gc->pc += cmdlen; +if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } #ifdef GLX_INDIRECT_RENDERING -static const struct proc_pair { - const char *name; - _glapi_proc proc; +static const struct proc_pair +{ + const char *name; + _glapi_proc proc; } proc_pairs[20] = { - { - "AreTexturesResidentEXT", (_glapi_proc) glAreTexturesResidentEXT}, { - "DeleteTexturesEXT", (_glapi_proc) glDeleteTexturesEXT}, { - "GenTexturesEXT", (_glapi_proc) glGenTexturesEXT}, { - "GetColorTableEXT", (_glapi_proc) gl_dispatch_stub_343}, { - "GetColorTableParameterfvEXT", (_glapi_proc) gl_dispatch_stub_344}, { - "GetColorTableParameterfvSGI", (_glapi_proc) gl_dispatch_stub_344}, { - "GetColorTableParameterivEXT", (_glapi_proc) gl_dispatch_stub_345}, { - "GetColorTableParameterivSGI", (_glapi_proc) gl_dispatch_stub_345}, { - "GetColorTableSGI", (_glapi_proc) gl_dispatch_stub_343}, { - "GetConvolutionFilterEXT", (_glapi_proc) gl_dispatch_stub_356}, { - "GetConvolutionParameterfvEXT", (_glapi_proc) gl_dispatch_stub_357}, { - "GetConvolutionParameterivEXT", (_glapi_proc) gl_dispatch_stub_358}, { - "GetHistogramEXT", (_glapi_proc) gl_dispatch_stub_361}, { - "GetHistogramParameterfvEXT", (_glapi_proc) gl_dispatch_stub_362}, { - "GetHistogramParameterivEXT", (_glapi_proc) gl_dispatch_stub_363}, { - "GetMinmaxEXT", (_glapi_proc) gl_dispatch_stub_364}, { - "GetMinmaxParameterfvEXT", (_glapi_proc) gl_dispatch_stub_365}, { - "GetMinmaxParameterivEXT", (_glapi_proc) gl_dispatch_stub_366}, { - "GetSeparableFilterEXT", (_glapi_proc) gl_dispatch_stub_359}, { - "IsTextureEXT", (_glapi_proc) glIsTextureEXT} + { "AreTexturesResidentEXT", (_glapi_proc) glAreTexturesResidentEXT }, + { "DeleteTexturesEXT", (_glapi_proc) glDeleteTexturesEXT }, + { "GenTexturesEXT", (_glapi_proc) glGenTexturesEXT }, + { "GetColorTableEXT", (_glapi_proc) gl_dispatch_stub_343 }, + { "GetColorTableParameterfvEXT", (_glapi_proc) gl_dispatch_stub_344 }, + { "GetColorTableParameterfvSGI", (_glapi_proc) gl_dispatch_stub_344 }, + { "GetColorTableParameterivEXT", (_glapi_proc) gl_dispatch_stub_345 }, + { "GetColorTableParameterivSGI", (_glapi_proc) gl_dispatch_stub_345 }, + { "GetColorTableSGI", (_glapi_proc) gl_dispatch_stub_343 }, + { "GetConvolutionFilterEXT", (_glapi_proc) gl_dispatch_stub_356 }, + { "GetConvolutionParameterfvEXT", (_glapi_proc) gl_dispatch_stub_357 }, + { "GetConvolutionParameterivEXT", (_glapi_proc) gl_dispatch_stub_358 }, + { "GetHistogramEXT", (_glapi_proc) gl_dispatch_stub_361 }, + { "GetHistogramParameterfvEXT", (_glapi_proc) gl_dispatch_stub_362 }, + { "GetHistogramParameterivEXT", (_glapi_proc) gl_dispatch_stub_363 }, + { "GetMinmaxEXT", (_glapi_proc) gl_dispatch_stub_364 }, + { "GetMinmaxParameterfvEXT", (_glapi_proc) gl_dispatch_stub_365 }, + { "GetMinmaxParameterivEXT", (_glapi_proc) gl_dispatch_stub_366 }, + { "GetSeparableFilterEXT", (_glapi_proc) gl_dispatch_stub_359 }, + { "IsTextureEXT", (_glapi_proc) glIsTextureEXT } }; static int __indirect_get_proc_compare(const void *key, const void *memb) { - const struct proc_pair *pair = (const struct proc_pair *) memb; - return strcmp((const char *) key, pair->name); + const struct proc_pair *pair = (const struct proc_pair *) memb; + return strcmp((const char *) key, pair->name); } _glapi_proc __indirect_get_proc_address(const char *name) { - const struct proc_pair *pair; - - /* skip "gl" */ - name += 2; - - pair = (const struct proc_pair *) bsearch((const void *) name, - (const void *) proc_pairs, - ARRAY_SIZE(proc_pairs), - sizeof(proc_pairs[0]), - __indirect_get_proc_compare); + const struct proc_pair *pair; + + /* skip "gl" */ + name += 2; + + pair = (const struct proc_pair *) bsearch((const void *) name, + (const void *) proc_pairs, ARRAY_SIZE(proc_pairs), sizeof(proc_pairs[0]), + __indirect_get_proc_compare); - return (pair) ? pair->proc : NULL; + return (pair) ? pair->proc : NULL; } #endif /* GLX_INDIRECT_RENDERING */ -#undef FASTCALL -#undef NOINLINE +# undef FASTCALL +# undef NOINLINE diff -Nru mesa-18.1.0/src/glx/indirect_size.c mesa-18.1.1/src/glx/indirect_size.c --- mesa-18.1.0/src/glx/indirect_size.c 2018-05-18 23:29:31.000000000 +0000 +++ mesa-18.1.1/src/glx/indirect_size.c 2018-06-01 15:19:04.000000000 +0000 @@ -30,350 +30,338 @@ #include #include "indirect_size.h" -#if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)) -#define PURE __attribute__((pure)) -#else -#define PURE -#endif - -#if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__) -#define FASTCALL __attribute__((fastcall)) -#else -#define FASTCALL -#endif +# if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)) +# define PURE __attribute__((pure)) +# else +# define PURE +# endif + +# if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__) +# define FASTCALL __attribute__((fastcall)) +# else +# define FASTCALL +# endif #ifdef HAVE_FUNC_ATTRIBUTE_ALIAS -#define ALIAS2(from,to) \ +# define ALIAS2(from,to) \ _X_INTERNAL PURE FASTCALL GLint __gl ## from ## _size( GLenum e ) \ __attribute__ ((alias( # to ))); -#define ALIAS(from,to) ALIAS2( from, __gl ## to ## _size ) +# define ALIAS(from,to) ALIAS2( from, __gl ## to ## _size ) #else -#define ALIAS(from,to) \ +# define ALIAS(from,to) \ _X_INTERNAL PURE FASTCALL GLint __gl ## from ## _size( GLenum e ) \ { return __gl ## to ## _size( e ); } #endif _X_INTERNAL PURE FASTCALL GLint -__glCallLists_size(GLenum e) +__glCallLists_size( GLenum e ) { - switch (e) { - case GL_BYTE: - case GL_UNSIGNED_BYTE: - return 1; - case GL_SHORT: - case GL_UNSIGNED_SHORT: - case GL_2_BYTES: - case GL_HALF_FLOAT: - return 2; - case GL_3_BYTES: - return 3; - case GL_INT: - case GL_UNSIGNED_INT: - case GL_FLOAT: - case GL_4_BYTES: - return 4; - default: - return 0; - } -} - -_X_INTERNAL PURE FASTCALL GLint -__glFogfv_size(GLenum e) -{ - switch (e) { - case GL_FOG_INDEX: - case GL_FOG_DENSITY: - case GL_FOG_START: - case GL_FOG_END: - case GL_FOG_MODE: - case GL_FOG_OFFSET_VALUE_SGIX: - case GL_FOG_DISTANCE_MODE_NV: - return 1; - case GL_FOG_COLOR: - return 4; - default: - return 0; - } -} - -_X_INTERNAL PURE FASTCALL GLint -__glLightfv_size(GLenum e) -{ - switch (e) { - case GL_SPOT_EXPONENT: - case GL_SPOT_CUTOFF: - case GL_CONSTANT_ATTENUATION: - case GL_LINEAR_ATTENUATION: - case GL_QUADRATIC_ATTENUATION: - return 1; - case GL_SPOT_DIRECTION: - return 3; - case GL_AMBIENT: - case GL_DIFFUSE: - case GL_SPECULAR: - case GL_POSITION: - return 4; - default: - return 0; - } -} - -_X_INTERNAL PURE FASTCALL GLint -__glLightModelfv_size(GLenum e) -{ - switch (e) { - case GL_LIGHT_MODEL_LOCAL_VIEWER: - case GL_LIGHT_MODEL_TWO_SIDE: - case GL_LIGHT_MODEL_COLOR_CONTROL: + switch( e ) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + return 1; + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_2_BYTES: + case GL_HALF_FLOAT: + return 2; + case GL_3_BYTES: + return 3; + case GL_INT: + case GL_UNSIGNED_INT: + case GL_FLOAT: + case GL_4_BYTES: + return 4; + default: return 0; + } +} + +_X_INTERNAL PURE FASTCALL GLint +__glFogfv_size( GLenum e ) +{ + switch( e ) { + case GL_FOG_INDEX: + case GL_FOG_DENSITY: + case GL_FOG_START: + case GL_FOG_END: + case GL_FOG_MODE: + case GL_FOG_OFFSET_VALUE_SGIX: + case GL_FOG_DISTANCE_MODE_NV: + return 1; + case GL_FOG_COLOR: + return 4; + default: return 0; + } +} + +_X_INTERNAL PURE FASTCALL GLint +__glLightfv_size( GLenum e ) +{ + switch( e ) { + case GL_SPOT_EXPONENT: + case GL_SPOT_CUTOFF: + case GL_CONSTANT_ATTENUATION: + case GL_LINEAR_ATTENUATION: + case GL_QUADRATIC_ATTENUATION: + return 1; + case GL_SPOT_DIRECTION: + return 3; + case GL_AMBIENT: + case GL_DIFFUSE: + case GL_SPECULAR: + case GL_POSITION: + return 4; + default: return 0; + } +} + +_X_INTERNAL PURE FASTCALL GLint +__glLightModelfv_size( GLenum e ) +{ + switch( e ) { + case GL_LIGHT_MODEL_LOCAL_VIEWER: + case GL_LIGHT_MODEL_TWO_SIDE: + case GL_LIGHT_MODEL_COLOR_CONTROL: /* case GL_LIGHT_MODEL_COLOR_CONTROL_EXT:*/ - return 1; - case GL_LIGHT_MODEL_AMBIENT: - return 4; - default: - return 0; + return 1; + case GL_LIGHT_MODEL_AMBIENT: + return 4; + default: return 0; } } _X_INTERNAL PURE FASTCALL GLint -__glMaterialfv_size(GLenum e) +__glMaterialfv_size( GLenum e ) { - switch (e) { - case GL_SHININESS: - return 1; - case GL_COLOR_INDEXES: - return 3; - case GL_AMBIENT: - case GL_DIFFUSE: - case GL_SPECULAR: - case GL_EMISSION: - case GL_AMBIENT_AND_DIFFUSE: - return 4; - default: - return 0; + switch( e ) { + case GL_SHININESS: + return 1; + case GL_COLOR_INDEXES: + return 3; + case GL_AMBIENT: + case GL_DIFFUSE: + case GL_SPECULAR: + case GL_EMISSION: + case GL_AMBIENT_AND_DIFFUSE: + return 4; + default: return 0; } } _X_INTERNAL PURE FASTCALL GLint -__glTexParameterfv_size(GLenum e) +__glTexParameterfv_size( GLenum e ) { - switch (e) { - case GL_TEXTURE_MAG_FILTER: - case GL_TEXTURE_MIN_FILTER: - case GL_TEXTURE_WRAP_S: - case GL_TEXTURE_WRAP_T: - case GL_TEXTURE_PRIORITY: - case GL_TEXTURE_WRAP_R: - case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB: + switch( e ) { + case GL_TEXTURE_MAG_FILTER: + case GL_TEXTURE_MIN_FILTER: + case GL_TEXTURE_WRAP_S: + case GL_TEXTURE_WRAP_T: + case GL_TEXTURE_PRIORITY: + case GL_TEXTURE_WRAP_R: + case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB: /* case GL_SHADOW_AMBIENT_SGIX:*/ - case GL_TEXTURE_MIN_LOD: - case GL_TEXTURE_MAX_LOD: - case GL_TEXTURE_BASE_LEVEL: - case GL_TEXTURE_MAX_LEVEL: - case GL_TEXTURE_CLIPMAP_FRAME_SGIX: - case GL_TEXTURE_LOD_BIAS_S_SGIX: - case GL_TEXTURE_LOD_BIAS_T_SGIX: - case GL_TEXTURE_LOD_BIAS_R_SGIX: - case GL_GENERATE_MIPMAP: + case GL_TEXTURE_MIN_LOD: + case GL_TEXTURE_MAX_LOD: + case GL_TEXTURE_BASE_LEVEL: + case GL_TEXTURE_MAX_LEVEL: + case GL_TEXTURE_CLIPMAP_FRAME_SGIX: + case GL_TEXTURE_LOD_BIAS_S_SGIX: + case GL_TEXTURE_LOD_BIAS_T_SGIX: + case GL_TEXTURE_LOD_BIAS_R_SGIX: + case GL_GENERATE_MIPMAP: /* case GL_GENERATE_MIPMAP_SGIS:*/ - case GL_TEXTURE_COMPARE_SGIX: - case GL_TEXTURE_COMPARE_OPERATOR_SGIX: - case GL_TEXTURE_MAX_CLAMP_S_SGIX: - case GL_TEXTURE_MAX_CLAMP_T_SGIX: - case GL_TEXTURE_MAX_CLAMP_R_SGIX: - case GL_TEXTURE_MAX_ANISOTROPY_EXT: - case GL_TEXTURE_LOD_BIAS: + case GL_TEXTURE_COMPARE_SGIX: + case GL_TEXTURE_COMPARE_OPERATOR_SGIX: + case GL_TEXTURE_MAX_CLAMP_S_SGIX: + case GL_TEXTURE_MAX_CLAMP_T_SGIX: + case GL_TEXTURE_MAX_CLAMP_R_SGIX: + case GL_TEXTURE_MAX_ANISOTROPY_EXT: + case GL_TEXTURE_LOD_BIAS: /* case GL_TEXTURE_LOD_BIAS_EXT:*/ - case GL_TEXTURE_STORAGE_HINT_APPLE: - case GL_STORAGE_PRIVATE_APPLE: - case GL_STORAGE_CACHED_APPLE: - case GL_STORAGE_SHARED_APPLE: - case GL_DEPTH_TEXTURE_MODE: + case GL_TEXTURE_STORAGE_HINT_APPLE: + case GL_STORAGE_PRIVATE_APPLE: + case GL_STORAGE_CACHED_APPLE: + case GL_STORAGE_SHARED_APPLE: + case GL_DEPTH_TEXTURE_MODE: /* case GL_DEPTH_TEXTURE_MODE_ARB:*/ - case GL_TEXTURE_COMPARE_MODE: + case GL_TEXTURE_COMPARE_MODE: /* case GL_TEXTURE_COMPARE_MODE_ARB:*/ - case GL_TEXTURE_COMPARE_FUNC: + case GL_TEXTURE_COMPARE_FUNC: /* case GL_TEXTURE_COMPARE_FUNC_ARB:*/ - case GL_TEXTURE_UNSIGNED_REMAP_MODE_NV: - return 1; - case GL_TEXTURE_CLIPMAP_CENTER_SGIX: - case GL_TEXTURE_CLIPMAP_OFFSET_SGIX: - return 2; - case GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX: - return 3; - case GL_TEXTURE_BORDER_COLOR: - case GL_POST_TEXTURE_FILTER_BIAS_SGIX: - case GL_POST_TEXTURE_FILTER_SCALE_SGIX: - return 4; - default: - return 0; + case GL_TEXTURE_UNSIGNED_REMAP_MODE_NV: + return 1; + case GL_TEXTURE_CLIPMAP_CENTER_SGIX: + case GL_TEXTURE_CLIPMAP_OFFSET_SGIX: + return 2; + case GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX: + return 3; + case GL_TEXTURE_BORDER_COLOR: + case GL_POST_TEXTURE_FILTER_BIAS_SGIX: + case GL_POST_TEXTURE_FILTER_SCALE_SGIX: + return 4; + default: return 0; } } _X_INTERNAL PURE FASTCALL GLint -__glTexEnvfv_size(GLenum e) -{ - switch (e) { - case GL_ALPHA_SCALE: - case GL_TEXTURE_ENV_MODE: - case GL_TEXTURE_LOD_BIAS: - case GL_COMBINE_RGB: - case GL_COMBINE_ALPHA: - case GL_RGB_SCALE: - case GL_SOURCE0_RGB: - case GL_SOURCE1_RGB: - case GL_SOURCE2_RGB: - case GL_SOURCE3_RGB_NV: - case GL_SOURCE0_ALPHA: - case GL_SOURCE1_ALPHA: - case GL_SOURCE2_ALPHA: - case GL_SOURCE3_ALPHA_NV: - case GL_OPERAND0_RGB: - case GL_OPERAND1_RGB: - case GL_OPERAND2_RGB: - case GL_OPERAND3_RGB_NV: - case GL_OPERAND0_ALPHA: - case GL_OPERAND1_ALPHA: - case GL_OPERAND2_ALPHA: - case GL_OPERAND3_ALPHA_NV: - case GL_BUMP_TARGET_ATI: - case GL_COORD_REPLACE_ARB: +__glTexEnvfv_size( GLenum e ) +{ + switch( e ) { + case GL_ALPHA_SCALE: + case GL_TEXTURE_ENV_MODE: + case GL_TEXTURE_LOD_BIAS: + case GL_COMBINE_RGB: + case GL_COMBINE_ALPHA: + case GL_RGB_SCALE: + case GL_SOURCE0_RGB: + case GL_SOURCE1_RGB: + case GL_SOURCE2_RGB: + case GL_SOURCE3_RGB_NV: + case GL_SOURCE0_ALPHA: + case GL_SOURCE1_ALPHA: + case GL_SOURCE2_ALPHA: + case GL_SOURCE3_ALPHA_NV: + case GL_OPERAND0_RGB: + case GL_OPERAND1_RGB: + case GL_OPERAND2_RGB: + case GL_OPERAND3_RGB_NV: + case GL_OPERAND0_ALPHA: + case GL_OPERAND1_ALPHA: + case GL_OPERAND2_ALPHA: + case GL_OPERAND3_ALPHA_NV: + case GL_BUMP_TARGET_ATI: + case GL_COORD_REPLACE_ARB: /* case GL_COORD_REPLACE_NV:*/ - return 1; - case GL_TEXTURE_ENV_COLOR: - return 4; - default: - return 0; + return 1; + case GL_TEXTURE_ENV_COLOR: + return 4; + default: return 0; } } _X_INTERNAL PURE FASTCALL GLint -__glTexGendv_size(GLenum e) +__glTexGendv_size( GLenum e ) { - switch (e) { - case GL_TEXTURE_GEN_MODE: - return 1; - case GL_OBJECT_PLANE: - case GL_EYE_PLANE: - return 4; - default: - return 0; + switch( e ) { + case GL_TEXTURE_GEN_MODE: + return 1; + case GL_OBJECT_PLANE: + case GL_EYE_PLANE: + return 4; + default: return 0; } } _X_INTERNAL PURE FASTCALL GLint -__glMap1d_size(GLenum e) +__glMap1d_size( GLenum e ) { - switch (e) { - case GL_MAP1_INDEX: - case GL_MAP1_TEXTURE_COORD_1: - return 1; - case GL_MAP1_TEXTURE_COORD_2: - return 2; - case GL_MAP1_NORMAL: - case GL_MAP1_TEXTURE_COORD_3: - case GL_MAP1_VERTEX_3: - return 3; - case GL_MAP1_COLOR_4: - case GL_MAP1_TEXTURE_COORD_4: - case GL_MAP1_VERTEX_4: - return 4; - default: - return 0; + switch( e ) { + case GL_MAP1_INDEX: + case GL_MAP1_TEXTURE_COORD_1: + return 1; + case GL_MAP1_TEXTURE_COORD_2: + return 2; + case GL_MAP1_NORMAL: + case GL_MAP1_TEXTURE_COORD_3: + case GL_MAP1_VERTEX_3: + return 3; + case GL_MAP1_COLOR_4: + case GL_MAP1_TEXTURE_COORD_4: + case GL_MAP1_VERTEX_4: + return 4; + default: return 0; } } _X_INTERNAL PURE FASTCALL GLint -__glMap2d_size(GLenum e) +__glMap2d_size( GLenum e ) { - switch (e) { - case GL_MAP2_INDEX: - case GL_MAP2_TEXTURE_COORD_1: - return 1; - case GL_MAP2_TEXTURE_COORD_2: - return 2; - case GL_MAP2_NORMAL: - case GL_MAP2_TEXTURE_COORD_3: - case GL_MAP2_VERTEX_3: - return 3; - case GL_MAP2_COLOR_4: - case GL_MAP2_TEXTURE_COORD_4: - case GL_MAP2_VERTEX_4: - return 4; - default: - return 0; + switch( e ) { + case GL_MAP2_INDEX: + case GL_MAP2_TEXTURE_COORD_1: + return 1; + case GL_MAP2_TEXTURE_COORD_2: + return 2; + case GL_MAP2_NORMAL: + case GL_MAP2_TEXTURE_COORD_3: + case GL_MAP2_VERTEX_3: + return 3; + case GL_MAP2_COLOR_4: + case GL_MAP2_TEXTURE_COORD_4: + case GL_MAP2_VERTEX_4: + return 4; + default: return 0; } } _X_INTERNAL PURE FASTCALL GLint -__glColorTableParameterfv_size(GLenum e) +__glColorTableParameterfv_size( GLenum e ) { - switch (e) { - case GL_COLOR_TABLE_SCALE: - case GL_COLOR_TABLE_BIAS: - return 4; - default: - return 0; + switch( e ) { + case GL_COLOR_TABLE_SCALE: + case GL_COLOR_TABLE_BIAS: + return 4; + default: return 0; } } _X_INTERNAL PURE FASTCALL GLint -__glConvolutionParameterfv_size(GLenum e) +__glConvolutionParameterfv_size( GLenum e ) { - switch (e) { - case GL_CONVOLUTION_BORDER_MODE: + switch( e ) { + case GL_CONVOLUTION_BORDER_MODE: /* case GL_CONVOLUTION_BORDER_MODE_EXT:*/ - return 1; - case GL_CONVOLUTION_FILTER_SCALE: + return 1; + case GL_CONVOLUTION_FILTER_SCALE: /* case GL_CONVOLUTION_FILTER_SCALE_EXT:*/ - case GL_CONVOLUTION_FILTER_BIAS: + case GL_CONVOLUTION_FILTER_BIAS: /* case GL_CONVOLUTION_FILTER_BIAS_EXT:*/ - case GL_CONVOLUTION_BORDER_COLOR: + case GL_CONVOLUTION_BORDER_COLOR: /* case GL_CONVOLUTION_BORDER_COLOR_HP:*/ - return 4; - default: - return 0; + return 4; + default: return 0; } } _X_INTERNAL PURE FASTCALL GLint -__glPointParameterfv_size(GLenum e) +__glPointParameterfv_size( GLenum e ) { - switch (e) { - case GL_POINT_SIZE_MIN: + switch( e ) { + case GL_POINT_SIZE_MIN: /* case GL_POINT_SIZE_MIN_ARB:*/ /* case GL_POINT_SIZE_MIN_SGIS:*/ - case GL_POINT_SIZE_MAX: + case GL_POINT_SIZE_MAX: /* case GL_POINT_SIZE_MAX_ARB:*/ /* case GL_POINT_SIZE_MAX_SGIS:*/ - case GL_POINT_FADE_THRESHOLD_SIZE: + case GL_POINT_FADE_THRESHOLD_SIZE: /* case GL_POINT_FADE_THRESHOLD_SIZE_ARB:*/ /* case GL_POINT_FADE_THRESHOLD_SIZE_SGIS:*/ - case GL_POINT_SPRITE_R_MODE_NV: - case GL_POINT_SPRITE_COORD_ORIGIN: - return 1; - case GL_POINT_DISTANCE_ATTENUATION: + case GL_POINT_SPRITE_R_MODE_NV: + case GL_POINT_SPRITE_COORD_ORIGIN: + return 1; + case GL_POINT_DISTANCE_ATTENUATION: /* case GL_POINT_DISTANCE_ATTENUATION_ARB:*/ /* case GL_POINT_DISTANCE_ATTENUATION_SGIS:*/ - return 3; - default: - return 0; + return 3; + default: return 0; } } -ALIAS(Fogiv, Fogfv) - ALIAS(Lightiv, Lightfv) - ALIAS(LightModeliv, LightModelfv) - ALIAS(Materialiv, Materialfv) - ALIAS(TexParameteriv, TexParameterfv) - ALIAS(TexEnviv, TexEnvfv) - ALIAS(TexGenfv, TexGendv) - ALIAS(TexGeniv, TexGendv) - ALIAS(Map1f, Map1d) - ALIAS(Map2f, Map2d) - ALIAS(ColorTableParameteriv, ColorTableParameterfv) - ALIAS(ConvolutionParameteriv, ConvolutionParameterfv) - ALIAS(PointParameteriv, PointParameterfv) -#undef PURE -#undef FASTCALL +ALIAS( Fogiv, Fogfv ) +ALIAS( Lightiv, Lightfv ) +ALIAS( LightModeliv, LightModelfv ) +ALIAS( Materialiv, Materialfv ) +ALIAS( TexParameteriv, TexParameterfv ) +ALIAS( TexEnviv, TexEnvfv ) +ALIAS( TexGenfv, TexGendv ) +ALIAS( TexGeniv, TexGendv ) +ALIAS( Map1f, Map1d ) +ALIAS( Map2f, Map2d ) +ALIAS( ColorTableParameteriv, ColorTableParameterfv ) +ALIAS( ConvolutionParameteriv, ConvolutionParameterfv ) +ALIAS( PointParameteriv, PointParameterfv ) + +# undef PURE +# undef FASTCALL diff -Nru mesa-18.1.0/src/glx/indirect_size.h mesa-18.1.1/src/glx/indirect_size.h --- mesa-18.1.0/src/glx/indirect_size.h 2018-05-18 23:29:30.000000000 +0000 +++ mesa-18.1.1/src/glx/indirect_size.h 2018-06-01 15:19:03.000000000 +0000 @@ -26,7 +26,7 @@ */ #if !defined( _INDIRECT_SIZE_H_ ) -#define _INDIRECT_SIZE_H_ +# define _INDIRECT_SIZE_H_ /** * \file @@ -38,17 +38,17 @@ #include -#if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)) -#define PURE __attribute__((pure)) -#else -#define PURE -#endif - -#if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__) -#define FASTCALL __attribute__((fastcall)) -#else -#define FASTCALL -#endif +# if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)) +# define PURE __attribute__((pure)) +# else +# define PURE +# endif + +# if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__) +# define FASTCALL __attribute__((fastcall)) +# else +# define FASTCALL +# endif extern _X_INTERNAL PURE FASTCALL GLint __glCallLists_size(GLenum); extern _X_INTERNAL PURE FASTCALL GLint __glFogfv_size(GLenum); @@ -72,14 +72,12 @@ extern _X_INTERNAL PURE FASTCALL GLint __glMap2f_size(GLenum); extern _X_INTERNAL PURE FASTCALL GLint __glColorTableParameterfv_size(GLenum); extern _X_INTERNAL PURE FASTCALL GLint __glColorTableParameteriv_size(GLenum); -extern _X_INTERNAL PURE FASTCALL GLint -__glConvolutionParameterfv_size(GLenum); -extern _X_INTERNAL PURE FASTCALL GLint -__glConvolutionParameteriv_size(GLenum); +extern _X_INTERNAL PURE FASTCALL GLint __glConvolutionParameterfv_size(GLenum); +extern _X_INTERNAL PURE FASTCALL GLint __glConvolutionParameteriv_size(GLenum); extern _X_INTERNAL PURE FASTCALL GLint __glPointParameterfv_size(GLenum); extern _X_INTERNAL PURE FASTCALL GLint __glPointParameteriv_size(GLenum); -#undef PURE -#undef FASTCALL +# undef PURE +# undef FASTCALL #endif /* !defined( _INDIRECT_SIZE_H_ ) */ diff -Nru mesa-18.1.0/src/intel/blorp/blorp_blit.c mesa-18.1.1/src/intel/blorp/blorp_blit.c --- mesa-18.1.0/src/intel/blorp/blorp_blit.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/intel/blorp/blorp_blit.c 2018-06-01 15:18:21.000000000 +0000 @@ -2413,7 +2413,9 @@ dst_layer, ISL_FORMAT_UNSUPPORTED, true); struct brw_blorp_blit_prog_key wm_prog_key = { - .shader_type = BLORP_SHADER_TYPE_BLIT + .shader_type = BLORP_SHADER_TYPE_BLIT, + .need_src_offset = src_surf->tile_x_sa || src_surf->tile_y_sa, + .need_dst_offset = dst_surf->tile_x_sa || dst_surf->tile_y_sa, }; const struct isl_format_layout *src_fmtl = diff -Nru mesa-18.1.0/src/intel/blorp/blorp.c mesa-18.1.1/src/intel/blorp/blorp.c --- mesa-18.1.0/src/intel/blorp/blorp.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/intel/blorp/blorp.c 2018-06-01 15:18:21.000000000 +0000 @@ -137,6 +137,28 @@ */ if (is_render_target && blorp->isl_dev->info->gen <= 6) info->view.array_len = MIN2(info->view.array_len, 512); + + if (surf->tile_x_sa || surf->tile_y_sa) { + /* This is only allowed on simple 2D surfaces without MSAA */ + assert(info->surf.dim == ISL_SURF_DIM_2D); + assert(info->surf.samples == 1); + assert(info->surf.levels == 1); + assert(info->surf.logical_level0_px.array_len == 1); + assert(info->aux_usage == ISL_AUX_USAGE_NONE); + + info->tile_x_sa = surf->tile_x_sa; + info->tile_y_sa = surf->tile_y_sa; + + /* Instead of using the X/Y Offset fields in RENDER_SURFACE_STATE, we + * place the image at the tile boundary and offset our sampling or + * rendering. For this reason, we need to grow the image by the offset + * to ensure that the hardware doesn't think we've gone past the edge. + */ + info->surf.logical_level0_px.w += surf->tile_x_sa; + info->surf.logical_level0_px.h += surf->tile_y_sa; + info->surf.phys_level0_sa.w += surf->tile_x_sa; + info->surf.phys_level0_sa.h += surf->tile_y_sa; + } } diff -Nru mesa-18.1.0/src/intel/blorp/blorp_clear.c mesa-18.1.1/src/intel/blorp/blorp_clear.c --- mesa-18.1.0/src/intel/blorp/blorp_clear.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/intel/blorp/blorp_clear.c 2018-06-01 15:18:21.000000000 +0000 @@ -438,6 +438,15 @@ params.x1 = x1; params.y1 = y1; + if (params.dst.tile_x_sa || params.dst.tile_y_sa) { + assert(params.dst.surf.samples == 1); + assert(num_layers == 1); + params.x0 += params.dst.tile_x_sa; + params.y0 += params.dst.tile_y_sa; + params.x1 += params.dst.tile_x_sa; + params.y1 += params.dst.tile_y_sa; + } + /* The MinLOD and MinimumArrayElement don't work properly for cube maps. * Convert them to a single slice on gen4. */ diff -Nru mesa-18.1.0/src/intel/blorp/blorp.h mesa-18.1.1/src/intel/blorp/blorp.h --- mesa-18.1.0/src/intel/blorp/blorp.h 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/intel/blorp/blorp.h 2018-06-01 15:18:21.000000000 +0000 @@ -109,6 +109,9 @@ * that it contains a swizzle of RGBA and resource min LOD of 0. */ struct blorp_address clear_color_addr; + + /* Only allowed for simple 2D non-MSAA surfaces */ + uint32_t tile_x_sa, tile_y_sa; }; void diff -Nru mesa-18.1.0/src/intel/compiler/brw_eu_emit.c mesa-18.1.1/src/intel/compiler/brw_eu_emit.c --- mesa-18.1.0/src/intel/compiler/brw_eu_emit.c 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/src/intel/compiler/brw_eu_emit.c 2018-06-01 15:18:21.000000000 +0000 @@ -3713,6 +3713,7 @@ if (bits != BRW_CR0_RND_MODE_MASK) { brw_inst *inst = brw_AND(p, brw_cr0_reg(0), brw_cr0_reg(0), brw_imm_ud(~BRW_CR0_RND_MODE_MASK)); + brw_inst_set_exec_size(p->devinfo, inst, BRW_EXECUTE_1); /* From the Skylake PRM, Volume 7, page 760: * "Implementation Restriction on Register Access: When the control @@ -3727,6 +3728,7 @@ if (bits) { brw_inst *inst = brw_OR(p, brw_cr0_reg(0), brw_cr0_reg(0), brw_imm_ud(bits)); + brw_inst_set_exec_size(p->devinfo, inst, BRW_EXECUTE_1); brw_inst_set_thread_control(p->devinfo, inst, BRW_THREAD_SWITCH); } } diff -Nru mesa-18.1.0/src/intel/dev/gen_device_info.c mesa-18.1.1/src/intel/dev/gen_device_info.c --- mesa-18.1.0/src/intel/dev/gen_device_info.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/intel/dev/gen_device_info.c 2018-06-01 15:18:21.000000000 +0000 @@ -732,10 +732,10 @@ .l3_banks = 2, }; -/*TODO: Initialize l3_banks when we know the number. */ static const struct gen_device_info gen_device_info_glk_2x6 = { GEN9_LP_FEATURES_2X6, .is_geminilake = true, + .l3_banks = 2, }; static const struct gen_device_info gen_device_info_cfl_gt1 = { diff -Nru mesa-18.1.0/src/loader/loader_dri3_helper.c mesa-18.1.1/src/loader/loader_dri3_helper.c --- mesa-18.1.0/src/loader/loader_dri3_helper.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/loader/loader_dri3_helper.c 2018-06-01 15:18:21.000000000 +0000 @@ -370,9 +370,17 @@ * checking for wrap. */ if (ce->kind == XCB_PRESENT_COMPLETE_KIND_PIXMAP) { - draw->recv_sbc = (draw->send_sbc & 0xffffffff00000000LL) | ce->serial; - if (draw->recv_sbc > draw->send_sbc) - draw->recv_sbc -= 0x100000000; + uint64_t recv_sbc = (draw->send_sbc & 0xffffffff00000000LL) | ce->serial; + + /* Only assume wraparound if that results in exactly the previous + * SBC + 1, otherwise ignore received SBC > sent SBC (those are + * probably from a previous loader_dri3_drawable instance) to avoid + * calculating bogus target MSC values in loader_dri3_swap_buffers_msc + */ + if (recv_sbc <= draw->send_sbc) + draw->recv_sbc = recv_sbc; + else if (recv_sbc == (draw->recv_sbc + 0x100000001ULL)) + draw->recv_sbc = recv_sbc - 0x100000000ULL; /* When moving from flip to copy, we assume that we can allocate in * a more optimal way if we don't need to cater for the display diff -Nru mesa-18.1.0/src/mesa/drivers/dri/i965/brw_blorp.c mesa-18.1.1/src/mesa/drivers/dri/i965/brw_blorp.c --- mesa-18.1.0/src/mesa/drivers/dri/i965/brw_blorp.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/drivers/dri/i965/brw_blorp.c 2018-06-01 15:18:21.000000000 +0000 @@ -152,14 +152,10 @@ .mocs = brw_get_bo_mocs(devinfo, mt->bo), }, .aux_usage = aux_usage, + .tile_x_sa = mt->level[*level].level_x, + .tile_y_sa = mt->level[*level].level_y, }; - struct intel_miptree_aux_buffer *aux_buf = NULL; - if (mt->mcs_buf) - aux_buf = mt->mcs_buf; - else if (mt->hiz_buf) - aux_buf = mt->hiz_buf; - if (mt->format == MESA_FORMAT_S_UINT8 && is_render_target && devinfo->gen <= 7) mt->r8stencil_needs_update = true; @@ -174,19 +170,19 @@ */ surf->clear_color = mt->fast_clear_color; - surf->aux_surf = &aux_buf->surf; + surf->aux_surf = &mt->aux_buf->surf; surf->aux_addr = (struct blorp_address) { .reloc_flags = is_render_target ? EXEC_OBJECT_WRITE : 0, .mocs = surf->addr.mocs, }; - surf->aux_addr.buffer = aux_buf->bo; - surf->aux_addr.offset = aux_buf->offset; + surf->aux_addr.buffer = mt->aux_buf->bo; + surf->aux_addr.offset = mt->aux_buf->offset; if (devinfo->gen >= 10) { surf->clear_color_addr = (struct blorp_address) { - .buffer = aux_buf->clear_color_bo, - .offset = aux_buf->clear_color_offset, + .buffer = mt->aux_buf->clear_color_bo, + .offset = mt->aux_buf->clear_color_offset, }; } } else { @@ -1216,7 +1212,7 @@ /* If the MCS buffer hasn't been allocated yet, we need to allocate it now. */ - if (can_fast_clear && !irb->mt->mcs_buf) { + if (can_fast_clear && !irb->mt->aux_buf) { assert(irb->mt->aux_usage == ISL_AUX_USAGE_CCS_D); if (!intel_miptree_alloc_ccs(brw, irb->mt)) { /* There are a few reasons in addition to out-of-memory, that can @@ -1615,7 +1611,7 @@ brw_emit_pipe_control_flush(brw, PIPE_CONTROL_DEPTH_STALL); } - assert(mt->aux_usage == ISL_AUX_USAGE_HIZ && mt->hiz_buf); + assert(mt->aux_usage == ISL_AUX_USAGE_HIZ && mt->aux_buf); struct isl_surf isl_tmp[2]; struct blorp_surf surf; diff -Nru mesa-18.1.0/src/mesa/drivers/dri/i965/brw_clear.c mesa-18.1.1/src/mesa/drivers/dri/i965/brw_clear.c --- mesa-18.1.0/src/mesa/drivers/dri/i965/brw_clear.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/drivers/dri/i965/brw_clear.c 2018-06-01 15:18:21.000000000 +0000 @@ -240,7 +240,7 @@ * buffer when doing a fast clear. Since we are skipping the fast * clear here, we need to update the clear color ourselves. */ - uint32_t clear_offset = mt->hiz_buf->clear_color_offset; + uint32_t clear_offset = mt->aux_buf->clear_color_offset; union isl_color_value clear_color = { .f32 = { clear_value, } }; /* We can't update the clear color while the hardware is still using @@ -249,7 +249,7 @@ */ brw_emit_pipe_control_flush(brw, PIPE_CONTROL_CS_STALL); for (int i = 0; i < 4; i++) { - brw_store_data_imm32(brw, mt->hiz_buf->clear_color_bo, + brw_store_data_imm32(brw, mt->aux_buf->clear_color_bo, clear_offset + i * 4, clear_color.u32[i]); } brw_emit_pipe_control_flush(brw, PIPE_CONTROL_STATE_CACHE_INVALIDATE); diff -Nru mesa-18.1.0/src/mesa/drivers/dri/i965/brw_wm.c mesa-18.1.1/src/mesa/drivers/dri/i965/brw_wm.c --- mesa-18.1.0/src/mesa/drivers/dri/i965/brw_wm.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/drivers/dri/i965/brw_wm.c 2018-06-01 15:18:21.000000000 +0000 @@ -384,7 +384,7 @@ if (intel_tex->mt->aux_usage == ISL_AUX_USAGE_MCS) { assert(devinfo->gen >= 7); assert(intel_tex->mt->surf.samples > 1); - assert(intel_tex->mt->mcs_buf); + assert(intel_tex->mt->aux_buf); assert(intel_tex->mt->surf.msaa_layout == ISL_MSAA_LAYOUT_ARRAY); key->compressed_multisample_layout_mask |= 1 << s; diff -Nru mesa-18.1.0/src/mesa/drivers/dri/i965/brw_wm_surface_state.c mesa-18.1.1/src/mesa/drivers/dri/i965/brw_wm_surface_state.c --- mesa-18.1.0/src/mesa/drivers/dri/i965/brw_wm_surface_state.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/drivers/dri/i965/brw_wm_surface_state.c 2018-06-01 15:18:21.000000000 +0000 @@ -155,26 +155,11 @@ struct brw_bo *aux_bo = NULL; struct isl_surf *aux_surf = NULL; uint64_t aux_offset = 0; - struct intel_miptree_aux_buffer *aux_buf = NULL; - switch (aux_usage) { - case ISL_AUX_USAGE_MCS: - case ISL_AUX_USAGE_CCS_D: - case ISL_AUX_USAGE_CCS_E: - aux_buf = mt->mcs_buf; - break; - - case ISL_AUX_USAGE_HIZ: - aux_buf = mt->hiz_buf; - break; - - case ISL_AUX_USAGE_NONE: - break; - } if (aux_usage != ISL_AUX_USAGE_NONE) { - aux_surf = &aux_buf->surf; - aux_bo = aux_buf->bo; - aux_offset = aux_buf->offset; + aux_surf = &mt->aux_buf->surf; + aux_bo = mt->aux_buf->bo; + aux_offset = mt->aux_buf->offset; /* We only really need a clear color if we also have an auxiliary * surface. Without one, it does nothing. @@ -192,8 +177,8 @@ struct brw_bo *clear_bo = NULL; uint32_t clear_offset = 0; if (use_clear_address) { - clear_bo = aux_buf->clear_color_bo; - clear_offset = aux_buf->clear_color_offset; + clear_bo = mt->aux_buf->clear_color_bo; + clear_offset = mt->aux_buf->clear_color_offset; } isl_surf_fill_state(&brw->isl_dev, state, .surf = &surf, .view = &view, @@ -652,26 +637,15 @@ .mocs = brw_get_bo_mocs(devinfo, bo)); } -void -brw_update_buffer_texture_surface(struct gl_context *ctx, - unsigned unit, - uint32_t *surf_offset) +static unsigned +buffer_texture_range_size(struct brw_context *brw, + struct gl_texture_object *obj) { - struct brw_context *brw = brw_context(ctx); - struct gl_texture_object *tObj = ctx->Texture.Unit[unit]._Current; - struct intel_buffer_object *intel_obj = - intel_buffer_object(tObj->BufferObject); - uint32_t size = tObj->BufferSize; - struct brw_bo *bo = NULL; - mesa_format format = tObj->_BufferObjectFormat; - const enum isl_format isl_format = brw_isl_format_for_mesa_format(format); - int texel_size = _mesa_get_format_bytes(format); - - if (intel_obj) { - size = MIN2(size, intel_obj->Base.Size); - bo = intel_bufferobj_buffer(brw, intel_obj, tObj->BufferOffset, size, - false); - } + assert(obj->Target == GL_TEXTURE_BUFFER); + const unsigned texel_size = _mesa_get_format_bytes(obj->_BufferObjectFormat); + const unsigned buffer_size = (!obj->BufferObject ? 0 : + obj->BufferObject->Size); + const unsigned buffer_offset = MIN2(buffer_size, obj->BufferOffset); /* The ARB_texture_buffer_specification says: * @@ -689,7 +663,29 @@ * so that when ISL divides by stride to obtain the number of texels, that * texel count is clamped to MAX_TEXTURE_BUFFER_SIZE. */ - size = MIN2(size, ctx->Const.MaxTextureBufferSize * (unsigned) texel_size); + return MIN3((unsigned)obj->BufferSize, + buffer_size - buffer_offset, + brw->ctx.Const.MaxTextureBufferSize * texel_size); +} + +void +brw_update_buffer_texture_surface(struct gl_context *ctx, + unsigned unit, + uint32_t *surf_offset) +{ + struct brw_context *brw = brw_context(ctx); + struct gl_texture_object *tObj = ctx->Texture.Unit[unit]._Current; + struct intel_buffer_object *intel_obj = + intel_buffer_object(tObj->BufferObject); + const unsigned size = buffer_texture_range_size(brw, tObj); + struct brw_bo *bo = NULL; + mesa_format format = tObj->_BufferObjectFormat; + const enum isl_format isl_format = brw_isl_format_for_mesa_format(format); + int texel_size = _mesa_get_format_bytes(format); + + if (intel_obj) + bo = intel_bufferobj_buffer(brw, intel_obj, tObj->BufferOffset, size, + false); if (isl_format == ISL_FORMAT_UNSUPPORTED) { _mesa_problem(NULL, "bad format %s for texture buffer\n", @@ -1490,8 +1486,7 @@ unsigned surface_idx, struct brw_image_param *param) { - struct gl_buffer_object *obj = u->TexObj->BufferObject; - const uint32_t size = MIN2((uint32_t)u->TexObj->BufferSize, obj->Size); + const unsigned size = buffer_texture_range_size(brw, u->TexObj); update_default_image_param(brw, u, surface_idx, param); param->size[0] = size / _mesa_get_format_bytes(u->_ActualFormat); @@ -1523,14 +1518,17 @@ const unsigned format = get_image_format(brw, u->_ActualFormat, access); if (obj->Target == GL_TEXTURE_BUFFER) { - struct intel_buffer_object *intel_obj = - intel_buffer_object(obj->BufferObject); const unsigned texel_size = (format == ISL_FORMAT_RAW ? 1 : _mesa_get_format_bytes(u->_ActualFormat)); + const unsigned buffer_size = buffer_texture_range_size(brw, obj); + struct brw_bo *const bo = !obj->BufferObject ? NULL : + intel_bufferobj_buffer(brw, intel_buffer_object(obj->BufferObject), + obj->BufferOffset, buffer_size, + access != GL_READ_ONLY); brw_emit_buffer_surface_state( - brw, surf_offset, intel_obj->buffer, obj->BufferOffset, - format, intel_obj->Base.Size, texel_size, + brw, surf_offset, bo, obj->BufferOffset, + format, buffer_size, texel_size, access != GL_READ_ONLY ? RELOC_WRITE : 0); update_buffer_image_param(brw, u, surface_idx, param); diff -Nru mesa-18.1.0/src/mesa/drivers/dri/i965/gen6_depth_state.c mesa-18.1.1/src/mesa/drivers/dri/i965/gen6_depth_state.c --- mesa-18.1.0/src/mesa/drivers/dri/i965/gen6_depth_state.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/drivers/dri/i965/gen6_depth_state.c 2018-06-01 15:18:21.000000000 +0000 @@ -160,13 +160,13 @@ assert(depth_mt); uint32_t offset; - isl_surf_get_image_offset_B_tile_sa(&depth_mt->hiz_buf->surf, + isl_surf_get_image_offset_B_tile_sa(&depth_mt->aux_buf->surf, lod, 0, 0, &offset, NULL, NULL); BEGIN_BATCH(3); OUT_BATCH((_3DSTATE_HIER_DEPTH_BUFFER << 16) | (3 - 2)); - OUT_BATCH(depth_mt->hiz_buf->surf.row_pitch - 1); - OUT_RELOC(depth_mt->hiz_buf->bo, RELOC_WRITE, offset); + OUT_BATCH(depth_mt->aux_buf->surf.row_pitch - 1); + OUT_RELOC(depth_mt->aux_buf->bo, RELOC_WRITE, offset); ADVANCE_BATCH(); } else { BEGIN_BATCH(3); diff -Nru mesa-18.1.0/src/mesa/drivers/dri/i965/gen7_misc_state.c mesa-18.1.1/src/mesa/drivers/dri/i965/gen7_misc_state.c --- mesa-18.1.0/src/mesa/drivers/dri/i965/gen7_misc_state.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/drivers/dri/i965/gen7_misc_state.c 2018-06-01 15:18:21.000000000 +0000 @@ -149,8 +149,8 @@ BEGIN_BATCH(3); OUT_BATCH(GEN7_3DSTATE_HIER_DEPTH_BUFFER << 16 | (3 - 2)); OUT_BATCH((mocs << 25) | - (depth_mt->hiz_buf->pitch - 1)); - OUT_RELOC(depth_mt->hiz_buf->bo, RELOC_WRITE, 0); + (depth_mt->aux_buf->pitch - 1)); + OUT_RELOC(depth_mt->aux_buf->bo, RELOC_WRITE, 0); ADVANCE_BATCH(); } diff -Nru mesa-18.1.0/src/mesa/drivers/dri/i965/gen8_depth_state.c mesa-18.1.1/src/mesa/drivers/dri/i965/gen8_depth_state.c --- mesa-18.1.0/src/mesa/drivers/dri/i965/gen8_depth_state.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/drivers/dri/i965/gen8_depth_state.c 2018-06-01 15:18:21.000000000 +0000 @@ -94,9 +94,9 @@ assert(depth_mt); BEGIN_BATCH(5); OUT_BATCH(GEN7_3DSTATE_HIER_DEPTH_BUFFER << 16 | (5 - 2)); - OUT_BATCH((depth_mt->hiz_buf->pitch - 1) | mocs_wb << 25); - OUT_RELOC64(depth_mt->hiz_buf->bo, RELOC_WRITE, 0); - OUT_BATCH(depth_mt->hiz_buf->qpitch >> 2); + OUT_BATCH((depth_mt->aux_buf->pitch - 1) | mocs_wb << 25); + OUT_RELOC64(depth_mt->aux_buf->bo, RELOC_WRITE, 0); + OUT_BATCH(depth_mt->aux_buf->qpitch >> 2); ADVANCE_BATCH(); } diff -Nru mesa-18.1.0/src/mesa/drivers/dri/i965/intel_mipmap_tree.c mesa-18.1.1/src/mesa/drivers/dri/i965/intel_mipmap_tree.c --- mesa-18.1.0/src/mesa/drivers/dri/i965/intel_mipmap_tree.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/drivers/dri/i965/intel_mipmap_tree.c 2018-06-01 15:18:21.000000000 +0000 @@ -950,7 +950,7 @@ assert(mt->last_level == 0); /* We shouldn't already have a CCS */ - assert(!mt->mcs_buf); + assert(!mt->aux_buf); if (!isl_surf_get_ccs_surf(&brw->isl_dev, &mt->surf, &temp_ccs_surf, image->aux_pitch)) @@ -959,14 +959,14 @@ assert(image->aux_offset < image->bo->size); assert(temp_ccs_surf.size <= image->bo->size - image->aux_offset); - mt->mcs_buf = calloc(sizeof(*mt->mcs_buf), 1); - if (mt->mcs_buf == NULL) + mt->aux_buf = calloc(sizeof(*mt->aux_buf), 1); + if (mt->aux_buf == NULL) return false; mt->aux_state = create_aux_state_map(mt, initial_state); if (!mt->aux_state) { - free(mt->mcs_buf); - mt->mcs_buf = NULL; + free(mt->aux_buf); + mt->aux_buf = NULL; return false; } @@ -977,24 +977,24 @@ */ const struct gen_device_info *devinfo = &brw->screen->devinfo; if (devinfo->gen >= 10) { - mt->mcs_buf->clear_color_bo = + mt->aux_buf->clear_color_bo = brw_bo_alloc(brw->bufmgr, "clear_color_bo", brw->isl_dev.ss.clear_color_state_size); - if (!mt->mcs_buf->clear_color_bo) { - free(mt->mcs_buf); - mt->mcs_buf = NULL; + if (!mt->aux_buf->clear_color_bo) { + free(mt->aux_buf); + mt->aux_buf = NULL; return false; } } - mt->mcs_buf->bo = image->bo; + mt->aux_buf->bo = image->bo; brw_bo_reference(image->bo); - mt->mcs_buf->offset = image->aux_offset; - mt->mcs_buf->size = image->bo->size - image->aux_offset; - mt->mcs_buf->pitch = image->aux_pitch; - mt->mcs_buf->qpitch = 0; - mt->mcs_buf->surf = temp_ccs_surf; + mt->aux_buf->offset = image->aux_offset; + mt->aux_buf->size = image->bo->size - image->aux_offset; + mt->aux_buf->pitch = image->aux_pitch; + mt->aux_buf->qpitch = 0; + mt->aux_buf->surf = temp_ccs_surf; return true; } @@ -1249,8 +1249,7 @@ brw_bo_unreference((*mt)->bo); intel_miptree_release(&(*mt)->stencil_mt); intel_miptree_release(&(*mt)->r8stencil_mt); - intel_miptree_aux_buffer_free((*mt)->hiz_buf); - intel_miptree_aux_buffer_free((*mt)->mcs_buf); + intel_miptree_aux_buffer_free((*mt)->aux_buf); free_aux_state_map((*mt)->aux_state); intel_miptree_release(&(*mt)->plane[0]); @@ -1656,12 +1655,12 @@ intel_obj->needs_validate = true; } -static void +static bool intel_miptree_init_mcs(struct brw_context *brw, struct intel_mipmap_tree *mt, int init_value) { - assert(mt->mcs_buf != NULL); + assert(mt->aux_buf != NULL); /* From the Ivy Bridge PRM, Vol 2 Part 1 p326: * @@ -1673,16 +1672,17 @@ * * Note: the clear value for MCS buffers is all 1's, so we memset to 0xff. */ - void *map = brw_bo_map(brw, mt->mcs_buf->bo, MAP_WRITE | MAP_RAW); + void *map = brw_bo_map(brw, mt->aux_buf->bo, MAP_WRITE | MAP_RAW); if (unlikely(map == NULL)) { fprintf(stderr, "Failed to map mcs buffer into GTT\n"); - brw_bo_unreference(mt->mcs_buf->bo); - free(mt->mcs_buf); - return; + intel_miptree_aux_buffer_free(mt->aux_buf); + mt->aux_buf = NULL; + return false; } void *data = map; - memset(data, init_value, mt->mcs_buf->size); - brw_bo_unmap(mt->mcs_buf->bo); + memset(data, init_value, mt->aux_buf->size); + brw_bo_unmap(mt->aux_buf->bo); + return true; } static struct intel_miptree_aux_buffer * @@ -1738,7 +1738,7 @@ GLuint num_samples) { assert(brw->screen->devinfo.gen >= 7); /* MCS only used on Gen7+ */ - assert(mt->mcs_buf == NULL); + assert(mt->aux_buf == NULL); assert(mt->aux_usage == ISL_AUX_USAGE_MCS); /* Multisampled miptrees are only supported for single level. */ @@ -1760,17 +1760,16 @@ * to be just used by the GPU. */ const uint32_t alloc_flags = 0; - mt->mcs_buf = intel_alloc_aux_buffer(brw, "mcs-miptree", + mt->aux_buf = intel_alloc_aux_buffer(brw, "mcs-miptree", &temp_mcs_surf, alloc_flags, mt); - if (!mt->mcs_buf) { + if (!mt->aux_buf || + !intel_miptree_init_mcs(brw, mt, 0xFF)) { free(aux_state); return false; } mt->aux_state = aux_state; - intel_miptree_init_mcs(brw, mt, 0xFF); - return true; } @@ -1778,7 +1777,7 @@ intel_miptree_alloc_ccs(struct brw_context *brw, struct intel_mipmap_tree *mt) { - assert(mt->mcs_buf == NULL); + assert(mt->aux_buf == NULL); assert(mt->aux_usage == ISL_AUX_USAGE_CCS_E || mt->aux_usage == ISL_AUX_USAGE_CCS_D); @@ -1804,14 +1803,12 @@ * A CCS value of 0 indicates that the corresponding block is in the * pass-through state which is what we want. * - * For CCS_D, on the other hand, we don't care as we're about to perform a - * fast-clear operation. In that case, being hot in caches more useful. + * For CCS_D, do the same thing. On gen9+, this avoids having any undefined + * bits in the aux buffer. */ - const uint32_t alloc_flags = mt->aux_usage == ISL_AUX_USAGE_CCS_E ? - BO_ALLOC_ZEROED : BO_ALLOC_BUSY; - mt->mcs_buf = intel_alloc_aux_buffer(brw, "ccs-miptree", - &temp_ccs_surf, alloc_flags, mt); - if (!mt->mcs_buf) { + mt->aux_buf = intel_alloc_aux_buffer(brw, "ccs-miptree", &temp_ccs_surf, + BO_ALLOC_ZEROED, mt); + if (!mt->aux_buf) { free(aux_state); return false; } @@ -1833,7 +1830,7 @@ { const struct gen_device_info *devinfo = &brw->screen->devinfo; - assert(mt->hiz_buf); + assert(mt->aux_buf); assert(mt->surf.size > 0); if (devinfo->gen >= 8 || devinfo->is_haswell) { @@ -1861,7 +1858,7 @@ intel_miptree_alloc_hiz(struct brw_context *brw, struct intel_mipmap_tree *mt) { - assert(mt->hiz_buf == NULL); + assert(mt->aux_buf == NULL); assert(mt->aux_usage == ISL_AUX_USAGE_HIZ); enum isl_aux_state **aux_state = @@ -1876,10 +1873,10 @@ assert(ok); const uint32_t alloc_flags = BO_ALLOC_BUSY; - mt->hiz_buf = intel_alloc_aux_buffer(brw, "hiz-miptree", + mt->aux_buf = intel_alloc_aux_buffer(brw, "hiz-miptree", &temp_hiz_surf, alloc_flags, mt); - if (!mt->hiz_buf) { + if (!mt->aux_buf) { free(aux_state); return false; } @@ -1952,7 +1949,7 @@ return false; } - if (!mt->hiz_buf) { + if (!mt->aux_buf) { return false; } @@ -2032,7 +2029,7 @@ { assert(_mesa_is_format_color_format(mt->format)); - if (!mt->mcs_buf) + if (!mt->aux_buf) return false; /* Clamp the level range to fit the miptree */ @@ -2059,7 +2056,7 @@ const struct intel_mipmap_tree *mt, unsigned level, unsigned layer) { - if (!mt->mcs_buf) + if (!mt->aux_buf) return; /* Fast color clear is supported for mipmapped surfaces only on Gen8+. */ @@ -2451,7 +2448,7 @@ break; case ISL_AUX_USAGE_MCS: - assert(mt->mcs_buf); + assert(mt->aux_buf); assert(start_level == 0 && num_levels == 1); const uint32_t level_layers = miptree_layer_range_length(mt, 0, start_layer, num_layers); @@ -2463,7 +2460,7 @@ case ISL_AUX_USAGE_CCS_D: case ISL_AUX_USAGE_CCS_E: - if (!mt->mcs_buf) + if (!mt->aux_buf) return; for (uint32_t l = 0; l < num_levels; l++) { @@ -2479,7 +2476,7 @@ break; case ISL_AUX_USAGE_HIZ: - assert(mt->hiz_buf); + assert(mt->aux_buf); for (uint32_t l = 0; l < num_levels; l++) { const uint32_t level = start_level + l; if (!intel_miptree_level_has_hiz(mt, level)) @@ -2513,7 +2510,7 @@ break; case ISL_AUX_USAGE_MCS: - assert(mt->mcs_buf); + assert(mt->aux_buf); for (uint32_t a = 0; a < num_layers; a++) { intel_miptree_finish_mcs_write(brw, mt, start_layer + a, aux_usage); @@ -2522,7 +2519,7 @@ case ISL_AUX_USAGE_CCS_D: case ISL_AUX_USAGE_CCS_E: - if (!mt->mcs_buf) + if (!mt->aux_buf) return; for (uint32_t a = 0; a < num_layers; a++) { @@ -2553,7 +2550,7 @@ intel_miptree_check_level_layer(mt, level, layer); if (_mesa_is_format_color_format(mt->format)) { - assert(mt->mcs_buf != NULL); + assert(mt->aux_buf != NULL); assert(mt->surf.samples == 1 || mt->surf.msaa_layout == ISL_MSAA_LAYOUT_ARRAY); } else if (mt->format == MESA_FORMAT_S_UINT8) { @@ -2574,7 +2571,7 @@ num_layers = miptree_layer_range_length(mt, level, start_layer, num_layers); if (_mesa_is_format_color_format(mt->format)) { - assert(mt->mcs_buf != NULL); + assert(mt->aux_buf != NULL); assert(mt->surf.samples == 1 || mt->surf.msaa_layout == ISL_MSAA_LAYOUT_ARRAY); } else if (mt->format == MESA_FORMAT_S_UINT8) { @@ -2637,7 +2634,7 @@ case ISL_AUX_USAGE_CCS_D: case ISL_AUX_USAGE_CCS_E: - if (!mt->mcs_buf) { + if (!mt->aux_buf) { assert(mt->aux_usage == ISL_AUX_USAGE_CCS_D); return ISL_AUX_USAGE_NONE; } @@ -2725,12 +2722,12 @@ switch (mt->aux_usage) { case ISL_AUX_USAGE_MCS: - assert(mt->mcs_buf); + assert(mt->aux_buf); return ISL_AUX_USAGE_MCS; case ISL_AUX_USAGE_CCS_D: case ISL_AUX_USAGE_CCS_E: - if (!mt->mcs_buf) { + if (!mt->aux_buf) { assert(mt->aux_usage == ISL_AUX_USAGE_CCS_D); return ISL_AUX_USAGE_NONE; } @@ -2785,7 +2782,7 @@ uint32_t start_layer, uint32_t layer_count) { intel_miptree_prepare_access(brw, mt, level, 1, start_layer, layer_count, - mt->aux_usage, mt->hiz_buf != NULL); + mt->aux_usage, mt->aux_buf != NULL); } void @@ -2796,7 +2793,7 @@ { if (depth_written) { intel_miptree_finish_write(brw, mt, level, start_layer, layer_count, - mt->hiz_buf != NULL); + mt->aux_buf != NULL); } } @@ -2820,7 +2817,7 @@ assert(mt->surf.logical_level0_px.depth == 1); assert(mt->surf.logical_level0_px.array_len == 1); assert(mt->surf.samples == 1); - assert(mt->mcs_buf != NULL); + assert(mt->aux_buf != NULL); aux_usage = mod_info->aux_usage; supports_fast_clear = mod_info->supports_clear_color; @@ -2835,7 +2832,7 @@ intel_miptree_finish_external(struct brw_context *brw, struct intel_mipmap_tree *mt) { - if (!mt->mcs_buf) + if (!mt->aux_buf) return; /* We don't know the actual aux state of the aux surface. The previous @@ -2876,31 +2873,15 @@ 0, INTEL_REMAINING_LAYERS, ISL_AUX_USAGE_NONE, false); - if (mt->mcs_buf) { - intel_miptree_aux_buffer_free(mt->mcs_buf); - mt->mcs_buf = NULL; - - /* Any pending MCS/CCS operations are no longer needed. Trying to - * execute any will likely crash due to the missing aux buffer. So let's - * delete all pending ops. - */ - free(mt->aux_state); - mt->aux_state = NULL; - brw->ctx.NewDriverState |= BRW_NEW_AUX_STATE; - } - - if (mt->hiz_buf) { - intel_miptree_aux_buffer_free(mt->hiz_buf); - mt->hiz_buf = NULL; + if (mt->aux_buf) { + intel_miptree_aux_buffer_free(mt->aux_buf); + mt->aux_buf = NULL; + /* Make future calls of intel_miptree_level_has_hiz() return false. */ for (uint32_t l = mt->first_level; l <= mt->last_level; ++l) { mt->level[l].has_hiz = false; } - /* Any pending HiZ operations are no longer needed. Trying to execute - * any will likely crash due to the missing aux buffer. So let's delete - * all pending ops. - */ free(mt->aux_state); mt->aux_state = NULL; brw->ctx.NewDriverState |= BRW_NEW_AUX_STATE; diff -Nru mesa-18.1.0/src/mesa/drivers/dri/i965/intel_mipmap_tree.h mesa-18.1.1/src/mesa/drivers/dri/i965/intel_mipmap_tree.h --- mesa-18.1.0/src/mesa/drivers/dri/i965/intel_mipmap_tree.h 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/drivers/dri/i965/intel_mipmap_tree.h 2018-06-01 15:18:21.000000000 +0000 @@ -273,16 +273,6 @@ uint32_t offset; /** - * \brief HiZ aux buffer - * - * To allocate the hiz buffer, use intel_miptree_alloc_hiz(). - * - * To determine if hiz is enabled, do not check this pointer. Instead, use - * intel_miptree_level_has_hiz(). - */ - struct intel_miptree_aux_buffer *hiz_buf; - - /** * \brief The type of auxiliary compression used by this miptree. * * This describes the type of auxiliary compression that is intended to be @@ -335,15 +325,29 @@ bool r8stencil_needs_update; /** - * \brief MCS auxiliary buffer. + * \brief CCS, MCS, or HiZ auxiliary buffer. + * + * NULL if no auxiliary buffer is in use for this surface. + * + * For single-sampled color miptrees: + * This buffer contains the Color Control Surface, which stores the + * necessary information to implement lossless color compression (CCS_E) + * and "fast color clear" (CCS_D) behaviour. + * + * For multi-sampled color miptrees: + * This buffer contains the Multisample Control Surface, which stores the + * necessary information to implement compressed MSAA + * (INTEL_MSAA_FORMAT_CMS). * - * This buffer contains the "multisample control surface", which stores - * the necessary information to implement compressed MSAA - * (INTEL_MSAA_FORMAT_CMS) and "fast color clear" behaviour on Gen7+. + * For depth miptrees: + * This buffer contains the Hierarchical Depth Buffer, which stores the + * necessary information to implement lossless depth compression and fast + * depth clear behavior. * - * NULL if no MCS buffer is in use for this surface. + * To determine if HiZ is enabled, do not check this pointer. Instead, + * use intel_miptree_level_has_hiz(). */ - struct intel_miptree_aux_buffer *mcs_buf; + struct intel_miptree_aux_buffer *aux_buf; /** * Planes 1 and 2 in case this is a planar surface. diff -Nru mesa-18.1.0/src/mesa/drivers/dri/i965/intel_tex_image.c mesa-18.1.1/src/mesa/drivers/dri/i965/intel_tex_image.c --- mesa-18.1.0/src/mesa/drivers/dri/i965/intel_tex_image.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/drivers/dri/i965/intel_tex_image.c 2018-06-01 15:18:21.000000000 +0000 @@ -543,7 +543,7 @@ * should be a no-op in almost all cases. On the off chance that someone * ever triggers this, we should at least warn them. */ - if (intel_tex->mt->mcs_buf && + if (intel_tex->mt->aux_buf && intel_miptree_get_aux_state(intel_tex->mt, 0, 0) != isl_drm_modifier_get_default_aux_state(intel_tex->mt->drm_modifier)) { _mesa_warning(ctx, "Aux state changed between BindTexImage and " diff -Nru mesa-18.1.0/src/mesa/main/dlist.c mesa-18.1.1/src/mesa/main/dlist.c --- mesa-18.1.0/src/mesa/main/dlist.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/main/dlist.c 2018-06-01 15:18:21.000000000 +0000 @@ -6587,7 +6587,7 @@ n[2].i = x; } if (ctx->ExecuteFlag) { - /*CALL_Uniform1ui(ctx->Exec, (location, x));*/ + CALL_Uniform1ui(ctx->Exec, (location, x)); } } @@ -6604,7 +6604,7 @@ n[3].i = y; } if (ctx->ExecuteFlag) { - /*CALL_Uniform2ui(ctx->Exec, (location, x, y));*/ + CALL_Uniform2ui(ctx->Exec, (location, x, y)); } } @@ -6622,7 +6622,7 @@ n[4].i = z; } if (ctx->ExecuteFlag) { - /*CALL_Uniform3ui(ctx->Exec, (location, x, y, z));*/ + CALL_Uniform3ui(ctx->Exec, (location, x, y, z)); } } @@ -6641,7 +6641,7 @@ n[5].i = w; } if (ctx->ExecuteFlag) { - /*CALL_Uniform4ui(ctx->Exec, (location, x, y, z, w));*/ + CALL_Uniform4ui(ctx->Exec, (location, x, y, z, w)); } } @@ -6660,7 +6660,7 @@ save_pointer(&n[3], memdup(v, count * 1 * sizeof(*v))); } if (ctx->ExecuteFlag) { - /*CALL_Uniform1uiv(ctx->Exec, (location, count, v));*/ + CALL_Uniform1uiv(ctx->Exec, (location, count, v)); } } @@ -6677,7 +6677,7 @@ save_pointer(&n[3], memdup(v, count * 2 * sizeof(*v))); } if (ctx->ExecuteFlag) { - /*CALL_Uniform2uiv(ctx->Exec, (location, count, v));*/ + CALL_Uniform2uiv(ctx->Exec, (location, count, v)); } } @@ -6694,7 +6694,7 @@ save_pointer(&n[3], memdup(v, count * 3 * sizeof(*v))); } if (ctx->ExecuteFlag) { - /*CALL_Uniform3uiv(ctx->Exec, (location, count, v));*/ + CALL_Uniform3uiv(ctx->Exec, (location, count, v)); } } @@ -6711,7 +6711,7 @@ save_pointer(&n[3], memdup(v, count * 4 * sizeof(*v))); } if (ctx->ExecuteFlag) { - /*CALL_Uniform4uiv(ctx->Exec, (location, count, v));*/ + CALL_Uniform4uiv(ctx->Exec, (location, count, v)); } } @@ -8723,34 +8723,29 @@ CALL_Uniform4iv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3]))); break; case OPCODE_UNIFORM_1UI: - /*CALL_Uniform1uiARB(ctx->Exec, (n[1].i, n[2].i));*/ + CALL_Uniform1ui(ctx->Exec, (n[1].i, n[2].i)); break; case OPCODE_UNIFORM_2UI: - /*CALL_Uniform2uiARB(ctx->Exec, (n[1].i, n[2].i, n[3].i));*/ + CALL_Uniform2ui(ctx->Exec, (n[1].i, n[2].i, n[3].i)); break; case OPCODE_UNIFORM_3UI: - /*CALL_Uniform3uiARB(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));*/ + CALL_Uniform3ui(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i)); break; case OPCODE_UNIFORM_4UI: - /*CALL_Uniform4uiARB(ctx->Exec, - (n[1].i, n[2].i, n[3].i, n[4].i, n[5].i)); - */ + CALL_Uniform4ui(ctx->Exec, + (n[1].i, n[2].i, n[3].i, n[4].i, n[5].i)); break; case OPCODE_UNIFORM_1UIV: - /*CALL_Uniform1uivARB(ctx->Exec, (n[1].i, n[2].i, - get_pointer(&n[3])));*/ + CALL_Uniform1uiv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3]))); break; case OPCODE_UNIFORM_2UIV: - /*CALL_Uniform2uivARB(ctx->Exec, (n[1].i, n[2].i, - get_pointer(&n[3])));*/ + CALL_Uniform2uiv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3]))); break; case OPCODE_UNIFORM_3UIV: - /*CALL_Uniform3uivARB(ctx->Exec, (n[1].i, n[2].i, - get_pointer(&n[3])));*/ + CALL_Uniform3uiv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3]))); break; case OPCODE_UNIFORM_4UIV: - /*CALL_Uniform4uivARB(ctx->Exec, (n[1].i, n[2].i, - get_pointer(&n[3])));*/ + CALL_Uniform4uiv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3]))); break; case OPCODE_UNIFORM_MATRIX22: CALL_UniformMatrix2fv(ctx->Exec, @@ -9931,7 +9926,6 @@ SET_ClearBufferuiv(table, save_ClearBufferuiv); SET_ClearBufferfv(table, save_ClearBufferfv); SET_ClearBufferfi(table, save_ClearBufferfi); -#if 0 SET_Uniform1ui(table, save_Uniform1ui); SET_Uniform2ui(table, save_Uniform2ui); SET_Uniform3ui(table, save_Uniform3ui); @@ -9940,16 +9934,6 @@ SET_Uniform2uiv(table, save_Uniform2uiv); SET_Uniform3uiv(table, save_Uniform3uiv); SET_Uniform4uiv(table, save_Uniform4uiv); -#else - (void) save_Uniform1ui; - (void) save_Uniform2ui; - (void) save_Uniform3ui; - (void) save_Uniform4ui; - (void) save_Uniform1uiv; - (void) save_Uniform2uiv; - (void) save_Uniform3uiv; - (void) save_Uniform4uiv; -#endif /* These are: */ SET_BeginTransformFeedback(table, save_BeginTransformFeedback); diff -Nru mesa-18.1.0/src/mesa/main/glformats.c mesa-18.1.1/src/mesa/main/glformats.c --- mesa-18.1.0/src/mesa/main/glformats.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/main/glformats.c 2018-06-01 15:18:21.000000000 +0000 @@ -563,6 +563,8 @@ return sizeof(GLuint); else return -1; + case GL_UNSIGNED_INT64_ARB: + return comps * 8; default: return -1; } diff -Nru mesa-18.1.0/src/mesa/main/shaderapi.c mesa-18.1.1/src/mesa/main/shaderapi.c --- mesa-18.1.0/src/mesa/main/shaderapi.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/main/shaderapi.c 2018-06-01 15:18:21.000000000 +0000 @@ -159,6 +159,9 @@ { for (int i = 0; i < MESA_SHADER_STAGES; i++) { _mesa_reference_program(ctx, &ctx->Shader.CurrentProgram[i], NULL); + _mesa_reference_shader_program(ctx, + &ctx->Shader.ReferencedPrograms[i], + NULL); } _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, NULL); diff -Nru mesa-18.1.0/src/mesa/main/shaderimage.c mesa-18.1.1/src/mesa/main/shaderimage.c --- mesa-18.1.0/src/mesa/main/shaderimage.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/main/shaderimage.c 2018-06-01 15:18:21.000000000 +0000 @@ -479,13 +479,6 @@ if (!t) return GL_FALSE; - /* The GL 4.5 Core spec doesn't say anything about buffers. In practice, - * the image buffer format is always compatible with the underlying - * buffer storage. - */ - if (t->Target == GL_TEXTURE_BUFFER) - return GL_TRUE; - if (!t->_BaseComplete && !t->_MipmapComplete) _mesa_test_texobj_completeness(ctx, t); @@ -499,14 +492,20 @@ u->_Layer >= _mesa_get_texture_layers(t, u->Level)) return GL_FALSE; - struct gl_texture_image *img = (t->Target == GL_TEXTURE_CUBE_MAP ? - t->Image[u->_Layer][u->Level] : - t->Image[0][u->Level]); + if (t->Target == GL_TEXTURE_BUFFER) { + tex_format = _mesa_get_shader_image_format(t->BufferObjectFormat); - if (!img || img->Border || img->NumSamples > ctx->Const.MaxImageSamples) - return GL_FALSE; + } else { + struct gl_texture_image *img = (t->Target == GL_TEXTURE_CUBE_MAP ? + t->Image[u->_Layer][u->Level] : + t->Image[0][u->Level]); + + if (!img || img->Border || img->NumSamples > ctx->Const.MaxImageSamples) + return GL_FALSE; + + tex_format = _mesa_get_shader_image_format(img->InternalFormat); + } - tex_format = _mesa_get_shader_image_format(img->InternalFormat); if (!tex_format) return GL_FALSE; diff -Nru mesa-18.1.0/src/mesa/state_tracker/st_cb_texture.c mesa-18.1.1/src/mesa/state_tracker/st_cb_texture.c --- mesa-18.1.0/src/mesa/state_tracker/st_cb_texture.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/state_tracker/st_cb_texture.c 2018-06-01 15:18:21.000000000 +0000 @@ -2491,19 +2491,10 @@ if (tObj->Immutable) return GL_TRUE; - if (_mesa_is_texture_complete(tObj, &tObj->Sampler)) { - /* The texture is complete and we know exactly how many mipmap levels - * are present/needed. This is conditional because we may be called - * from the st_generate_mipmap() function when the texture object is - * incomplete. In that case, we'll have set stObj->lastLevel before - * we get here. - */ - if (stObj->base.Sampler.MinFilter == GL_LINEAR || - stObj->base.Sampler.MinFilter == GL_NEAREST) - stObj->lastLevel = stObj->base.BaseLevel; - else - stObj->lastLevel = stObj->base._MaxLevel; - } + if (tObj->_MipmapComplete) + stObj->lastLevel = stObj->base._MaxLevel; + else if (tObj->_BaseComplete) + stObj->lastLevel = stObj->base.BaseLevel; /* Skip the loop over images in the common case of no images having * changed. But if the GL_BASE_LEVEL or GL_MAX_LEVEL change to something we diff -Nru mesa-18.1.0/src/mesa/vbo/vbo_private.h mesa-18.1.1/src/mesa/vbo/vbo_private.h --- mesa-18.1.0/src/mesa/vbo/vbo_private.h 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/mesa/vbo/vbo_private.h 2018-06-01 15:18:21.000000000 +0000 @@ -97,8 +97,8 @@ case GL_FLOAT: case GL_INT: case GL_UNSIGNED_INT: - case GL_UNSIGNED_INT64_ARB: return GL_FALSE; + case GL_UNSIGNED_INT64_ARB: case GL_DOUBLE: return GL_TRUE; default: diff -Nru mesa-18.1.0/src/vulkan/wsi/wsi_common_x11.c mesa-18.1.1/src/vulkan/wsi/wsi_common_x11.c --- mesa-18.1.0/src/vulkan/wsi/wsi_common_x11.c 2018-05-18 23:28:41.000000000 +0000 +++ mesa-18.1.1/src/vulkan/wsi/wsi_common_x11.c 2018-06-01 15:18:21.000000000 +0000 @@ -1421,10 +1421,10 @@ for (uint32_t j = 0; j < image; j++) x11_image_finish(chain, pAllocator, &chain->images[j]); -fail_register: for (int i = 0; i < ARRAY_SIZE(modifiers); i++) vk_free(pAllocator, modifiers[i]); +fail_register: xcb_unregister_for_special_event(chain->conn, chain->special_event); wsi_swapchain_finish(&chain->base); diff -Nru mesa-18.1.0/VERSION mesa-18.1.1/VERSION --- mesa-18.1.0/VERSION 2018-05-18 23:28:40.000000000 +0000 +++ mesa-18.1.1/VERSION 2018-06-01 15:18:20.000000000 +0000 @@ -1 +1 @@ -18.1.0 +18.1.1