src/mesa/main/context.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   5  * Copyright (C) 2008  VMware, Inc.  All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23  * OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 /**
  27  * \file context.c
  28  * Mesa context/visual/framebuffer management functions.
  29  * \author Brian Paul
  30  */
  31
  32 /**
  33  * \mainpage Mesa Main Module
  34  *
  35  * \section MainIntroduction Introduction
  36  *
  37  * The Mesa Main module consists of all the files in the main/ directory.
  38  * Among the features of this module are:
  39  * <UL>
  40  * <LI> Structures to represent most GL state </LI>
  41  * <LI> State set/get functions </LI>
  42  * <LI> Display lists </LI>
  43  * <LI> Texture unit, object and image handling </LI>
  44  * <LI> Matrix and attribute stacks </LI>
  45  * </UL>
  46  *
  47  * Other modules are responsible for API dispatch, vertex transformation,
  48  * point/line/triangle setup, rasterization, vertex array caching,
  49  * vertex/fragment programs/shaders, etc.
  50  *
  51  *
  52  * \section AboutDoxygen About Doxygen
  53  *
  54  * If you're viewing this information as Doxygen-generated HTML you'll
  55  * see the documentation index at the top of this page.
  56  *
  57  * The first line lists the Mesa source code modules.
  58  * The second line lists the indexes available for viewing the documentation
  59  * for each module.
  60  *
  61  * Selecting the <b>Main page</b> link will display a summary of the module
  62  * (this page).
  63  *
  64  * Selecting <b>Data Structures</b> will list all C structures.
  65  *
  66  * Selecting the <b>File List</b> link will list all the source files in
  67  * the module.
  68  * Selecting a filename will show a list of all functions defined in that file.
  69  *
  70  * Selecting the <b>Data Fields</b> link will display a list of all
  71  * documented structure members.
  72  *
  73  * Selecting the <b>Globals</b> link will display a list
  74  * of all functions, structures, global variables and macros in the module.
  75  *
  76  */
  77
  78
  79 #include "glheader.h"
  80 #include "imports.h"
  81 #include "accum.h"
  82 #include "api_exec.h"
  83 #include "api_loopback.h"
  84 #include "arrayobj.h"
  85 #include "attrib.h"
  86 #include "bbox.h"
  87 #include "blend.h"
  88 #include "buffers.h"
  89 #include "bufferobj.h"
  90 #include "conservativeraster.h"
  91 #include "context.h"
  92 #include "cpuinfo.h"
  93 #include "debug.h"
  94 #include "debug_output.h"
  95 #include "depth.h"
  96 #include "dlist.h"
  97 #include "eval.h"
  98 #include "extensions.h"
  99 #include "fbobject.h"
 100 #include "feedback.h"
 101 #include "fog.h"
 102 #include "formats.h"
 103 #include "framebuffer.h"
 104 #include "glthread.h"
 105 #include "hint.h"
 106 #include "hash.h"
 107 #include "light.h"
 108 #include "lines.h"
 109 #include "macros.h"
 110 #include "matrix.h"
 111 #include "multisample.h"
 112 #include "performance_monitor.h"
 113 #include "performance_query.h"
 114 #include "pipelineobj.h"
 115 #include "pixel.h"
 116 #include "pixelstore.h"
 117 #include "points.h"
 118 #include "polygon.h"
 119 #include "queryobj.h"
 120 #include "syncobj.h"
 121 #include "rastpos.h"
 122 #include "remap.h"
 123 #include "scissor.h"
 124 #include "shared.h"
 125 #include "shaderobj.h"
 126 #include "shaderimage.h"
 127 #include "state.h"
 128 #include "util/debug.h"
 129 #include "util/disk_cache.h"
 130 #include "util/strtod.h"
 131 #include "stencil.h"
 132 #include "shaderimage.h"
 133 #include "texcompress_s3tc.h"
 134 #include "texstate.h"
 135 #include "transformfeedback.h"
 136 #include "mtypes.h"
 137 #include "varray.h"
 138 #include "version.h"
 139 #include "viewport.h"
 140 #include "texturebindless.h"
 141 #include "program/program.h"
 142 #include "math/m_matrix.h"
 143 #include "main/dispatch.h" /* for _gloffset_COUNT */
 144 #include "macros.h"
 145 #include "git_sha1.h"
 146
 147 #ifdef USE_SPARC_ASM
 148 #include "sparc/sparc.h"
 149 #endif
 150
 151 #include "compiler/glsl_types.h"
 152 #include "compiler/glsl/builtin_functions.h"
 153 #include "compiler/glsl/glsl_parser_extras.h"
 154 #include <stdbool.h>
 155
 156
 157 #ifndef MESA_VERBOSE
 158 int MESA_VERBOSE = 0;
 159 #endif
 160
 161 #ifndef MESA_DEBUG_FLAGS
 162 int MESA_DEBUG_FLAGS = 0;
 163 #endif
 164
 165
 166 /* ubyte -> float conversion */
 167 GLfloat _mesa_ubyte_to_float_color_tab[256];
 168
 169
 170
 171 /**
 172  * Swap buffers notification callback.
 173  *
 174  * \param ctx GL context.
 175  *
 176  * Called by window system just before swapping buffers.
 177  * We have to finish any pending rendering.
 178  */
 179 void
 180 _mesa_notifySwapBuffers(struct gl_context *ctx)
 181 {
 182    if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS)
 183       _mesa_debug(ctx, "SwapBuffers\n");
 184    FLUSH_VERTICES(ctx, 0);
 185    if (ctx->Driver.Flush) {
 186       ctx->Driver.Flush(ctx);
 187    }
 188 }
 189
 190
 191 /**********************************************************************/
 192 /** \name GL Visual allocation/destruction                            */
 193 /**********************************************************************/
 194 /*@{*/
 195
 196 /**
 197  * Allocates a struct gl_config structure and initializes it via
 198  * _mesa_initialize_visual().
 199  *
 200  * \param dbFlag double buffering
 201  * \param stereoFlag stereo buffer
 202  * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
 203  * is acceptable but the actual depth type will be GLushort or GLuint as
 204  * needed.
 205  * \param stencilBits requested minimum bits per stencil buffer value
 206  * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number
 207  * of bits per color component in accum buffer.
 208  * \param redBits number of bits per color component in frame buffer for RGB(A)
 209  * mode.  We always use 8 in core Mesa though.
 210  * \param greenBits same as above.
 211  * \param blueBits same as above.
 212  * \param alphaBits same as above.
 213  * \param numSamples not really used.
 214  *
 215  * \return pointer to new struct gl_config or NULL if requested parameters
 216  * can't be met.
 217  *
 218  * \note Need to add params for level and numAuxBuffers (at least)
 219  */
 220 struct gl_config *
 221 _mesa_create_visual( GLboolean dbFlag,
 222                      GLboolean stereoFlag,
 223                      GLint redBits,
 224                      GLint greenBits,
 225                      GLint blueBits,
 226                      GLint alphaBits,
 227                      GLint depthBits,
 228                      GLint stencilBits,
 229                      GLint accumRedBits,
 230                      GLint accumGreenBits,
 231                      GLint accumBlueBits,
 232                      GLint accumAlphaBits,
 233                      GLuint numSamples )
 234 {
 235    struct gl_config *vis = CALLOC_STRUCT(gl_config);
 236    if (vis) {
 237       if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag,
 238                                    redBits, greenBits, blueBits, alphaBits,
 239                                    depthBits, stencilBits,
 240                                    accumRedBits, accumGreenBits,
 241                                    accumBlueBits, accumAlphaBits,
 242                                    numSamples)) {
 243          free(vis);
 244          return NULL;
 245       }
 246    }
 247    return vis;
 248 }
 249
 250
 251 /**
 252  * Makes some sanity checks and fills in the fields of the struct
 253  * gl_config object with the given parameters.  If the caller needs to
 254  * set additional fields, he should just probably init the whole
 255  * gl_config object himself.
 256  *
 257  * \return GL_TRUE on success, or GL_FALSE on failure.
 258  *
 259  * \sa _mesa_create_visual() above for the parameter description.
 260  */
 261 GLboolean
 262 _mesa_initialize_visual( struct gl_config *vis,
 263                          GLboolean dbFlag,
 264                          GLboolean stereoFlag,
 265                          GLint redBits,
 266                          GLint greenBits,
 267                          GLint blueBits,
 268                          GLint alphaBits,
 269                          GLint depthBits,
 270                          GLint stencilBits,
 271                          GLint accumRedBits,
 272                          GLint accumGreenBits,
 273                          GLint accumBlueBits,
 274                          GLint accumAlphaBits,
 275                          GLuint numSamples )
 276 {
 277    assert(vis);
 278
 279    if (depthBits < 0 || depthBits > 32) {
 280       return GL_FALSE;
 281    }
 282    if (stencilBits < 0 || stencilBits > 8) {
 283       return GL_FALSE;
 284    }
 285    assert(accumRedBits >= 0);
 286    assert(accumGreenBits >= 0);
 287    assert(accumBlueBits >= 0);
 288    assert(accumAlphaBits >= 0);
 289
 290    vis->doubleBufferMode = dbFlag;
 291    vis->stereoMode       = stereoFlag;
 292
 293    vis->redBits          = redBits;
 294    vis->greenBits        = greenBits;
 295    vis->blueBits         = blueBits;
 296    vis->alphaBits        = alphaBits;
 297    vis->rgbBits          = redBits + greenBits + blueBits;
 298
 299    vis->depthBits      = depthBits;
 300    vis->stencilBits    = stencilBits;
 301
 302    vis->accumRedBits   = accumRedBits;
 303    vis->accumGreenBits = accumGreenBits;
 304    vis->accumBlueBits  = accumBlueBits;
 305    vis->accumAlphaBits = accumAlphaBits;
 306
 307    vis->numAuxBuffers = 0;
 308    vis->level = 0;
 309    vis->sampleBuffers = numSamples > 0 ? 1 : 0;
 310    vis->samples = numSamples;
 311
 312    return GL_TRUE;
 313 }
 314
 315
 316 /**
 317  * Destroy a visual and free its memory.
 318  *
 319  * \param vis visual.
 320  *
 321  * Frees the visual structure.
 322  */
 323 void
 324 _mesa_destroy_visual( struct gl_config *vis )
 325 {
 326    free(vis);
 327 }
 328
 329 /*@}*/
 330
 331
 332 /**********************************************************************/
 333 /** \name Context allocation, initialization, destroying
 334  *
 335  * The purpose of the most initialization functions here is to provide the
 336  * default state values according to the OpenGL specification.
 337  */
 338 /**********************************************************************/
 339 /*@{*/
 340
 341
 342 /**
 343  * One-time initialization mutex lock.
 344  *
 345  * \sa Used by one_time_init().
 346  */
 347 mtx_t OneTimeLock = _MTX_INITIALIZER_NP;
 348
 349
 350 /**
 351  * Calls all the various one-time-fini functions in Mesa
 352  */
 353
 354 static void
 355 one_time_fini(void)
 356 {
 357    glsl_type_singleton_decref();
 358    _mesa_locale_fini();
 359 }
 360
 361 /**
 362  * Calls all the various one-time-init functions in Mesa.
 363  *
 364  * While holding a global mutex lock, calls several initialization functions,
 365  * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
 366  * defined.
 367  *
 368  * \sa _math_init().
 369  */
 370 static void
 371 one_time_init( struct gl_context *ctx )
 372 {
 373    static GLbitfield api_init_mask = 0x0;
 374
 375    mtx_lock(&OneTimeLock);
 376
 377    /* truly one-time init */
 378    if (!api_init_mask) {
 379       GLuint i;
 380
 381       STATIC_ASSERT(sizeof(GLbyte) == 1);
 382       STATIC_ASSERT(sizeof(GLubyte) == 1);
 383       STATIC_ASSERT(sizeof(GLshort) == 2);
 384       STATIC_ASSERT(sizeof(GLushort) == 2);
 385       STATIC_ASSERT(sizeof(GLint) == 4);
 386       STATIC_ASSERT(sizeof(GLuint) == 4);
 387
 388       _mesa_locale_init();
 389
 390       _mesa_one_time_init_extension_overrides(ctx);
 391
 392       _mesa_get_cpu_features();
 393
 394       for (i = 0; i < 256; i++) {
 395          _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
 396       }
 397
 398       atexit(one_time_fini);
 399
 400 #if defined(DEBUG)
 401       if (MESA_VERBOSE != 0) {
 402          _mesa_debug(ctx, "Mesa " PACKAGE_VERSION " DEBUG build" MESA_GIT_SHA1 "\n");
 403       }
 404 #endif
 405
 406       /* Take a glsl type reference for the duration of libGL's life to avoid
 407        * unecessary creation/destruction of glsl types.
 408        */
 409       glsl_type_singleton_init_or_ref();
 410    }
 411
 412    /* per-API one-time init */
 413    if (!(api_init_mask & (1 << ctx->API))) {
 414       _mesa_init_remap_table();
 415    }
 416
 417    api_init_mask |= 1 << ctx->API;
 418
 419    mtx_unlock(&OneTimeLock);
 420 }
 421
 422
 423 /**
 424  * Initialize fields of gl_current_attrib (aka ctx->Current.*)
 425  */
 426 static void
 427 _mesa_init_current(struct gl_context *ctx)
 428 {
 429    GLuint i;
 430
 431    /* Init all to (0,0,0,1) */
 432    for (i = 0; i < ARRAY_SIZE(ctx->Current.Attrib); i++) {
 433       ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
 434    }
 435
 436    /* redo special cases: */
 437    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
 438    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
 439    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
 440    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
 441    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
 442 }
 443
 444
 445 /**
 446  * Init vertex/fragment/geometry program limits.
 447  * Important: drivers should override these with actual limits.
 448  */
 449 static void
 450 init_program_limits(struct gl_constants *consts, gl_shader_stage stage,
 451                     struct gl_program_constants *prog)
 452 {
 453    prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;
 454    prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;
 455    prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;
 456    prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;
 457    prog->MaxTemps = MAX_PROGRAM_TEMPS;
 458    prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
 459    prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
 460    prog->MaxAddressOffset = MAX_PROGRAM_LOCAL_PARAMS;
 461
 462    switch (stage) {
 463    case MESA_SHADER_VERTEX:
 464       prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
 465       prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS;
 466       prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
 467       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
 468       prog->MaxInputComponents = 0; /* value not used */
 469       prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */
 470       break;
 471    case MESA_SHADER_FRAGMENT:
 472       prog->MaxParameters = MAX_FRAGMENT_PROGRAM_PARAMS;
 473       prog->MaxAttribs = MAX_FRAGMENT_PROGRAM_INPUTS;
 474       prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
 475       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
 476       prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */
 477       prog->MaxOutputComponents = 0; /* value not used */
 478       break;
 479    case MESA_SHADER_TESS_CTRL:
 480    case MESA_SHADER_TESS_EVAL:
 481    case MESA_SHADER_GEOMETRY:
 482       prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
 483       prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS;
 484       prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
 485       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
 486       prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */
 487       prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */
 488       break;
 489    case MESA_SHADER_COMPUTE:
 490       prog->MaxParameters = 0; /* not meaningful for compute shaders */
 491       prog->MaxAttribs = 0; /* not meaningful for compute shaders */
 492       prog->MaxAddressRegs = 0; /* not meaningful for compute shaders */
 493       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
 494       prog->MaxInputComponents = 0; /* not meaningful for compute shaders */
 495       prog->MaxOutputComponents = 0; /* not meaningful for compute shaders */
 496       break;
 497    default:
 498       assert(0 && "Bad shader stage in init_program_limits()");
 499    }
 500
 501    /* Set the native limits to zero.  This implies that there is no native
 502     * support for shaders.  Let the drivers fill in the actual values.
 503     */
 504    prog->MaxNativeInstructions = 0;
 505    prog->MaxNativeAluInstructions = 0;
 506    prog->MaxNativeTexInstructions = 0;
 507    prog->MaxNativeTexIndirections = 0;
 508    prog->MaxNativeAttribs = 0;
 509    prog->MaxNativeTemps = 0;
 510    prog->MaxNativeAddressRegs = 0;
 511    prog->MaxNativeParameters = 0;
 512
 513    /* Set GLSL datatype range/precision info assuming IEEE float values.
 514     * Drivers should override these defaults as needed.
 515     */
 516    prog->MediumFloat.RangeMin = 127;
 517    prog->MediumFloat.RangeMax = 127;
 518    prog->MediumFloat.Precision = 23;
 519    prog->LowFloat = prog->HighFloat = prog->MediumFloat;
 520
 521    /* Assume ints are stored as floats for now, since this is the least-common
 522     * denominator.  The OpenGL ES spec implies (page 132) that the precision
 523     * of integer types should be 0.  Practically speaking, IEEE
 524     * single-precision floating point values can only store integers in the
 525     * range [-0x01000000, 0x01000000] without loss of precision.
 526     */
 527    prog->MediumInt.RangeMin = 24;
 528    prog->MediumInt.RangeMax = 24;
 529    prog->MediumInt.Precision = 0;
 530    prog->LowInt = prog->HighInt = prog->MediumInt;
 531
 532    prog->MaxUniformBlocks = 12;
 533    prog->MaxCombinedUniformComponents = (prog->MaxUniformComponents +
 534                                          consts->MaxUniformBlockSize / 4 *
 535                                          prog->MaxUniformBlocks);
 536
 537    prog->MaxAtomicBuffers = 0;
 538    prog->MaxAtomicCounters = 0;
 539
 540    prog->MaxShaderStorageBlocks = 8;
 541 }
 542
 543
 544 /**
 545  * Initialize fields of gl_constants (aka ctx->Const.*).
 546  * Use defaults from config.h.  The device drivers will often override
 547  * some of these values (such as number of texture units).
 548  */
 549 void
 550 _mesa_init_constants(struct gl_constants *consts, gl_api api)
 551 {
 552    int i;
 553    assert(consts);
 554
 555    /* Constants, may be overriden (usually only reduced) by device drivers */
 556    consts->MaxTextureMbytes = MAX_TEXTURE_MBYTES;
 557    consts->MaxTextureSize = 1 << (MAX_TEXTURE_LEVELS - 1);
 558    consts->Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
 559    consts->MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
 560    consts->MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
 561    consts->MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
 562    consts->MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
 563    consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 564    consts->MaxTextureUnits = MIN2(consts->MaxTextureCoordUnits,
 565                                      consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);
 566    consts->MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
 567    consts->MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
 568    consts->MaxTextureBufferSize = 65536;
 569    consts->TextureBufferOffsetAlignment = 1;
 570    consts->MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
 571    consts->SubPixelBits = SUB_PIXEL_BITS;
 572    consts->MinPointSize = MIN_POINT_SIZE;
 573    consts->MaxPointSize = MAX_POINT_SIZE;
 574    consts->MinPointSizeAA = MIN_POINT_SIZE;
 575    consts->MaxPointSizeAA = MAX_POINT_SIZE;
 576    consts->PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
 577    consts->MinLineWidth = MIN_LINE_WIDTH;
 578    consts->MaxLineWidth = MAX_LINE_WIDTH;
 579    consts->MinLineWidthAA = MIN_LINE_WIDTH;
 580    consts->MaxLineWidthAA = MAX_LINE_WIDTH;
 581    consts->LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
 582    consts->MaxClipPlanes = 6;
 583    consts->MaxLights = MAX_LIGHTS;
 584    consts->MaxShininess = 128.0;
 585    consts->MaxSpotExponent = 128.0;
 586    consts->MaxViewportWidth = 16384;
 587    consts->MaxViewportHeight = 16384;
 588    consts->MinMapBufferAlignment = 64;
 589
 590    /* Driver must override these values if ARB_viewport_array is supported. */
 591    consts->MaxViewports = 1;
 592    consts->ViewportSubpixelBits = 0;
 593    consts->ViewportBounds.Min = 0;
 594    consts->ViewportBounds.Max = 0;
 595
 596    /** GL_ARB_uniform_buffer_object */
 597    consts->MaxCombinedUniformBlocks = 36;
 598    consts->MaxUniformBufferBindings = 36;
 599    consts->MaxUniformBlockSize = 16384;
 600    consts->UniformBufferOffsetAlignment = 1;
 601
 602    /** GL_ARB_shader_storage_buffer_object */
 603    consts->MaxCombinedShaderStorageBlocks = 8;
 604    consts->MaxShaderStorageBufferBindings = 8;
 605    consts->MaxShaderStorageBlockSize = 128 * 1024 * 1024; /* 2^27 */
 606    consts->ShaderStorageBufferOffsetAlignment = 256;
 607
 608    /* GL_ARB_explicit_uniform_location, GL_MAX_UNIFORM_LOCATIONS */
 609    consts->MaxUserAssignableUniformLocations =
 610       4 * MESA_SHADER_STAGES * MAX_UNIFORMS;
 611
 612    for (i = 0; i < MESA_SHADER_STAGES; i++)
 613       init_program_limits(consts, i, &consts->Program[i]);
 614
 615    consts->MaxProgramMatrices = MAX_PROGRAM_MATRICES;
 616    consts->MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
 617
 618    /* Set the absolute minimum possible GLSL version.  API_OPENGL_CORE can
 619     * mean an OpenGL 3.0 forward-compatible context, so that implies a minimum
 620     * possible version of 1.30.  Otherwise, the minimum possible version 1.20.
 621     * Since Mesa unconditionally advertises GL_ARB_shading_language_100 and
 622     * GL_ARB_shader_objects, every driver has GLSL 1.20... even if they don't
 623     * advertise any extensions to enable any shader stages (e.g.,
 624     * GL_ARB_vertex_shader).
 625     */
 626    consts->GLSLVersion = api == API_OPENGL_CORE ? 130 : 120;
 627    consts->GLSLVersionCompat = consts->GLSLVersion;
 628
 629    consts->GLSLLowerConstArrays = true;
 630
 631    /* Assume that if GLSL 1.30+ (or GLSL ES 3.00+) is supported that
 632     * gl_VertexID is implemented using a native hardware register with OpenGL
 633     * semantics.
 634     */
 635    consts->VertexID_is_zero_based = false;
 636
 637    /* GL_ARB_draw_buffers */
 638    consts->MaxDrawBuffers = MAX_DRAW_BUFFERS;
 639
 640    consts->MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
 641    consts->MaxRenderbufferSize = MAX_RENDERBUFFER_SIZE;
 642
 643    consts->Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 644    consts->MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
 645    consts->MaxVarying = 16; /* old limit not to break tnl and swrast */
 646    consts->Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 647    consts->MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES;
 648    consts->MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS;
 649    consts->MaxGeometryShaderInvocations = MAX_GEOMETRY_SHADER_INVOCATIONS;
 650
 651 #ifdef DEBUG
 652    consts->GenerateTemporaryNames = true;
 653 #else
 654    consts->GenerateTemporaryNames = false;
 655 #endif
 656
 657    /* GL_ARB_framebuffer_object */
 658    consts->MaxSamples = 0;
 659
 660    /* GLSL default if NativeIntegers == FALSE */
 661    consts->UniformBooleanTrue = FLOAT_AS_UNION(1.0f).u;
 662
 663    /* GL_ARB_sync */
 664    consts->MaxServerWaitTimeout = 0x7fffffff7fffffffULL;
 665
 666    /* GL_EXT_provoking_vertex */
 667    consts->QuadsFollowProvokingVertexConvention = GL_TRUE;
 668
 669    /** GL_ARB_viewport_array */
 670    consts->LayerAndVPIndexProvokingVertex = GL_UNDEFINED_VERTEX;
 671
 672    /* GL_EXT_transform_feedback */
 673    consts->MaxTransformFeedbackBuffers = MAX_FEEDBACK_BUFFERS;
 674    consts->MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;
 675    consts->MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;
 676    consts->MaxVertexStreams = 1;
 677
 678    /* GL 3.2  */
 679    consts->ProfileMask = api == API_OPENGL_CORE
 680                           ? GL_CONTEXT_CORE_PROFILE_BIT
 681                           : GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
 682
 683    /* GL 4.4 */
 684    consts->MaxVertexAttribStride = 2048;
 685
 686    /** GL_EXT_gpu_shader4 */
 687    consts->MinProgramTexelOffset = -8;
 688    consts->MaxProgramTexelOffset = 7;
 689
 690    /* GL_ARB_texture_gather */
 691    consts->MinProgramTextureGatherOffset = -8;
 692    consts->MaxProgramTextureGatherOffset = 7;
 693
 694    /* GL_ARB_robustness */
 695    consts->ResetStrategy = GL_NO_RESET_NOTIFICATION_ARB;
 696
 697    /* GL_KHR_robustness */
 698    consts->RobustAccess = GL_FALSE;
 699
 700    /* ES 3.0 or ARB_ES3_compatibility */
 701    consts->MaxElementIndex = 0xffffffffu;
 702
 703    /* GL_ARB_texture_multisample */
 704    consts->MaxColorTextureSamples = 1;
 705    consts->MaxDepthTextureSamples = 1;
 706    consts->MaxIntegerSamples = 1;
 707
 708    /* GL_ARB_shader_atomic_counters */
 709    consts->MaxAtomicBufferBindings = MAX_COMBINED_ATOMIC_BUFFERS;
 710    consts->MaxAtomicBufferSize = MAX_ATOMIC_COUNTERS * ATOMIC_COUNTER_SIZE;
 711    consts->MaxCombinedAtomicBuffers = MAX_COMBINED_ATOMIC_BUFFERS;
 712    consts->MaxCombinedAtomicCounters = MAX_ATOMIC_COUNTERS;
 713
 714    /* GL_ARB_vertex_attrib_binding */
 715    consts->MaxVertexAttribRelativeOffset = 2047;
 716    consts->MaxVertexAttribBindings = MAX_VERTEX_GENERIC_ATTRIBS;
 717
 718    /* GL_ARB_compute_shader */
 719    consts->MaxComputeWorkGroupCount[0] = 65535;
 720    consts->MaxComputeWorkGroupCount[1] = 65535;
 721    consts->MaxComputeWorkGroupCount[2] = 65535;
 722    consts->MaxComputeWorkGroupSize[0] = 1024;
 723    consts->MaxComputeWorkGroupSize[1] = 1024;
 724    consts->MaxComputeWorkGroupSize[2] = 64;
 725    /* Enables compute support for GLES 3.1 if >= 128 */
 726    consts->MaxComputeWorkGroupInvocations = 0;
 727
 728    /** GL_ARB_gpu_shader5 */
 729    consts->MinFragmentInterpolationOffset = MIN_FRAGMENT_INTERPOLATION_OFFSET;
 730    consts->MaxFragmentInterpolationOffset = MAX_FRAGMENT_INTERPOLATION_OFFSET;
 731
 732    /** GL_KHR_context_flush_control */
 733    consts->ContextReleaseBehavior = GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH;
 734
 735    /** GL_ARB_tessellation_shader */
 736    consts->MaxTessGenLevel = MAX_TESS_GEN_LEVEL;
 737    consts->MaxPatchVertices = MAX_PATCH_VERTICES;
 738    consts->Program[MESA_SHADER_TESS_CTRL].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 739    consts->Program[MESA_SHADER_TESS_EVAL].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 740    consts->MaxTessPatchComponents = MAX_TESS_PATCH_COMPONENTS;
 741    consts->MaxTessControlTotalOutputComponents = MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS;
 742    consts->PrimitiveRestartForPatches = false;
 743
 744    /** GL_ARB_compute_variable_group_size */
 745    consts->MaxComputeVariableGroupSize[0] = 512;
 746    consts->MaxComputeVariableGroupSize[1] = 512;
 747    consts->MaxComputeVariableGroupSize[2] = 64;
 748    consts->MaxComputeVariableGroupInvocations = 512;
 749
 750    /** GL_NV_conservative_raster */
 751    consts->MaxSubpixelPrecisionBiasBits = 0;
 752
 753    /** GL_NV_conservative_raster_dilate */
 754    consts->ConservativeRasterDilateRange[0] = 0.0;
 755    consts->ConservativeRasterDilateRange[1] = 0.0;
 756    consts->ConservativeRasterDilateGranularity = 0.0;
 757
 758    consts->glBeginEndBufferSize = 512 * 1024;
 759 }
 760
 761
 762 /**
 763  * Do some sanity checks on the limits/constants for the given context.
 764  * Only called the first time a context is bound.
 765  */
 766 static void
 767 check_context_limits(struct gl_context *ctx)
 768 {
 769    (void) ctx;
 770
 771    /* check that we don't exceed the size of various bitfields */
 772    assert(VARYING_SLOT_MAX <=
 773           (8 * sizeof(ctx->VertexProgram._Current->info.outputs_written)));
 774    assert(VARYING_SLOT_MAX <=
 775           (8 * sizeof(ctx->FragmentProgram._Current->info.inputs_read)));
 776
 777    /* shader-related checks */
 778    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
 779    assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
 780
 781    /* Texture unit checks */
 782    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits > 0);
 783    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
 784    assert(ctx->Const.MaxTextureCoordUnits > 0);
 785    assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
 786    assert(ctx->Const.MaxTextureUnits > 0);
 787    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
 788    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
 789    assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits,
 790                                              ctx->Const.MaxTextureCoordUnits));
 791    assert(ctx->Const.MaxCombinedTextureImageUnits > 0);
 792    assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
 793    assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
 794    /* number of coord units cannot be greater than number of image units */
 795    assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);
 796
 797
 798    /* Texture size checks */
 799    assert(ctx->Const.MaxTextureSize <= (1 << (MAX_TEXTURE_LEVELS - 1)));
 800    assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
 801    assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
 802    assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
 803
 804    /* Texture level checks */
 805    assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
 806    assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
 807
 808    /* Max texture size should be <= max viewport size (render to texture) */
 809    assert(ctx->Const.MaxTextureSize <= ctx->Const.MaxViewportWidth);
 810    assert(ctx->Const.MaxTextureSize <= ctx->Const.MaxViewportHeight);
 811
 812    assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
 813
 814    /* if this fails, add more enum values to gl_buffer_index */
 815    assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT);
 816
 817    /* XXX probably add more tests */
 818 }
 819
 820
 821 /**
 822  * Initialize the attribute groups in a GL context.
 823  *
 824  * \param ctx GL context.
 825  *
 826  * Initializes all the attributes, calling the respective <tt>init*</tt>
 827  * functions for the more complex data structures.
 828  */
 829 static GLboolean
 830 init_attrib_groups(struct gl_context *ctx)
 831 {
 832    assert(ctx);
 833
 834    /* Constants */
 835    _mesa_init_constants(&ctx->Const, ctx->API);
 836
 837    /* Extensions */
 838    _mesa_init_extensions(&ctx->Extensions);
 839
 840    /* Attribute Groups */
 841    _mesa_init_accum( ctx );
 842    _mesa_init_attrib( ctx );
 843    _mesa_init_bbox( ctx );
 844    _mesa_init_buffer_objects( ctx );
 845    _mesa_init_color( ctx );
 846    _mesa_init_conservative_raster( ctx );
 847    _mesa_init_current( ctx );
 848    _mesa_init_depth( ctx );
 849    _mesa_init_debug( ctx );
 850    _mesa_init_debug_output( ctx );
 851    _mesa_init_display_list( ctx );
 852    _mesa_init_eval( ctx );
 853    _mesa_init_fbobjects( ctx );
 854    _mesa_init_feedback( ctx );
 855    _mesa_init_fog( ctx );
 856    _mesa_init_hint( ctx );
 857    _mesa_init_image_units( ctx );
 858    _mesa_init_line( ctx );
 859    _mesa_init_lighting( ctx );
 860    _mesa_init_matrix( ctx );
 861    _mesa_init_multisample( ctx );
 862    _mesa_init_performance_monitors( ctx );
 863    _mesa_init_performance_queries( ctx );
 864    _mesa_init_pipeline( ctx );
 865    _mesa_init_pixel( ctx );
 866    _mesa_init_pixelstore( ctx );
 867    _mesa_init_point( ctx );
 868    _mesa_init_polygon( ctx );
 869    _mesa_init_program( ctx );
 870    _mesa_init_queryobj( ctx );
 871    _mesa_init_sync( ctx );
 872    _mesa_init_rastpos( ctx );
 873    _mesa_init_scissor( ctx );
 874    _mesa_init_shader_state( ctx );
 875    _mesa_init_stencil( ctx );
 876    _mesa_init_transform( ctx );
 877    _mesa_init_transform_feedback( ctx );
 878    _mesa_init_varray( ctx );
 879    _mesa_init_viewport( ctx );
 880    _mesa_init_resident_handles( ctx );
 881
 882    if (!_mesa_init_texture( ctx ))
 883       return GL_FALSE;
 884
 885    /* Miscellaneous */
 886    ctx->TileRasterOrderIncreasingX = GL_TRUE;
 887    ctx->TileRasterOrderIncreasingY = GL_TRUE;
 888    ctx->NewState = _NEW_ALL;
 889    ctx->NewDriverState = ~0;
 890    ctx->ErrorValue = GL_NO_ERROR;
 891    ctx->ShareGroupReset = false;
 892    ctx->varying_vp_inputs = VERT_BIT_ALL;
 893
 894    return GL_TRUE;
 895 }
 896
 897
 898 /**
 899  * Update default objects in a GL context with respect to shared state.
 900  *
 901  * \param ctx GL context.
 902  *
 903  * Removes references to old default objects, (texture objects, program
 904  * objects, etc.) and changes to reference those from the current shared
 905  * state.
 906  */
 907 static GLboolean
 908 update_default_objects(struct gl_context *ctx)
 909 {
 910    assert(ctx);
 911
 912    _mesa_update_default_objects_program(ctx);
 913    _mesa_update_default_objects_texture(ctx);
 914    _mesa_update_default_objects_buffer_objects(ctx);
 915
 916    return GL_TRUE;
 917 }
 918
 919
 920 /* XXX this is temporary and should be removed at some point in the
 921  * future when there's a reasonable expectation that the libGL library
 922  * contains the _glapi_new_nop_table() and _glapi_set_nop_handler()
 923  * functions which were added in Mesa 10.6.
 924  */
 925 #if !defined(_WIN32)
 926 /* Avoid libGL / driver ABI break */
 927 #define USE_GLAPI_NOP_FEATURES 0
 928 #else
 929 #define USE_GLAPI_NOP_FEATURES 1
 930 #endif
 931
 932
 933 /**
 934  * This function is called by the glapi no-op functions.  For each OpenGL
 935  * function/entrypoint there's a simple no-op function.  These "no-op"
 936  * functions call this function.
 937  *
 938  * If there's a current OpenGL context for the calling thread, we record a
 939  * GL_INVALID_OPERATION error.  This can happen either because the app's
 940  * calling an unsupported extension function, or calling an illegal function
 941  * (such as glClear between glBegin/glEnd).
 942  *
 943  * If there's no current OpenGL context for the calling thread, we can
 944  * print a message to stderr.
 945  *
 946  * \param name  the name of the OpenGL function
 947  */
 948 #if USE_GLAPI_NOP_FEATURES
 949 static void
 950 nop_handler(const char *name)
 951 {
 952    GET_CURRENT_CONTEXT(ctx);
 953    if (ctx) {
 954       _mesa_error(ctx, GL_INVALID_OPERATION, "%s(invalid call)", name);
 955    }
 956 #ifndef NDEBUG
 957    else if (getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG")) {
 958       fprintf(stderr,
 959               "GL User Error: gl%s called without a rendering context\n",
 960               name);
 961       fflush(stderr);
 962    }
 963 #endif
 964 }
 965 #endif
 966
 967
 968 /**
 969  * Special no-op glFlush, see below.
 970  */
 971 #if defined(_WIN32)
 972 static void GLAPIENTRY
 973 nop_glFlush(void)
 974 {
 975    /* don't record an error like we do in nop_handler() */
 976 }
 977 #endif
 978
 979
 980 #if !USE_GLAPI_NOP_FEATURES
 981 static int
 982 generic_nop(void)
 983 {
 984    GET_CURRENT_CONTEXT(ctx);
 985    _mesa_error(ctx, GL_INVALID_OPERATION,
 986                "unsupported function called "
 987                "(unsupported extension or deprecated function?)");
 988    return 0;
 989 }
 990 #endif
 991
 992
 993 /**
 994  * Create a new API dispatch table in which all entries point to the
 995  * generic_nop() function.  This will not work on Windows because of
 996  * the __stdcall convention which requires the callee to clean up the
 997  * call stack.  That's impossible with one generic no-op function.
 998  */
 999 struct _glapi_table *
1000 _mesa_new_nop_table(unsigned numEntries)
1001 {
1002    struct _glapi_table *table;
1003
1004 #if !USE_GLAPI_NOP_FEATURES
1005    table = malloc(numEntries * sizeof(_glapi_proc));
1006    if (table) {
1007       _glapi_proc *entry = (_glapi_proc *) table;
1008       unsigned i;
1009       for (i = 0; i < numEntries; i++) {
1010          entry[i] = (_glapi_proc) generic_nop;
1011       }
1012    }
1013 #else
1014    table = _glapi_new_nop_table(numEntries);
1015 #endif
1016    return table;
1017 }
1018
1019
1020 /**
1021  * Allocate and initialize a new dispatch table.  The table will be
1022  * populated with pointers to "no-op" functions.  In turn, the no-op
1023  * functions will call nop_handler() above.
1024  */
1025 struct _glapi_table *
1026 _mesa_alloc_dispatch_table(void)
1027 {
1028    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1029     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
1030     * Mesa we do this to accommodate different versions of libGL and various
1031     * DRI drivers.
1032     */
1033    int numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT);
1034
1035    struct _glapi_table *table = _mesa_new_nop_table(numEntries);
1036
1037 #if defined(_WIN32)
1038    if (table) {
1039       /* This is a special case for Windows in the event that
1040        * wglGetProcAddress is called between glBegin/End().
1041        *
1042        * The MS opengl32.dll library apparently calls glFlush from
1043        * wglGetProcAddress().  If we're inside glBegin/End(), glFlush
1044        * will dispatch to _mesa_generic_nop() and we'll generate a
1045        * GL_INVALID_OPERATION error.
1046        *
1047        * The specific case which hits this is piglit's primitive-restart
1048        * test which calls glPrimitiveRestartNV() inside glBegin/End.  The
1049        * first time we call glPrimitiveRestartNV() Piglit's API dispatch
1050        * code will try to resolve the function by calling wglGetProcAddress.
1051        * This raises GL_INVALID_OPERATION and an assert(glGetError()==0)
1052        * will fail causing the test to fail.  By suppressing the error, the
1053        * assertion passes and the test continues.
1054        */
1055       SET_Flush(table, nop_glFlush);
1056    }
1057 #endif
1058
1059 #if USE_GLAPI_NOP_FEATURES
1060    _glapi_set_nop_handler(nop_handler);
1061 #endif
1062
1063    return table;
1064 }
1065
1066 /**
1067  * Creates a minimal dispatch table for use within glBegin()/glEnd().
1068  *
1069  * This ensures that we generate GL_INVALID_OPERATION errors from most
1070  * functions, since the set of functions that are valid within Begin/End is
1071  * very small.
1072  *
1073  * From the GL 1.0 specification section 2.6.3, "GL Commands within
1074  * Begin/End"
1075  *
1076  *     "The only GL commands that are allowed within any Begin/End pairs are
1077  *      the commands for specifying vertex coordinates, vertex color, normal
1078  *      coordinates, and texture coordinates (Vertex, Color, Index, Normal,
1079  *      TexCoord), EvalCoord and EvalPoint commands (see section 5.1),
1080  *      commands for specifying lighting material parameters (Material
1081  *      commands see section 2.12.2), display list invocation commands
1082  *      (CallList and CallLists see section 5.4), and the EdgeFlag
1083  *      command. Executing Begin after Begin has already been executed but
1084  *      before an End is issued generates the INVALID OPERATION error, as does
1085  *      executing End without a previous corresponding Begin. Executing any
1086  *      other GL command within Begin/End results in the error INVALID
1087  *      OPERATION."
1088  *
1089  * The table entries for specifying vertex attributes are set up by
1090  * install_vtxfmt() and _mesa_loopback_init_api_table(), and End() and dlists
1091  * are set by install_vtxfmt() as well.
1092  */
1093 static struct _glapi_table *
1094 create_beginend_table(const struct gl_context *ctx)
1095 {
1096    struct _glapi_table *table;
1097
1098    table = _mesa_alloc_dispatch_table();
1099    if (!table)
1100       return NULL;
1101
1102    /* Fill in functions which return a value, since they should return some
1103     * specific value even if they emit a GL_INVALID_OPERATION error from them
1104     * being called within glBegin()/glEnd().
1105     */
1106 #define COPY_DISPATCH(func) SET_##func(table, GET_##func(ctx->Exec))
1107
1108    COPY_DISPATCH(GenLists);
1109    COPY_DISPATCH(IsProgram);
1110    COPY_DISPATCH(IsVertexArray);
1111    COPY_DISPATCH(IsBuffer);
1112    COPY_DISPATCH(IsEnabled);
1113    COPY_DISPATCH(IsEnabledi);
1114    COPY_DISPATCH(IsRenderbuffer);
1115    COPY_DISPATCH(IsFramebuffer);
1116    COPY_DISPATCH(CheckFramebufferStatus);
1117    COPY_DISPATCH(RenderMode);
1118    COPY_DISPATCH(GetString);
1119    COPY_DISPATCH(GetStringi);
1120    COPY_DISPATCH(GetPointerv);
1121    COPY_DISPATCH(IsQuery);
1122    COPY_DISPATCH(IsSampler);
1123    COPY_DISPATCH(IsSync);
1124    COPY_DISPATCH(IsTexture);
1125    COPY_DISPATCH(IsTransformFeedback);
1126    COPY_DISPATCH(DeleteQueries);
1127    COPY_DISPATCH(AreTexturesResident);
1128    COPY_DISPATCH(FenceSync);
1129    COPY_DISPATCH(ClientWaitSync);
1130    COPY_DISPATCH(MapBuffer);
1131    COPY_DISPATCH(UnmapBuffer);
1132    COPY_DISPATCH(MapBufferRange);
1133    COPY_DISPATCH(ObjectPurgeableAPPLE);
1134    COPY_DISPATCH(ObjectUnpurgeableAPPLE);
1135
1136    _mesa_loopback_init_api_table(ctx, table);
1137
1138    return table;
1139 }
1140
1141 void
1142 _mesa_initialize_dispatch_tables(struct gl_context *ctx)
1143 {
1144    /* Do the code-generated setup of the exec table in api_exec.c. */
1145    _mesa_initialize_exec_table(ctx);
1146
1147    if (ctx->Save)
1148       _mesa_initialize_save_table(ctx);
1149 }
1150
1151 /**
1152  * Initialize a struct gl_context struct (rendering context).
1153  *
1154  * This includes allocating all the other structs and arrays which hang off of
1155  * the context by pointers.
1156  * Note that the driver needs to pass in its dd_function_table here since
1157  * we need to at least call driverFunctions->NewTextureObject to create the
1158  * default texture objects.
1159  *
1160  * Called by _mesa_create_context().
1161  *
1162  * Performs the imports and exports callback tables initialization, and
1163  * miscellaneous one-time initializations. If no shared context is supplied one
1164  * is allocated, and increase its reference count.  Setups the GL API dispatch
1165  * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.
1166  * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
1167  * for debug flags.
1168  *
1169  * \param ctx the context to initialize
1170  * \param api the GL API type to create the context for
1171  * \param visual describes the visual attributes for this context or NULL to
1172  *               create a configless context
1173  * \param share_list points to context to share textures, display lists,
1174  *        etc with, or NULL
1175  * \param driverFunctions table of device driver functions for this context
1176  *        to use
1177  */
1178 GLboolean
1179 _mesa_initialize_context(struct gl_context *ctx,
1180                          gl_api api,
1181                          const struct gl_config *visual,
1182                          struct gl_context *share_list,
1183                          const struct dd_function_table *driverFunctions)
1184 {
1185    struct gl_shared_state *shared;
1186    int i;
1187
1188    assert(driverFunctions->NewTextureObject);
1189    assert(driverFunctions->FreeTextureImageBuffer);
1190
1191    ctx->API = api;
1192    ctx->DrawBuffer = NULL;
1193    ctx->ReadBuffer = NULL;
1194    ctx->WinSysDrawBuffer = NULL;
1195    ctx->WinSysReadBuffer = NULL;
1196
1197    if (visual) {
1198       ctx->Visual = *visual;
1199       ctx->HasConfig = GL_TRUE;
1200    }
1201    else {
1202       memset(&ctx->Visual, 0, sizeof ctx->Visual);
1203       ctx->HasConfig = GL_FALSE;
1204    }
1205
1206    _mesa_override_gl_version(ctx);
1207
1208    /* misc one-time initializations */
1209    one_time_init(ctx);
1210
1211    /* Plug in driver functions and context pointer here.
1212     * This is important because when we call alloc_shared_state() below
1213     * we'll call ctx->Driver.NewTextureObject() to create the default
1214     * textures.
1215     */
1216    ctx->Driver = *driverFunctions;
1217
1218    if (share_list) {
1219       /* share state with another context */
1220       shared = share_list->Shared;
1221    }
1222    else {
1223       /* allocate new, unshared state */
1224       shared = _mesa_alloc_shared_state(ctx);
1225       if (!shared)
1226          return GL_FALSE;
1227    }
1228
1229    _mesa_reference_shared_state(ctx, &ctx->Shared, shared);
1230
1231    if (!init_attrib_groups( ctx ))
1232       goto fail;
1233
1234    /* KHR_no_error is likely to crash, overflow memory, etc if an application
1235     * has errors so don't enable it for setuid processes.
1236     */
1237    if (env_var_as_boolean("MESA_NO_ERROR", false)) {
1238 #if !defined(_WIN32)
1239       if (geteuid() == getuid())
1240 #endif
1241          ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR;
1242    }
1243
1244    /* setup the API dispatch tables with all nop functions */
1245    ctx->OutsideBeginEnd = _mesa_alloc_dispatch_table();
1246    if (!ctx->OutsideBeginEnd)
1247       goto fail;
1248    ctx->Exec = ctx->OutsideBeginEnd;
1249    ctx->CurrentClientDispatch = ctx->CurrentServerDispatch = ctx->OutsideBeginEnd;
1250
1251    ctx->FragmentProgram._MaintainTexEnvProgram
1252       = (getenv("MESA_TEX_PROG") != NULL);
1253
1254    ctx->VertexProgram._MaintainTnlProgram
1255       = (getenv("MESA_TNL_PROG") != NULL);
1256    if (ctx->VertexProgram._MaintainTnlProgram) {
1257       /* this is required... */
1258       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1259    }
1260
1261    /* Mesa core handles all the formats that mesa core knows about.
1262     * Drivers will want to override this list with just the formats
1263     * they can handle, and confirm that appropriate fallbacks exist in
1264     * _mesa_choose_tex_format().
1265     */
1266    memset(&ctx->TextureFormatSupported, GL_TRUE,
1267           sizeof(ctx->TextureFormatSupported));
1268
1269    switch (ctx->API) {
1270    case API_OPENGL_COMPAT:
1271       ctx->BeginEnd = create_beginend_table(ctx);
1272       ctx->Save = _mesa_alloc_dispatch_table();
1273       if (!ctx->BeginEnd || !ctx->Save)
1274          goto fail;
1275
1276       /* fall-through */
1277    case API_OPENGL_CORE:
1278       break;
1279    case API_OPENGLES:
1280       /**
1281        * GL_OES_texture_cube_map says
1282        * "Initially all texture generation modes are set to REFLECTION_MAP_OES"
1283        */
1284       for (i = 0; i < ARRAY_SIZE(ctx->Texture.FixedFuncUnit); i++) {
1285          struct gl_fixedfunc_texture_unit *texUnit =
1286             &ctx->Texture.FixedFuncUnit[i];
1287
1288          texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;
1289          texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;
1290          texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;
1291          texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1292          texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1293          texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1294       }
1295       break;
1296    case API_OPENGLES2:
1297       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1298       ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
1299       break;
1300    }
1301
1302    ctx->FirstTimeCurrent = GL_TRUE;
1303
1304    return GL_TRUE;
1305
1306 fail:
1307    _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1308    free(ctx->BeginEnd);
1309    free(ctx->OutsideBeginEnd);
1310    free(ctx->Save);
1311    return GL_FALSE;
1312 }
1313
1314
1315 /**
1316  * Free the data associated with the given context.
1317  *
1318  * But doesn't free the struct gl_context struct itself.
1319  *
1320  * \sa _mesa_initialize_context() and init_attrib_groups().
1321  */
1322 void
1323 _mesa_free_context_data(struct gl_context *ctx)
1324 {
1325    if (!_mesa_get_current_context()){
1326       /* No current context, but we may need one in order to delete
1327        * texture objs, etc.  So temporarily bind the context now.
1328        */
1329       _mesa_make_current(ctx, NULL, NULL);
1330    }
1331
1332    /* unreference WinSysDraw/Read buffers */
1333    _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
1334    _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
1335    _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
1336    _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
1337
1338    _mesa_reference_program(ctx, &ctx->VertexProgram.Current, NULL);
1339    _mesa_reference_program(ctx, &ctx->VertexProgram._Current, NULL);
1340    _mesa_reference_program(ctx, &ctx->VertexProgram._TnlProgram, NULL);
1341
1342    _mesa_reference_program(ctx, &ctx->TessCtrlProgram._Current, NULL);
1343    _mesa_reference_program(ctx, &ctx->TessEvalProgram._Current, NULL);
1344    _mesa_reference_program(ctx, &ctx->GeometryProgram._Current, NULL);
1345
1346    _mesa_reference_program(ctx, &ctx->FragmentProgram.Current, NULL);
1347    _mesa_reference_program(ctx, &ctx->FragmentProgram._Current, NULL);
1348    _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
1349
1350    _mesa_reference_program(ctx, &ctx->ComputeProgram._Current, NULL);
1351
1352    _mesa_reference_vao(ctx, &ctx->Array.VAO, NULL);
1353    _mesa_reference_vao(ctx, &ctx->Array.DefaultVAO, NULL);
1354    _mesa_reference_vao(ctx, &ctx->Array._EmptyVAO, NULL);
1355    _mesa_reference_vao(ctx, &ctx->Array._DrawVAO, NULL);
1356
1357    _mesa_free_attrib_data(ctx);
1358    _mesa_free_buffer_objects(ctx);
1359    _mesa_free_eval_data( ctx );
1360    _mesa_free_texture_data( ctx );
1361    _mesa_free_image_textures(ctx);
1362    _mesa_free_matrix_data( ctx );
1363    _mesa_free_pipeline_data(ctx);
1364    _mesa_free_program_data(ctx);
1365    _mesa_free_shader_state(ctx);
1366    _mesa_free_queryobj_data(ctx);
1367    _mesa_free_sync_data(ctx);
1368    _mesa_free_varray_data(ctx);
1369    _mesa_free_transform_feedback(ctx);
1370    _mesa_free_performance_monitors(ctx);
1371    _mesa_free_performance_queries(ctx);
1372    _mesa_free_resident_handles(ctx);
1373
1374    _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
1375    _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
1376    _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);
1377    _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
1378
1379    /* free dispatch tables */
1380    free(ctx->BeginEnd);
1381    free(ctx->OutsideBeginEnd);
1382    free(ctx->Save);
1383    free(ctx->ContextLost);
1384    free(ctx->MarshalExec);
1385
1386    /* Shared context state (display lists, textures, etc) */
1387    _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1388
1389    /* needs to be after freeing shared state */
1390    _mesa_free_display_list_data(ctx);
1391
1392    _mesa_free_errors_data(ctx);
1393
1394    free((void *)ctx->Extensions.String);
1395
1396    free(ctx->VersionString);
1397
1398    ralloc_free(ctx->SoftFP64);
1399
1400    /* unbind the context if it's currently bound */
1401    if (ctx == _mesa_get_current_context()) {
1402       _mesa_make_current(NULL, NULL, NULL);
1403    }
1404
1405    /* Do this after unbinding context to ensure any thread is finished. */
1406    if (ctx->shader_builtin_ref) {
1407       _mesa_glsl_builtin_functions_decref();
1408       ctx->shader_builtin_ref = false;
1409    }
1410
1411    free(ctx->Const.SpirVExtensions);
1412 }
1413
1414
1415 /**
1416  * Destroy a struct gl_context structure.
1417  *
1418  * \param ctx GL context.
1419  *
1420  * Calls _mesa_free_context_data() and frees the gl_context object itself.
1421  */
1422 void
1423 _mesa_destroy_context( struct gl_context *ctx )
1424 {
1425    if (ctx) {
1426       _mesa_free_context_data(ctx);
1427       free( (void *) ctx );
1428    }
1429 }
1430
1431
1432 /**
1433  * Copy attribute groups from one context to another.
1434  *
1435  * \param src source context
1436  * \param dst destination context
1437  * \param mask bitwise OR of GL_*_BIT flags
1438  *
1439  * According to the bits specified in \p mask, copies the corresponding
1440  * attributes from \p src into \p dst.  For many of the attributes a simple \c
1441  * memcpy is not enough due to the existence of internal pointers in their data
1442  * structures.
1443  */
1444 void
1445 _mesa_copy_context( const struct gl_context *src, struct gl_context *dst,
1446                     GLuint mask )
1447 {
1448    if (mask & GL_ACCUM_BUFFER_BIT) {
1449       /* OK to memcpy */
1450       dst->Accum = src->Accum;
1451    }
1452    if (mask & GL_COLOR_BUFFER_BIT) {
1453       /* OK to memcpy */
1454       dst->Color = src->Color;
1455    }
1456    if (mask & GL_CURRENT_BIT) {
1457       /* OK to memcpy */
1458       dst->Current = src->Current;
1459    }
1460    if (mask & GL_DEPTH_BUFFER_BIT) {
1461       /* OK to memcpy */
1462       dst->Depth = src->Depth;
1463    }
1464    if (mask & GL_ENABLE_BIT) {
1465       /* no op */
1466    }
1467    if (mask & GL_EVAL_BIT) {
1468       /* OK to memcpy */
1469       dst->Eval = src->Eval;
1470    }
1471    if (mask & GL_FOG_BIT) {
1472       /* OK to memcpy */
1473       dst->Fog = src->Fog;
1474    }
1475    if (mask & GL_HINT_BIT) {
1476       /* OK to memcpy */
1477       dst->Hint = src->Hint;
1478    }
1479    if (mask & GL_LIGHTING_BIT) {
1480       /* OK to memcpy */
1481       dst->Light = src->Light;
1482    }
1483    if (mask & GL_LINE_BIT) {
1484       /* OK to memcpy */
1485       dst->Line = src->Line;
1486    }
1487    if (mask & GL_LIST_BIT) {
1488       /* OK to memcpy */
1489       dst->List = src->List;
1490    }
1491    if (mask & GL_PIXEL_MODE_BIT) {
1492       /* OK to memcpy */
1493       dst->Pixel = src->Pixel;
1494    }
1495    if (mask & GL_POINT_BIT) {
1496       /* OK to memcpy */
1497       dst->Point = src->Point;
1498    }
1499    if (mask & GL_POLYGON_BIT) {
1500       /* OK to memcpy */
1501       dst->Polygon = src->Polygon;
1502    }
1503    if (mask & GL_POLYGON_STIPPLE_BIT) {
1504       /* Use loop instead of memcpy due to problem with Portland Group's
1505        * C compiler.  Reported by John Stone.
1506        */
1507       GLuint i;
1508       for (i = 0; i < 32; i++) {
1509          dst->PolygonStipple[i] = src->PolygonStipple[i];
1510       }
1511    }
1512    if (mask & GL_SCISSOR_BIT) {
1513       /* OK to memcpy */
1514       dst->Scissor = src->Scissor;
1515    }
1516    if (mask & GL_STENCIL_BUFFER_BIT) {
1517       /* OK to memcpy */
1518       dst->Stencil = src->Stencil;
1519    }
1520    if (mask & GL_TEXTURE_BIT) {
1521       /* Cannot memcpy because of pointers */
1522       _mesa_copy_texture_state(src, dst);
1523    }
1524    if (mask & GL_TRANSFORM_BIT) {
1525       /* OK to memcpy */
1526       dst->Transform = src->Transform;
1527    }
1528    if (mask & GL_VIEWPORT_BIT) {
1529       unsigned i;
1530       for (i = 0; i < src->Const.MaxViewports; i++) {
1531          /* OK to memcpy */
1532          dst->ViewportArray[i] = src->ViewportArray[i];
1533       }
1534    }
1535
1536    /* XXX FIXME:  Call callbacks?
1537     */
1538    dst->NewState = _NEW_ALL;
1539    dst->NewDriverState = ~0;
1540 }
1541
1542
1543 /**
1544  * Check if the given context can render into the given framebuffer
1545  * by checking visual attributes.
1546  *
1547  * \return GL_TRUE if compatible, GL_FALSE otherwise.
1548  */
1549 static GLboolean
1550 check_compatible(const struct gl_context *ctx,
1551                  const struct gl_framebuffer *buffer)
1552 {
1553    const struct gl_config *ctxvis = &ctx->Visual;
1554    const struct gl_config *bufvis = &buffer->Visual;
1555
1556    if (buffer == _mesa_get_incomplete_framebuffer())
1557       return GL_TRUE;
1558
1559 #define check_component(foo)           \
1560    if (ctxvis->foo && bufvis->foo &&   \
1561        ctxvis->foo != bufvis->foo)     \
1562       return GL_FALSE
1563
1564    check_component(redShift);
1565    check_component(greenShift);
1566    check_component(blueShift);
1567    check_component(redBits);
1568    check_component(greenBits);
1569    check_component(blueBits);
1570    check_component(depthBits);
1571    check_component(stencilBits);
1572
1573 #undef check_component
1574
1575    return GL_TRUE;
1576 }
1577
1578
1579 /**
1580  * Check if the viewport/scissor size has not yet been initialized.
1581  * Initialize the size if the given width and height are non-zero.
1582  */
1583 static void
1584 check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)
1585 {
1586    if (!ctx->ViewportInitialized && width > 0 && height > 0) {
1587       unsigned i;
1588
1589       /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
1590        * potential infinite recursion.
1591        */
1592       ctx->ViewportInitialized = GL_TRUE;
1593
1594       /* Note: ctx->Const.MaxViewports may not have been set by the driver
1595        * yet, so just initialize all of them.
1596        */
1597       for (i = 0; i < MAX_VIEWPORTS; i++) {
1598          _mesa_set_viewport(ctx, i, 0, 0, width, height);
1599          _mesa_set_scissor(ctx, i, 0, 0, width, height);
1600       }
1601    }
1602 }
1603
1604
1605 static void
1606 handle_first_current(struct gl_context *ctx)
1607 {
1608    if (ctx->Version == 0 || !ctx->DrawBuffer) {
1609       /* probably in the process of tearing down the context */
1610       return;
1611    }
1612
1613    check_context_limits(ctx);
1614
1615    _mesa_update_vertex_processing_mode(ctx);
1616
1617    /* According to GL_MESA_configless_context the default value of
1618     * glDrawBuffers depends on the config of the first surface it is bound to.
1619     * For GLES it is always GL_BACK which has a magic interpretation.
1620     */
1621    if (!ctx->HasConfig && _mesa_is_desktop_gl(ctx)) {
1622       if (ctx->DrawBuffer != _mesa_get_incomplete_framebuffer()) {
1623          GLenum16 buffer;
1624
1625          if (ctx->DrawBuffer->Visual.doubleBufferMode)
1626             buffer = GL_BACK;
1627          else
1628             buffer = GL_FRONT;
1629
1630          _mesa_drawbuffers(ctx, ctx->DrawBuffer, 1, &buffer,
1631                            NULL /* destMask */);
1632       }
1633
1634       if (ctx->ReadBuffer != _mesa_get_incomplete_framebuffer()) {
1635          gl_buffer_index bufferIndex;
1636          GLenum buffer;
1637
1638          if (ctx->ReadBuffer->Visual.doubleBufferMode) {
1639             buffer = GL_BACK;
1640             bufferIndex = BUFFER_BACK_LEFT;
1641          }
1642          else {
1643             buffer = GL_FRONT;
1644             bufferIndex = BUFFER_FRONT_LEFT;
1645          }
1646
1647          _mesa_readbuffer(ctx, ctx->ReadBuffer, buffer, bufferIndex);
1648       }
1649    }
1650
1651    /* Determine if generic vertex attribute 0 aliases the conventional
1652     * glVertex position.
1653     */
1654    {
1655       const bool is_forward_compatible_context =
1656          ctx->Const.ContextFlags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT;
1657
1658       /* In OpenGL 3.1 attribute 0 becomes non-magic, just like in OpenGL ES
1659        * 2.0.  Note that we cannot just check for API_OPENGL_COMPAT here because
1660        * that will erroneously allow this usage in a 3.0 forward-compatible
1661        * context too.
1662        */
1663       ctx->_AttribZeroAliasesVertex = (ctx->API == API_OPENGLES
1664                                        || (ctx->API == API_OPENGL_COMPAT
1665                                            && !is_forward_compatible_context));
1666    }
1667
1668    /* We can use this to help debug user's problems.  Tell them to set
1669     * the MESA_INFO env variable before running their app.  Then the
1670     * first time each context is made current we'll print some useful
1671     * information.
1672     */
1673    if (getenv("MESA_INFO")) {
1674       _mesa_print_info(ctx);
1675    }
1676 }
1677
1678 /**
1679  * Bind the given context to the given drawBuffer and readBuffer and
1680  * make it the current context for the calling thread.
1681  * We'll render into the drawBuffer and read pixels from the
1682  * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1683  *
1684  * We check that the context's and framebuffer's visuals are compatible
1685  * and return immediately if they're not.
1686  *
1687  * \param newCtx  the new GL context. If NULL then there will be no current GL
1688  *                context.
1689  * \param drawBuffer  the drawing framebuffer
1690  * \param readBuffer  the reading framebuffer
1691  */
1692 GLboolean
1693 _mesa_make_current( struct gl_context *newCtx,
1694                     struct gl_framebuffer *drawBuffer,
1695                     struct gl_framebuffer *readBuffer )
1696 {
1697    GET_CURRENT_CONTEXT(curCtx);
1698
1699    if (MESA_VERBOSE & VERBOSE_API)
1700       _mesa_debug(newCtx, "_mesa_make_current()\n");
1701
1702    /* Check that the context's and framebuffer's visuals are compatible.
1703     */
1704    if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1705       if (!check_compatible(newCtx, drawBuffer)) {
1706          _mesa_warning(newCtx,
1707               "MakeCurrent: incompatible visuals for context and drawbuffer");
1708          return GL_FALSE;
1709       }
1710    }
1711    if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1712       if (!check_compatible(newCtx, readBuffer)) {
1713          _mesa_warning(newCtx,
1714               "MakeCurrent: incompatible visuals for context and readbuffer");
1715          return GL_FALSE;
1716       }
1717    }
1718
1719    if (curCtx &&
1720        (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) &&
1721        /* make sure this context is valid for flushing */
1722        curCtx != newCtx &&
1723        curCtx->Const.ContextReleaseBehavior ==
1724        GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH) {
1725       _mesa_flush(curCtx);
1726    }
1727
1728    /* Call this periodically to detect when the user has begun using
1729     * GL rendering from multiple threads.
1730     */
1731    _glapi_check_multithread();
1732
1733    if (!newCtx) {
1734       _glapi_set_dispatch(NULL);  /* none current */
1735       /* We need old ctx to correctly release Draw/ReadBuffer
1736        * and avoid a surface leak in st_renderbuffer_delete.
1737        * Therefore, first drop buffers then set new ctx to NULL.
1738        */
1739       if (curCtx) {
1740          _mesa_reference_framebuffer(&curCtx->WinSysDrawBuffer, NULL);
1741          _mesa_reference_framebuffer(&curCtx->WinSysReadBuffer, NULL);
1742       }
1743       _glapi_set_context(NULL);
1744       assert(_mesa_get_current_context() == NULL);
1745    }
1746    else {
1747       _glapi_set_context((void *) newCtx);
1748       assert(_mesa_get_current_context() == newCtx);
1749       _glapi_set_dispatch(newCtx->CurrentClientDispatch);
1750
1751       if (drawBuffer && readBuffer) {
1752          assert(_mesa_is_winsys_fbo(drawBuffer));
1753          assert(_mesa_is_winsys_fbo(readBuffer));
1754          _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1755          _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1756
1757          /*
1758           * Only set the context's Draw/ReadBuffer fields if they're NULL
1759           * or not bound to a user-created FBO.
1760           */
1761          if (!newCtx->DrawBuffer || _mesa_is_winsys_fbo(newCtx->DrawBuffer)) {
1762             _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1763             /* Update the FBO's list of drawbuffers/renderbuffers.
1764              * For winsys FBOs this comes from the GL state (which may have
1765              * changed since the last time this FBO was bound).
1766              */
1767             _mesa_update_draw_buffers(newCtx);
1768          }
1769          if (!newCtx->ReadBuffer || _mesa_is_winsys_fbo(newCtx->ReadBuffer)) {
1770             _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1771             /* In _mesa_initialize_window_framebuffer, for single-buffered
1772              * visuals, the ColorReadBuffer is set to be GL_FRONT, even with
1773              * GLES contexts. When calling read_buffer, we verify we are reading
1774              * from GL_BACK in is_legal_es3_readbuffer_enum.  But the default is
1775              * incorrect, and certain dEQP tests check this.  So fix it here.
1776              */
1777             if (_mesa_is_gles(newCtx) &&
1778                !newCtx->ReadBuffer->Visual.doubleBufferMode)
1779                if (newCtx->ReadBuffer->ColorReadBuffer == GL_FRONT)
1780                   newCtx->ReadBuffer->ColorReadBuffer = GL_BACK;
1781          }
1782
1783          /* XXX only set this flag if we're really changing the draw/read
1784           * framebuffer bindings.
1785           */
1786          newCtx->NewState |= _NEW_BUFFERS;
1787
1788          check_init_viewport(newCtx, drawBuffer->Width, drawBuffer->Height);
1789       }
1790
1791       if (newCtx->FirstTimeCurrent) {
1792          handle_first_current(newCtx);
1793          newCtx->FirstTimeCurrent = GL_FALSE;
1794       }
1795    }
1796
1797    return GL_TRUE;
1798 }
1799
1800
1801 /**
1802  * Make context 'ctx' share the display lists, textures and programs
1803  * that are associated with 'ctxToShare'.
1804  * Any display lists, textures or programs associated with 'ctx' will
1805  * be deleted if nobody else is sharing them.
1806  */
1807 GLboolean
1808 _mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)
1809 {
1810    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1811       struct gl_shared_state *oldShared = NULL;
1812
1813       /* save ref to old state to prevent it from being deleted immediately */
1814       _mesa_reference_shared_state(ctx, &oldShared, ctx->Shared);
1815
1816       /* update ctx's Shared pointer */
1817       _mesa_reference_shared_state(ctx, &ctx->Shared, ctxToShare->Shared);
1818
1819       update_default_objects(ctx);
1820
1821       /* release the old shared state */
1822       _mesa_reference_shared_state(ctx, &oldShared, NULL);
1823
1824       return GL_TRUE;
1825    }
1826    else {
1827       return GL_FALSE;
1828    }
1829 }
1830
1831
1832
1833 /**
1834  * \return pointer to the current GL context for this thread.
1835  *
1836  * Calls _glapi_get_context(). This isn't the fastest way to get the current
1837  * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in
1838  * context.h.
1839  */
1840 struct gl_context *
1841 _mesa_get_current_context( void )
1842 {
1843    return (struct gl_context *) _glapi_get_context();
1844 }
1845
1846
1847 /**
1848  * Get context's current API dispatch table.
1849  *
1850  * It'll either be the immediate-mode execute dispatcher, the display list
1851  * compile dispatcher, or the thread marshalling dispatcher.
1852  *
1853  * \param ctx GL context.
1854  *
1855  * \return pointer to dispatch_table.
1856  *
1857  * Simply returns __struct gl_contextRec::CurrentClientDispatch.
1858  */
1859 struct _glapi_table *
1860 _mesa_get_dispatch(struct gl_context *ctx)
1861 {
1862    return ctx->CurrentClientDispatch;
1863 }
1864
1865 /*@}*/
1866
1867
1868 /**********************************************************************/
1869 /** \name Miscellaneous functions                                     */
1870 /**********************************************************************/
1871 /*@{*/
1872 /**
1873  * Flush commands.
1874  */
1875 void
1876 _mesa_flush(struct gl_context *ctx)
1877 {
1878    FLUSH_VERTICES( ctx, 0 );
1879    if (ctx->Driver.Flush) {
1880       ctx->Driver.Flush(ctx);
1881    }
1882 }
1883
1884
1885
1886 /**
1887  * Flush commands and wait for completion.
1888  *
1889  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1890  * dd_function_table::Finish driver callback, if not NULL.
1891  */
1892 void GLAPIENTRY
1893 _mesa_Finish(void)
1894 {
1895    GET_CURRENT_CONTEXT(ctx);
1896    ASSERT_OUTSIDE_BEGIN_END(ctx);
1897
1898    FLUSH_VERTICES(ctx, 0);
1899
1900    if (ctx->Driver.Finish) {
1901       ctx->Driver.Finish(ctx);
1902    }
1903 }
1904
1905
1906 /**
1907  * Execute glFlush().
1908  *
1909  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1910  * dd_function_table::Flush driver callback, if not NULL.
1911  */
1912 void GLAPIENTRY
1913 _mesa_Flush(void)
1914 {
1915    GET_CURRENT_CONTEXT(ctx);
1916    ASSERT_OUTSIDE_BEGIN_END(ctx);
1917    _mesa_flush(ctx);
1918 }
1919
1920
1921 /*@}*/