Lines Matching refs:ctx

61 _mesa_glthread_should_execute_list(struct gl_context *ctx,
67  * \param ctx GL context.
72 #define SAVE_FLUSH_VERTICES(ctx)                     \
74       if (ctx->Driver.SaveNeedFlush)                 \
75          vbo_save_SaveFlushVertices(ctx);            \
83  * \param ctx GL context.
86 #define ASSERT_OUTSIDE_SAVE_BEGIN_END_WITH_RETVAL(ctx, retval)          \
88       if (ctx->Driver.CurrentSavePrimitive <= PRIM_MAX) {               \
89          _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glBegin/End" ); \
98  * \param ctx GL context.
100 #define ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx)                              \
102       if (ctx->Driver.CurrentSavePrimitive <= PRIM_MAX) {               \
103          _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glBegin/End" ); \
112  * \param ctx GL context.
114 #define ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx)                    \
116       ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx);                               \
117       SAVE_FLUSH_VERTICES(ctx);                                         \
124  * \param ctx GL context.
127 #define ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, retval) \
129       ASSERT_OUTSIDE_SAVE_BEGIN_END_WITH_RETVAL(ctx, retval);           \
130       SAVE_FLUSH_VERTICES(ctx);                                         \
740 vbo_destroy_vertex_list(struct gl_context *ctx, struct vbo_save_vertex_list *node)
743       _mesa_reference_vao(ctx, &node->cold->VAO[mode], NULL);
757    _mesa_reference_buffer_object(ctx, &node->cold->ib.obj, NULL);
766 vbo_print_vertex_list(struct gl_context *ctx, struct vbo_save_vertex_list *node, OpCode op, FILE *f)
771    (void) ctx;
797 Node *get_list_head(struct gl_context *ctx, struct gl_display_list *dlist)
800       &ctx->Shared->small_dlist_store.ptr[dlist->start] :
809 is_bitmap_list(struct gl_context *ctx, struct gl_display_list *dlist)
811    Node *n = get_list_head(ctx, dlist);
825 is_empty_list(struct gl_context *ctx, struct gl_display_list *dlist)
827    Node *n = get_list_head(ctx, dlist);
836 _mesa_delete_bitmap_atlas(struct gl_context *ctx, struct gl_bitmap_atlas *atlas)
839       _mesa_delete_texture_object(ctx, atlas->texObj);
850 lookup_bitmap_atlas(struct gl_context *ctx, GLuint listBase)
855    atlas = _mesa_HashLookup(ctx->Shared->BitmapAtlas, listBase);
864 alloc_bitmap_atlas(struct gl_context *ctx, GLuint listBase, bool isGenName)
869    assert(_mesa_HashLookup(ctx->Shared->BitmapAtlas, listBase) == NULL);
873       _mesa_HashInsert(ctx->Shared->BitmapAtlas, listBase, atlas, isGenName);
889 build_bitmap_atlas(struct gl_context *ctx, struct gl_bitmap_atlas *atlas,
901    assert(ctx->Extensions.NV_texture_rectangle);
902    assert(ctx->Const.MaxTextureRectSize >= 1024);
919       struct gl_display_list *list = _mesa_lookup_list(ctx, listBase + i, true);
925       if (!list || is_empty_list(ctx, list)) {
931       if (!is_bitmap_list(ctx, list)) {
938       n = get_list_head(ctx, list);
977    else if (atlas->texHeight > ctx->Const.MaxTextureRectSize) {
983    atlas->texObj = _mesa_new_texture_object(ctx, 999, GL_TEXTURE_RECTANGLE);
996    atlas->texImage = _mesa_get_tex_image(ctx, atlas->texObj,
1002    if (ctx->Const.BitmapUsesRed)
1003       _mesa_init_teximage_fields(ctx, atlas->texImage,
1007       _mesa_init_teximage_fields(ctx, atlas->texImage,
1012    if (!st_AllocTextureImageBuffer(ctx, atlas->texImage)) {
1017    st_MapTextureImage(ctx, atlas->texImage, 0,
1028       struct gl_display_list *list = _mesa_lookup_list(ctx, listBase + i, true);
1029       const Node *n = get_list_head(ctx, list);
1046                              &ctx->DefaultPacking, bitmap_image,
1052    st_UnmapTextureImage(ctx, atlas->texImage, 0);
1059    _mesa_error(ctx, GL_OUT_OF_MEMORY, "Display list bitmap atlas");
1062       _mesa_delete_texture_object(ctx, atlas->texObj);
1089 _mesa_lookup_list(struct gl_context *ctx, GLuint list, bool locked)
1092       _mesa_HashLookupMaybeLocked(ctx->Shared->DisplayList, list, locked);
1101 _mesa_delete_list(struct gl_context *ctx, struct gl_display_list *dlist)
1105    n = block = get_list_head(ctx, dlist);
1325             vbo_destroy_vertex_list(ctx, (struct vbo_save_vertex_list *) &n[0]);
1337                   util_idalloc_free(&ctx->Shared->small_dlist_store.free_idx,
1387 destroy_list(struct gl_context *ctx, GLuint list)
1394    dlist = _mesa_lookup_list(ctx, list, true);
1398    if (is_bitmap_list(ctx, dlist)) {
1404       _mesa_HashWalk(ctx->Shared->BitmapAtlas,
1408    _mesa_delete_list(ctx, dlist);
1409    _mesa_HashRemoveLocked(ctx->Shared->DisplayList, list);
1422 unpack_image(struct gl_context *ctx, GLuint dimensions,
1443          _mesa_error(ctx, GL_OUT_OF_MEMORY, "display list construction");
1453          _mesa_bufferobj_map_range(ctx, 0, unpack->BufferObj->Size,
1458          _mesa_error(ctx, GL_INVALID_OPERATION, "unable to map PBO");
1466       _mesa_bufferobj_unmap(ctx, unpack->BufferObj, MAP_INTERNAL);
1469          _mesa_error(ctx, GL_OUT_OF_MEMORY, "display list construction");
1475    _mesa_error(ctx, GL_INVALID_OPERATION, "invalid PBO access");
1500 dlist_alloc(struct gl_context *ctx, OpCode opcode, GLuint bytes, bool align8)
1509        ctx->ListState.CurrentPos % 2 == 1) {
1510       Node *last = ctx->ListState.CurrentBlock + ctx->ListState.CurrentPos -
1511                    ctx->ListState.LastInstSize;
1513       ctx->ListState.CurrentPos++;
1516    if (ctx->ListState.CurrentPos + numNodes + contNodes > BLOCK_SIZE) {
1519       Node *n = ctx->ListState.CurrentBlock + ctx->ListState.CurrentPos;
1523          _mesa_error(ctx, GL_OUT_OF_MEMORY, "Building display list");
1531       ctx->ListState.CurrentBlock = newblock;
1532       ctx->ListState.CurrentPos = 0;
1535    Node *n = ctx->ListState.CurrentBlock + ctx->ListState.CurrentPos;
1536    ctx->ListState.CurrentPos += numNodes;
1540    ctx->ListState.LastInstSize = numNodes;
1547 _mesa_dlist_alloc_vertex_list(struct gl_context *ctx, bool copy_to_current)
1549    Node *n =  dlist_alloc(ctx,
1573 alloc_instruction(struct gl_context *ctx, OpCode opcode, GLuint nparams)
1575    return dlist_alloc(ctx, opcode, nparams * sizeof(Node), false);
1585    GET_CURRENT_CONTEXT(ctx);
1587    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1588    n = alloc_instruction(ctx, OPCODE_ACCUM, 2);
1593    if (ctx->ExecuteFlag) {
1594       CALL_Accum(ctx->Exec, (op, value));
1602    GET_CURRENT_CONTEXT(ctx);
1604    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1605    n = alloc_instruction(ctx, OPCODE_ALPHA_FUNC, 2);
1610    if (ctx->ExecuteFlag) {
1611       CALL_AlphaFunc(ctx->Exec, (func, ref));
1619    GET_CURRENT_CONTEXT(ctx);
1621    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1622    n = alloc_instruction(ctx, OPCODE_BIND_TEXTURE, 2);
1627    if (ctx->ExecuteFlag) {
1628       CALL_BindTexture(ctx->Exec, (target, texture));
1638    GET_CURRENT_CONTEXT(ctx);
1640    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1641    n = alloc_instruction(ctx, OPCODE_BITMAP, 6 + POINTER_DWORDS);
1650                    unpack_image(ctx, 2, width, height, 1, GL_COLOR_INDEX,
1651                                 GL_BITMAP, pixels, &ctx->Unpack));
1653    if (ctx->ExecuteFlag) {
1654       CALL_Bitmap(ctx->Exec, (width, height,
1663    GET_CURRENT_CONTEXT(ctx);
1665    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1666    n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION, 1);
1670    if (ctx->ExecuteFlag) {
1671       CALL_BlendEquation(ctx->Exec, (mode));
1679    GET_CURRENT_CONTEXT(ctx);
1681    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1682    n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_SEPARATE, 2);
1687    if (ctx->ExecuteFlag) {
1688       CALL_BlendEquationSeparate(ctx->Exec, (modeRGB, modeA));
1697    GET_CURRENT_CONTEXT(ctx);
1699    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1700    n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_SEPARATE, 4);
1707    if (ctx->ExecuteFlag) {
1708       CALL_BlendFuncSeparate(ctx->Exec,
1724    GET_CURRENT_CONTEXT(ctx);
1726    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1727    n = alloc_instruction(ctx, OPCODE_BLEND_COLOR, 4);
1734    if (ctx->ExecuteFlag) {
1735       CALL_BlendColor(ctx->Exec, (red, green, blue, alpha));
1744    GET_CURRENT_CONTEXT(ctx);
1746    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1747    n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_SEPARATE_I, 5);
1755    if (ctx->ExecuteFlag) {
1756       CALL_BlendFuncSeparateiARB(ctx->Exec, (buf, sfactorRGB, dfactorRGB,
1765    GET_CURRENT_CONTEXT(ctx);
1767    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1768    n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_I, 3);
1774    if (ctx->ExecuteFlag) {
1775       CALL_BlendFunciARB(ctx->Exec, (buf, sfactor, dfactor));
1783    GET_CURRENT_CONTEXT(ctx);
1785    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1786    n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_I, 2);
1791    if (ctx->ExecuteFlag) {
1792       CALL_BlendEquationiARB(ctx->Exec, (buf, mode));
1800    GET_CURRENT_CONTEXT(ctx);
1802    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1803    n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_SEPARATE_I, 3);
1809    if (ctx->ExecuteFlag) {
1810       CALL_BlendEquationSeparateiARB(ctx->Exec, (buf, modeRGB, modeA));
1822    GET_CURRENT_CONTEXT(ctx);
1823    _mesa_error(ctx, GL_INVALID_OPERATION,
1834    GET_CURRENT_CONTEXT(ctx);
1835    _mesa_error(ctx, GL_INVALID_OPERATION,
1847    GET_CURRENT_CONTEXT(ctx);
1848    _mesa_error(ctx, GL_INVALID_OPERATION,
1860    GET_CURRENT_CONTEXT(ctx);
1861    _mesa_error(ctx, GL_INVALID_OPERATION,
1873    GET_CURRENT_CONTEXT(ctx);
1874    _mesa_error(ctx, GL_INVALID_OPERATION,
1887    GET_CURRENT_CONTEXT(ctx);
1888    _mesa_error(ctx, GL_INVALID_OPERATION,
1896    GET_CURRENT_CONTEXT(ctx);
1897    _mesa_error(ctx, GL_INVALID_OPERATION,
1906    GET_CURRENT_CONTEXT(ctx);
1907    _mesa_error(ctx, GL_INVALID_OPERATION,
1917    GET_CURRENT_CONTEXT(ctx);
1918    _mesa_error(ctx, GL_INVALID_OPERATION,
1929    GET_CURRENT_CONTEXT(ctx);
1930    _mesa_error(ctx, GL_INVALID_OPERATION,
1940 invalidate_saved_current_state(struct gl_context *ctx)
1945       ctx->ListState.ActiveAttribSize[i] = 0;
1948       ctx->ListState.ActiveMaterialSize[i] = 0;
1951    bool use_loopback = ctx->ListState.Current.UseLoopback;
1952    memset(&ctx->ListState.Current, 0, sizeof ctx->ListState.Current);
1953    ctx->ListState.Current.UseLoopback = use_loopback;
1955    ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
1962    GET_CURRENT_CONTEXT(ctx);
1964    SAVE_FLUSH_VERTICES(ctx);
1966    n = alloc_instruction(ctx, OPCODE_CALL_LIST, 1);
1974    invalidate_saved_current_state( ctx );
1976    if (ctx->ExecuteFlag) {
1985    GET_CURRENT_CONTEXT(ctx);
1990    SAVE_FLUSH_VERTICES(ctx);
2022    n = alloc_instruction(ctx, OPCODE_CALL_LISTS, 2 + POINTER_DWORDS);
2032    invalidate_saved_current_state( ctx );
2034    if (ctx->ExecuteFlag) {
2035       CALL_CallLists(ctx->Exec, (num, type, lists));
2043    GET_CURRENT_CONTEXT(ctx);
2045    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2046    n = alloc_instruction(ctx, OPCODE_CLEAR, 1);
2050    if (ctx->ExecuteFlag) {
2051       CALL_Clear(ctx->Exec, (mask));
2059    GET_CURRENT_CONTEXT(ctx);
2061    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2062    n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_IV, 6);
2078    if (ctx->ExecuteFlag) {
2079       CALL_ClearBufferiv(ctx->Exec, (buffer, drawbuffer, value));
2087    GET_CURRENT_CONTEXT(ctx);
2089    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2090    n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_UIV, 6);
2106    if (ctx->ExecuteFlag) {
2107       CALL_ClearBufferuiv(ctx->Exec, (buffer, drawbuffer, value));
2115    GET_CURRENT_CONTEXT(ctx);
2117    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2118    n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_FV, 6);
2134    if (ctx->ExecuteFlag) {
2135       CALL_ClearBufferfv(ctx->Exec, (buffer, drawbuffer, value));
2144    GET_CURRENT_CONTEXT(ctx);
2146    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2147    n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_FI, 4);
2154    if (ctx->ExecuteFlag) {
2155       CALL_ClearBufferfi(ctx->Exec, (buffer, drawbuffer, depth, stencil));
2163    GET_CURRENT_CONTEXT(ctx);
2165    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2166    n = alloc_instruction(ctx, OPCODE_CLEAR_ACCUM, 4);
2173    if (ctx->ExecuteFlag) {
2174       CALL_ClearAccum(ctx->Exec, (red, green, blue, alpha));
2182    GET_CURRENT_CONTEXT(ctx);
2184    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2185    n = alloc_instruction(ctx, OPCODE_CLEAR_COLOR, 4);
2192    if (ctx->ExecuteFlag) {
2193       CALL_ClearColor(ctx->Exec, (red, green, blue, alpha));
2201    GET_CURRENT_CONTEXT(ctx);
2203    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2204    n = alloc_instruction(ctx, OPCODE_CLEAR_DEPTH, 1);
2208    if (ctx->ExecuteFlag) {
2209       CALL_ClearDepth(ctx->Exec, (depth));
2217    GET_CURRENT_CONTEXT(ctx);
2219    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2220    n = alloc_instruction(ctx, OPCODE_CLEAR_INDEX, 1);
2224    if (ctx->ExecuteFlag) {
2225       CALL_ClearIndex(ctx->Exec, (c));
2233    GET_CURRENT_CONTEXT(ctx);
2235    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2236    n = alloc_instruction(ctx, OPCODE_CLEAR_STENCIL, 1);
2240    if (ctx->ExecuteFlag) {
2241       CALL_ClearStencil(ctx->Exec, (s));
2249    GET_CURRENT_CONTEXT(ctx);
2251    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2252    n = alloc_instruction(ctx, OPCODE_CLIP_PLANE, 5);
2260    if (ctx->ExecuteFlag) {
2261       CALL_ClipPlane(ctx->Exec, (plane, equ));
2271    GET_CURRENT_CONTEXT(ctx);
2273    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2274    n = alloc_instruction(ctx, OPCODE_COLOR_MASK, 4);
2281    if (ctx->ExecuteFlag) {
2282       CALL_ColorMask(ctx->Exec, (red, green, blue, alpha));
2291    GET_CURRENT_CONTEXT(ctx);
2293    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2294    n = alloc_instruction(ctx, OPCODE_COLOR_MASK_INDEXED, 5);
2302    if (ctx->ExecuteFlag) {
2303       /*CALL_ColorMaski(ctx->Exec, (buf, red, green, blue, alpha));*/
2311    GET_CURRENT_CONTEXT(ctx);
2313    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2315    n = alloc_instruction(ctx, OPCODE_COLOR_MATERIAL, 2);
2320    if (ctx->ExecuteFlag) {
2321       CALL_ColorMaterial(ctx->Exec, (face, mode));
2329    GET_CURRENT_CONTEXT(ctx);
2331    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2332    n = alloc_instruction(ctx, OPCODE_COPY_PIXELS, 5);
2340    if (ctx->ExecuteFlag) {
2341       CALL_CopyPixels(ctx->Exec, (x, y, width, height, type));
2351    GET_CURRENT_CONTEXT(ctx);
2353    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2354    n = alloc_instruction(ctx, OPCODE_COPY_TEX_IMAGE1D, 7);
2364    if (ctx->ExecuteFlag) {
2365       CALL_CopyTexImage1D(ctx->Exec, (target, level, internalformat,
2377    GET_CURRENT_CONTEXT(ctx);
2379    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2380    n = alloc_instruction(ctx, OPCODE_COPY_TEX_IMAGE2D, 8);
2391    if (ctx->ExecuteFlag) {
2392       CALL_CopyTexImage2D(ctx->Exec, (target, level, internalformat,
2403    GET_CURRENT_CONTEXT(ctx);
2405    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2406    n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE1D, 6);
2415    if (ctx->ExecuteFlag) {
2416       CALL_CopyTexSubImage1D(ctx->Exec,
2427    GET_CURRENT_CONTEXT(ctx);
2429    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2430    n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE2D, 8);
2441    if (ctx->ExecuteFlag) {
2442       CALL_CopyTexSubImage2D(ctx->Exec, (target, level, xoffset, yoffset,
2453    GET_CURRENT_CONTEXT(ctx);
2455    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2456    n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE3D, 9);
2468    if (ctx->ExecuteFlag) {
2469       CALL_CopyTexSubImage3D(ctx->Exec, (target, level,
2479    GET_CURRENT_CONTEXT(ctx);
2481    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2482    n = alloc_instruction(ctx, OPCODE_CULL_FACE, 1);
2486    if (ctx->ExecuteFlag) {
2487       CALL_CullFace(ctx->Exec, (mode));
2495    GET_CURRENT_CONTEXT(ctx);
2497    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2498    n = alloc_instruction(ctx, OPCODE_DEPTH_FUNC, 1);
2502    if (ctx->ExecuteFlag) {
2503       CALL_DepthFunc(ctx->Exec, (func));
2511    GET_CURRENT_CONTEXT(ctx);
2513    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2514    n = alloc_instruction(ctx, OPCODE_DEPTH_MASK, 1);
2518    if (ctx->ExecuteFlag) {
2519       CALL_DepthMask(ctx->Exec, (mask));
2527    GET_CURRENT_CONTEXT(ctx);
2529    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2530    n = alloc_instruction(ctx, OPCODE_DEPTH_RANGE, 2);
2535    if (ctx->ExecuteFlag) {
2536       CALL_DepthRange(ctx->Exec, (nearval, farval));
2544    GET_CURRENT_CONTEXT(ctx);
2546    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2547    n = alloc_instruction(ctx, OPCODE_DISABLE, 1);
2551    if (ctx->ExecuteFlag) {
2552       CALL_Disable(ctx->Exec, (cap));
2560    GET_CURRENT_CONTEXT(ctx);
2562    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2563    n = alloc_instruction(ctx, OPCODE_DISABLE_INDEXED, 2);
2568    if (ctx->ExecuteFlag) {
2569       CALL_Disablei(ctx->Exec, (index, cap));
2577    GET_CURRENT_CONTEXT(ctx);
2579    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2580    n = alloc_instruction(ctx, OPCODE_DRAW_BUFFER, 1);
2584    if (ctx->ExecuteFlag) {
2585       CALL_DrawBuffer(ctx->Exec, (mode));
2594    GET_CURRENT_CONTEXT(ctx);
2597    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2599    n = alloc_instruction(ctx, OPCODE_DRAW_PIXELS, 4 + POINTER_DWORDS);
2606                    unpack_image(ctx, 2, width, height, 1, format, type,
2607                                 pixels, &ctx->Unpack));
2609    if (ctx->ExecuteFlag) {
2610       CALL_DrawPixels(ctx->Exec, (width, height, format, type, pixels));
2619    GET_CURRENT_CONTEXT(ctx);
2621    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2622    n = alloc_instruction(ctx, OPCODE_ENABLE, 1);
2626    if (ctx->ExecuteFlag) {
2627       CALL_Enable(ctx->Exec, (cap));
2636    GET_CURRENT_CONTEXT(ctx);
2638    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2639    n = alloc_instruction(ctx, OPCODE_ENABLE_INDEXED, 2);
2644    if (ctx->ExecuteFlag) {
2645       CALL_Enablei(ctx->Exec, (index, cap));
2654    GET_CURRENT_CONTEXT(ctx);
2656    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2657    n = alloc_instruction(ctx, OPCODE_EVALMESH1, 3);
2663    if (ctx->ExecuteFlag) {
2664       CALL_EvalMesh1(ctx->Exec, (mode, i1, i2));
2672    GET_CURRENT_CONTEXT(ctx);
2674    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2675    n = alloc_instruction(ctx, OPCODE_EVALMESH2, 5);
2683    if (ctx->ExecuteFlag) {
2684       CALL_EvalMesh2(ctx->Exec, (mode, i1, i2, j1, j2));
2694    GET_CURRENT_CONTEXT(ctx);
2696    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2697    n = alloc_instruction(ctx, OPCODE_FOG, 5);
2705    if (ctx->ExecuteFlag) {
2706       CALL_Fogfv(ctx->Exec, (pname, params));
2764    GET_CURRENT_CONTEXT(ctx);
2766    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2767    n = alloc_instruction(ctx, OPCODE_FRONT_FACE, 1);
2771    if (ctx->ExecuteFlag) {
2772       CALL_FrontFace(ctx->Exec, (mode));
2781    GET_CURRENT_CONTEXT(ctx);
2783    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2784    n = alloc_instruction(ctx, OPCODE_FRUSTUM, 6);
2793    if (ctx->ExecuteFlag) {
2794       CALL_Frustum(ctx->Exec, (left, right, bottom, top, nearval, farval));
2802    GET_CURRENT_CONTEXT(ctx);
2804    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2805    n = alloc_instruction(ctx, OPCODE_HINT, 2);
2810    if (ctx->ExecuteFlag) {
2811       CALL_Hint(ctx->Exec, (target, mode));
2819    GET_CURRENT_CONTEXT(ctx);
2821    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2822    n = alloc_instruction(ctx, OPCODE_INDEX_MASK, 1);
2826    if (ctx->ExecuteFlag) {
2827       CALL_IndexMask(ctx->Exec, (mask));
2835    GET_CURRENT_CONTEXT(ctx);
2836    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2837    (void) alloc_instruction(ctx, OPCODE_INIT_NAMES, 0);
2838    if (ctx->ExecuteFlag) {
2839       CALL_InitNames(ctx->Exec, ());
2847    GET_CURRENT_CONTEXT(ctx);
2849    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2850    n = alloc_instruction(ctx, OPCODE_LIGHT, 6);
2893    if (ctx->ExecuteFlag) {
2894       CALL_Lightfv(ctx->Exec, (light, pname, params));
2961    GET_CURRENT_CONTEXT(ctx);
2963    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2964    n = alloc_instruction(ctx, OPCODE_LIGHT_MODEL, 5);
2972    if (ctx->ExecuteFlag) {
2973       CALL_LightModelfv(ctx->Exec, (pname, params));
3028    GET_CURRENT_CONTEXT(ctx);
3030    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3031    n = alloc_instruction(ctx, OPCODE_LINE_STIPPLE, 2);
3036    if (ctx->ExecuteFlag) {
3037       CALL_LineStipple(ctx->Exec, (factor, pattern));
3045    GET_CURRENT_CONTEXT(ctx);
3047    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3048    n = alloc_instruction(ctx, OPCODE_LINE_WIDTH, 1);
3052    if (ctx->ExecuteFlag) {
3053       CALL_LineWidth(ctx->Exec, (width));
3061    GET_CURRENT_CONTEXT(ctx);
3063    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3064    n = alloc_instruction(ctx, OPCODE_LIST_BASE, 1);
3068    if (ctx->ExecuteFlag) {
3069       CALL_ListBase(ctx->Exec, (base));
3077    GET_CURRENT_CONTEXT(ctx);
3078    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3079    (void) alloc_instruction(ctx, OPCODE_LOAD_IDENTITY, 0);
3080    if (ctx->ExecuteFlag) {
3081       CALL_LoadIdentity(ctx->Exec, ());
3089    GET_CURRENT_CONTEXT(ctx);
3091    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3092    n = alloc_instruction(ctx, OPCODE_LOAD_MATRIX, 16);
3099    if (ctx->ExecuteFlag) {
3100       CALL_LoadMatrixf(ctx->Exec, (m));
3120    GET_CURRENT_CONTEXT(ctx);
3122    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3123    n = alloc_instruction(ctx, OPCODE_LOAD_NAME, 1);
3127    if (ctx->ExecuteFlag) {
3128       CALL_LoadName(ctx->Exec, (name));
3136    GET_CURRENT_CONTEXT(ctx);
3138    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3139    n = alloc_instruction(ctx, OPCODE_LOGIC_OP, 1);
3143    if (ctx->ExecuteFlag) {
3144       CALL_LogicOp(ctx->Exec, (opcode));
3153    GET_CURRENT_CONTEXT(ctx);
3155    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3156    n = alloc_instruction(ctx, OPCODE_MAP1, 5 + POINTER_DWORDS);
3166    if (ctx->ExecuteFlag) {
3167       CALL_Map1d(ctx->Exec, (target, u1, u2, stride, order, points));
3175    GET_CURRENT_CONTEXT(ctx);
3177    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3178    n = alloc_instruction(ctx, OPCODE_MAP1, 5 + POINTER_DWORDS);
3188    if (ctx->ExecuteFlag) {
3189       CALL_Map1f(ctx->Exec, (target, u1, u2, stride, order, points));
3200    GET_CURRENT_CONTEXT(ctx);
3202    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3203    n = alloc_instruction(ctx, OPCODE_MAP2, 9 + POINTER_DWORDS);
3219    if (ctx->ExecuteFlag) {
3220       CALL_Map2d(ctx->Exec, (target,
3233    GET_CURRENT_CONTEXT(ctx);
3235    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3236    n = alloc_instruction(ctx, OPCODE_MAP2, 9 + POINTER_DWORDS);
3252    if (ctx->ExecuteFlag) {
3253       CALL_Map2f(ctx->Exec, (target, u1, u2, ustride, uorder,
3262    GET_CURRENT_CONTEXT(ctx);
3264    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3265    n = alloc_instruction(ctx, OPCODE_MAPGRID1, 3);
3271    if (ctx->ExecuteFlag) {
3272       CALL_MapGrid1f(ctx->Exec, (un, u1, u2));
3288    GET_CURRENT_CONTEXT(ctx);
3290    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3291    n = alloc_instruction(ctx, OPCODE_MAPGRID2, 6);
3300    if (ctx->ExecuteFlag) {
3301       CALL_MapGrid2f(ctx->Exec, (un, u1, u2, vn, v1, v2));
3319    GET_CURRENT_CONTEXT(ctx);
3321    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3322    n = alloc_instruction(ctx, OPCODE_MATRIX_MODE, 1);
3326    if (ctx->ExecuteFlag) {
3327       CALL_MatrixMode(ctx->Exec, (mode));
3335    GET_CURRENT_CONTEXT(ctx);
3337    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3338    n = alloc_instruction(ctx, OPCODE_MULT_MATRIX, 16);
3345    if (ctx->ExecuteFlag) {
3346       CALL_MultMatrixf(ctx->Exec, (m));
3366    GET_CURRENT_CONTEXT(ctx);
3368    _mesa_error(ctx, GL_INVALID_OPERATION, "glNewList");
3379    GET_CURRENT_CONTEXT(ctx);
3381    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3382    n = alloc_instruction(ctx, OPCODE_ORTHO, 6);
3391    if (ctx->ExecuteFlag) {
3392       CALL_Ortho(ctx->Exec, (left, right, bottom, top, nearval, farval));
3400    GET_CURRENT_CONTEXT(ctx);
3402    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3403    n = alloc_instruction(ctx, OPCODE_PATCH_PARAMETER_I, 2);
3408    if (ctx->ExecuteFlag) {
3409       CALL_PatchParameteri(ctx->Exec, (pname, value));
3417    GET_CURRENT_CONTEXT(ctx);
3419    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3422       n = alloc_instruction(ctx, OPCODE_PATCH_PARAMETER_FV_OUTER, 5);
3425       n = alloc_instruction(ctx, OPCODE_PATCH_PARAMETER_FV_INNER, 3);
3439    if (ctx->ExecuteFlag) {
3440       CALL_PatchParameterfv(ctx->Exec, (pname, params));
3448    GET_CURRENT_CONTEXT(ctx);
3450    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3451    n = alloc_instruction(ctx, OPCODE_PIXEL_MAP, 2 + POINTER_DWORDS);
3457    if (ctx->ExecuteFlag) {
3458       CALL_PixelMapfv(ctx->Exec, (map, mapsize, values));
3504    GET_CURRENT_CONTEXT(ctx);
3506    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3507    n = alloc_instruction(ctx, OPCODE_PIXEL_TRANSFER, 2);
3512    if (ctx->ExecuteFlag) {
3513       CALL_PixelTransferf(ctx->Exec, (pname, param));
3528    GET_CURRENT_CONTEXT(ctx);
3530    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3531    n = alloc_instruction(ctx, OPCODE_PIXEL_ZOOM, 2);
3536    if (ctx->ExecuteFlag) {
3537       CALL_PixelZoom(ctx->Exec, (xfactor, yfactor));
3545    GET_CURRENT_CONTEXT(ctx);
3547    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3548    n = alloc_instruction(ctx, OPCODE_POINT_PARAMETERS, 4);
3555    if (ctx->ExecuteFlag) {
3556       CALL_PointParameterfv(ctx->Exec, (pname, params));
3592    GET_CURRENT_CONTEXT(ctx);
3594    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3595    n = alloc_instruction(ctx, OPCODE_POINT_SIZE, 1);
3599    if (ctx->ExecuteFlag) {
3600       CALL_PointSize(ctx->Exec, (size));
3608    GET_CURRENT_CONTEXT(ctx);
3610    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3611    n = alloc_instruction(ctx, OPCODE_POLYGON_MODE, 2);
3616    if (ctx->ExecuteFlag) {
3617       CALL_PolygonMode(ctx->Exec, (face, mode));
3625    GET_CURRENT_CONTEXT(ctx);
3628    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3630    n = alloc_instruction(ctx, OPCODE_POLYGON_STIPPLE, POINTER_DWORDS);
3633                    unpack_image(ctx, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
3634                                 pattern, &ctx->Unpack));
3636    if (ctx->ExecuteFlag) {
3637       CALL_PolygonStipple(ctx->Exec, ((GLubyte *) pattern));
3645    GET_CURRENT_CONTEXT(ctx);
3647    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3648    n = alloc_instruction(ctx, OPCODE_POLYGON_OFFSET, 2);
3653    if (ctx->ExecuteFlag) {
3654       CALL_PolygonOffset(ctx->Exec, (factor, units));
3662    GET_CURRENT_CONTEXT(ctx);
3664    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3665    n = alloc_instruction(ctx, OPCODE_POLYGON_OFFSET_CLAMP, 3);
3671    if (ctx->ExecuteFlag) {
3672       CALL_PolygonOffsetClampEXT(ctx->Exec, (factor, units, clamp));
3679    GET_CURRENT_CONTEXT(ctx);
3680    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3681    (void) alloc_instruction(ctx, OPCODE_POP_ATTRIB, 0);
3682    if (ctx->ExecuteFlag) {
3683       CALL_PopAttrib(ctx->Exec, ());
3691    GET_CURRENT_CONTEXT(ctx);
3692    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3693    (void) alloc_instruction(ctx, OPCODE_POP_MATRIX, 0);
3694    if (ctx->ExecuteFlag) {
3695       CALL_PopMatrix(ctx->Exec, ());
3703    GET_CURRENT_CONTEXT(ctx);
3704    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3705    (void) alloc_instruction(ctx, OPCODE_POP_NAME, 0);
3706    if (ctx->ExecuteFlag) {
3707       CALL_PopName(ctx->Exec, ());
3716    GET_CURRENT_CONTEXT(ctx);
3718    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3722       n = alloc_instruction(ctx, OPCODE_PRIORITIZE_TEXTURE, 2);
3728    if (ctx->ExecuteFlag) {
3729       CALL_PrioritizeTextures(ctx->Exec, (num, textures, priorities));
3737    GET_CURRENT_CONTEXT(ctx);
3739    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3740    n = alloc_instruction(ctx, OPCODE_PUSH_ATTRIB, 1);
3744    if (ctx->ExecuteFlag) {
3745       CALL_PushAttrib(ctx->Exec, (mask));
3753    GET_CURRENT_CONTEXT(ctx);
3754    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3755    (void) alloc_instruction(ctx, OPCODE_PUSH_MATRIX, 0);
3756    if (ctx->ExecuteFlag) {
3757       CALL_PushMatrix(ctx->Exec, ());
3765    GET_CURRENT_CONTEXT(ctx);
3767    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3768    n = alloc_instruction(ctx, OPCODE_PUSH_NAME, 1);
3772    if (ctx->ExecuteFlag) {
3773       CALL_PushName(ctx->Exec, (name));
3781    GET_CURRENT_CONTEXT(ctx);
3783    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3784    n = alloc_instruction(ctx, OPCODE_RASTER_POS, 4);
3791    if (ctx->ExecuteFlag) {
3792       CALL_RasterPos4f(ctx->Exec, (x, y, z, w));
3940    GET_CURRENT_CONTEXT(ctx);
3942    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3943    n = alloc_instruction(ctx, OPCODE_PASSTHROUGH, 1);
3947    if (ctx->ExecuteFlag) {
3948       CALL_PassThrough(ctx->Exec, (token));
3956    GET_CURRENT_CONTEXT(ctx);
3958    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3959    n = alloc_instruction(ctx, OPCODE_READ_BUFFER, 1);
3963    if (ctx->ExecuteFlag) {
3964       CALL_ReadBuffer(ctx->Exec, (mode));
3972    GET_CURRENT_CONTEXT(ctx);
3974    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3975    n = alloc_instruction(ctx, OPCODE_ROTATE, 4);
3982    if (ctx->ExecuteFlag) {
3983       CALL_Rotatef(ctx->Exec, (angle, x, y, z));
3998    GET_CURRENT_CONTEXT(ctx);
4000    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4001    n = alloc_instruction(ctx, OPCODE_SCALE, 3);
4007    if (ctx->ExecuteFlag) {
4008       CALL_Scalef(ctx->Exec, (x, y, z));
4023    GET_CURRENT_CONTEXT(ctx);
4025    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4026    n = alloc_instruction(ctx, OPCODE_SCISSOR, 4);
4033    if (ctx->ExecuteFlag) {
4034       CALL_Scissor(ctx->Exec, (x, y, width, height));
4042    GET_CURRENT_CONTEXT(ctx);
4044    ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx);
4046    if (ctx->ExecuteFlag) {
4047       CALL_ShadeModel(ctx->Exec, (mode));
4054    if (ctx->ListState.Current.ShadeModel == mode)
4057    SAVE_FLUSH_VERTICES(ctx);
4059    ctx->ListState.Current.ShadeModel = mode;
4061    n = alloc_instruction(ctx, OPCODE_SHADE_MODEL, 1);
4071    GET_CURRENT_CONTEXT(ctx);
4073    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4074    n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC, 3);
4080    if (ctx->ExecuteFlag) {
4081       CALL_StencilFunc(ctx->Exec, (func, ref, mask));
4089    GET_CURRENT_CONTEXT(ctx);
4091    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4092    n = alloc_instruction(ctx, OPCODE_STENCIL_MASK, 1);
4096    if (ctx->ExecuteFlag) {
4097       CALL_StencilMask(ctx->Exec, (mask));
4105    GET_CURRENT_CONTEXT(ctx);
4107    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4108    n = alloc_instruction(ctx, OPCODE_STENCIL_OP, 3);
4114    if (ctx->ExecuteFlag) {
4115       CALL_StencilOp(ctx->Exec, (fail, zfail, zpass));
4123    GET_CURRENT_CONTEXT(ctx);
4125    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4126    n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
4133    if (ctx->ExecuteFlag) {
4134       CALL_StencilFuncSeparate(ctx->Exec, (face, func, ref, mask));
4143    GET_CURRENT_CONTEXT(ctx);
4145    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4147    n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
4155    n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
4162    if (ctx->ExecuteFlag) {
4163       CALL_StencilFuncSeparate(ctx->Exec, (GL_FRONT, frontfunc, ref, mask));
4164       CALL_StencilFuncSeparate(ctx->Exec, (GL_BACK, backfunc, ref, mask));
4172    GET_CURRENT_CONTEXT(ctx);
4174    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4175    n = alloc_instruction(ctx, OPCODE_STENCIL_MASK_SEPARATE, 2);
4180    if (ctx->ExecuteFlag) {
4181       CALL_StencilMaskSeparate(ctx->Exec, (face, mask));
4189    GET_CURRENT_CONTEXT(ctx);
4191    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4192    n = alloc_instruction(ctx, OPCODE_STENCIL_OP_SEPARATE, 4);
4199    if (ctx->ExecuteFlag) {
4200       CALL_StencilOpSeparate(ctx->Exec, (face, fail, zfail, zpass));
4208    GET_CURRENT_CONTEXT(ctx);
4210    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4211    n = alloc_instruction(ctx, OPCODE_TEXENV, 6);
4226    if (ctx->ExecuteFlag) {
4227       CALL_TexEnvfv(ctx->Exec, (target, pname, params));
4273    GET_CURRENT_CONTEXT(ctx);
4275    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4276    n = alloc_instruction(ctx, OPCODE_TEXGEN, 6);
4285    if (ctx->ExecuteFlag) {
4286       CALL_TexGenfv(ctx->Exec, (coord, pname, params));
4348    GET_CURRENT_CONTEXT(ctx);
4350    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4351    n = alloc_instruction(ctx, OPCODE_TEXPARAMETER, 6);
4360    if (ctx->ExecuteFlag) {
4361       CALL_TexParameterfv(ctx->Exec, (target, pname, params));
4402    GET_CURRENT_CONTEXT(ctx);
4405       CALL_TexImage1D(ctx->Exec, (target, level, components, width,
4410       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4411       n = alloc_instruction(ctx, OPCODE_TEX_IMAGE1D, 7 + POINTER_DWORDS);
4421                       unpack_image(ctx, 1, width, 1, 1, format, type,
4422                                    pixels, &ctx->Unpack));
4424       if (ctx->ExecuteFlag) {
4425          CALL_TexImage1D(ctx->Exec, (target, level, components, width,
4438    GET_CURRENT_CONTEXT(ctx);
4441       CALL_TexImage2D(ctx->Exec, (target, level, components, width,
4446       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4447       n = alloc_instruction(ctx, OPCODE_TEX_IMAGE2D, 8 + POINTER_DWORDS);
4458                       unpack_image(ctx, 2, width, height, 1, format, type,
4459                                    pixels, &ctx->Unpack));
4461       if (ctx->ExecuteFlag) {
4462          CALL_TexImage2D(ctx->Exec, (target, level, components, width,
4476    GET_CURRENT_CONTEXT(ctx);
4479       CALL_TexImage3D(ctx->Exec, (target, level, internalFormat, width,
4485       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4486       n = alloc_instruction(ctx, OPCODE_TEX_IMAGE3D, 9 + POINTER_DWORDS);
4498                       unpack_image(ctx, 3, width, height, depth, format, type,
4499                                    pixels, &ctx->Unpack));
4501       if (ctx->ExecuteFlag) {
4502          CALL_TexImage3D(ctx->Exec, (target, level, internalFormat, width,
4515    GET_CURRENT_CONTEXT(ctx);
4518    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4520    n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE1D, 6 + POINTER_DWORDS);
4529                    unpack_image(ctx, 1, width, 1, 1, format, type,
4530                                 pixels, &ctx->Unpack));
4532    if (ctx->ExecuteFlag) {
4533       CALL_TexSubImage1D(ctx->Exec, (target, level, xoffset, width,
4545    GET_CURRENT_CONTEXT(ctx);
4548    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4550    n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE2D, 8 + POINTER_DWORDS);
4561                    unpack_image(ctx, 2, width, height, 1, format, type,
4562                                 pixels, &ctx->Unpack));
4564    if (ctx->ExecuteFlag) {
4565       CALL_TexSubImage2D(ctx->Exec, (target, level, xoffset, yoffset,
4577    GET_CURRENT_CONTEXT(ctx);
4580    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4582    n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE3D, 10 + POINTER_DWORDS);
4595                    unpack_image(ctx, 3, width, height, depth, format, type,
4596                                 pixels, &ctx->Unpack));
4598    if (ctx->ExecuteFlag) {
4599       CALL_TexSubImage3D(ctx->Exec, (target, level,
4610    GET_CURRENT_CONTEXT(ctx);
4612    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4613    n = alloc_instruction(ctx, OPCODE_TRANSLATE, 3);
4619    if (ctx->ExecuteFlag) {
4620       CALL_Translatef(ctx->Exec, (x, y, z));
4636    GET_CURRENT_CONTEXT(ctx);
4638    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4639    n = alloc_instruction(ctx, OPCODE_VIEWPORT, 4);
4646    if (ctx->ExecuteFlag) {
4647       CALL_Viewport(ctx->Exec, (x, y, width, height));
4655    GET_CURRENT_CONTEXT(ctx);
4657    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4658    n = alloc_instruction(ctx, OPCODE_VIEWPORT_INDEXED_F, 5);
4666    if (ctx->ExecuteFlag) {
4667       CALL_ViewportIndexedf(ctx->Exec, (index, x, y, width, height));
4674    GET_CURRENT_CONTEXT(ctx);
4676    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4677    n = alloc_instruction(ctx, OPCODE_VIEWPORT_INDEXED_FV, 5);
4685    if (ctx->ExecuteFlag) {
4686       CALL_ViewportIndexedfv(ctx->Exec, (index, v));
4693    GET_CURRENT_CONTEXT(ctx);
4695    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4696    n = alloc_instruction(ctx, OPCODE_VIEWPORT_ARRAY_V, 2 + POINTER_DWORDS);
4702    if (ctx->ExecuteFlag) {
4703       CALL_ViewportArrayv(ctx->Exec, (first, count, v));
4711    GET_CURRENT_CONTEXT(ctx);
4713    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4714    n = alloc_instruction(ctx, OPCODE_SCISSOR_INDEXED, 5);
4722    if (ctx->ExecuteFlag) {
4723       CALL_ScissorIndexed(ctx->Exec, (index, left, bottom, width, height));
4730    GET_CURRENT_CONTEXT(ctx);
4732    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4733    n = alloc_instruction(ctx, OPCODE_SCISSOR_INDEXED_V, 5);
4741    if (ctx->ExecuteFlag) {
4742       CALL_ScissorIndexedv(ctx->Exec, (index, v));
4749    GET_CURRENT_CONTEXT(ctx);
4751    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4752    n = alloc_instruction(ctx, OPCODE_SCISSOR_ARRAY_V, 2 + POINTER_DWORDS);
4758    if (ctx->ExecuteFlag) {
4759       CALL_ScissorArrayv(ctx->Exec, (first, count, v));
4766    GET_CURRENT_CONTEXT(ctx);
4768    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4769    node = alloc_instruction(ctx, OPCODE_DEPTH_INDEXED, 3);
4778    if (ctx->ExecuteFlag) {
4779       CALL_DepthRangeIndexed(ctx->Exec, (index, n, f));
4786    GET_CURRENT_CONTEXT(ctx);
4788    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4789    n = alloc_instruction(ctx, OPCODE_DEPTH_ARRAY_V, 2 + POINTER_DWORDS);
4795    if (ctx->ExecuteFlag) {
4796       CALL_DepthRangeArrayv(ctx->Exec, (first, count, v));
4803    GET_CURRENT_CONTEXT(ctx);
4805    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4806    n = alloc_instruction(ctx, OPCODE_WINDOW_POS, 4);
4813    if (ctx->ExecuteFlag) {
4814       CALL_WindowPos4fMESA(ctx->Exec, (x, y, z, w));
4964    GET_CURRENT_CONTEXT(ctx);
4966    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4967    n = alloc_instruction(ctx, OPCODE_ACTIVE_TEXTURE, 1);
4971    if (ctx->ExecuteFlag) {
4972       CALL_ActiveTexture(ctx->Exec, (target));
5016    GET_CURRENT_CONTEXT(ctx);
5024       _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", func);
5040    GET_CURRENT_CONTEXT(ctx);
5043       CALL_CompressedTexImage1D(ctx->Exec, (target, level, internalFormat,
5049       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5051       n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_1D,
5063       if (ctx->ExecuteFlag) {
5064          CALL_CompressedTexImage1D(ctx->Exec,
5078    GET_CURRENT_CONTEXT(ctx);
5081       CALL_CompressedTexImage2D(ctx->Exec, (target, level, internalFormat,
5087       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5089       n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_2D,
5102       if (ctx->ExecuteFlag) {
5103          CALL_CompressedTexImage2D(ctx->Exec,
5117    GET_CURRENT_CONTEXT(ctx);
5120       CALL_CompressedTexImage3D(ctx->Exec, (target, level, internalFormat,
5126       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5128       n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_3D,
5142       if (ctx->ExecuteFlag) {
5143          CALL_CompressedTexImage3D(ctx->Exec,
5158    GET_CURRENT_CONTEXT(ctx);
5159    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5161    n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D,
5173    if (ctx->ExecuteFlag) {
5174       CALL_CompressedTexSubImage1D(ctx->Exec, (target, level, xoffset,
5188    GET_CURRENT_CONTEXT(ctx);
5189    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5191    n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D,
5205    if (ctx->ExecuteFlag) {
5206       CALL_CompressedTexSubImage2D(ctx->Exec,
5220    GET_CURRENT_CONTEXT(ctx);
5221    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5223    n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D,
5239    if (ctx->ExecuteFlag) {
5240       CALL_CompressedTexSubImage3D(ctx->Exec,
5252    GET_CURRENT_CONTEXT(ctx);
5254    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5255    n = alloc_instruction(ctx, OPCODE_SAMPLE_COVERAGE, 2);
5260    if (ctx->ExecuteFlag) {
5261       CALL_SampleCoverage(ctx->Exec, (value, invert));
5272    GET_CURRENT_CONTEXT(ctx);
5274    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5275    n = alloc_instruction(ctx, OPCODE_BIND_PROGRAM_ARB, 2);
5280    if (ctx->ExecuteFlag) {
5281       CALL_BindProgramARB(ctx->Exec, (target, id));
5289    GET_CURRENT_CONTEXT(ctx);
5291    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5292    n = alloc_instruction(ctx, OPCODE_PROGRAM_ENV_PARAMETER_ARB, 6);
5301    if (ctx->ExecuteFlag) {
5302       CALL_ProgramEnvParameter4fARB(ctx->Exec, (target, index, x, y, z, w));
5320    GET_CURRENT_CONTEXT(ctx);
5322    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5329          n = alloc_instruction(ctx, OPCODE_PROGRAM_ENV_PARAMETER_ARB, 6);
5342    if (ctx->ExecuteFlag) {
5343       CALL_ProgramEnvParameters4fvEXT(ctx->Exec, (target, index, count, params));
5373    GET_CURRENT_CONTEXT(ctx);
5375    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5376    n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
5385    if (ctx->ExecuteFlag) {
5386       CALL_ProgramLocalParameter4fARB(ctx->Exec, (target, index, x, y, z, w));
5395    GET_CURRENT_CONTEXT(ctx);
5397    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5398    n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
5407    if (ctx->ExecuteFlag) {
5408       CALL_ProgramLocalParameter4fvARB(ctx->Exec, (target, index, params));
5417    GET_CURRENT_CONTEXT(ctx);
5419    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5426          n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
5439    if (ctx->ExecuteFlag) {
5440       CALL_ProgramLocalParameters4fvEXT(ctx->Exec, (target, index, count, params));
5450    GET_CURRENT_CONTEXT(ctx);
5452    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5453    n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
5462    if (ctx->ExecuteFlag) {
5463       CALL_ProgramLocalParameter4dARB(ctx->Exec, (target, index, x, y, z, w));
5472    GET_CURRENT_CONTEXT(ctx);
5474    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5475    n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
5484    if (ctx->ExecuteFlag) {
5485       CALL_ProgramLocalParameter4dvARB(ctx->Exec, (target, index, params));
5494    GET_CURRENT_CONTEXT(ctx);
5496    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5497    n = alloc_instruction(ctx, OPCODE_ACTIVE_STENCIL_FACE_EXT, 1);
5501    if (ctx->ExecuteFlag) {
5502       CALL_ActiveStencilFaceEXT(ctx->Exec, (face));
5511    GET_CURRENT_CONTEXT(ctx);
5513    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5514    n = alloc_instruction(ctx, OPCODE_DEPTH_BOUNDS_EXT, 2);
5519    if (ctx->ExecuteFlag) {
5520       CALL_DepthBoundsEXT(ctx->Exec, (zmin, zmax));
5530    GET_CURRENT_CONTEXT(ctx);
5533    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5535    n = alloc_instruction(ctx, OPCODE_PROGRAM_STRING_ARB, 3 + POINTER_DWORDS);
5539          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");
5548    if (ctx->ExecuteFlag) {
5549       CALL_ProgramStringARB(ctx->Exec, (target, format, len, string));
5557    GET_CURRENT_CONTEXT(ctx);
5559    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5560    n = alloc_instruction(ctx, OPCODE_BEGIN_QUERY_ARB, 2);
5565    if (ctx->ExecuteFlag) {
5566       CALL_BeginQuery(ctx->Exec, (target, id));
5573    GET_CURRENT_CONTEXT(ctx);
5575    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5576    n = alloc_instruction(ctx, OPCODE_END_QUERY_ARB, 1);
5580    if (ctx->ExecuteFlag) {
5581       CALL_EndQuery(ctx->Exec, (target));
5588    GET_CURRENT_CONTEXT(ctx);
5590    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5591    n = alloc_instruction(ctx, OPCODE_QUERY_COUNTER, 2);
5596    if (ctx->ExecuteFlag) {
5597       CALL_QueryCounter(ctx->Exec, (id, target));
5604    GET_CURRENT_CONTEXT(ctx);
5606    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5607    n = alloc_instruction(ctx, OPCODE_BEGIN_QUERY_INDEXED, 3);
5613    if (ctx->ExecuteFlag) {
5614       CALL_BeginQueryIndexed(ctx->Exec, (target, index, id));
5621    GET_CURRENT_CONTEXT(ctx);
5623    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5624    n = alloc_instruction(ctx, OPCODE_END_QUERY_INDEXED, 2);
5629    if (ctx->ExecuteFlag) {
5630       CALL_EndQueryIndexed(ctx->Exec, (target, index));
5638    GET_CURRENT_CONTEXT(ctx);
5640    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5641    n = alloc_instruction(ctx, OPCODE_DRAW_BUFFERS_ARB, 1 + MAX_DRAW_BUFFERS);
5651    if (ctx->ExecuteFlag) {
5652       CALL_DrawBuffers(ctx->Exec, (count, buffers));
5659    GET_CURRENT_CONTEXT(ctx);
5662    n = alloc_instruction(ctx, OPCODE_BIND_FRAGMENT_SHADER_ATI, 1);
5666    if (ctx->ExecuteFlag) {
5667       CALL_BindFragmentShaderATI(ctx->Exec, (id));
5674    GET_CURRENT_CONTEXT(ctx);
5677    n = alloc_instruction(ctx, OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI, 5);
5685    if (ctx->ExecuteFlag) {
5686       CALL_SetFragmentShaderConstantATI(ctx->Exec, (dst, value));
5693    GET_CURRENT_CONTEXT(ctx);
5695    SAVE_FLUSH_VERTICES(ctx);
5696    n = alloc_instruction(ctx, OPCODE_EVAL_C1, 1);
5700    if (ctx->ExecuteFlag) {
5701       CALL_EvalCoord1f(ctx->Exec, (x));
5714    GET_CURRENT_CONTEXT(ctx);
5716    SAVE_FLUSH_VERTICES(ctx);
5717    n = alloc_instruction(ctx, OPCODE_EVAL_C2, 2);
5722    if (ctx->ExecuteFlag) {
5723       CALL_EvalCoord2f(ctx->Exec, (x, y));
5737    GET_CURRENT_CONTEXT(ctx);
5739    SAVE_FLUSH_VERTICES(ctx);
5740    n = alloc_instruction(ctx, OPCODE_EVAL_P1, 1);
5744    if (ctx->ExecuteFlag) {
5745       CALL_EvalPoint1(ctx->Exec, (x));
5752    GET_CURRENT_CONTEXT(ctx);
5754    SAVE_FLUSH_VERTICES(ctx);
5755    n = alloc_instruction(ctx, OPCODE_EVAL_P2, 2);
5760    if (ctx->ExecuteFlag) {
5761       CALL_EvalPoint2(ctx->Exec, (x, y));
5784    GET_CURRENT_CONTEXT(ctx);
5795       _mesa_compile_error(ctx, GL_INVALID_ENUM, "glMaterial(face)");
5814       _mesa_compile_error(ctx, GL_INVALID_ENUM, "glMaterial(pname)");
5818    if (ctx->ExecuteFlag) {
5819       CALL_Materialfv(ctx->Exec, (face, pname, param));
5822    bitmask = _mesa_material_bitmask(ctx, face, pname, ~0, NULL);
5826     * about ctx->Driver.CurrentSavePrimitive here.
5830          if (ctx->ListState.ActiveMaterialSize[i] == args &&
5831              compare_vec(ctx->ListState.CurrentMaterial[i], param, args)) {
5836             ctx->ListState.ActiveMaterialSize[i] = args;
5837             COPY_SZ_4V(ctx->ListState.CurrentMaterial[i], args, param);
5846    SAVE_FLUSH_VERTICES(ctx);
5848    n = alloc_instruction(ctx, OPCODE_MATERIAL, 6);
5860    GET_CURRENT_CONTEXT(ctx);
5862    if (!_mesa_is_valid_prim_mode(ctx, mode)) {
5864       _mesa_compile_error(ctx, GL_INVALID_ENUM, "glBegin(mode)");
5866    else if (_mesa_inside_dlist_begin_end(ctx)) {
5868       _mesa_compile_error(ctx, GL_INVALID_OPERATION, "recursive glBegin");
5871       ctx->Driver.CurrentSavePrimitive = mode;
5873       vbo_save_NotifyBegin(ctx, mode, false);
5880    GET_CURRENT_CONTEXT(ctx);
5881    SAVE_FLUSH_VERTICES(ctx);
5882    (void) alloc_instruction(ctx, OPCODE_END, 0);
5883    ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
5884    if (ctx->ExecuteFlag) {
5885       CALL_End(ctx->Exec, ());
5893    GET_CURRENT_CONTEXT(ctx);
5894    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5895    (void) alloc_instruction(ctx, OPCODE_PRIMITIVE_RESTART_NV, 0);
5896    if (ctx->ExecuteFlag) {
5897       CALL_PrimitiveRestartNV(ctx->Exec, ());
5907    GET_CURRENT_CONTEXT(ctx);
5909    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5910    n = alloc_instruction(ctx, OPCODE_BLIT_FRAMEBUFFER, 10);
5923    if (ctx->ExecuteFlag) {
5924       CALL_BlitFramebuffer(ctx->Exec, (srcX0, srcY0, srcX1, srcY1,
5935    GET_CURRENT_CONTEXT(ctx);
5937    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5938    n = alloc_instruction(ctx, OPCODE_PROVOKING_VERTEX, 1);
5942    if (ctx->ExecuteFlag) {
5943       /*CALL_ProvokingVertex(ctx->Exec, (mode));*/
5953    GET_CURRENT_CONTEXT(ctx);
5955    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5956    n = alloc_instruction(ctx, OPCODE_BEGIN_TRANSFORM_FEEDBACK, 1);
5960    if (ctx->ExecuteFlag) {
5961       CALL_BeginTransformFeedback(ctx->Exec, (mode));
5970    GET_CURRENT_CONTEXT(ctx);
5971    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5972    (void) alloc_instruction(ctx, OPCODE_END_TRANSFORM_FEEDBACK, 0);
5973    if (ctx->ExecuteFlag) {
5974       CALL_EndTransformFeedback(ctx->Exec, ());
5981    GET_CURRENT_CONTEXT(ctx);
5983    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5984    n = alloc_instruction(ctx, OPCODE_BIND_TRANSFORM_FEEDBACK, 2);
5989    if (ctx->ExecuteFlag) {
5990       CALL_BindTransformFeedback(ctx->Exec, (target, name));
5997    GET_CURRENT_CONTEXT(ctx);
5998    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5999    (void) alloc_instruction(ctx, OPCODE_PAUSE_TRANSFORM_FEEDBACK, 0);
6000    if (ctx->ExecuteFlag) {
6001       CALL_PauseTransformFeedback(ctx->Exec, ());
6008    GET_CURRENT_CONTEXT(ctx);
6009    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6010    (void) alloc_instruction(ctx, OPCODE_RESUME_TRANSFORM_FEEDBACK, 0);
6011    if (ctx->ExecuteFlag) {
6012       CALL_ResumeTransformFeedback(ctx->Exec, ());
6019    GET_CURRENT_CONTEXT(ctx);
6021    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6022    n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK, 2);
6027    if (ctx->ExecuteFlag) {
6028       CALL_DrawTransformFeedback(ctx->Exec, (mode, name));
6035    GET_CURRENT_CONTEXT(ctx);
6037    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6038    n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM, 3);
6044    if (ctx->ExecuteFlag) {
6045       CALL_DrawTransformFeedbackStream(ctx->Exec, (mode, name, stream));
6053    GET_CURRENT_CONTEXT(ctx);
6055    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6056    n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_INSTANCED, 3);
6062    if (ctx->ExecuteFlag) {
6063       CALL_DrawTransformFeedbackInstanced(ctx->Exec, (mode, name, primcount));
6071    GET_CURRENT_CONTEXT(ctx);
6073    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6074    n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM_INSTANCED, 4);
6081    if (ctx->ExecuteFlag) {
6082       CALL_DrawTransformFeedbackStreamInstanced(ctx->Exec, (mode, name, stream,
6091    GET_CURRENT_CONTEXT(ctx);
6093    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6094    n = alloc_instruction(ctx, OPCODE_DISPATCH_COMPUTE, 3);
6100    if (ctx->ExecuteFlag) {
6101       CALL_DispatchCompute(ctx->Exec, (num_groups_x, num_groups_y,
6109    GET_CURRENT_CONTEXT(ctx);
6110    _mesa_error(ctx, GL_INVALID_OPERATION,
6115 save_Attr32bit(struct gl_context *ctx, unsigned attr, unsigned size,
6119    SAVE_FLUSH_VERTICES(ctx);
6139    n = alloc_instruction(ctx, base_op + size - 1, 1 + size);
6148    ctx->ListState.ActiveAttribSize[index] = size;
6149    ASSIGN_4V(ctx->ListState.CurrentAttrib[index], x, y, z, w);
6151    if (ctx->ExecuteFlag) {
6155                CALL_VertexAttrib4fNV(ctx->Exec, (attr, uif(x), uif(y), uif(z), uif(w)));
6157                CALL_VertexAttrib3fNV(ctx->Exec, (attr, uif(x), uif(y), uif(z)));
6159                CALL_VertexAttrib2fNV(ctx->Exec, (attr, uif(x), uif(y)));
6161                CALL_VertexAttrib1fNV(ctx->Exec, (attr, uif(x)));
6164                CALL_VertexAttrib4fARB(ctx->Exec, (attr, uif(x), uif(y), uif(z), uif(w)));
6166                CALL_VertexAttrib3fARB(ctx->Exec, (attr, uif(x), uif(y), uif(z)));
6168                CALL_VertexAttrib2fARB(ctx->Exec, (attr, uif(x), uif(y)));
6170                CALL_VertexAttrib1fARB(ctx->Exec, (attr, uif(x)));
6174             CALL_VertexAttribI4iEXT(ctx->Exec, (attr, x, y, z, w));
6176             CALL_VertexAttribI3iEXT(ctx->Exec, (attr, x, y, z));
6178             CALL_VertexAttribI2iEXT(ctx->Exec, (attr, x, y));
6180             CALL_VertexAttribI1iEXT(ctx->Exec, (attr, x));
6186 save_Attr64bit(struct gl_context *ctx, unsigned attr, unsigned size,
6190    SAVE_FLUSH_VERTICES(ctx);
6202    n = alloc_instruction(ctx, base_op + size - 1, 1 + size * 2);
6211    ctx->ListState.ActiveAttribSize[index] = size;
6212    memcpy(ctx->ListState.CurrentAttrib[index], &n[2], size * sizeof(uint64_t));
6214    if (ctx->ExecuteFlag) {
6218             CALL_VertexAttribL4dv(ctx->Exec, (attr, (GLdouble*)v));
6220             CALL_VertexAttribL3dv(ctx->Exec, (attr, (GLdouble*)v));
6222             CALL_VertexAttribL2dv(ctx->Exec, (attr, (GLdouble*)v));
6224             CALL_VertexAttribL1d(ctx->Exec, (attr, UINT64_AS_DOUBLE(x)));
6226          CALL_VertexAttribL1ui64ARB(ctx->Exec, (attr, x));
6237 is_vertex_position(const struct gl_context *ctx, GLuint index)
6240            _mesa_attr_zero_aliases_vertex(ctx) &&
6241            _mesa_inside_dlist_begin_end(ctx));
6256       save_Attr32bit(ctx, A, N, T, V0, V1, V2, V3);                     \
6258       save_Attr64bit(ctx, A, N, T, V0, V1, V2, V3);                     \
6263 #define ERROR(err) _mesa_error(ctx, err, __func__)
6282    GET_CURRENT_CONTEXT(ctx);
6284    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6285    n = alloc_instruction(ctx, OPCODE_USE_PROGRAM, 1);
6289    if (ctx->ExecuteFlag) {
6290       CALL_UseProgram(ctx->Exec, (program));
6298    GET_CURRENT_CONTEXT(ctx);
6300    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6301    n = alloc_instruction(ctx, OPCODE_UNIFORM_1F, 2);
6306    if (ctx->ExecuteFlag) {
6307       CALL_Uniform1f(ctx->Exec, (location, x));
6315    GET_CURRENT_CONTEXT(ctx);
6317    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6318    n = alloc_instruction(ctx, OPCODE_UNIFORM_2F, 3);
6324    if (ctx->ExecuteFlag) {
6325       CALL_Uniform2f(ctx->Exec, (location, x, y));
6333    GET_CURRENT_CONTEXT(ctx);
6335    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6336    n = alloc_instruction(ctx, OPCODE_UNIFORM_3F, 4);
6343    if (ctx->ExecuteFlag) {
6344       CALL_Uniform3f(ctx->Exec, (location, x, y, z));
6352    GET_CURRENT_CONTEXT(ctx);
6354    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6355    n = alloc_instruction(ctx, OPCODE_UNIFORM_4F, 5);
6363    if (ctx->ExecuteFlag) {
6364       CALL_Uniform4f(ctx->Exec, (location, x, y, z, w));
6372    GET_CURRENT_CONTEXT(ctx);
6374    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6375    n = alloc_instruction(ctx, OPCODE_UNIFORM_1FV, 2 + POINTER_DWORDS);
6381    if (ctx->ExecuteFlag) {
6382       CALL_Uniform1fv(ctx->Exec, (location, count, v));
6389    GET_CURRENT_CONTEXT(ctx);
6391    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6392    n = alloc_instruction(ctx, OPCODE_UNIFORM_2FV, 2 + POINTER_DWORDS);
6398    if (ctx->ExecuteFlag) {
6399       CALL_Uniform2fv(ctx->Exec, (location, count, v));
6406    GET_CURRENT_CONTEXT(ctx);
6408    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6409    n = alloc_instruction(ctx, OPCODE_UNIFORM_3FV, 2 + POINTER_DWORDS);
6415    if (ctx->ExecuteFlag) {
6416       CALL_Uniform3fv(ctx->Exec, (location, count, v));
6423    GET_CURRENT_CONTEXT(ctx);
6425    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6426    n = alloc_instruction(ctx, OPCODE_UNIFORM_4FV, 2 + POINTER_DWORDS);
6432    if (ctx->ExecuteFlag) {
6433       CALL_Uniform4fv(ctx->Exec, (location, count, v));
6441    GET_CURRENT_CONTEXT(ctx);
6443    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6444    n = alloc_instruction(ctx, OPCODE_UNIFORM_1D, 3);
6449    if (ctx->ExecuteFlag) {
6450       CALL_Uniform1d(ctx->Exec, (location, x));
6458    GET_CURRENT_CONTEXT(ctx);
6460    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6461    n = alloc_instruction(ctx, OPCODE_UNIFORM_2D, 5);
6467    if (ctx->ExecuteFlag) {
6468       CALL_Uniform2d(ctx->Exec, (location, x, y));
6476    GET_CURRENT_CONTEXT(ctx);
6478    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6479    n = alloc_instruction(ctx, OPCODE_UNIFORM_3D, 7);
6486    if (ctx->ExecuteFlag) {
6487       CALL_Uniform3d(ctx->Exec, (location, x, y, z));
6495    GET_CURRENT_CONTEXT(ctx);
6497    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6498    n = alloc_instruction(ctx, OPCODE_UNIFORM_4D, 9);
6506    if (ctx->ExecuteFlag) {
6507       CALL_Uniform4d(ctx->Exec, (location, x, y, z, w));
6515    GET_CURRENT_CONTEXT(ctx);
6517    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6518    n = alloc_instruction(ctx, OPCODE_UNIFORM_1DV, 2 + POINTER_DWORDS);
6524    if (ctx->ExecuteFlag) {
6525       CALL_Uniform1dv(ctx->Exec, (location, count, v));
6533    GET_CURRENT_CONTEXT(ctx);
6535    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6536    n = alloc_instruction(ctx, OPCODE_UNIFORM_2DV, 2 + POINTER_DWORDS);
6542    if (ctx->ExecuteFlag) {
6543       CALL_Uniform2dv(ctx->Exec, (location, count, v));
6551    GET_CURRENT_CONTEXT(ctx);
6553    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6554    n = alloc_instruction(ctx, OPCODE_UNIFORM_3DV, 2 + POINTER_DWORDS);
6560    if (ctx->ExecuteFlag) {
6561       CALL_Uniform3dv(ctx->Exec, (location, count, v));
6569    GET_CURRENT_CONTEXT(ctx);
6571    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6572    n = alloc_instruction(ctx, OPCODE_UNIFORM_4DV, 2 + POINTER_DWORDS);
6578    if (ctx->ExecuteFlag) {
6579       CALL_Uniform4dv(ctx->Exec, (location, count, v));
6587    GET_CURRENT_CONTEXT(ctx);
6589    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6590    n = alloc_instruction(ctx, OPCODE_UNIFORM_1I, 2);
6595    if (ctx->ExecuteFlag) {
6596       CALL_Uniform1i(ctx->Exec, (location, x));
6603    GET_CURRENT_CONTEXT(ctx);
6605    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6606    n = alloc_instruction(ctx, OPCODE_UNIFORM_2I, 3);
6612    if (ctx->ExecuteFlag) {
6613       CALL_Uniform2i(ctx->Exec, (location, x, y));
6620    GET_CURRENT_CONTEXT(ctx);
6622    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6623    n = alloc_instruction(ctx, OPCODE_UNIFORM_3I, 4);
6630    if (ctx->ExecuteFlag) {
6631       CALL_Uniform3i(ctx->Exec, (location, x, y, z));
6638    GET_CURRENT_CONTEXT(ctx);
6640    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6641    n = alloc_instruction(ctx, OPCODE_UNIFORM_4I, 5);
6649    if (ctx->ExecuteFlag) {
6650       CALL_Uniform4i(ctx->Exec, (location, x, y, z, w));
6659    GET_CURRENT_CONTEXT(ctx);
6661    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6662    n = alloc_instruction(ctx, OPCODE_UNIFORM_1IV, 2 + POINTER_DWORDS);
6668    if (ctx->ExecuteFlag) {
6669       CALL_Uniform1iv(ctx->Exec, (location, count, v));
6676    GET_CURRENT_CONTEXT(ctx);
6678    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6679    n = alloc_instruction(ctx, OPCODE_UNIFORM_2IV, 2 + POINTER_DWORDS);
6685    if (ctx->ExecuteFlag) {
6686       CALL_Uniform2iv(ctx->Exec, (location, count, v));
6693    GET_CURRENT_CONTEXT(ctx);
6695    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6696    n = alloc_instruction(ctx, OPCODE_UNIFORM_3IV, 2 + POINTER_DWORDS);
6702    if (ctx->ExecuteFlag) {
6703       CALL_Uniform3iv(ctx->Exec, (location, count, v));
6710    GET_CURRENT_CONTEXT(ctx);
6712    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6713    n = alloc_instruction(ctx, OPCODE_UNIFORM_4IV, 2 + POINTER_DWORDS);
6719    if (ctx->ExecuteFlag) {
6720       CALL_Uniform4iv(ctx->Exec, (location, count, v));
6729    GET_CURRENT_CONTEXT(ctx);
6731    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6732    n = alloc_instruction(ctx, OPCODE_UNIFORM_1UI, 2);
6737    if (ctx->ExecuteFlag) {
6738       CALL_Uniform1ui(ctx->Exec, (location, x));
6745    GET_CURRENT_CONTEXT(ctx);
6747    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6748    n = alloc_instruction(ctx, OPCODE_UNIFORM_2UI, 3);
6754    if (ctx->ExecuteFlag) {
6755       CALL_Uniform2ui(ctx->Exec, (location, x, y));
6762    GET_CURRENT_CONTEXT(ctx);
6764    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6765    n = alloc_instruction(ctx, OPCODE_UNIFORM_3UI, 4);
6772    if (ctx->ExecuteFlag) {
6773       CALL_Uniform3ui(ctx->Exec, (location, x, y, z));
6780    GET_CURRENT_CONTEXT(ctx);
6782    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6783    n = alloc_instruction(ctx, OPCODE_UNIFORM_4UI, 5);
6791    if (ctx->ExecuteFlag) {
6792       CALL_Uniform4ui(ctx->Exec, (location, x, y, z, w));
6801    GET_CURRENT_CONTEXT(ctx);
6803    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6804    n = alloc_instruction(ctx, OPCODE_UNIFORM_1UIV, 2 + POINTER_DWORDS);
6810    if (ctx->ExecuteFlag) {
6811       CALL_Uniform1uiv(ctx->Exec, (location, count, v));
6818    GET_CURRENT_CONTEXT(ctx);
6820    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6821    n = alloc_instruction(ctx, OPCODE_UNIFORM_2UIV, 2 + POINTER_DWORDS);
6827    if (ctx->ExecuteFlag) {
6828       CALL_Uniform2uiv(ctx->Exec, (location, count, v));
6835    GET_CURRENT_CONTEXT(ctx);
6837    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6838    n = alloc_instruction(ctx, OPCODE_UNIFORM_3UIV, 2 + POINTER_DWORDS);
6844    if (ctx->ExecuteFlag) {
6845       CALL_Uniform3uiv(ctx->Exec, (location, count, v));
6852    GET_CURRENT_CONTEXT(ctx);
6854    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6855    n = alloc_instruction(ctx, OPCODE_UNIFORM_4UIV, 2 + POINTER_DWORDS);
6861    if (ctx->ExecuteFlag) {
6862       CALL_Uniform4uiv(ctx->Exec, (location, count, v));
6872    GET_CURRENT_CONTEXT(ctx);
6874    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6875    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX22, 3 + POINTER_DWORDS);
6882    if (ctx->ExecuteFlag) {
6883       CALL_UniformMatrix2fv(ctx->Exec, (location, count, transpose, m));
6891    GET_CURRENT_CONTEXT(ctx);
6893    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6894    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX33, 3 + POINTER_DWORDS);
6901    if (ctx->ExecuteFlag) {
6902       CALL_UniformMatrix3fv(ctx->Exec, (location, count, transpose, m));
6910    GET_CURRENT_CONTEXT(ctx);
6912    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6913    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX44, 3 + POINTER_DWORDS);
6920    if (ctx->ExecuteFlag) {
6921       CALL_UniformMatrix4fv(ctx->Exec, (location, count, transpose, m));
6930    GET_CURRENT_CONTEXT(ctx);
6932    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6933    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX23, 3 + POINTER_DWORDS);
6940    if (ctx->ExecuteFlag) {
6941       CALL_UniformMatrix2x3fv(ctx->Exec, (location, count, transpose, m));
6949    GET_CURRENT_CONTEXT(ctx);
6951    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6952    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX32, 3 + POINTER_DWORDS);
6959    if (ctx->ExecuteFlag) {
6960       CALL_UniformMatrix3x2fv(ctx->Exec, (location, count, transpose, m));
6969    GET_CURRENT_CONTEXT(ctx);
6971    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6972    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX24, 3 + POINTER_DWORDS);
6979    if (ctx->ExecuteFlag) {
6980       CALL_UniformMatrix2x4fv(ctx->Exec, (location, count, transpose, m));
6988    GET_CURRENT_CONTEXT(ctx);
6990    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6991    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX42, 3 + POINTER_DWORDS);
6998    if (ctx->ExecuteFlag) {
6999       CALL_UniformMatrix4x2fv(ctx->Exec, (location, count, transpose, m));
7008    GET_CURRENT_CONTEXT(ctx);
7010    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7011    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX34, 3 + POINTER_DWORDS);
7018    if (ctx->ExecuteFlag) {
7019       CALL_UniformMatrix3x4fv(ctx->Exec, (location, count, transpose, m));
7027    GET_CURRENT_CONTEXT(ctx);
7029    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7030    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX43, 3 + POINTER_DWORDS);
7037    if (ctx->ExecuteFlag) {
7038       CALL_UniformMatrix4x3fv(ctx->Exec, (location, count, transpose, m));
7047    GET_CURRENT_CONTEXT(ctx);
7049    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7050    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX22D, 3 + POINTER_DWORDS);
7057    if (ctx->ExecuteFlag) {
7058       CALL_UniformMatrix2dv(ctx->Exec, (location, count, transpose, m));
7066    GET_CURRENT_CONTEXT(ctx);
7068    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7069    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX33D, 3 + POINTER_DWORDS);
7076    if (ctx->ExecuteFlag) {
7077       CALL_UniformMatrix3dv(ctx->Exec, (location, count, transpose, m));
7085    GET_CURRENT_CONTEXT(ctx);
7087    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7088    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX44D, 3 + POINTER_DWORDS);
7095    if (ctx->ExecuteFlag) {
7096       CALL_UniformMatrix4dv(ctx->Exec, (location, count, transpose, m));
7105    GET_CURRENT_CONTEXT(ctx);
7107    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7108    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX23D, 3 + POINTER_DWORDS);
7115    if (ctx->ExecuteFlag) {
7116       CALL_UniformMatrix2x3dv(ctx->Exec, (location, count, transpose, m));
7125    GET_CURRENT_CONTEXT(ctx);
7127    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7128    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX32D, 3 + POINTER_DWORDS);
7135    if (ctx->ExecuteFlag) {
7136       CALL_UniformMatrix3x2dv(ctx->Exec, (location, count, transpose, m));
7145    GET_CURRENT_CONTEXT(ctx);
7147    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7148    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX24D, 3 + POINTER_DWORDS);
7155    if (ctx->ExecuteFlag) {
7156       CALL_UniformMatrix2x4dv(ctx->Exec, (location, count, transpose, m));
7164    GET_CURRENT_CONTEXT(ctx);
7166    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7167    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX42D, 3 + POINTER_DWORDS);
7174    if (ctx->ExecuteFlag) {
7175       CALL_UniformMatrix4x2dv(ctx->Exec, (location, count, transpose, m));
7184    GET_CURRENT_CONTEXT(ctx);
7186    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7187    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX34D, 3 + POINTER_DWORDS);
7194    if (ctx->ExecuteFlag) {
7195       CALL_UniformMatrix3x4dv(ctx->Exec, (location, count, transpose, m));
7204    GET_CURRENT_CONTEXT(ctx);
7206    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7207    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX43D, 3 + POINTER_DWORDS);
7214    if (ctx->ExecuteFlag) {
7215       CALL_UniformMatrix4x3dv(ctx->Exec, (location, count, transpose, m));
7222    GET_CURRENT_CONTEXT(ctx);
7224    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7225    n = alloc_instruction(ctx, OPCODE_UNIFORM_1I64, 3);
7230    if (ctx->ExecuteFlag) {
7231       CALL_Uniform1i64ARB(ctx->Exec, (location, x));
7238    GET_CURRENT_CONTEXT(ctx);
7240    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7241    n = alloc_instruction(ctx, OPCODE_UNIFORM_2I64, 5);
7247    if (ctx->ExecuteFlag) {
7248       CALL_Uniform2i64ARB(ctx->Exec, (location, x, y));
7255    GET_CURRENT_CONTEXT(ctx);
7257    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7258    n = alloc_instruction(ctx, OPCODE_UNIFORM_3I64, 7);
7265    if (ctx->ExecuteFlag) {
7266       CALL_Uniform3i64ARB(ctx->Exec, (location, x, y, z));
7273    GET_CURRENT_CONTEXT(ctx);
7275    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7276    n = alloc_instruction(ctx, OPCODE_UNIFORM_4I64, 9);
7284    if (ctx->ExecuteFlag) {
7285       CALL_Uniform4i64ARB(ctx->Exec, (location, x, y, z, w));
7292    GET_CURRENT_CONTEXT(ctx);
7294    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7295    n = alloc_instruction(ctx, OPCODE_UNIFORM_1I64V, 2 + POINTER_DWORDS);
7301    if (ctx->ExecuteFlag) {
7302       CALL_Uniform1i64vARB(ctx->Exec, (location, count, v));
7309    GET_CURRENT_CONTEXT(ctx);
7311    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7312    n = alloc_instruction(ctx, OPCODE_UNIFORM_2I64V, 2 + POINTER_DWORDS);
7318    if (ctx->ExecuteFlag) {
7319       CALL_Uniform2i64vARB(ctx->Exec, (location, count, v));
7326    GET_CURRENT_CONTEXT(ctx);
7328    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7329    n = alloc_instruction(ctx, OPCODE_UNIFORM_3I64V, 2 + POINTER_DWORDS);
7335    if (ctx->ExecuteFlag) {
7336       CALL_Uniform3i64vARB(ctx->Exec, (location, count, v));
7343    GET_CURRENT_CONTEXT(ctx);
7345    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7346    n = alloc_instruction(ctx, OPCODE_UNIFORM_4I64V, 2 + POINTER_DWORDS);
7352    if (ctx->ExecuteFlag) {
7353       CALL_Uniform4i64vARB(ctx->Exec, (location, count, v));
7360    GET_CURRENT_CONTEXT(ctx);
7362    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7363    n = alloc_instruction(ctx, OPCODE_UNIFORM_1UI64, 3);
7368    if (ctx->ExecuteFlag) {
7369       CALL_Uniform1ui64ARB(ctx->Exec, (location, x));
7376    GET_CURRENT_CONTEXT(ctx);
7378    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7379    n = alloc_instruction(ctx, OPCODE_UNIFORM_2UI64, 5);
7385    if (ctx->ExecuteFlag) {
7386       CALL_Uniform2ui64ARB(ctx->Exec, (location, x, y));
7393    GET_CURRENT_CONTEXT(ctx);
7395    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7396    n = alloc_instruction(ctx, OPCODE_UNIFORM_3UI64, 7);
7403    if (ctx->ExecuteFlag) {
7404       CALL_Uniform3ui64ARB(ctx->Exec, (location, x, y, z));
7411    GET_CURRENT_CONTEXT(ctx);
7413    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7414    n = alloc_instruction(ctx, OPCODE_UNIFORM_4UI64, 9);
7422    if (ctx->ExecuteFlag) {
7423       CALL_Uniform4ui64ARB(ctx->Exec, (location, x, y, z, w));
7430    GET_CURRENT_CONTEXT(ctx);
7432    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7433    n = alloc_instruction(ctx, OPCODE_UNIFORM_1UI64V, 2 + POINTER_DWORDS);
7439    if (ctx->ExecuteFlag) {
7440       CALL_Uniform1ui64vARB(ctx->Exec, (location, count, v));
7447    GET_CURRENT_CONTEXT(ctx);
7449    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7450    n = alloc_instruction(ctx, OPCODE_UNIFORM_2UI64V, 2 + POINTER_DWORDS);
7456    if (ctx->ExecuteFlag) {
7457       CALL_Uniform2ui64vARB(ctx->Exec, (location, count, v));
7464    GET_CURRENT_CONTEXT(ctx);
7466    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7467    n = alloc_instruction(ctx, OPCODE_UNIFORM_3UI64V, 2 + POINTER_DWORDS);
7473    if (ctx->ExecuteFlag) {
7474       CALL_Uniform3ui64vARB(ctx->Exec, (location, count, v));
7481    GET_CURRENT_CONTEXT(ctx);
7483    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7484    n = alloc_instruction(ctx, OPCODE_UNIFORM_4UI64V, 2 + POINTER_DWORDS);
7490    if (ctx->ExecuteFlag) {
7491       CALL_Uniform4ui64vARB(ctx->Exec, (location, count, v));
7498    GET_CURRENT_CONTEXT(ctx);
7500    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7501    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1I64, 4);
7507    if (ctx->ExecuteFlag) {
7508       CALL_ProgramUniform1i64ARB(ctx->Exec, (program, location, x));
7516    GET_CURRENT_CONTEXT(ctx);
7518    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7519    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2I64, 6);
7526    if (ctx->ExecuteFlag) {
7527       CALL_ProgramUniform2i64ARB(ctx->Exec, (program, location, x, y));
7535    GET_CURRENT_CONTEXT(ctx);
7537    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7538    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3I64, 8);
7546    if (ctx->ExecuteFlag) {
7547       CALL_ProgramUniform3i64ARB(ctx->Exec, (program, location, x, y, z));
7555    GET_CURRENT_CONTEXT(ctx);
7557    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7558    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4I64, 10);
7567    if (ctx->ExecuteFlag) {
7568       CALL_ProgramUniform4i64ARB(ctx->Exec, (program, location, x, y, z, w));
7576    GET_CURRENT_CONTEXT(ctx);
7578    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7579    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1I64V, 3 + POINTER_DWORDS);
7586    if (ctx->ExecuteFlag) {
7587       CALL_ProgramUniform1i64vARB(ctx->Exec, (program, location, count, v));
7595    GET_CURRENT_CONTEXT(ctx);
7597    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7598    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2I64V, 3 + POINTER_DWORDS);
7605    if (ctx->ExecuteFlag) {
7606       CALL_ProgramUniform2i64vARB(ctx->Exec, (program, location, count, v));
7614    GET_CURRENT_CONTEXT(ctx);
7616    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7617    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3I64V, 3 + POINTER_DWORDS);
7624    if (ctx->ExecuteFlag) {
7625       CALL_ProgramUniform3i64vARB(ctx->Exec, (program, location, count, v));
7633    GET_CURRENT_CONTEXT(ctx);
7635    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7636    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4I64V, 3 + POINTER_DWORDS);
7643    if (ctx->ExecuteFlag) {
7644       CALL_ProgramUniform4i64vARB(ctx->Exec, (program, location, count, v));
7651    GET_CURRENT_CONTEXT(ctx);
7653    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7654    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1UI64, 4);
7660    if (ctx->ExecuteFlag) {
7661       CALL_ProgramUniform1ui64ARB(ctx->Exec, (program, location, x));
7669    GET_CURRENT_CONTEXT(ctx);
7671    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7672    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2UI64, 6);
7679    if (ctx->ExecuteFlag) {
7680       CALL_ProgramUniform2ui64ARB(ctx->Exec, (program, location, x, y));
7688    GET_CURRENT_CONTEXT(ctx);
7690    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7691    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3UI64, 8);
7699    if (ctx->ExecuteFlag) {
7700       CALL_ProgramUniform3ui64ARB(ctx->Exec, (program, location, x, y, z));
7708    GET_CURRENT_CONTEXT(ctx);
7710    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7711    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4UI64, 10);
7720    if (ctx->ExecuteFlag) {
7721       CALL_ProgramUniform4i64ARB(ctx->Exec, (program, location, x, y, z, w));
7729    GET_CURRENT_CONTEXT(ctx);
7731    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7732    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1UI64V,
7740    if (ctx->ExecuteFlag) {
7741       CALL_ProgramUniform1ui64vARB(ctx->Exec, (program, location, count, v));
7749    GET_CURRENT_CONTEXT(ctx);
7751    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7752    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2UI64V,
7760    if (ctx->ExecuteFlag) {
7761       CALL_ProgramUniform2ui64vARB(ctx->Exec, (program, location, count, v));
7769    GET_CURRENT_CONTEXT(ctx);
7771    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7772    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3UI64V,
7780    if (ctx->ExecuteFlag) {
7781       CALL_ProgramUniform3ui64vARB(ctx->Exec, (program, location, count, v));
7789    GET_CURRENT_CONTEXT(ctx);
7791    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7792    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4UI64V,
7800    if (ctx->ExecuteFlag) {
7801       CALL_ProgramUniform4ui64vARB(ctx->Exec, (program, location, count, v));
7809    GET_CURRENT_CONTEXT(ctx);
7811    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7812    n = alloc_instruction(ctx, OPCODE_USE_PROGRAM_STAGES, 3);
7818    if (ctx->ExecuteFlag) {
7819       CALL_UseProgramStages(ctx->Exec, (pipeline, stages, program));
7826    GET_CURRENT_CONTEXT(ctx);
7828    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7829    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1F, 3);
7835    if (ctx->ExecuteFlag) {
7836       CALL_ProgramUniform1f(ctx->Exec, (program, location, x));
7843    GET_CURRENT_CONTEXT(ctx);
7845    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7846    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2F, 4);
7853    if (ctx->ExecuteFlag) {
7854       CALL_ProgramUniform2f(ctx->Exec, (program, location, x, y));
7862    GET_CURRENT_CONTEXT(ctx);
7864    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7865    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3F, 5);
7873    if (ctx->ExecuteFlag) {
7874       CALL_ProgramUniform3f(ctx->Exec, (program, location, x, y, z));
7882    GET_CURRENT_CONTEXT(ctx);
7884    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7885    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4F, 6);
7894    if (ctx->ExecuteFlag) {
7895       CALL_ProgramUniform4f(ctx->Exec, (program, location, x, y, z, w));
7903    GET_CURRENT_CONTEXT(ctx);
7905    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7906    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1FV, 3 + POINTER_DWORDS);
7913    if (ctx->ExecuteFlag) {
7914       CALL_ProgramUniform1fv(ctx->Exec, (program, location, count, v));
7922    GET_CURRENT_CONTEXT(ctx);
7924    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7925    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2FV, 3 + POINTER_DWORDS);
7932    if (ctx->ExecuteFlag) {
7933       CALL_ProgramUniform2fv(ctx->Exec, (program, location, count, v));
7941    GET_CURRENT_CONTEXT(ctx);
7943    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7944    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3FV, 3 + POINTER_DWORDS);
7951    if (ctx->ExecuteFlag) {
7952       CALL_ProgramUniform3fv(ctx->Exec, (program, location, count, v));
7960    GET_CURRENT_CONTEXT(ctx);
7962    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7963    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4FV, 3 + POINTER_DWORDS);
7970    if (ctx->ExecuteFlag) {
7971       CALL_ProgramUniform4fv(ctx->Exec, (program, location, count, v));
7978    GET_CURRENT_CONTEXT(ctx);
7980    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7981    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1D, 4);
7987    if (ctx->ExecuteFlag) {
7988       CALL_ProgramUniform1d(ctx->Exec, (program, location, x));
7995    GET_CURRENT_CONTEXT(ctx);
7997    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7998    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2D, 6);
8005    if (ctx->ExecuteFlag) {
8006       CALL_ProgramUniform2d(ctx->Exec, (program, location, x, y));
8014    GET_CURRENT_CONTEXT(ctx);
8016    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8017    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3D, 8);
8025    if (ctx->ExecuteFlag) {
8026       CALL_ProgramUniform3d(ctx->Exec, (program, location, x, y, z));
8034    GET_CURRENT_CONTEXT(ctx);
8036    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8037    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4D, 10);
8046    if (ctx->ExecuteFlag) {
8047       CALL_ProgramUniform4d(ctx->Exec, (program, location, x, y, z, w));
8055    GET_CURRENT_CONTEXT(ctx);
8057    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8058    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1DV, 3 + POINTER_DWORDS);
8065    if (ctx->ExecuteFlag) {
8066       CALL_ProgramUniform1dv(ctx->Exec, (program, location, count, v));
8074    GET_CURRENT_CONTEXT(ctx);
8076    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8077    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2DV, 3 + POINTER_DWORDS);
8084    if (ctx->ExecuteFlag) {
8085       CALL_ProgramUniform2dv(ctx->Exec, (program, location, count, v));
8093    GET_CURRENT_CONTEXT(ctx);
8095    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8096    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3DV, 3 + POINTER_DWORDS);
8103    if (ctx->ExecuteFlag) {
8104       CALL_ProgramUniform3dv(ctx->Exec, (program, location, count, v));
8112    GET_CURRENT_CONTEXT(ctx);
8114    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8115    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4DV, 3 + POINTER_DWORDS);
8122    if (ctx->ExecuteFlag) {
8123       CALL_ProgramUniform4dv(ctx->Exec, (program, location, count, v));
8130    GET_CURRENT_CONTEXT(ctx);
8132    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8133    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1I, 3);
8139    if (ctx->ExecuteFlag) {
8140       CALL_ProgramUniform1i(ctx->Exec, (program, location, x));
8147    GET_CURRENT_CONTEXT(ctx);
8149    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8150    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2I, 4);
8157    if (ctx->ExecuteFlag) {
8158       CALL_ProgramUniform2i(ctx->Exec, (program, location, x, y));
8166    GET_CURRENT_CONTEXT(ctx);
8168    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8169    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3I, 5);
8177    if (ctx->ExecuteFlag) {
8178       CALL_ProgramUniform3i(ctx->Exec, (program, location, x, y, z));
8186    GET_CURRENT_CONTEXT(ctx);
8188    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8189    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4I, 6);
8198    if (ctx->ExecuteFlag) {
8199       CALL_ProgramUniform4i(ctx->Exec, (program, location, x, y, z, w));
8207    GET_CURRENT_CONTEXT(ctx);
8209    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8210    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1IV, 3 + POINTER_DWORDS);
8217    if (ctx->ExecuteFlag) {
8218       CALL_ProgramUniform1iv(ctx->Exec, (program, location, count, v));
8226    GET_CURRENT_CONTEXT(ctx);
8228    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8229    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2IV, 3 + POINTER_DWORDS);
8236    if (ctx->ExecuteFlag) {
8237       CALL_ProgramUniform2iv(ctx->Exec, (program, location, count, v));
8245    GET_CURRENT_CONTEXT(ctx);
8247    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8248    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3IV, 3 + POINTER_DWORDS);
8255    if (ctx->ExecuteFlag) {
8256       CALL_ProgramUniform3iv(ctx->Exec, (program, location, count, v));
8264    GET_CURRENT_CONTEXT(ctx);
8266    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8267    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4IV, 3 + POINTER_DWORDS);
8274    if (ctx->ExecuteFlag) {
8275       CALL_ProgramUniform4iv(ctx->Exec, (program, location, count, v));
8282    GET_CURRENT_CONTEXT(ctx);
8284    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8285    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1UI, 3);
8291    if (ctx->ExecuteFlag) {
8292       CALL_ProgramUniform1ui(ctx->Exec, (program, location, x));
8299    GET_CURRENT_CONTEXT(ctx);
8301    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8302    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2UI, 4);
8309    if (ctx->ExecuteFlag) {
8310       CALL_ProgramUniform2ui(ctx->Exec, (program, location, x, y));
8318    GET_CURRENT_CONTEXT(ctx);
8320    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8321    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3UI, 5);
8329    if (ctx->ExecuteFlag) {
8330       CALL_ProgramUniform3ui(ctx->Exec, (program, location, x, y, z));
8338    GET_CURRENT_CONTEXT(ctx);
8340    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8341    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4UI, 6);
8350    if (ctx->ExecuteFlag) {
8351       CALL_ProgramUniform4ui(ctx->Exec, (program, location, x, y, z, w));
8359    GET_CURRENT_CONTEXT(ctx);
8361    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8362    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1UIV, 3 + POINTER_DWORDS);
8369    if (ctx->ExecuteFlag) {
8370       CALL_ProgramUniform1uiv(ctx->Exec, (program, location, count, v));
8378    GET_CURRENT_CONTEXT(ctx);
8380    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8381    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2UIV, 3 + POINTER_DWORDS);
8388    if (ctx->ExecuteFlag) {
8389       CALL_ProgramUniform2uiv(ctx->Exec, (program, location, count, v));
8397    GET_CURRENT_CONTEXT(ctx);
8399    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8400    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3UIV, 3 + POINTER_DWORDS);
8407    if (ctx->ExecuteFlag) {
8408       CALL_ProgramUniform3uiv(ctx->Exec, (program, location, count, v));
8416    GET_CURRENT_CONTEXT(ctx);
8418    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8419    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4UIV, 3 + POINTER_DWORDS);
8426    if (ctx->ExecuteFlag) {
8427       CALL_ProgramUniform4uiv(ctx->Exec, (program, location, count, v));
8435    GET_CURRENT_CONTEXT(ctx);
8437    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8438    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX22F,
8447    if (ctx->ExecuteFlag) {
8448       CALL_ProgramUniformMatrix2fv(ctx->Exec,
8457    GET_CURRENT_CONTEXT(ctx);
8459    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8460    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX23F,
8469    if (ctx->ExecuteFlag) {
8470       CALL_ProgramUniformMatrix2x3fv(ctx->Exec,
8479    GET_CURRENT_CONTEXT(ctx);
8481    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8482    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX24F,
8491    if (ctx->ExecuteFlag) {
8492       CALL_ProgramUniformMatrix2x4fv(ctx->Exec,
8501    GET_CURRENT_CONTEXT(ctx);
8503    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8504    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX32F,
8513    if (ctx->ExecuteFlag) {
8514       CALL_ProgramUniformMatrix3x2fv(ctx->Exec,
8523    GET_CURRENT_CONTEXT(ctx);
8525    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8526    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX33F,
8535    if (ctx->ExecuteFlag) {
8536       CALL_ProgramUniformMatrix3fv(ctx->Exec,
8545    GET_CURRENT_CONTEXT(ctx);
8547    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8548    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX34F,
8557    if (ctx->ExecuteFlag) {
8558       CALL_ProgramUniformMatrix3x4fv(ctx->Exec,
8567    GET_CURRENT_CONTEXT(ctx);
8569    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8570    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX42F,
8579    if (ctx->ExecuteFlag) {
8580       CALL_ProgramUniformMatrix4x2fv(ctx->Exec,
8589    GET_CURRENT_CONTEXT(ctx);
8591    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8592    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX43F,
8601    if (ctx->ExecuteFlag) {
8602       CALL_ProgramUniformMatrix4x3fv(ctx->Exec,
8611    GET_CURRENT_CONTEXT(ctx);
8613    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8614    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX44F,
8623    if (ctx->ExecuteFlag) {
8624       CALL_ProgramUniformMatrix4fv(ctx->Exec,
8633    GET_CURRENT_CONTEXT(ctx);
8635    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8636    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX22D,
8645    if (ctx->ExecuteFlag) {
8646       CALL_ProgramUniformMatrix2dv(ctx->Exec,
8655    GET_CURRENT_CONTEXT(ctx);
8657    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8658    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX23D,
8667    if (ctx->ExecuteFlag) {
8668       CALL_ProgramUniformMatrix2x3dv(ctx->Exec,
8677    GET_CURRENT_CONTEXT(ctx);
8679    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8680    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX24D,
8689    if (ctx->ExecuteFlag) {
8690       CALL_ProgramUniformMatrix2x4dv(ctx->Exec,
8699    GET_CURRENT_CONTEXT(ctx);
8701    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8702    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX32D,
8711    if (ctx->ExecuteFlag) {
8712       CALL_ProgramUniformMatrix3x2dv(ctx->Exec,
8721    GET_CURRENT_CONTEXT(ctx);
8723    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8724    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX33D,
8733    if (ctx->ExecuteFlag) {
8734       CALL_ProgramUniformMatrix3dv(ctx->Exec,
8743    GET_CURRENT_CONTEXT(ctx);
8745    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8746    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX34D,
8755    if (ctx->ExecuteFlag) {
8756       CALL_ProgramUniformMatrix3x4dv(ctx->Exec,
8765    GET_CURRENT_CONTEXT(ctx);
8767    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8768    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX42D,
8777    if (ctx->ExecuteFlag) {
8778       CALL_ProgramUniformMatrix4x2dv(ctx->Exec,
8787    GET_CURRENT_CONTEXT(ctx);
8789    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8790    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX43D,
8799    if (ctx->ExecuteFlag) {
8800       CALL_ProgramUniformMatrix4x3dv(ctx->Exec,
8809    GET_CURRENT_CONTEXT(ctx);
8811    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8812    n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX44D,
8821    if (ctx->ExecuteFlag) {
8822       CALL_ProgramUniformMatrix4dv(ctx->Exec,
8830    GET_CURRENT_CONTEXT(ctx);
8832    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8833    n = alloc_instruction(ctx, OPCODE_CLIP_CONTROL, 2);
8838    if (ctx->ExecuteFlag) {
8839       CALL_ClipControl(ctx->Exec, (origin, depth));
8846    GET_CURRENT_CONTEXT(ctx);
8848    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8849    n = alloc_instruction(ctx, OPCODE_CLAMP_COLOR, 2);
8854    if (ctx->ExecuteFlag) {
8855       CALL_ClampColor(ctx->Exec, (target, clamp));
8863    GET_CURRENT_CONTEXT(ctx);
8865    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8866    n = alloc_instruction(ctx, OPCODE_CLEARCOLOR_I, 4);
8873    if (ctx->ExecuteFlag) {
8874       CALL_ClearColorIiEXT(ctx->Exec, (red, green, blue, alpha));
8882    GET_CURRENT_CONTEXT(ctx);
8884    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8885    n = alloc_instruction(ctx, OPCODE_CLEARCOLOR_UI, 4);
8892    if (ctx->ExecuteFlag) {
8893       CALL_ClearColorIuiEXT(ctx->Exec, (red, green, blue, alpha));
8901    GET_CURRENT_CONTEXT(ctx);
8903    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8904    n = alloc_instruction(ctx, OPCODE_TEXPARAMETER_I, 6);
8913    if (ctx->ExecuteFlag) {
8914       CALL_TexParameterIiv(ctx->Exec, (target, pname, params));
8922    GET_CURRENT_CONTEXT(ctx);
8924    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8925    n = alloc_instruction(ctx, OPCODE_TEXPARAMETER_UI, 6);
8934    if (ctx->ExecuteFlag) {
8935       CALL_TexParameterIuiv(ctx->Exec, (target, pname, params));
8943    GET_CURRENT_CONTEXT(ctx);
8945    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8946    n = alloc_instruction(ctx, OPCODE_VERTEX_ATTRIB_DIVISOR, 2);
8951    if (ctx->ExecuteFlag) {
8952       CALL_VertexAttribDivisor(ctx->Exec, (index, divisor));
8961    GET_CURRENT_CONTEXT(ctx);
8962    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8963    alloc_instruction(ctx, OPCODE_TEXTURE_BARRIER_NV, 0);
8964    if (ctx->ExecuteFlag) {
8965       CALL_TextureBarrierNV(ctx->Exec, ());
8975    GET_CURRENT_CONTEXT(ctx);
8976    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8977    n = alloc_instruction(ctx, OPCODE_BIND_SAMPLER, 2);
8982    if (ctx->ExecuteFlag) {
8983       CALL_BindSampler(ctx->Exec, (unit, sampler));
8991    GET_CURRENT_CONTEXT(ctx);
8992    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
8993    n = alloc_instruction(ctx, OPCODE_SAMPLER_PARAMETERIV, 6);
9007    if (ctx->ExecuteFlag) {
9008       CALL_SamplerParameteriv(ctx->Exec, (sampler, pname, params));
9025    GET_CURRENT_CONTEXT(ctx);
9026    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9027    n = alloc_instruction(ctx, OPCODE_SAMPLER_PARAMETERFV, 6);
9041    if (ctx->ExecuteFlag) {
9042       CALL_SamplerParameterfv(ctx->Exec, (sampler, pname, params));
9059    GET_CURRENT_CONTEXT(ctx);
9060    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9061    n = alloc_instruction(ctx, OPCODE_SAMPLER_PARAMETERIIV, 6);
9075    if (ctx->ExecuteFlag) {
9076       CALL_SamplerParameterIiv(ctx->Exec, (sampler, pname, params));
9084    GET_CURRENT_CONTEXT(ctx);
9085    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9086    n = alloc_instruction(ctx, OPCODE_SAMPLER_PARAMETERUIV, 6);
9100    if (ctx->ExecuteFlag) {
9101       CALL_SamplerParameterIuiv(ctx->Exec, (sampler, pname, params));
9109    GET_CURRENT_CONTEXT(ctx);
9110    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9111    n = alloc_instruction(ctx, OPCODE_WAIT_SYNC, 4);
9120    if (ctx->ExecuteFlag) {
9121       CALL_WaitSync(ctx->Exec, (sync, flags, timeout));
9130    GET_CURRENT_CONTEXT(ctx);
9132    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9133    n = alloc_instruction(ctx, OPCODE_BEGIN_CONDITIONAL_RENDER, 2);
9138    if (ctx->ExecuteFlag) {
9139       CALL_BeginConditionalRender(ctx->Exec, (queryId, mode));
9146    GET_CURRENT_CONTEXT(ctx);
9147    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9148    alloc_instruction(ctx, OPCODE_END_CONDITIONAL_RENDER, 0);
9149    if (ctx->ExecuteFlag) {
9150       CALL_EndConditionalRender(ctx->Exec, ());
9157    GET_CURRENT_CONTEXT(ctx);
9159    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9160    n = alloc_instruction(ctx, OPCODE_UNIFORM_BLOCK_BINDING, 3);
9166    if (ctx->ExecuteFlag) {
9167       CALL_UniformBlockBinding(ctx->Exec, (prog, index, binding));
9175    GET_CURRENT_CONTEXT(ctx);
9177    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9178    n = alloc_instruction(ctx, OPCODE_UNIFORM_SUBROUTINES, 2 + POINTER_DWORDS);
9188    if (ctx->ExecuteFlag) {
9189       CALL_UniformSubroutinesuiv(ctx->Exec, (shadertype, count, indices));
9197    GET_CURRENT_CONTEXT(ctx);
9199    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9200    n = alloc_instruction(ctx, OPCODE_WINDOW_RECTANGLES, 2 + POINTER_DWORDS);
9210    if (ctx->ExecuteFlag) {
9211       CALL_WindowRectanglesEXT(ctx->Exec, (mode, count, box));
9220    GET_CURRENT_CONTEXT(ctx);
9222    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9223    n = alloc_instruction(ctx, OPCODE_SUBPIXEL_PRECISION_BIAS, 2);
9228    if (ctx->ExecuteFlag) {
9229       CALL_SubpixelPrecisionBiasNV(ctx->Exec, (xbits, ybits));
9237    GET_CURRENT_CONTEXT(ctx);
9239    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9240    n = alloc_instruction(ctx, OPCODE_CONSERVATIVE_RASTER_PARAMETER_F, 2);
9245    if (ctx->ExecuteFlag) {
9246       CALL_ConservativeRasterParameterfNV(ctx->Exec, (pname, param));
9254    GET_CURRENT_CONTEXT(ctx);
9256    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9257    n = alloc_instruction(ctx, OPCODE_CONSERVATIVE_RASTER_PARAMETER_I, 2);
9262    if (ctx->ExecuteFlag) {
9263       CALL_ConservativeRasterParameteriNV(ctx->Exec, (pname, param));
9272    GET_CURRENT_CONTEXT(ctx);
9274    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9275    n = alloc_instruction(ctx, OPCODE_MATRIX_LOAD, 17);
9282    if (ctx->ExecuteFlag) {
9283       CALL_MatrixLoadfEXT(ctx->Exec, (matrixMode, m));
9300    GET_CURRENT_CONTEXT(ctx);
9302    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9303    n = alloc_instruction(ctx, OPCODE_MATRIX_MULT, 17);
9310    if (ctx->ExecuteFlag) {
9311       CALL_MatrixMultfEXT(ctx->Exec, (matrixMode, m));
9328    GET_CURRENT_CONTEXT(ctx);
9330    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9331    n = alloc_instruction(ctx, OPCODE_MATRIX_ROTATE, 5);
9339    if (ctx->ExecuteFlag) {
9340       CALL_MatrixRotatefEXT(ctx->Exec, (matrixMode, angle, x, y, z));
9353    GET_CURRENT_CONTEXT(ctx);
9355    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9356    n = alloc_instruction(ctx, OPCODE_MATRIX_SCALE, 4);
9363    if (ctx->ExecuteFlag) {
9364       CALL_MatrixScalefEXT(ctx->Exec, (matrixMode, x, y, z));
9377    GET_CURRENT_CONTEXT(ctx);
9379    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9380    n = alloc_instruction(ctx, OPCODE_MATRIX_TRANSLATE, 4);
9387    if (ctx->ExecuteFlag) {
9388       CALL_MatrixTranslatefEXT(ctx->Exec, (matrixMode, x, y, z));
9401    GET_CURRENT_CONTEXT(ctx);
9403    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9404    n = alloc_instruction(ctx, OPCODE_MATRIX_LOAD_IDENTITY, 1);
9408    if (ctx->ExecuteFlag) {
9409       CALL_MatrixLoadIdentityEXT(ctx->Exec, (matrixMode));
9417    GET_CURRENT_CONTEXT(ctx);
9419    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9420    n = alloc_instruction(ctx, OPCODE_MATRIX_ORTHO, 7);
9430    if (ctx->ExecuteFlag) {
9431       CALL_MatrixOrthoEXT(ctx->Exec, (matrixMode, left, right, bottom, top, nearval, farval));
9440    GET_CURRENT_CONTEXT(ctx);
9442    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9443    n = alloc_instruction(ctx, OPCODE_MATRIX_FRUSTUM, 7);
9453    if (ctx->ExecuteFlag) {
9454       CALL_MatrixFrustumEXT(ctx->Exec, (matrixMode, left, right, bottom, top, nearval, farval));
9461    GET_CURRENT_CONTEXT(ctx);
9463    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9464    n = alloc_instruction(ctx, OPCODE_MATRIX_PUSH, 1);
9468    if (ctx->ExecuteFlag) {
9469       CALL_MatrixPushEXT(ctx->Exec, (matrixMode));
9476    GET_CURRENT_CONTEXT(ctx);
9478    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9479    n = alloc_instruction(ctx, OPCODE_MATRIX_POP, 1);
9483    if (ctx->ExecuteFlag) {
9484       CALL_MatrixPopEXT(ctx->Exec, (matrixMode));
9524    GET_CURRENT_CONTEXT(ctx);
9526    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9527    n = alloc_instruction(ctx, OPCODE_TEXTUREPARAMETER_F, 7);
9537    if (ctx->ExecuteFlag) {
9538       CALL_TextureParameterfvEXT(ctx->Exec, (texture, target, pname, params));
9555    GET_CURRENT_CONTEXT(ctx);
9557    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9558    n = alloc_instruction(ctx, OPCODE_TEXTUREPARAMETER_I, 7);
9568    if (ctx->ExecuteFlag) {
9569       CALL_TextureParameterivEXT(ctx->Exec, (texture, target, pname, params));
9585    GET_CURRENT_CONTEXT(ctx);
9587    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9588    n = alloc_instruction(ctx, OPCODE_TEXTUREPARAMETER_II, 7);
9598    if (ctx->ExecuteFlag) {
9599       CALL_TextureParameterIivEXT(ctx->Exec, (texture, target, pname, params));
9606    GET_CURRENT_CONTEXT(ctx);
9608    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9609    n = alloc_instruction(ctx, OPCODE_TEXTUREPARAMETER_IUI, 7);
9619    if (ctx->ExecuteFlag) {
9620       CALL_TextureParameterIuivEXT(ctx->Exec, (texture, target, pname, params));
9631    GET_CURRENT_CONTEXT(ctx);
9634       CALL_TextureImage1DEXT(ctx->Exec, (texture, target, level, components, width,
9639       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9640       n = alloc_instruction(ctx, OPCODE_TEXTURE_IMAGE1D, 8 + POINTER_DWORDS);
9651                       unpack_image(ctx, 1, width, 1, 1, format, type,
9652                                    pixels, &ctx->Unpack));
9654       if (ctx->ExecuteFlag) {
9655          CALL_TextureImage1DEXT(ctx->Exec, (texture, target, level, components, width,
9668    GET_CURRENT_CONTEXT(ctx);
9671       CALL_TextureImage2DEXT(ctx->Exec, (texture, target, level, components, width,
9676       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9677       n = alloc_instruction(ctx, OPCODE_TEXTURE_IMAGE2D, 9 + POINTER_DWORDS);
9689                       unpack_image(ctx, 2, width, height, 1, format, type,
9690                                    pixels, &ctx->Unpack));
9692       if (ctx->ExecuteFlag) {
9693          CALL_TextureImage2DEXT(ctx->Exec, (texture, target, level, components, width,
9707    GET_CURRENT_CONTEXT(ctx);
9710       CALL_TextureImage3DEXT(ctx->Exec, (texture, target, level, internalFormat, width,
9716       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9717       n = alloc_instruction(ctx, OPCODE_TEXTURE_IMAGE3D, 10 + POINTER_DWORDS);
9730                       unpack_image(ctx, 3, width, height, depth, format, type,
9731                                    pixels, &ctx->Unpack));
9733       if (ctx->ExecuteFlag) {
9734          CALL_TextureImage3DEXT(ctx->Exec, (texture, target, level, internalFormat,
9747    GET_CURRENT_CONTEXT(ctx);
9750    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9752    n = alloc_instruction(ctx, OPCODE_TEXTURE_SUB_IMAGE1D, 7 + POINTER_DWORDS);
9762                    unpack_image(ctx, 1, width, 1, 1, format, type,
9763                                 pixels, &ctx->Unpack));
9765    if (ctx->ExecuteFlag) {
9766       CALL_TextureSubImage1DEXT(ctx->Exec, (texture, target, level, xoffset, width,
9778    GET_CURRENT_CONTEXT(ctx);
9781    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9783    n = alloc_instruction(ctx, OPCODE_TEXTURE_SUB_IMAGE2D, 9 + POINTER_DWORDS);
9795                    unpack_image(ctx, 2, width, height, 1, format, type,
9796                                 pixels, &ctx->Unpack));
9798    if (ctx->ExecuteFlag) {
9799       CALL_TextureSubImage2DEXT(ctx->Exec, (texture, target, level, xoffset, yoffset,
9811    GET_CURRENT_CONTEXT(ctx);
9814    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9816    n = alloc_instruction(ctx, OPCODE_TEXTURE_SUB_IMAGE3D, 11 + POINTER_DWORDS);
9830                    unpack_image(ctx, 3, width, height, depth, format, type,
9831                                 pixels, &ctx->Unpack));
9833    if (ctx->ExecuteFlag) {
9834       CALL_TextureSubImage3DEXT(ctx->Exec, (texture, target, level,
9846    GET_CURRENT_CONTEXT(ctx);
9848    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9849    n = alloc_instruction(ctx, OPCODE_COPY_TEXTURE_IMAGE1D, 8);
9860    if (ctx->ExecuteFlag) {
9861       CALL_CopyTextureImage1DEXT(ctx->Exec, (texture, target, level,
9873    GET_CURRENT_CONTEXT(ctx);
9875    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9876    n = alloc_instruction(ctx, OPCODE_COPY_TEXTURE_IMAGE2D, 9);
9888    if (ctx->ExecuteFlag) {
9889       CALL_CopyTextureImage2DEXT(ctx->Exec, (texture, target, level,
9899    GET_CURRENT_CONTEXT(ctx);
9901    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9902    n = alloc_instruction(ctx, OPCODE_COPY_TEXTURE_SUB_IMAGE1D, 7);
9912    if (ctx->ExecuteFlag) {
9913       CALL_CopyTextureSubImage1DEXT(ctx->Exec,
9923    GET_CURRENT_CONTEXT(ctx);
9925    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9926    n = alloc_instruction(ctx, OPCODE_COPY_TEXTURE_SUB_IMAGE2D, 9);
9938    if (ctx->ExecuteFlag) {
9939       CALL_CopyTextureSubImage2DEXT(ctx->Exec, (texture, target, level,
9951    GET_CURRENT_CONTEXT(ctx);
9953    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9954    n = alloc_instruction(ctx, OPCODE_COPY_TEXTURE_SUB_IMAGE3D, 10);
9967    if (ctx->ExecuteFlag) {
9968       CALL_CopyTextureSubImage3DEXT(ctx->Exec, (texture, target, level,
9978    GET_CURRENT_CONTEXT(ctx);
9980    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
9981    n = alloc_instruction(ctx, OPCODE_BIND_MULTITEXTURE, 3);
9987    if (ctx->ExecuteFlag) {
9988       CALL_BindMultiTextureEXT(ctx->Exec, (texunit, target, texture));
9997    GET_CURRENT_CONTEXT(ctx);
9999    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10000    n = alloc_instruction(ctx, OPCODE_MULTITEXPARAMETER_F, 7);
10010    if (ctx->ExecuteFlag) {
10011       CALL_MultiTexParameterfvEXT(ctx->Exec, (texunit, target, pname, params));
10028    GET_CURRENT_CONTEXT(ctx);
10030    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10031    n = alloc_instruction(ctx, OPCODE_MULTITEXPARAMETER_I, 7);
10041    if (ctx->ExecuteFlag) {
10042       CALL_MultiTexParameterivEXT(ctx->Exec, (texunit, target, pname, params));
10049    GET_CURRENT_CONTEXT(ctx);
10051    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10052    n = alloc_instruction(ctx, OPCODE_MULTITEXPARAMETER_II, 7);
10062    if (ctx->ExecuteFlag) {
10063       CALL_MultiTexParameterIivEXT(ctx->Exec, (texunit, target, pname, params));
10070    GET_CURRENT_CONTEXT(ctx);
10072    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10073    n = alloc_instruction(ctx, OPCODE_MULTITEXPARAMETER_IUI, 7);
10083    if (ctx->ExecuteFlag) {
10084       CALL_MultiTexParameterIuivEXT(ctx->Exec, (texunit, target, pname, params));
10104    GET_CURRENT_CONTEXT(ctx);
10107       CALL_MultiTexImage1DEXT(ctx->Exec, (texunit, target, level, components, width,
10112       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10113       n = alloc_instruction(ctx, OPCODE_MULTITEX_IMAGE1D, 8 + POINTER_DWORDS);
10124                       unpack_image(ctx, 1, width, 1, 1, format, type,
10125                                    pixels, &ctx->Unpack));
10127       if (ctx->ExecuteFlag) {
10128          CALL_MultiTexImage1DEXT(ctx->Exec, (texunit, target, level, components, width,
10141    GET_CURRENT_CONTEXT(ctx);
10144       CALL_MultiTexImage2DEXT(ctx->Exec, (texunit, target, level, components, width,
10149       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10150       n = alloc_instruction(ctx, OPCODE_MULTITEX_IMAGE2D, 9 + POINTER_DWORDS);
10162                       unpack_image(ctx, 2, width, height, 1, format, type,
10163                                    pixels, &ctx->Unpack));
10165       if (ctx->ExecuteFlag) {
10166          CALL_MultiTexImage2DEXT(ctx->Exec, (texunit, target, level, components, width,
10180    GET_CURRENT_CONTEXT(ctx);
10183       CALL_MultiTexImage3DEXT(ctx->Exec, (texunit, target, level, internalFormat, width,
10189       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10190       n = alloc_instruction(ctx, OPCODE_MULTITEX_IMAGE3D, 10 + POINTER_DWORDS);
10203                       unpack_image(ctx, 3, width, height, depth, format, type,
10204                                    pixels, &ctx->Unpack));
10206       if (ctx->ExecuteFlag) {
10207          CALL_MultiTexImage3DEXT(ctx->Exec, (texunit, target, level, internalFormat,
10220    GET_CURRENT_CONTEXT(ctx);
10223    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10225    n = alloc_instruction(ctx, OPCODE_MULTITEX_SUB_IMAGE1D, 7 + POINTER_DWORDS);
10235                    unpack_image(ctx, 1, width, 1, 1, format, type,
10236                                 pixels, &ctx->Unpack));
10238    if (ctx->ExecuteFlag) {
10239       CALL_MultiTexSubImage1DEXT(ctx->Exec, (texunit, target, level, xoffset, width,
10251    GET_CURRENT_CONTEXT(ctx);
10254    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10256    n = alloc_instruction(ctx, OPCODE_MULTITEX_SUB_IMAGE2D, 9 + POINTER_DWORDS);
10268                    unpack_image(ctx, 2, width, height, 1, format, type,
10269                                 pixels, &ctx->Unpack));
10271    if (ctx->ExecuteFlag) {
10272       CALL_MultiTexSubImage2DEXT(ctx->Exec, (texunit, target, level, xoffset, yoffset,
10284    GET_CURRENT_CONTEXT(ctx);
10287    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10289    n = alloc_instruction(ctx, OPCODE_MULTITEX_SUB_IMAGE3D, 11 + POINTER_DWORDS);
10303                    unpack_image(ctx, 3, width, height, depth, format, type,
10304                                 pixels, &ctx->Unpack));
10306    if (ctx->ExecuteFlag) {
10307       CALL_MultiTexSubImage3DEXT(ctx->Exec, (texunit, target, level,
10320    GET_CURRENT_CONTEXT(ctx);
10322    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10323    n = alloc_instruction(ctx, OPCODE_COPY_MULTITEX_IMAGE1D, 8);
10334    if (ctx->ExecuteFlag) {
10335       CALL_CopyMultiTexImage1DEXT(ctx->Exec, (texunit, target, level,
10348    GET_CURRENT_CONTEXT(ctx);
10350    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10351    n = alloc_instruction(ctx, OPCODE_COPY_MULTITEX_IMAGE2D, 9);
10363    if (ctx->ExecuteFlag) {
10364       CALL_CopyMultiTexImage2DEXT(ctx->Exec, (texunit, target, level,
10375    GET_CURRENT_CONTEXT(ctx);
10377    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10378    n = alloc_instruction(ctx, OPCODE_COPY_MULTITEX_SUB_IMAGE1D, 7);
10388    if (ctx->ExecuteFlag) {
10389       CALL_CopyMultiTexSubImage1DEXT(ctx->Exec,
10400    GET_CURRENT_CONTEXT(ctx);
10402    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10403    n = alloc_instruction(ctx, OPCODE_COPY_MULTITEX_SUB_IMAGE2D, 9);
10415    if (ctx->ExecuteFlag) {
10416       CALL_CopyMultiTexSubImage2DEXT(ctx->Exec, (texunit, target, level,
10428    GET_CURRENT_CONTEXT(ctx);
10430    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10431    n = alloc_instruction(ctx, OPCODE_COPY_MULTITEX_SUB_IMAGE3D, 10);
10444    if (ctx->ExecuteFlag) {
10445       CALL_CopyMultiTexSubImage3DEXT(ctx->Exec, (texunit, target, level,
10455    GET_CURRENT_CONTEXT(ctx);
10457    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10458    n = alloc_instruction(ctx, OPCODE_MULTITEXENV, 7);
10474    if (ctx->ExecuteFlag) {
10475       CALL_MultiTexEnvfvEXT(ctx->Exec, (texunit, target, pname, params));
10524    GET_CURRENT_CONTEXT(ctx);
10527       CALL_CompressedTextureImage1DEXT(ctx->Exec, (texture, target, level,
10534       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10536       n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEXTURE_IMAGE_1D,
10549       if (ctx->ExecuteFlag) {
10550          CALL_CompressedTextureImage1DEXT(ctx->Exec,
10564    GET_CURRENT_CONTEXT(ctx);
10567       CALL_CompressedTextureImage2DEXT(ctx->Exec, (texture, target, level,
10573       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10575       n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEXTURE_IMAGE_2D,
10589       if (ctx->ExecuteFlag) {
10590          CALL_CompressedTextureImage2DEXT(ctx->Exec,
10604    GET_CURRENT_CONTEXT(ctx);
10607       CALL_CompressedTextureImage3DEXT(ctx->Exec, (texture, target, level,
10614       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10616       n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEXTURE_IMAGE_3D,
10631       if (ctx->ExecuteFlag) {
10632          CALL_CompressedTextureImage3DEXT(ctx->Exec,
10647    GET_CURRENT_CONTEXT(ctx);
10648    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10650    n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEXTURE_SUB_IMAGE_1D,
10663    if (ctx->ExecuteFlag) {
10664       CALL_CompressedTextureSubImage1DEXT(ctx->Exec, (texture, target, level, xoffset,
10677    GET_CURRENT_CONTEXT(ctx);
10678    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10680    n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEXTURE_SUB_IMAGE_2D,
10695    if (ctx->ExecuteFlag) {
10696       CALL_CompressedTextureSubImage2DEXT(ctx->Exec,
10710    GET_CURRENT_CONTEXT(ctx);
10711    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10713    n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEXTURE_SUB_IMAGE_3D,
10730    if (ctx->ExecuteFlag) {
10731       CALL_CompressedTextureSubImage3DEXT(ctx->Exec,
10745    GET_CURRENT_CONTEXT(ctx);
10748       CALL_CompressedMultiTexImage1DEXT(ctx->Exec, (texunit, target, level,
10755       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10757       n = alloc_instruction(ctx, OPCODE_COMPRESSED_MULTITEX_IMAGE_1D,
10770       if (ctx->ExecuteFlag) {
10771          CALL_CompressedMultiTexImage1DEXT(ctx->Exec,
10785    GET_CURRENT_CONTEXT(ctx);
10788       CALL_CompressedMultiTexImage2DEXT(ctx->Exec, (texunit, target, level,
10794       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10796       n = alloc_instruction(ctx, OPCODE_COMPRESSED_MULTITEX_IMAGE_2D,
10810       if (ctx->ExecuteFlag) {
10811          CALL_CompressedMultiTexImage2DEXT(ctx->Exec,
10825    GET_CURRENT_CONTEXT(ctx);
10828       CALL_CompressedMultiTexImage3DEXT(ctx->Exec, (texunit, target, level,
10835       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10837       n = alloc_instruction(ctx, OPCODE_COMPRESSED_MULTITEX_IMAGE_3D,
10852       if (ctx->ExecuteFlag) {
10853          CALL_CompressedMultiTexImage3DEXT(ctx->Exec,
10868    GET_CURRENT_CONTEXT(ctx);
10869    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10871    n = alloc_instruction(ctx, OPCODE_COMPRESSED_MULTITEX_SUB_IMAGE_1D,
10884    if (ctx->ExecuteFlag) {
10885       CALL_CompressedMultiTexSubImage1DEXT(ctx->Exec, (texunit, target, level, xoffset,
10898    GET_CURRENT_CONTEXT(ctx);
10899    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10901    n = alloc_instruction(ctx, OPCODE_COMPRESSED_MULTITEX_SUB_IMAGE_2D,
10916    if (ctx->ExecuteFlag) {
10917       CALL_CompressedMultiTexSubImage2DEXT(ctx->Exec,
10931    GET_CURRENT_CONTEXT(ctx);
10932    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10934    n = alloc_instruction(ctx, OPCODE_COMPRESSED_MULTITEX_SUB_IMAGE_3D,
10951    if (ctx->ExecuteFlag) {
10952       CALL_CompressedMultiTexSubImage3DEXT(ctx->Exec,
10964    GET_CURRENT_CONTEXT(ctx);
10967    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10969    n = alloc_instruction(ctx, OPCODE_NAMED_PROGRAM_STRING, 4 + POINTER_DWORDS);
10973          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glNamedProgramStringEXT");
10983    if (ctx->ExecuteFlag) {
10984       CALL_NamedProgramStringEXT(ctx->Exec, (program, target, format, len, string));
10993    GET_CURRENT_CONTEXT(ctx);
10995    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
10996    n = alloc_instruction(ctx, OPCODE_NAMED_PROGRAM_LOCAL_PARAMETER, 7);
11006    if (ctx->ExecuteFlag) {
11007       CALL_NamedProgramLocalParameter4fEXT(ctx->Exec, (program, target, index, x, y, z, w));
11044    GET_CURRENT_CONTEXT(ctx);
11046    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
11047    n = alloc_instruction(ctx, OPCODE_PRIMITIVE_BOUNDING_BOX, 8);
11058    if (ctx->ExecuteFlag) {
11059       CALL_PrimitiveBoundingBox(ctx->Exec, (minX, minY, minZ, minW,
11071 save_error(struct gl_context *ctx, GLenum error, const char *s)
11074    n = alloc_instruction(ctx, OPCODE_ERROR, 1 + POINTER_DWORDS);
11090 _mesa_compile_error(struct gl_context *ctx, GLenum error, const char *s)
11092    if (ctx->CompileFlag)
11093       save_error(ctx, error, s);
11094    if (ctx->ExecuteFlag)
11095       _mesa_error(ctx, error, "%s", s);
11103 _mesa_get_list(struct gl_context *ctx, GLuint list,
11108       list > 0 ? _mesa_lookup_list(ctx, list, locked) : NULL;
11127  * Must be called with ctx->Shared->DisplayList locked.
11131 execute_list(struct gl_context *ctx, GLuint list)
11136    if (list == 0 || !_mesa_get_list(ctx, list, &dlist, true))
11139    n = get_list_head(ctx, dlist);
11146             _mesa_error(ctx, n[1].e, "%s", (const char *) get_pointer(&n[2]));
11149             CALL_Accum(ctx->Exec, (n[1].e, n[2].f));
11152             CALL_AlphaFunc(ctx->Exec, (n[1].e, n[2].f));
11155             CALL_BindTexture(ctx->Exec, (n[1].e, n[2].ui));
11159                const struct gl_pixelstore_attrib save = ctx->Unpack;
11160                ctx->Unpack = ctx->DefaultPacking;
11161                CALL_Bitmap(ctx->Exec, ((GLsizei) n[1].i, (GLsizei) n[2].i,
11164                ctx->Unpack = save;      /* restore */
11168             CALL_BlendColor(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
11171             CALL_BlendEquation(ctx->Exec, (n[1].e));
11174             CALL_BlendEquationSeparate(ctx->Exec, (n[1].e, n[2].e));
11177             CALL_BlendFuncSeparate(ctx->Exec,
11183             CALL_BlendFunciARB(ctx->Exec, (n[1].ui, n[2].e, n[3].e));
11187             CALL_BlendFuncSeparateiARB(ctx->Exec, (n[1].ui, n[2].e, n[3].e,
11192             CALL_BlendEquationiARB(ctx->Exec, (n[1].ui, n[2].e));
11196             CALL_BlendEquationSeparateiARB(ctx->Exec,
11202             if (ctx->ListState.CallDepth < MAX_LIST_NESTING) {
11203                ctx->ListState.CallDepth++;
11204                execute_list(ctx, n[1].ui);
11205                ctx->ListState.CallDepth--;
11209             if (ctx->ListState.CallDepth < MAX_LIST_NESTING) {
11210                ctx->ListState.CallDepth++;
11211                _mesa_HashUnlockMutex(ctx->Shared->DisplayList);
11212                CALL_CallLists(ctx->Exec, (n[1].i, n[2].e, get_pointer(&n[3])));
11213                _mesa_HashLockMutex(ctx->Shared->DisplayList);
11214                ctx->ListState.CallDepth--;
11218             CALL_Clear(ctx->Exec, (n[1].bf));
11227                CALL_ClearBufferiv(ctx->Exec, (n[1].e, n[2].i, value));
11237                CALL_ClearBufferuiv(ctx->Exec, (n[1].e, n[2].i, value));
11247                CALL_ClearBufferfv(ctx->Exec, (n[1].e, n[2].i, value));
11251             CALL_ClearBufferfi(ctx->Exec, (n[1].e, n[2].i, n[3].f, n[4].i));
11254             CALL_ClearColor(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
11257             CALL_ClearAccum(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
11260             CALL_ClearDepth(ctx->Exec, ((GLclampd) n[1].f));
11263             CALL_ClearIndex(ctx->Exec, ((GLfloat) n[1].ui));
11266             CALL_ClearStencil(ctx->Exec, (n[1].i));
11275                CALL_ClipPlane(ctx->Exec, (n[1].e, eq));
11279             CALL_ColorMask(ctx->Exec, (n[1].b, n[2].b, n[3].b, n[4].b));
11282             CALL_ColorMaski(ctx->Exec, (n[1].ui, n[2].b, n[3].b,
11286             CALL_ColorMaterial(ctx->Exec, (n[1].e, n[2].e));
11289             CALL_CopyPixels(ctx->Exec, (n[1].i, n[2].i,
11294             CALL_CopyTexImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].i,
11298             CALL_CopyTexImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].i,
11302             CALL_CopyTexSubImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
11306             CALL_CopyTexSubImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
11311             CALL_CopyTexSubImage3D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
11316             CALL_CullFace(ctx->Exec, (n[1].e));
11319             CALL_DepthFunc(ctx->Exec, (n[1].e));
11322             CALL_DepthMask(ctx->Exec, (n[1].b));
11325             CALL_DepthRange(ctx->Exec,
11329             CALL_Disable(ctx->Exec, (n[1].e));
11332             CALL_Disablei(ctx->Exec, (n[1].ui, n[2].e));
11335             CALL_DrawBuffer(ctx->Exec, (n[1].e));
11339                const struct gl_pixelstore_attrib save = ctx->Unpack;
11340                ctx->Unpack = ctx->DefaultPacking;
11341                CALL_DrawPixels(ctx->Exec, (n[1].i, n[2].i, n[3].e, n[4].e,
11343                ctx->Unpack = save;      /* restore */
11347             CALL_Enable(ctx->Exec, (n[1].e));
11350             CALL_Enablei(ctx->Exec, (n[1].ui, n[2].e));
11353             CALL_EvalMesh1(ctx->Exec, (n[1].e, n[2].i, n[3].i));
11356             CALL_EvalMesh2(ctx->Exec,
11366                CALL_Fogfv(ctx->Exec, (n[1].e, p));
11370             CALL_FrontFace(ctx->Exec, (n[1].e));
11373             CALL_Frustum(ctx->Exec,
11377             CALL_Hint(ctx->Exec, (n[1].e, n[2].e));
11380             CALL_IndexMask(ctx->Exec, (n[1].ui));
11383             CALL_InitNames(ctx->Exec, ());
11392                CALL_Lightfv(ctx->Exec, (n[1].e, n[2].e, p));
11402                CALL_LightModelfv(ctx->Exec, (n[1].e, p));
11406             CALL_LineStipple(ctx->Exec, (n[1].i, n[2].us));
11409             CALL_LineWidth(ctx->Exec, (n[1].f));
11412             CALL_ListBase(ctx->Exec, (n[1].ui));
11415             CALL_LoadIdentity(ctx->Exec, ());
11419             CALL_LoadMatrixf(ctx->Exec, (&n[1].f));
11422             CALL_LoadName(ctx->Exec, (n[1].ui));
11425             CALL_LogicOp(ctx->Exec, (n[1].e));
11434                CALL_Map1f(ctx->Exec, (target, u1, u2, ustride, uorder,
11449                CALL_Map2f(ctx->Exec, (target, u1, u2, ustride, uorder,
11455             CALL_MapGrid1f(ctx->Exec, (n[1].i, n[2].f, n[3].f));
11458             CALL_MapGrid2f(ctx->Exec,
11462             CALL_MatrixMode(ctx->Exec, (n[1].e));
11465             CALL_MultMatrixf(ctx->Exec, (&n[1].f));
11468             CALL_Ortho(ctx->Exec,
11472             CALL_PassThrough(ctx->Exec, (n[1].f));
11475             CALL_PatchParameteri(ctx->Exec, (n[1].e, n[2].i));
11482                CALL_PatchParameterfv(ctx->Exec, (n[1].e, params));
11492                CALL_PatchParameterfv(ctx->Exec, (n[1].e, params));
11496             CALL_PixelMapfv(ctx->Exec,
11500             CALL_PixelTransferf(ctx->Exec, (n[1].e, n[2].f));
11503             CALL_PixelZoom(ctx->Exec, (n[1].f, n[2].f));
11506             CALL_PointSize(ctx->Exec, (n[1].f));
11514                CALL_PointParameterfv(ctx->Exec, (n[1].e, params));
11518             CALL_PolygonMode(ctx->Exec, (n[1].e, n[2].e));
11522                const struct gl_pixelstore_attrib save = ctx->Unpack;
11523                ctx->Unpack = ctx->DefaultPacking;
11524                CALL_PolygonStipple(ctx->Exec, (get_pointer(&n[1])));
11525                ctx->Unpack = save;      /* restore */
11529             CALL_PolygonOffset(ctx->Exec, (n[1].f, n[2].f));
11532             CALL_PolygonOffsetClampEXT(ctx->Exec, (n[1].f, n[2].f, n[3].f));
11535             CALL_PopAttrib(ctx->Exec, ());
11538             CALL_PopMatrix(ctx->Exec, ());
11541             CALL_PopName(ctx->Exec, ());
11544             CALL_PrioritizeTextures(ctx->Exec, (1, &n[1].ui, &n[2].f));
11547             CALL_PushAttrib(ctx->Exec, (n[1].bf));
11550             CALL_PushMatrix(ctx->Exec, ());
11553             CALL_PushName(ctx->Exec, (n[1].ui));
11556             CALL_RasterPos4f(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
11559             CALL_ReadBuffer(ctx->Exec, (n[1].e));
11562             CALL_Rotatef(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
11565             CALL_Scalef(ctx->Exec, (n[1].f, n[2].f, n[3].f));
11568             CALL_Scissor(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
11571             CALL_ShadeModel(ctx->Exec, (n[1].e));
11574             CALL_ProvokingVertex(ctx->Exec, (n[1].e));
11577             CALL_StencilFunc(ctx->Exec, (n[1].e, n[2].i, n[3].ui));
11580             CALL_StencilMask(ctx->Exec, (n[1].ui));
11583             CALL_StencilOp(ctx->Exec, (n[1].e, n[2].e, n[3].e));
11586             CALL_StencilFuncSeparate(ctx->Exec,
11590             CALL_StencilMaskSeparate(ctx->Exec, (n[1].e, n[2].ui));
11593             CALL_StencilOpSeparate(ctx->Exec,
11603                CALL_TexEnvfv(ctx->Exec, (n[1].e, n[2].e, params));
11613                CALL_TexGenfv(ctx->Exec, (n[1].e, n[2].e, params));
11623                CALL_TexParameterfv(ctx->Exec, (n[1].e, n[2].e, params));
11628                const struct gl_pixelstore_attrib save = ctx->Unpack;
11629                ctx->Unpack = ctx->DefaultPacking;
11630                CALL_TexImage1D(ctx->Exec, (n[1].e,      /* target */
11638                ctx->Unpack = save;      /* restore */
11643                const struct gl_pixelstore_attrib save = ctx->Unpack;
11644                ctx->Unpack = ctx->DefaultPacking;
11645                CALL_TexImage2D(ctx->Exec, (n[1].e,      /* target */
11654                ctx->Unpack = save;      /* restore */
11659                const struct gl_pixelstore_attrib save = ctx->Unpack;
11660                ctx->Unpack = ctx->DefaultPacking;
11661                CALL_TexImage3D(ctx->Exec, (n[1].e,      /* target */
11671                ctx->Unpack = save;      /* restore */
11676                const struct gl_pixelstore_attrib save = ctx->Unpack;
11677                ctx->Unpack = ctx->DefaultPacking;
11678                CALL_TexSubImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
11681                ctx->Unpack = save;      /* restore */
11686                const struct gl_pixelstore_attrib save = ctx->Unpack;
11687                ctx->Unpack = ctx->DefaultPacking;
11688                CALL_TexSubImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
11692                ctx->Unpack = save;      /* restore */
11697                const struct gl_pixelstore_attrib save = ctx->Unpack;
11698                ctx->Unpack = ctx->DefaultPacking;
11699                CALL_TexSubImage3D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
11703                ctx->Unpack = save;      /* restore */
11707             CALL_Translatef(ctx->Exec, (n[1].f, n[2].f, n[3].f));
11710             CALL_Viewport(ctx->Exec, (n[1].i, n[2].i,
11714             CALL_WindowPos4fMESA(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
11717             CALL_ViewportArrayv(ctx->Exec, (n[1].ui, n[2].si,
11721             CALL_ViewportIndexedf(ctx->Exec, (n[1].ui, n[2].f, n[3].f, n[4].f,
11730             CALL_ViewportIndexedfv(ctx->Exec, (n[1].ui, v));
11734             CALL_ScissorArrayv(ctx->Exec, (n[1].ui, n[2].si,
11738             CALL_ScissorIndexed(ctx->Exec, (n[1].ui, n[2].i, n[3].i, n[4].si,
11747             CALL_ScissorIndexedv(ctx->Exec, (n[1].ui, v));
11751             CALL_DepthRangeArrayv(ctx->Exec, (n[1].ui, n[2].si,
11755             CALL_DepthRangeIndexed(ctx->Exec, (n[1].ui, n[2].f, n[3].f));
11758             CALL_ActiveTexture(ctx->Exec, (n[1].e));
11761             CALL_CompressedTexImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].e,
11766             CALL_CompressedTexImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].e,
11771             CALL_CompressedTexImage3D(ctx->Exec, (n[1].e, n[2].i, n[3].e,
11777             CALL_CompressedTexSubImage1D(ctx->Exec,
11783             CALL_CompressedTexSubImage2D(ctx->Exec,
11789             CALL_CompressedTexSubImage3D(ctx->Exec,
11796             CALL_SampleCoverage(ctx->Exec, (n[1].f, n[2].b));
11799             CALL_WindowPos3f(ctx->Exec, (n[1].f, n[2].f, n[3].f));
11802             CALL_BindProgramARB(ctx->Exec, (n[1].e, n[2].ui));
11805             CALL_ProgramLocalParameter4fARB(ctx->Exec,
11810             CALL_ActiveStencilFaceEXT(ctx->Exec, (n[1].e));
11813             CALL_DepthBoundsEXT(ctx->Exec, (n[1].f, n[2].f));
11816             CALL_ProgramStringARB(ctx->Exec,
11821             CALL_ProgramEnvParameter4fARB(ctx->Exec, (n[1].e, n[2].ui, n[3].f,
11826             CALL_BeginQuery(ctx->Exec, (n[1].e, n[2].ui));
11829             CALL_EndQuery(ctx->Exec, (n[1].e));
11832             CALL_QueryCounter(ctx->Exec, (n[1].ui, n[2].e));
11835             CALL_BeginQueryIndexed(ctx->Exec, (n[1].e, n[2].ui, n[3].ui));
11838             CALL_EndQueryIndexed(ctx->Exec, (n[1].e, n[2].ui));
11846                CALL_DrawBuffers(ctx->Exec, (n[1].i, buffers));
11850             CALL_BlitFramebuffer(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i,
11855             CALL_PrimitiveRestartNV(ctx->Exec, ());
11859             CALL_UseProgram(ctx->Exec, (n[1].ui));
11862             CALL_Uniform1f(ctx->Exec, (n[1].i, n[2].f));
11865             CALL_Uniform2f(ctx->Exec, (n[1].i, n[2].f, n[3].f));
11868             CALL_Uniform3f(ctx->Exec, (n[1].i, n[2].f, n[3].f, n[4].f));
11871             CALL_Uniform4f(ctx->Exec,
11875             CALL_Uniform1fv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
11878             CALL_Uniform2fv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
11881             CALL_Uniform3fv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
11884             CALL_Uniform4fv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
11892             CALL_Uniform1d(ctx->Exec, (n[1].i, x.d));
11904             CALL_Uniform2d(ctx->Exec, (n[1].i, x.d, y.d));
11919             CALL_Uniform3d(ctx->Exec, (n[1].i, x.d, y.d, z.d));
11937             CALL_Uniform4d(ctx->Exec, (n[1].i, x.d, y.d, z.d, w.d));
11941             CALL_Uniform1dv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
11944             CALL_Uniform2dv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
11947             CALL_Uniform3dv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
11950             CALL_Uniform4dv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
11953             CALL_Uniform1i(ctx->Exec, (n[1].i, n[2].i));
11956             CALL_Uniform2i(ctx->Exec, (n[1].i, n[2].i, n[3].i));
11959             CALL_Uniform3i(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
11962             CALL_Uniform4i(ctx->Exec,
11966             CALL_Uniform1iv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
11969             CALL_Uniform2iv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
11972             CALL_Uniform3iv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
11975             CALL_Uniform4iv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
11978             CALL_Uniform1ui(ctx->Exec, (n[1].i, n[2].i));
11981             CALL_Uniform2ui(ctx->Exec, (n[1].i, n[2].i, n[3].i));
11984             CALL_Uniform3ui(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
11987             CALL_Uniform4ui(ctx->Exec,
11991             CALL_Uniform1uiv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
11994             CALL_Uniform2uiv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
11997             CALL_Uniform3uiv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
12000             CALL_Uniform4uiv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
12003             CALL_UniformMatrix2fv(ctx->Exec,
12007             CALL_UniformMatrix3fv(ctx->Exec,
12011             CALL_UniformMatrix4fv(ctx->Exec,
12015             CALL_UniformMatrix2x3fv(ctx->Exec,
12019             CALL_UniformMatrix3x2fv(ctx->Exec,
12023             CALL_UniformMatrix2x4fv(ctx->Exec,
12027             CALL_UniformMatrix4x2fv(ctx->Exec,
12031             CALL_UniformMatrix3x4fv(ctx->Exec,
12035             CALL_UniformMatrix4x3fv(ctx->Exec,
12039             CALL_UniformMatrix2dv(ctx->Exec,
12043             CALL_UniformMatrix3dv(ctx->Exec,
12047             CALL_UniformMatrix4dv(ctx->Exec,
12051             CALL_UniformMatrix2x3dv(ctx->Exec,
12055             CALL_UniformMatrix3x2dv(ctx->Exec,
12059             CALL_UniformMatrix2x4dv(ctx->Exec,
12063             CALL_UniformMatrix4x2dv(ctx->Exec,
12067             CALL_UniformMatrix3x4dv(ctx->Exec,
12071             CALL_UniformMatrix4x3dv(ctx->Exec,
12081             CALL_Uniform1i64ARB(ctx->Exec, (n[1].i, x.int64));
12093             CALL_Uniform2i64ARB(ctx->Exec, (n[1].i, x.int64, y.int64));
12109             CALL_Uniform3i64ARB(ctx->Exec, (n[1].i, x.int64, y.int64, z.int64));
12127             CALL_Uniform4i64ARB(ctx->Exec, (n[1].i, x.int64, y.int64, z.int64, w.int64));
12131             CALL_Uniform1i64vARB(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
12134             CALL_Uniform2i64vARB(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
12137             CALL_Uniform3i64vARB(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
12140             CALL_Uniform4i64vARB(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
12148             CALL_Uniform1ui64ARB(ctx->Exec, (n[1].i, x.uint64));
12160             CALL_Uniform2ui64ARB(ctx->Exec, (n[1].i, x.uint64, y.uint64));
12176             CALL_Uniform3ui64ARB(ctx->Exec, (n[1].i, x.uint64, y.uint64,
12195             CALL_Uniform4ui64ARB(ctx->Exec, (n[1].i, x.uint64, y.uint64,
12200             CALL_Uniform1ui64vARB(ctx->Exec, (n[1].i, n[2].i,
12204             CALL_Uniform2ui64vARB(ctx->Exec, (n[1].i, n[2].i,
12208             CALL_Uniform3ui64vARB(ctx->Exec, (n[1].i, n[2].i,
12212             CALL_Uniform4ui64vARB(ctx->Exec, (n[1].i, n[2].i,
12222             CALL_ProgramUniform1i64ARB(ctx->Exec, (n[1].ui, n[2].i, x.int64));
12234             CALL_ProgramUniform2i64ARB(ctx->Exec, (n[1].ui, n[2].i, x.int64,
12250             CALL_ProgramUniform3i64ARB(ctx->Exec, (n[1].ui, n[2].i, x.int64,
12269             CALL_ProgramUniform4i64ARB(ctx->Exec, (n[1].ui, n[2].i, x.int64,
12274             CALL_ProgramUniform1i64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12278             CALL_ProgramUniform2i64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12282             CALL_ProgramUniform3i64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12286             CALL_ProgramUniform4i64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12295             CALL_ProgramUniform1i64ARB(ctx->Exec, (n[1].ui, n[2].i, x.uint64));
12307             CALL_ProgramUniform2ui64ARB(ctx->Exec, (n[1].ui, n[2].i, x.uint64,
12323             CALL_ProgramUniform3ui64ARB(ctx->Exec, (n[1].ui, n[2].i, x.uint64,
12342             CALL_ProgramUniform4ui64ARB(ctx->Exec, (n[1].ui, n[2].i, x.uint64,
12347             CALL_ProgramUniform1ui64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12351             CALL_ProgramUniform2ui64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12355             CALL_ProgramUniform3ui64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12359             CALL_ProgramUniform4ui64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12364             CALL_UseProgramStages(ctx->Exec, (n[1].ui, n[2].ui, n[3].ui));
12367             CALL_ProgramUniform1f(ctx->Exec, (n[1].ui, n[2].i, n[3].f));
12370             CALL_ProgramUniform2f(ctx->Exec, (n[1].ui, n[2].i, n[3].f, n[4].f));
12373             CALL_ProgramUniform3f(ctx->Exec, (n[1].ui, n[2].i,
12377             CALL_ProgramUniform4f(ctx->Exec, (n[1].ui, n[2].i,
12381             CALL_ProgramUniform1fv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12385             CALL_ProgramUniform2fv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12389             CALL_ProgramUniform3fv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12393             CALL_ProgramUniform4fv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12402             CALL_ProgramUniform1d(ctx->Exec, (n[1].ui, n[2].i, x.d));
12414             CALL_ProgramUniform2d(ctx->Exec, (n[1].ui, n[2].i, x.d, y.d));
12429             CALL_ProgramUniform3d(ctx->Exec, (n[1].ui, n[2].i,
12448             CALL_ProgramUniform4d(ctx->Exec, (n[1].ui, n[2].i,
12453             CALL_ProgramUniform1dv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12457             CALL_ProgramUniform2dv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12461             CALL_ProgramUniform3dv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12465             CALL_ProgramUniform4dv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12469             CALL_ProgramUniform1i(ctx->Exec, (n[1].ui, n[2].i, n[3].i));
12472             CALL_ProgramUniform2i(ctx->Exec, (n[1].ui, n[2].i, n[3].i, n[4].i));
12475             CALL_ProgramUniform3i(ctx->Exec, (n[1].ui, n[2].i,
12479             CALL_ProgramUniform4i(ctx->Exec, (n[1].ui, n[2].i,
12483             CALL_ProgramUniform1iv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12487             CALL_ProgramUniform2iv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12491             CALL_ProgramUniform3iv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12495             CALL_ProgramUniform4iv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12499             CALL_ProgramUniform1ui(ctx->Exec, (n[1].ui, n[2].i, n[3].ui));
12502             CALL_ProgramUniform2ui(ctx->Exec, (n[1].ui, n[2].i,
12506             CALL_ProgramUniform3ui(ctx->Exec, (n[1].ui, n[2].i,
12510             CALL_ProgramUniform4ui(ctx->Exec, (n[1].ui, n[2].i,
12515             CALL_ProgramUniform1uiv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12519             CALL_ProgramUniform2uiv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12523             CALL_ProgramUniform3uiv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12527             CALL_ProgramUniform4uiv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
12531             CALL_ProgramUniformMatrix2fv(ctx->Exec,
12536             CALL_ProgramUniformMatrix2x3fv(ctx->Exec,
12541             CALL_ProgramUniformMatrix2x4fv(ctx->Exec,
12546             CALL_ProgramUniformMatrix3x2fv(ctx->Exec,
12551             CALL_ProgramUniformMatrix3fv(ctx->Exec,
12556             CALL_ProgramUniformMatrix3x4fv(ctx->Exec,
12561             CALL_ProgramUniformMatrix4x2fv(ctx->Exec,
12566             CALL_ProgramUniformMatrix4x3fv(ctx->Exec,
12571             CALL_ProgramUniformMatrix4fv(ctx->Exec,
12576             CALL_ProgramUniformMatrix2dv(ctx->Exec,
12581             CALL_ProgramUniformMatrix2x3dv(ctx->Exec,
12586             CALL_ProgramUniformMatrix2x4dv(ctx->Exec,
12591             CALL_ProgramUniformMatrix3x2dv(ctx->Exec,
12596             CALL_ProgramUniformMatrix3dv(ctx->Exec,
12601             CALL_ProgramUniformMatrix3x4dv(ctx->Exec,
12606             CALL_ProgramUniformMatrix4x2dv(ctx->Exec,
12611             CALL_ProgramUniformMatrix4x3dv(ctx->Exec,
12616             CALL_ProgramUniformMatrix4dv(ctx->Exec,
12622             CALL_ClipControl(ctx->Exec, (n[1].e, n[2].e));
12626             CALL_ClampColor(ctx->Exec, (n[1].e, n[2].e));
12630             CALL_BindFragmentShaderATI(ctx->Exec, (n[1].i));
12633             CALL_SetFragmentShaderConstantATI(ctx->Exec, (n[1].ui, &n[2].f));
12636             CALL_VertexAttrib1fNV(ctx->Exec, (n[1].e, n[2].f));
12639             CALL_VertexAttrib2fvNV(ctx->Exec, (n[1].e, &n[2].f));
12642             CALL_VertexAttrib3fvNV(ctx->Exec, (n[1].e, &n[2].f));
12645             CALL_VertexAttrib4fvNV(ctx->Exec, (n[1].e, &n[2].f));
12648             CALL_VertexAttrib1fARB(ctx->Exec, (n[1].e, n[2].f));
12651             CALL_VertexAttrib2fvARB(ctx->Exec, (n[1].e, &n[2].f));
12654             CALL_VertexAttrib3fvARB(ctx->Exec, (n[1].e, &n[2].f));
12657             CALL_VertexAttrib4fvARB(ctx->Exec, (n[1].e, &n[2].f));
12660             CALL_VertexAttribI1iEXT(ctx->Exec, (n[1].e, n[2].i));
12663             CALL_VertexAttribI2ivEXT(ctx->Exec, (n[1].e, &n[2].i));
12666             CALL_VertexAttribI3ivEXT(ctx->Exec, (n[1].e, &n[2].i));
12669             CALL_VertexAttribI4ivEXT(ctx->Exec, (n[1].e, &n[2].i));
12673             CALL_VertexAttribL1d(ctx->Exec, (n[1].ui, *d));
12678             CALL_VertexAttribL2dv(ctx->Exec, (n[1].ui, d));
12683             CALL_VertexAttribL3dv(ctx->Exec, (n[1].ui, d));
12688             CALL_VertexAttribL4dv(ctx->Exec, (n[1].ui, d));
12693             CALL_VertexAttribL1ui64ARB(ctx->Exec, (n[1].ui, *ui64));
12697             CALL_Materialfv(ctx->Exec, (n[1].e, n[2].e, &n[3].f));
12700             CALL_Begin(ctx->Exec, (n[1].e));
12703             CALL_End(ctx->Exec, ());
12706             CALL_EvalCoord1f(ctx->Exec, (n[1].f));
12709             CALL_EvalCoord2f(ctx->Exec, (n[1].f, n[2].f));
12712             CALL_EvalPoint1(ctx->Exec, (n[1].i));
12715             CALL_EvalPoint2(ctx->Exec, (n[1].i, n[2].i));
12720             CALL_ClearColorIiEXT(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
12723             CALL_ClearColorIuiEXT(ctx->Exec,
12733                CALL_TexParameterIiv(ctx->Exec, (n[1].e, n[2].e, params));
12743                CALL_TexParameterIuiv(ctx->Exec, (n[1].e, n[2].e, params));
12749             CALL_VertexAttribDivisor(ctx->Exec, (n[1].ui, n[2].ui));
12753             CALL_TextureBarrierNV(ctx->Exec, ());
12758             CALL_BeginTransformFeedback(ctx->Exec, (n[1].e));
12761             CALL_EndTransformFeedback(ctx->Exec, ());
12764             CALL_BindTransformFeedback(ctx->Exec, (n[1].e, n[2].ui));
12767             CALL_PauseTransformFeedback(ctx->Exec, ());
12770             CALL_ResumeTransformFeedback(ctx->Exec, ());
12773             CALL_DrawTransformFeedback(ctx->Exec, (n[1].e, n[2].ui));
12776             CALL_DrawTransformFeedbackStream(ctx->Exec,
12780             CALL_DrawTransformFeedbackInstanced(ctx->Exec,
12784             CALL_DrawTransformFeedbackStreamInstanced(ctx->Exec,
12790             CALL_BindSampler(ctx->Exec, (n[1].ui, n[2].ui));
12799                CALL_SamplerParameteriv(ctx->Exec, (n[1].ui, n[2].e, params));
12809                CALL_SamplerParameterfv(ctx->Exec, (n[1].ui, n[2].e, params));
12819                CALL_SamplerParameterIiv(ctx->Exec, (n[1].ui, n[2].e, params));
12829                CALL_SamplerParameterIuiv(ctx->Exec, (n[1].ui, n[2].e, params));
12835             CALL_DispatchCompute(ctx->Exec, (n[1].ui, n[2].ui, n[3].ui));
12844                CALL_WaitSync(ctx->Exec,
12851             CALL_BeginConditionalRender(ctx->Exec, (n[1].i, n[2].e));
12854             CALL_EndConditionalRender(ctx->Exec, ());
12858             CALL_UniformBlockBinding(ctx->Exec, (n[1].ui, n[2].ui, n[3].ui));
12862             CALL_UniformSubroutinesuiv(ctx->Exec, (n[1].e, n[2].si,
12869                   ctx->Exec, (n[1].e, n[2].si, get_pointer(&n[3])));
12874             CALL_SubpixelPrecisionBiasNV(ctx->Exec, (n[1].ui, n[2].ui));
12879             CALL_ConservativeRasterParameterfNV(ctx->Exec, (n[1].e, n[2].f));
12884             CALL_ConservativeRasterParameteriNV(ctx->Exec, (n[1].e, n[2].i));
12889             CALL_MatrixLoadfEXT(ctx->Exec, (n[1].e, &n[2].f));
12892             CALL_MatrixMultfEXT(ctx->Exec, (n[1].e, &n[2].f));
12895             CALL_MatrixRotatefEXT(ctx->Exec, (n[1].e, n[2].f, n[3].f, n[4].f, n[5].f));
12898             CALL_MatrixScalefEXT(ctx->Exec, (n[1].e, n[2].f, n[3].f, n[4].f));
12901             CALL_MatrixTranslatefEXT(ctx->Exec, (n[1].e, n[2].f, n[3].f, n[4].f));
12904             CALL_MatrixLoadIdentityEXT(ctx->Exec, (n[1].e));
12907             CALL_MatrixOrthoEXT(ctx->Exec, (n[1].e,
12912             CALL_MatrixFrustumEXT(ctx->Exec, (n[1].e,
12917             CALL_MatrixPushEXT(ctx->Exec, (n[1].e));
12920             CALL_MatrixPopEXT(ctx->Exec, (n[1].e));
12929                CALL_TextureParameterfvEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].e, params));
12939                CALL_TextureParameterivEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].e, params));
12949                CALL_TextureParameterIivEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].e, params));
12959                CALL_TextureParameterIuivEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].e, params));
12964                const struct gl_pixelstore_attrib save = ctx->Unpack;
12965                ctx->Unpack = ctx->DefaultPacking;
12966                CALL_TextureImage1DEXT(ctx->Exec, (n[1].ui, /* texture */
12975                ctx->Unpack = save;      /* restore */
12980                const struct gl_pixelstore_attrib save = ctx->Unpack;
12981                ctx->Unpack = ctx->DefaultPacking;
12982                CALL_TextureImage2DEXT(ctx->Exec, (n[1].ui, /* texture */
12992                ctx->Unpack = save;      /* restore */
12997                const struct gl_pixelstore_attrib save = ctx->Unpack;
12998                ctx->Unpack = ctx->DefaultPacking;
12999                CALL_TextureImage3DEXT(ctx->Exec, (n[1].ui, /* texture */
13010                ctx->Unpack = save;      /* restore */
13015                const struct gl_pixelstore_attrib save = ctx->Unpack;
13016                ctx->Unpack = ctx->DefaultPacking;
13017                CALL_TextureSubImage1DEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].i,
13020                ctx->Unpack = save;      /* restore */
13025                const struct gl_pixelstore_attrib save = ctx->Unpack;
13026                ctx->Unpack = ctx->DefaultPacking;
13027                CALL_TextureSubImage2DEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].i,
13031                ctx->Unpack = save;
13036                const struct gl_pixelstore_attrib save = ctx->Unpack;
13037                ctx->Unpack = ctx->DefaultPacking;
13038                CALL_TextureSubImage3DEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].i,
13043                ctx->Unpack = save;      /* restore */
13047             CALL_CopyTextureImage1DEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].i,
13052             CALL_CopyTextureImage2DEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].i,
13057             CALL_CopyTextureSubImage1DEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].i,
13062             CALL_CopyTextureSubImage2DEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].i,
13067             CALL_CopyTextureSubImage3DEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].i,
13073             CALL_BindMultiTextureEXT(ctx->Exec, (n[1].e, n[2].e, n[3].ui));
13082                CALL_MultiTexParameterfvEXT(ctx->Exec, (n[1].e, n[2].e, n[3].e, params));
13092                CALL_MultiTexParameterivEXT(ctx->Exec, (n[1].e, n[2].e, n[3].e, params));
13102                CALL_MultiTexParameterIivEXT(ctx->Exec, (n[1].e, n[2].e, n[3].e, params));
13112                CALL_MultiTexParameterIuivEXT(ctx->Exec, (n[1].e, n[2].e, n[3].e, params));
13117                const struct gl_pixelstore_attrib save = ctx->Unpack;
13118                ctx->Unpack = ctx->DefaultPacking;
13119                CALL_MultiTexImage1DEXT(ctx->Exec, (n[1].e, /* texture */
13128                ctx->Unpack = save;      /* restore */
13133                const struct gl_pixelstore_attrib save = ctx->Unpack;
13134                ctx->Unpack = ctx->DefaultPacking;
13135                CALL_MultiTexImage2DEXT(ctx->Exec, (n[1].e, /* texture */
13145                ctx->Unpack = save;      /* restore */
13150                const struct gl_pixelstore_attrib save = ctx->Unpack;
13151                ctx->Unpack = ctx->DefaultPacking;
13152                CALL_MultiTexImage3DEXT(ctx->Exec, (n[1].e, /* texture */
13163                ctx->Unpack = save;      /* restore */
13168                const struct gl_pixelstore_attrib save = ctx->Unpack;
13169                ctx->Unpack = ctx->DefaultPacking;
13170                CALL_MultiTexSubImage1DEXT(ctx->Exec, (n[1].e, n[2].e, n[3].i,
13173                ctx->Unpack = save;      /* restore */
13178                const struct gl_pixelstore_attrib save = ctx->Unpack;
13179                ctx->Unpack = ctx->DefaultPacking;
13180                CALL_MultiTexSubImage2DEXT(ctx->Exec, (n[1].e, n[2].e, n[3].i,
13184                ctx->Unpack = save;      /* restore */
13189                const struct gl_pixelstore_attrib save = ctx->Unpack;
13190                ctx->Unpack = ctx->DefaultPacking;
13191                CALL_MultiTexSubImage3DEXT(ctx->Exec, (n[1].e, n[2].e, n[3].i,
13196                ctx->Unpack = save;      /* restore */
13200             CALL_CopyMultiTexImage1DEXT(ctx->Exec, (n[1].e, n[2].e, n[3].i,
13205             CALL_CopyMultiTexImage2DEXT(ctx->Exec, (n[1].e, n[2].e, n[3].i,
13210             CALL_CopyMultiTexSubImage1DEXT(ctx->Exec, (n[1].e, n[2].e, n[3].i,
13215             CALL_CopyMultiTexSubImage2DEXT(ctx->Exec, (n[1].e, n[2].e, n[3].i,
13220             CALL_CopyMultiTexSubImage3DEXT(ctx->Exec, (n[1].e, n[2].e, n[3].i,
13232                CALL_MultiTexEnvfvEXT(ctx->Exec, (n[1].e, n[2].e, n[3].e, params));
13236             CALL_CompressedTextureImage1DEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].i,
13241             CALL_CompressedTextureImage2DEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].i,
13247             CALL_CompressedTextureImage3DEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].i,
13253             CALL_CompressedTextureSubImage1DEXT(ctx->Exec,
13259             CALL_CompressedTextureSubImage2DEXT(ctx->Exec,
13265             CALL_CompressedTextureSubImage3DEXT(ctx->Exec,
13272             CALL_CompressedMultiTexImage1DEXT(ctx->Exec, (n[1].e, n[2].e, n[3].i,
13277             CALL_CompressedMultiTexImage2DEXT(ctx->Exec, (n[1].e, n[2].e, n[3].i,
13283             CALL_CompressedMultiTexImage3DEXT(ctx->Exec, (n[1].e, n[2].e, n[3].i,
13289             CALL_CompressedMultiTexSubImage1DEXT(ctx->Exec,
13295             CALL_CompressedMultiTexSubImage2DEXT(ctx->Exec,
13301             CALL_CompressedMultiTexSubImage3DEXT(ctx->Exec,
13308             CALL_NamedProgramStringEXT(ctx->Exec,
13313             CALL_NamedProgramLocalParameter4fEXT(ctx->Exec,
13319             CALL_PrimitiveBoundingBox(ctx->Exec,
13324             vbo_save_playback_vertex_list(ctx, &n[0], false);
13328             vbo_save_playback_vertex_list(ctx, &n[0], true);
13332             vbo_save_playback_vertex_list_loopback(ctx, &n[0]);
13343                _mesa_problem(ctx, "%s", msg);
13368    GET_CURRENT_CONTEXT(ctx);
13369    FLUSH_VERTICES(ctx, 0, 0);      /* must be called before assert */
13370    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
13371    return _mesa_get_list(ctx, list, NULL, false);
13381    GET_CURRENT_CONTEXT(ctx);
13383    FLUSH_VERTICES(ctx, 0, 0);      /* must be called before assert */
13384    ASSERT_OUTSIDE_BEGIN_END(ctx);
13387       _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteLists");
13395       struct gl_bitmap_atlas *atlas = lookup_bitmap_atlas(ctx, list);
13397          _mesa_delete_bitmap_atlas(ctx, atlas);
13398          _mesa_HashRemove(ctx->Shared->BitmapAtlas, list);
13402    _mesa_HashLockMutex(ctx->Shared->DisplayList);
13404       destroy_list(ctx, i);
13406    _mesa_HashUnlockMutex(ctx->Shared->DisplayList);
13417    GET_CURRENT_CONTEXT(ctx);
13419    FLUSH_VERTICES(ctx, 0, 0);      /* must be called before assert */
13420    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
13423       _mesa_error(ctx, GL_INVALID_VALUE, "glGenLists");
13433    _mesa_HashLockMutex(ctx->Shared->DisplayList);
13435    base = _mesa_HashFindFreeKeyBlock(ctx->Shared->DisplayList, range);
13440          _mesa_HashInsertLocked(ctx->Shared->DisplayList, base + i,
13451       struct gl_bitmap_atlas *atlas = lookup_bitmap_atlas(ctx, base);
13453          atlas = alloc_bitmap_atlas(ctx, base, true);
13462    _mesa_HashUnlockMutex(ctx->Shared->DisplayList);
13474    GET_CURRENT_CONTEXT(ctx);
13476    FLUSH_CURRENT(ctx, 0);       /* must be called before assert */
13477    ASSERT_OUTSIDE_BEGIN_END(ctx);
13480       _mesa_debug(ctx, "glNewList %u %s\n", name,
13484       _mesa_error(ctx, GL_INVALID_VALUE, "glNewList");
13489       _mesa_error(ctx, GL_INVALID_ENUM, "glNewList");
13493    if (ctx->ListState.CurrentList) {
13495       _mesa_error(ctx, GL_INVALID_OPERATION, "glNewList");
13499    ctx->CompileFlag = GL_TRUE;
13500    ctx->ExecuteFlag = (mode == GL_COMPILE_AND_EXECUTE);
13503    invalidate_saved_current_state( ctx );
13506    ctx->ListState.CurrentList = make_list(name, BLOCK_SIZE);
13507    ctx->ListState.CurrentBlock = ctx->ListState.CurrentList->Head;
13508    ctx->ListState.CurrentPos = 0;
13509    ctx->ListState.LastInstSize = 0;
13510    ctx->ListState.Current.UseLoopback = false;
13512    vbo_save_NewList(ctx, name, mode);
13514    ctx->CurrentServerDispatch = ctx->Save;
13515    _glapi_set_dispatch(ctx->CurrentServerDispatch);
13516    if (!ctx->GLThread.enabled) {
13517       ctx->CurrentClientDispatch = ctx->CurrentServerDispatch;
13527 replace_op_vertex_list_recursively(struct gl_context *ctx, struct gl_display_list *dlist)
13529    Node *n = get_list_head(ctx, dlist);
13541             replace_op_vertex_list_recursively(ctx, _mesa_lookup_list(ctx, (int)n[1].ui, true));
13555                      replace_op_vertex_list_recursively(ctx, _mesa_lookup_list(ctx, (int)bptr[i], true));
13560                      replace_op_vertex_list_recursively(ctx, _mesa_lookup_list(ctx, (int)ubptr[i], true));
13565                      replace_op_vertex_list_recursively(ctx, _mesa_lookup_list(ctx, (int)sptr[i], true));
13570                      replace_op_vertex_list_recursively(ctx, _mesa_lookup_list(ctx, (int)usptr[i], true));
13575                      replace_op_vertex_list_recursively(ctx, _mesa_lookup_list(ctx, (int)iptr[i], true));
13580                      replace_op_vertex_list_recursively(ctx, _mesa_lookup_list(ctx, (int)uiptr[i], true));
13585                      replace_op_vertex_list_recursively(ctx, _mesa_lookup_list(ctx, (int)fptr[i], true));
13590                      replace_op_vertex_list_recursively(ctx,
13591                                                 _mesa_lookup_list(ctx, (int)ubptr[2 * i] * 256 +
13598                      replace_op_vertex_list_recursively(ctx,
13599                                                 _mesa_lookup_list(ctx, (int)ubptr[3 * i] * 65536 +
13607                      replace_op_vertex_list_recursively(ctx,
13608                                                 _mesa_lookup_list(ctx, (int)ubptr[4 * i] * 16777216 +
13633    GET_CURRENT_CONTEXT(ctx);
13634    SAVE_FLUSH_VERTICES(ctx);
13635    FLUSH_VERTICES(ctx, 0, 0);
13638       _mesa_debug(ctx, "glEndList\n");
13640    if (ctx->ExecuteFlag && _mesa_inside_dlist_begin_end(ctx)) {
13641       _mesa_error(ctx, GL_INVALID_OPERATION,
13646    if (!ctx->ListState.CurrentList) {
13647       _mesa_error(ctx, GL_INVALID_OPERATION, "glEndList");
13654    vbo_save_EndList(ctx);
13656    (void) alloc_instruction(ctx, OPCODE_END_OF_LIST, 0);
13658    _mesa_HashLockMutex(ctx->Shared->DisplayList);
13660    if (ctx->ListState.Current.UseLoopback)
13661       replace_op_vertex_list_recursively(ctx, ctx->ListState.CurrentList);
13663    struct gl_dlist_state *list = &ctx->ListState;
13665       _mesa_glthread_should_execute_list(ctx, list->CurrentList);
13666    ctx->Shared->DisplayListsAffectGLThread |= list->CurrentList->execute_glthread;
13671        * of memory (list->CurrentBlock), we store them in ctx->Shared->small_dlist_store.ptr.
13678       if (ctx->Shared->small_dlist_store.size == 0) {
13679          util_idalloc_init(&ctx->Shared->small_dlist_store.free_idx, MAX2(1, list->CurrentPos));
13682       start = util_idalloc_alloc_range(&ctx->Shared->small_dlist_store.free_idx, list->CurrentPos);
13684       if ((start + list->CurrentPos) > ctx->Shared->small_dlist_store.size) {
13685          ctx->Shared->small_dlist_store.size =
13686             ctx->Shared->small_dlist_store.free_idx.num_elements * 32;
13687          ctx->Shared->small_dlist_store.ptr = realloc(
13688             ctx->Shared->small_dlist_store.ptr,
13689             ctx->Shared->small_dlist_store.size * sizeof(Node));
13694       memcpy(&ctx->Shared->small_dlist_store.ptr[start],
13698       assert (ctx->Shared->small_dlist_store.ptr[start + list->CurrentList->count - 1].opcode == OPCODE_END_OF_LIST);
13707    destroy_list(ctx, ctx->ListState.CurrentList->Name);
13710    _mesa_HashInsertLocked(ctx->Shared->DisplayList,
13711                           ctx->ListState.CurrentList->Name,
13712                           ctx->ListState.CurrentList, true);
13715       mesa_print_display_list(ctx->ListState.CurrentList->Name);
13717    _mesa_HashUnlockMutex(ctx->Shared->DisplayList);
13719    ctx->ListState.CurrentList = NULL;
13720    ctx->ListState.CurrentBlock = NULL;
13721    ctx->ListState.CurrentPos = 0;
13722    ctx->ListState.LastInstSize = 0;
13723    ctx->ExecuteFlag = GL_TRUE;
13724    ctx->CompileFlag = GL_FALSE;
13726    ctx->CurrentServerDispatch = ctx->Exec;
13727    _glapi_set_dispatch(ctx->CurrentServerDispatch);
13728    if (!ctx->GLThread.enabled) {
13729       ctx->CurrentClientDispatch = ctx->CurrentServerDispatch;
13738    GET_CURRENT_CONTEXT(ctx);
13739    FLUSH_CURRENT(ctx, 0);
13742       _mesa_debug(ctx, "glCallList %d\n", list);
13745       _mesa_error(ctx, GL_INVALID_VALUE, "glCallList(list==0)");
13756    save_compile_flag = ctx->CompileFlag;
13758       ctx->CompileFlag = GL_FALSE;
13761    _mesa_HashLockMutex(ctx->Shared->DisplayList);
13762    execute_list(ctx, list);
13763    _mesa_HashUnlockMutex(ctx->Shared->DisplayList);
13764    ctx->CompileFlag = save_compile_flag;
13768       ctx->CurrentServerDispatch = ctx->Save;
13769        _glapi_set_dispatch(ctx->CurrentServerDispatch);
13770       if (!ctx->GLThread.enabled) {
13771          ctx->CurrentClientDispatch = ctx->CurrentServerDispatch;
13783 render_bitmap_atlas(struct gl_context *ctx, GLsizei n, GLenum type,
13790        !ctx->Current.RasterPosValid ||
13791        ctx->List.ListBase == 0 ||
13797    atlas = lookup_bitmap_atlas(ctx, ctx->List.ListBase);
13803       atlas = alloc_bitmap_atlas(ctx, ctx->List.ListBase, false);
13813       build_bitmap_atlas(ctx, atlas, ctx->List.ListBase);
13829    st_DrawAtlasBitmaps(ctx, atlas, n, (const GLubyte *) lists);
13841    GET_CURRENT_CONTEXT(ctx);
13845       _mesa_debug(ctx, "glCallLists %d\n", n);
13848       _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");
13853       _mesa_error(ctx, GL_INVALID_VALUE, "glCallLists(n < 0)");
13860    if (render_bitmap_atlas(ctx, n, type, lists)) {
13868    save_compile_flag = ctx->CompileFlag;
13869    ctx->CompileFlag = GL_FALSE;
13879    GLuint base = ctx->List.ListBase;
13881    _mesa_HashLockMutex(ctx->Shared->DisplayList);
13888          execute_list(ctx, base + (int)bptr[i]);
13893          execute_list(ctx, base + (int)ubptr[i]);
13898          execute_list(ctx, base + (int)sptr[i]);
13903          execute_list(ctx, base + (int)usptr[i]);
13908          execute_list(ctx, base + (int)iptr[i]);
13913          execute_list(ctx, base + (int)uiptr[i]);
13918          execute_list(ctx, base + (int)fptr[i]);
13923          execute_list(ctx, base +
13931          execute_list(ctx, base +
13940          execute_list(ctx, base +
13949    _mesa_HashUnlockMutex(ctx->Shared->DisplayList);
13950    ctx->CompileFlag = save_compile_flag;
13954       ctx->CurrentServerDispatch = ctx->Save;
13955       _glapi_set_dispatch(ctx->CurrentServerDispatch);
13956       if (!ctx->GLThread.enabled) {
13957          ctx->CurrentClientDispatch = ctx->CurrentServerDispatch;
13969    GET_CURRENT_CONTEXT(ctx);
13970    FLUSH_VERTICES(ctx, 0, GL_LIST_BIT);   /* must be called before assert */
13971    ASSERT_OUTSIDE_BEGIN_END(ctx);
13972    ctx->List.ListBase = base;
13984 _mesa_initialize_save_table(const struct gl_context *ctx)
13986    struct _glapi_table *table = ctx->Save;
13993    memcpy(table, ctx->Exec, numEntries * sizeof(_glapi_proc));
14013 print_list(struct gl_context *ctx, GLuint list, const char *fname)
14025    if (!_mesa_get_list(ctx, list, &dlist, true)) {
14033    n = get_list_head(ctx, dlist);
14284             vbo_print_vertex_list(ctx, (struct vbo_save_vertex_list *) &n[0], opcode, f);
14313 _mesa_glthread_execute_list(struct gl_context *ctx, GLuint list)
14318        !_mesa_get_list(ctx, list, &dlist, true) ||
14322    Node *n = get_list_head(ctx, dlist);
14330             if (ctx->GLThread.ListCallDepth < MAX_LIST_NESTING) {
14331                ctx->GLThread.ListCallDepth++;
14332                _mesa_glthread_execute_list(ctx, n[1].ui);
14333                ctx->GLThread.ListCallDepth--;
14337             if (ctx->GLThread.ListCallDepth < MAX_LIST_NESTING) {
14338                ctx->GLThread.ListCallDepth++;
14339                _mesa_glthread_CallLists(ctx, n[1].i, n[2].e, get_pointer(&n[3]));
14340                ctx->GLThread.ListCallDepth--;
14344             _mesa_glthread_Disable(ctx, n[1].e);
14347             _mesa_glthread_Enable(ctx, n[1].e);
14350             _mesa_glthread_ListBase(ctx, n[1].ui);
14353             _mesa_glthread_MatrixMode(ctx, n[1].e);
14356             _mesa_glthread_PopAttrib(ctx);
14359             _mesa_glthread_PopMatrix(ctx);
14362             _mesa_glthread_PushAttrib(ctx, n[1].bf);
14365             _mesa_glthread_PushMatrix(ctx);
14368             _mesa_glthread_ActiveTexture(ctx, n[1].e);
14371             _mesa_glthread_MatrixPushEXT(ctx, n[1].e);
14374             _mesa_glthread_MatrixPopEXT(ctx, n[1].e);
14380             ctx->GLThread.ListCallDepth--;
14394 _mesa_glthread_should_execute_list(struct gl_context *ctx,
14397    Node *n = get_list_head(ctx, dlist);
14443    GET_CURRENT_CONTEXT(ctx);
14444    print_list(ctx, list, NULL);
14456 _mesa_init_display_list(struct gl_context *ctx)
14459    ctx->ListState.CallDepth = 1;
14460    ctx->ExecuteFlag = GL_TRUE;
14461    ctx->CompileFlag = GL_FALSE;
14462    ctx->ListState.CurrentBlock = NULL;
14463    ctx->ListState.CurrentPos = 0;
14464    ctx->ListState.LastInstSize = 0;
14467    ctx->List.ListBase = 0;
14472 _mesa_install_save_vtxfmt(struct gl_context *ctx)
14474    struct _glapi_table *tab = ctx->Save;
14475    assert(ctx->API == API_OPENGL_COMPAT);