src/mesa/main/shader_query.cpp

   1 /*
   2  * Copyright © 2011 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 /**
  25  * \file shader_query.cpp
  26  * C-to-C++ bridge functions to query GLSL shader data
  27  *
  28  * \author Ian Romanick <ian.d.romanick@intel.com>
  29  */
  30
  31 #include "main/context.h"
  32 #include "main/core.h"
  33 #include "main/enums.h"
  34 #include "main/shaderapi.h"
  35 #include "main/shaderobj.h"
  36 #include "main/uniforms.h"
  37 #include "glsl/glsl_symbol_table.h"
  38 #include "glsl/ir.h"
  39 #include "glsl/program.h"
  40 #include "program/hash_table.h"
  41 #include "util/strndup.h"
  42
  43
  44 static GLint
  45 program_resource_location(struct gl_shader_program *shProg,
  46                           struct gl_program_resource *res, const char *name,
  47                           unsigned array_index);
  48
  49 /**
  50  * Declare convenience functions to return resource data in a given type.
  51  * Warning! this is not type safe so be *very* careful when using these.
  52  */
  53 #define DECL_RESOURCE_FUNC(name, type) \
  54 const type * RESOURCE_ ## name (gl_program_resource *res) { \
  55    assert(res->Data); \
  56    return (type *) res->Data; \
  57 }
  58
  59 DECL_RESOURCE_FUNC(VAR, ir_variable);
  60 DECL_RESOURCE_FUNC(UBO, gl_uniform_block);
  61 DECL_RESOURCE_FUNC(UNI, gl_uniform_storage);
  62 DECL_RESOURCE_FUNC(ATC, gl_active_atomic_buffer);
  63 DECL_RESOURCE_FUNC(XFB, gl_transform_feedback_varying_info);
  64 DECL_RESOURCE_FUNC(SUB, gl_subroutine_function);
  65
  66 void GLAPIENTRY
  67 _mesa_BindAttribLocation(GLhandleARB program, GLuint index,
  68                             const GLcharARB *name)
  69 {
  70    GET_CURRENT_CONTEXT(ctx);
  71
  72    struct gl_shader_program *const shProg =
  73       _mesa_lookup_shader_program_err(ctx, program, "glBindAttribLocation");
  74    if (!shProg)
  75       return;
  76
  77    if (!name)
  78       return;
  79
  80    if (strncmp(name, "gl_", 3) == 0) {
  81       _mesa_error(ctx, GL_INVALID_OPERATION,
  82                   "glBindAttribLocation(illegal name)");
  83       return;
  84    }
  85
  86    if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
  87       _mesa_error(ctx, GL_INVALID_VALUE, "glBindAttribLocation(index)");
  88       return;
  89    }
  90
  91    /* Replace the current value if it's already in the list.  Add
  92     * VERT_ATTRIB_GENERIC0 because that's how the linker differentiates
  93     * between built-in attributes and user-defined attributes.
  94     */
  95    shProg->AttributeBindings->put(index + VERT_ATTRIB_GENERIC0, name);
  96
  97    /*
  98     * Note that this attribute binding won't go into effect until
  99     * glLinkProgram is called again.
 100     */
 101 }
 102
 103 static bool
 104 is_active_attrib(const ir_variable *var)
 105 {
 106    if (!var)
 107       return false;
 108
 109    switch (var->data.mode) {
 110    case ir_var_shader_in:
 111       return var->data.location != -1;
 112
 113    case ir_var_system_value:
 114       /* From GL 4.3 core spec, section 11.1.1 (Vertex Attributes):
 115        * "For GetActiveAttrib, all active vertex shader input variables
 116        * are enumerated, including the special built-in inputs gl_VertexID
 117        * and gl_InstanceID."
 118        */
 119       return var->data.location == SYSTEM_VALUE_VERTEX_ID ||
 120              var->data.location == SYSTEM_VALUE_VERTEX_ID_ZERO_BASE ||
 121              var->data.location == SYSTEM_VALUE_INSTANCE_ID;
 122
 123    default:
 124       return false;
 125    }
 126 }
 127
 128 void GLAPIENTRY
 129 _mesa_GetActiveAttrib(GLhandleARB program, GLuint desired_index,
 130                          GLsizei maxLength, GLsizei * length, GLint * size,
 131                          GLenum * type, GLcharARB * name)
 132 {
 133    GET_CURRENT_CONTEXT(ctx);
 134    struct gl_shader_program *shProg;
 135
 136    if (maxLength < 0) {
 137       _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(maxLength < 0)");
 138       return;
 139    }
 140
 141    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveAttrib");
 142    if (!shProg)
 143       return;
 144
 145    if (!shProg->LinkStatus) {
 146       _mesa_error(ctx, GL_INVALID_VALUE,
 147                   "glGetActiveAttrib(program not linked)");
 148       return;
 149    }
 150
 151    if (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL) {
 152       _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(no vertex shader)");
 153       return;
 154    }
 155
 156    struct gl_program_resource *res =
 157       _mesa_program_resource_find_index(shProg, GL_PROGRAM_INPUT,
 158                                         desired_index);
 159
 160    /* User asked for index that does not exist. */
 161    if (!res) {
 162       _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");
 163       return;
 164    }
 165
 166    const ir_variable *const var = RESOURCE_VAR(res);
 167
 168    if (!is_active_attrib(var))
 169       return;
 170
 171    const char *var_name = var->name;
 172
 173    /* Since gl_VertexID may be lowered to gl_VertexIDMESA, we need to
 174     * consider gl_VertexIDMESA as gl_VertexID for purposes of checking
 175     * active attributes.
 176     */
 177    if (var->data.mode == ir_var_system_value &&
 178        var->data.location == SYSTEM_VALUE_VERTEX_ID_ZERO_BASE) {
 179       var_name = "gl_VertexID";
 180    }
 181
 182    _mesa_copy_string(name, maxLength, length, var_name);
 183
 184    if (size)
 185       _mesa_program_resource_prop(shProg, res, desired_index, GL_ARRAY_SIZE,
 186                                   size, "glGetActiveAttrib");
 187
 188    if (type)
 189       _mesa_program_resource_prop(shProg, res, desired_index, GL_TYPE,
 190                                   (GLint *) type, "glGetActiveAttrib");
 191 }
 192
 193 GLint GLAPIENTRY
 194 _mesa_GetAttribLocation(GLhandleARB program, const GLcharARB * name)
 195 {
 196    GET_CURRENT_CONTEXT(ctx);
 197    struct gl_shader_program *const shProg =
 198       _mesa_lookup_shader_program_err(ctx, program, "glGetAttribLocation");
 199
 200    if (!shProg) {
 201       return -1;
 202    }
 203
 204    if (!shProg->LinkStatus) {
 205       _mesa_error(ctx, GL_INVALID_OPERATION,
 206                   "glGetAttribLocation(program not linked)");
 207       return -1;
 208    }
 209
 210    if (!name)
 211       return -1;
 212
 213    /* Not having a vertex shader is not an error.
 214     */
 215    if (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL)
 216       return -1;
 217
 218    unsigned array_index = 0;
 219    struct gl_program_resource *res =
 220       _mesa_program_resource_find_name(shProg, GL_PROGRAM_INPUT, name,
 221                                        &array_index);
 222
 223    if (!res)
 224       return -1;
 225
 226    GLint loc = program_resource_location(shProg, res, name, array_index);
 227
 228    /* The extra check against against 0 is made because of builtin-attribute
 229     * locations that have offset applied. Function program_resource_location
 230     * can return built-in attribute locations < 0 and glGetAttribLocation
 231     * cannot be used on "conventional" attributes.
 232     *
 233     * From page 95 of the OpenGL 3.0 spec:
 234     *
 235     *     "If name is not an active attribute, if name is a conventional
 236     *     attribute, or if an error occurs, -1 will be returned."
 237     */
 238    return (loc >= 0) ? loc : -1;
 239 }
 240
 241 unsigned
 242 _mesa_count_active_attribs(struct gl_shader_program *shProg)
 243 {
 244    if (!shProg->LinkStatus
 245        || shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL) {
 246       return 0;
 247    }
 248
 249    struct gl_program_resource *res = shProg->ProgramResourceList;
 250    unsigned count = 0;
 251    for (unsigned j = 0; j < shProg->NumProgramResourceList; j++, res++) {
 252       if (res->Type == GL_PROGRAM_INPUT &&
 253           res->StageReferences & (1 << MESA_SHADER_VERTEX) &&
 254           is_active_attrib(RESOURCE_VAR(res)))
 255          count++;
 256    }
 257    return count;
 258 }
 259
 260
 261 size_t
 262 _mesa_longest_attribute_name_length(struct gl_shader_program *shProg)
 263 {
 264    if (!shProg->LinkStatus
 265        || shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL) {
 266       return 0;
 267    }
 268
 269    struct gl_program_resource *res = shProg->ProgramResourceList;
 270    size_t longest = 0;
 271    for (unsigned j = 0; j < shProg->NumProgramResourceList; j++, res++) {
 272       if (res->Type == GL_PROGRAM_INPUT &&
 273           res->StageReferences & (1 << MESA_SHADER_VERTEX)) {
 274
 275           const size_t length = strlen(RESOURCE_VAR(res)->name);
 276           if (length >= longest)
 277              longest = length + 1;
 278       }
 279    }
 280
 281    return longest;
 282 }
 283
 284 void GLAPIENTRY
 285 _mesa_BindFragDataLocation(GLuint program, GLuint colorNumber,
 286                            const GLchar *name)
 287 {
 288    _mesa_BindFragDataLocationIndexed(program, colorNumber, 0, name);
 289 }
 290
 291 void GLAPIENTRY
 292 _mesa_BindFragDataLocationIndexed(GLuint program, GLuint colorNumber,
 293                                   GLuint index, const GLchar *name)
 294 {
 295    GET_CURRENT_CONTEXT(ctx);
 296
 297    struct gl_shader_program *const shProg =
 298       _mesa_lookup_shader_program_err(ctx, program, "glBindFragDataLocationIndexed");
 299    if (!shProg)
 300       return;
 301
 302    if (!name)
 303       return;
 304
 305    if (strncmp(name, "gl_", 3) == 0) {
 306       _mesa_error(ctx, GL_INVALID_OPERATION, "glBindFragDataLocationIndexed(illegal name)");
 307       return;
 308    }
 309
 310    if (index > 1) {
 311       _mesa_error(ctx, GL_INVALID_VALUE, "glBindFragDataLocationIndexed(index)");
 312       return;
 313    }
 314
 315    if (index == 0 && colorNumber >= ctx->Const.MaxDrawBuffers) {
 316       _mesa_error(ctx, GL_INVALID_VALUE, "glBindFragDataLocationIndexed(colorNumber)");
 317       return;
 318    }
 319
 320    if (index == 1 && colorNumber >= ctx->Const.MaxDualSourceDrawBuffers) {
 321       _mesa_error(ctx, GL_INVALID_VALUE, "glBindFragDataLocationIndexed(colorNumber)");
 322       return;
 323    }
 324
 325    /* Replace the current value if it's already in the list.  Add
 326     * FRAG_RESULT_DATA0 because that's how the linker differentiates
 327     * between built-in attributes and user-defined attributes.
 328     */
 329    shProg->FragDataBindings->put(colorNumber + FRAG_RESULT_DATA0, name);
 330    shProg->FragDataIndexBindings->put(index, name);
 331    /*
 332     * Note that this binding won't go into effect until
 333     * glLinkProgram is called again.
 334     */
 335
 336 }
 337
 338 GLint GLAPIENTRY
 339 _mesa_GetFragDataIndex(GLuint program, const GLchar *name)
 340 {
 341    GET_CURRENT_CONTEXT(ctx);
 342    struct gl_shader_program *const shProg =
 343       _mesa_lookup_shader_program_err(ctx, program, "glGetFragDataIndex");
 344
 345    if (!shProg) {
 346       return -1;
 347    }
 348
 349    if (!shProg->LinkStatus) {
 350       _mesa_error(ctx, GL_INVALID_OPERATION,
 351                   "glGetFragDataIndex(program not linked)");
 352       return -1;
 353    }
 354
 355    if (!name)
 356       return -1;
 357
 358    if (strncmp(name, "gl_", 3) == 0) {
 359       _mesa_error(ctx, GL_INVALID_OPERATION,
 360                   "glGetFragDataIndex(illegal name)");
 361       return -1;
 362    }
 363
 364    /* Not having a fragment shader is not an error.
 365     */
 366    if (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL)
 367       return -1;
 368
 369    return _mesa_program_resource_location_index(shProg, GL_PROGRAM_OUTPUT,
 370                                                 name);
 371 }
 372
 373 GLint GLAPIENTRY
 374 _mesa_GetFragDataLocation(GLuint program, const GLchar *name)
 375 {
 376    GET_CURRENT_CONTEXT(ctx);
 377    struct gl_shader_program *const shProg =
 378       _mesa_lookup_shader_program_err(ctx, program, "glGetFragDataLocation");
 379
 380    if (!shProg) {
 381       return -1;
 382    }
 383
 384    if (!shProg->LinkStatus) {
 385       _mesa_error(ctx, GL_INVALID_OPERATION,
 386                   "glGetFragDataLocation(program not linked)");
 387       return -1;
 388    }
 389
 390    if (!name)
 391       return -1;
 392
 393    if (strncmp(name, "gl_", 3) == 0) {
 394       _mesa_error(ctx, GL_INVALID_OPERATION,
 395                   "glGetFragDataLocation(illegal name)");
 396       return -1;
 397    }
 398
 399    /* Not having a fragment shader is not an error.
 400     */
 401    if (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL)
 402       return -1;
 403
 404    unsigned array_index = 0;
 405    struct gl_program_resource *res =
 406       _mesa_program_resource_find_name(shProg, GL_PROGRAM_OUTPUT, name,
 407                                        &array_index);
 408
 409    if (!res)
 410       return -1;
 411
 412    GLint loc = program_resource_location(shProg, res, name, array_index);
 413
 414    /* The extra check against against 0 is made because of builtin-attribute
 415     * locations that have offset applied. Function program_resource_location
 416     * can return built-in attribute locations < 0 and glGetFragDataLocation
 417     * cannot be used on "conventional" attributes.
 418     *
 419     * From page 95 of the OpenGL 3.0 spec:
 420     *
 421     *     "If name is not an active attribute, if name is a conventional
 422     *     attribute, or if an error occurs, -1 will be returned."
 423     */
 424    return (loc >= 0) ? loc : -1;
 425 }
 426
 427 const char*
 428 _mesa_program_resource_name(struct gl_program_resource *res)
 429 {
 430    const ir_variable *var;
 431    switch (res->Type) {
 432    case GL_UNIFORM_BLOCK:
 433    case GL_SHADER_STORAGE_BLOCK:
 434       return RESOURCE_UBO(res)->Name;
 435    case GL_TRANSFORM_FEEDBACK_VARYING:
 436       return RESOURCE_XFB(res)->Name;
 437    case GL_PROGRAM_INPUT:
 438       var = RESOURCE_VAR(res);
 439       /* Special case gl_VertexIDMESA -> gl_VertexID. */
 440       if (var->data.mode == ir_var_system_value &&
 441           var->data.location == SYSTEM_VALUE_VERTEX_ID_ZERO_BASE) {
 442          return "gl_VertexID";
 443       }
 444    /* fallthrough */
 445    case GL_PROGRAM_OUTPUT:
 446       return RESOURCE_VAR(res)->name;
 447    case GL_UNIFORM:
 448    case GL_BUFFER_VARIABLE:
 449       return RESOURCE_UNI(res)->name;
 450    case GL_VERTEX_SUBROUTINE_UNIFORM:
 451    case GL_GEOMETRY_SUBROUTINE_UNIFORM:
 452    case GL_FRAGMENT_SUBROUTINE_UNIFORM:
 453    case GL_COMPUTE_SUBROUTINE_UNIFORM:
 454    case GL_TESS_CONTROL_SUBROUTINE_UNIFORM:
 455    case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM:
 456       return RESOURCE_UNI(res)->name + MESA_SUBROUTINE_PREFIX_LEN;
 457    case GL_VERTEX_SUBROUTINE:
 458    case GL_GEOMETRY_SUBROUTINE:
 459    case GL_FRAGMENT_SUBROUTINE:
 460    case GL_COMPUTE_SUBROUTINE:
 461    case GL_TESS_CONTROL_SUBROUTINE:
 462    case GL_TESS_EVALUATION_SUBROUTINE:
 463       return RESOURCE_SUB(res)->name;
 464    default:
 465       assert(!"support for resource type not implemented");
 466    }
 467    return NULL;
 468 }
 469
 470
 471 unsigned
 472 _mesa_program_resource_array_size(struct gl_program_resource *res)
 473 {
 474    switch (res->Type) {
 475    case GL_TRANSFORM_FEEDBACK_VARYING:
 476       return RESOURCE_XFB(res)->Size > 1 ?
 477              RESOURCE_XFB(res)->Size : 0;
 478    case GL_PROGRAM_INPUT:
 479    case GL_PROGRAM_OUTPUT:
 480       return RESOURCE_VAR(res)->type->length;
 481    case GL_UNIFORM:
 482    case GL_VERTEX_SUBROUTINE_UNIFORM:
 483    case GL_GEOMETRY_SUBROUTINE_UNIFORM:
 484    case GL_FRAGMENT_SUBROUTINE_UNIFORM:
 485    case GL_COMPUTE_SUBROUTINE_UNIFORM:
 486    case GL_TESS_CONTROL_SUBROUTINE_UNIFORM:
 487    case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM:
 488       return RESOURCE_UNI(res)->array_elements;
 489    case GL_BUFFER_VARIABLE:
 490       /* Unsized arrays */
 491       if (RESOURCE_UNI(res)->array_stride > 0 &&
 492           RESOURCE_UNI(res)->array_elements == 0)
 493          return 1;
 494       else
 495          return RESOURCE_UNI(res)->array_elements;
 496    case GL_VERTEX_SUBROUTINE:
 497    case GL_GEOMETRY_SUBROUTINE:
 498    case GL_FRAGMENT_SUBROUTINE:
 499    case GL_COMPUTE_SUBROUTINE:
 500    case GL_TESS_CONTROL_SUBROUTINE:
 501    case GL_TESS_EVALUATION_SUBROUTINE:
 502    case GL_ATOMIC_COUNTER_BUFFER:
 503    case GL_UNIFORM_BLOCK:
 504    case GL_SHADER_STORAGE_BLOCK:
 505       return 0;
 506    default:
 507       assert(!"support for resource type not implemented");
 508    }
 509    return 0;
 510 }
 511
 512 /**
 513  * Checks if array subscript is valid and if so sets array_index.
 514  */
 515 static bool
 516 valid_array_index(const GLchar *name, unsigned *array_index)
 517 {
 518    long idx = 0;
 519    const GLchar *out_base_name_end;
 520
 521    idx = parse_program_resource_name(name, &out_base_name_end);
 522    if (idx < 0)
 523       return false;
 524
 525    if (array_index)
 526       *array_index = idx;
 527
 528    return true;
 529 }
 530
 531 /* Find a program resource with specific name in given interface.
 532  */
 533 struct gl_program_resource *
 534 _mesa_program_resource_find_name(struct gl_shader_program *shProg,
 535                                  GLenum programInterface, const char *name,
 536                                  unsigned *array_index)
 537 {
 538    struct gl_program_resource *res = shProg->ProgramResourceList;
 539    for (unsigned i = 0; i < shProg->NumProgramResourceList; i++, res++) {
 540       if (res->Type != programInterface)
 541          continue;
 542
 543       /* Resource basename. */
 544       const char *rname = _mesa_program_resource_name(res);
 545       unsigned baselen = strlen(rname);
 546
 547       if (strncmp(rname, name, baselen) == 0) {
 548          switch (programInterface) {
 549          case GL_UNIFORM_BLOCK:
 550          case GL_SHADER_STORAGE_BLOCK:
 551             /* Basename match, check if array or struct. */
 552             if (name[baselen] == '\0' ||
 553                 name[baselen] == '[' ||
 554                 name[baselen] == '.') {
 555                return res;
 556             }
 557             break;
 558          case GL_TRANSFORM_FEEDBACK_VARYING:
 559          case GL_BUFFER_VARIABLE:
 560          case GL_UNIFORM:
 561          case GL_VERTEX_SUBROUTINE_UNIFORM:
 562          case GL_GEOMETRY_SUBROUTINE_UNIFORM:
 563          case GL_FRAGMENT_SUBROUTINE_UNIFORM:
 564          case GL_COMPUTE_SUBROUTINE_UNIFORM:
 565          case GL_TESS_CONTROL_SUBROUTINE_UNIFORM:
 566          case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM:
 567          case GL_VERTEX_SUBROUTINE:
 568          case GL_GEOMETRY_SUBROUTINE:
 569          case GL_FRAGMENT_SUBROUTINE:
 570          case GL_COMPUTE_SUBROUTINE:
 571          case GL_TESS_CONTROL_SUBROUTINE:
 572          case GL_TESS_EVALUATION_SUBROUTINE:
 573             if (name[baselen] == '.') {
 574                return res;
 575             }
 576             /* fall-through */
 577          case GL_PROGRAM_INPUT:
 578          case GL_PROGRAM_OUTPUT:
 579             if (name[baselen] == '\0') {
 580                return res;
 581             } else if (name[baselen] == '[' &&
 582                 valid_array_index(name, array_index)) {
 583                return res;
 584             }
 585             break;
 586          default:
 587             assert(!"not implemented for given interface");
 588          }
 589       }
 590    }
 591    return NULL;
 592 }
 593
 594 static GLuint
 595 calc_resource_index(struct gl_shader_program *shProg,
 596                     struct gl_program_resource *res)
 597 {
 598    unsigned i;
 599    GLuint index = 0;
 600    for (i = 0; i < shProg->NumProgramResourceList; i++) {
 601       if (&shProg->ProgramResourceList[i] == res)
 602          return index;
 603       if (shProg->ProgramResourceList[i].Type == res->Type)
 604          index++;
 605    }
 606    return GL_INVALID_INDEX;
 607 }
 608
 609 /**
 610  * Calculate index for the given resource.
 611  */
 612 GLuint
 613 _mesa_program_resource_index(struct gl_shader_program *shProg,
 614                              struct gl_program_resource *res)
 615 {
 616    if (!res)
 617       return GL_INVALID_INDEX;
 618
 619    switch (res->Type) {
 620    case GL_ATOMIC_COUNTER_BUFFER:
 621       return RESOURCE_ATC(res) - shProg->AtomicBuffers;
 622    case GL_UNIFORM_BLOCK:
 623    case GL_SHADER_STORAGE_BLOCK:
 624    case GL_TRANSFORM_FEEDBACK_VARYING:
 625    default:
 626       return calc_resource_index(shProg, res);
 627    }
 628 }
 629
 630 /* Find a program resource with specific index in given interface.
 631  */
 632 struct gl_program_resource *
 633 _mesa_program_resource_find_index(struct gl_shader_program *shProg,
 634                                   GLenum programInterface, GLuint index)
 635 {
 636    struct gl_program_resource *res = shProg->ProgramResourceList;
 637    int idx = -1;
 638
 639    for (unsigned i = 0; i < shProg->NumProgramResourceList; i++, res++) {
 640       if (res->Type != programInterface)
 641          continue;
 642
 643       switch (res->Type) {
 644       case GL_UNIFORM_BLOCK:
 645       case GL_ATOMIC_COUNTER_BUFFER:
 646       case GL_SHADER_STORAGE_BLOCK:
 647          if (_mesa_program_resource_index(shProg, res) == index)
 648             return res;
 649          break;
 650       case GL_TRANSFORM_FEEDBACK_VARYING:
 651       case GL_PROGRAM_INPUT:
 652       case GL_PROGRAM_OUTPUT:
 653       case GL_UNIFORM:
 654       case GL_VERTEX_SUBROUTINE_UNIFORM:
 655       case GL_GEOMETRY_SUBROUTINE_UNIFORM:
 656       case GL_FRAGMENT_SUBROUTINE_UNIFORM:
 657       case GL_COMPUTE_SUBROUTINE_UNIFORM:
 658       case GL_TESS_CONTROL_SUBROUTINE_UNIFORM:
 659       case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM:
 660       case GL_VERTEX_SUBROUTINE:
 661       case GL_GEOMETRY_SUBROUTINE:
 662       case GL_FRAGMENT_SUBROUTINE:
 663       case GL_COMPUTE_SUBROUTINE:
 664       case GL_TESS_CONTROL_SUBROUTINE:
 665       case GL_TESS_EVALUATION_SUBROUTINE:
 666       case GL_BUFFER_VARIABLE:
 667          if (++idx == (int) index)
 668             return res;
 669          break;
 670       default:
 671          assert(!"not implemented for given interface");
 672       }
 673    }
 674    return NULL;
 675 }
 676
 677 /* Function returns if resource name is expected to have index
 678  * appended into it.
 679  *
 680  *
 681  * Page 61 (page 73 of the PDF) in section 2.11 of the OpenGL ES 3.0
 682  * spec says:
 683  *
 684  *     "If the active uniform is an array, the uniform name returned in
 685  *     name will always be the name of the uniform array appended with
 686  *     "[0]"."
 687  *
 688  * The same text also appears in the OpenGL 4.2 spec.  It does not,
 689  * however, appear in any previous spec.  Previous specifications are
 690  * ambiguous in this regard.  However, either name can later be passed
 691  * to glGetUniformLocation (and related APIs), so there shouldn't be any
 692  * harm in always appending "[0]" to uniform array names.
 693  *
 694  * Geometry shader stage has different naming convention where the 'normal'
 695  * condition is an array, therefore for variables referenced in geometry
 696  * stage we do not add '[0]'.
 697  *
 698  * Note, that TCS outputs and TES inputs should not have index appended
 699  * either.
 700  */
 701 static bool
 702 add_index_to_name(struct gl_program_resource *res)
 703 {
 704    bool add_index = !(((res->Type == GL_PROGRAM_INPUT) &&
 705                        res->StageReferences & (1 << MESA_SHADER_GEOMETRY)));
 706
 707    /* Transform feedback varyings have array index already appended
 708     * in their names.
 709     */
 710    if (res->Type == GL_TRANSFORM_FEEDBACK_VARYING)
 711       add_index = false;
 712
 713    return add_index;
 714 }
 715
 716 /* Get name length of a program resource. This consists of
 717  * base name + 3 for '[0]' if resource is an array.
 718  */
 719 extern unsigned
 720 _mesa_program_resource_name_len(struct gl_program_resource *res)
 721 {
 722    unsigned length = strlen(_mesa_program_resource_name(res));
 723    if (_mesa_program_resource_array_size(res) && add_index_to_name(res))
 724       length += 3;
 725    return length;
 726 }
 727
 728 /* Get full name of a program resource.
 729  */
 730 bool
 731 _mesa_get_program_resource_name(struct gl_shader_program *shProg,
 732                                 GLenum programInterface, GLuint index,
 733                                 GLsizei bufSize, GLsizei *length,
 734                                 GLchar *name, const char *caller)
 735 {
 736    GET_CURRENT_CONTEXT(ctx);
 737
 738    /* Find resource with given interface and index. */
 739    struct gl_program_resource *res =
 740       _mesa_program_resource_find_index(shProg, programInterface, index);
 741
 742    /* The error INVALID_VALUE is generated if <index> is greater than
 743    * or equal to the number of entries in the active resource list for
 744    * <programInterface>.
 745    */
 746    if (!res) {
 747       _mesa_error(ctx, GL_INVALID_VALUE, "%s(index %u)", caller, index);
 748       return false;
 749    }
 750
 751    if (bufSize < 0) {
 752       _mesa_error(ctx, GL_INVALID_VALUE, "%s(bufSize %d)", caller, bufSize);
 753       return false;
 754    }
 755
 756    GLsizei localLength;
 757
 758    if (length == NULL)
 759       length = &localLength;
 760
 761    _mesa_copy_string(name, bufSize, length, _mesa_program_resource_name(res));
 762
 763    if (_mesa_program_resource_array_size(res) && add_index_to_name(res)) {
 764       int i;
 765
 766       /* The comparison is strange because *length does *NOT* include the
 767        * terminating NUL, but maxLength does.
 768        */
 769       for (i = 0; i < 3 && (*length + i + 1) < bufSize; i++)
 770          name[*length + i] = "[0]"[i];
 771
 772       name[*length + i] = '\0';
 773       *length += i;
 774    }
 775    return true;
 776 }
 777
 778 static GLint
 779 program_resource_location(struct gl_shader_program *shProg,
 780                           struct gl_program_resource *res, const char *name,
 781                           unsigned array_index)
 782 {
 783    /* Built-in locations should report GL_INVALID_INDEX. */
 784    if (is_gl_identifier(name))
 785       return GL_INVALID_INDEX;
 786
 787    /* VERT_ATTRIB_GENERIC0 and FRAG_RESULT_DATA0 are decremented as these
 788     * offsets are used internally to differentiate between built-in attributes
 789     * and user-defined attributes.
 790     */
 791    switch (res->Type) {
 792    case GL_PROGRAM_INPUT:
 793       /* If the input is an array, fail if the index is out of bounds. */
 794       if (array_index > 0
 795           && array_index >= RESOURCE_VAR(res)->type->length) {
 796          return -1;
 797       }
 798       return RESOURCE_VAR(res)->data.location + array_index - VERT_ATTRIB_GENERIC0;
 799    case GL_PROGRAM_OUTPUT:
 800       /* If the output is an array, fail if the index is out of bounds. */
 801       if (array_index > 0
 802           && array_index >= RESOURCE_VAR(res)->type->length) {
 803          return -1;
 804       }
 805       return RESOURCE_VAR(res)->data.location + array_index - FRAG_RESULT_DATA0;
 806    case GL_UNIFORM:
 807       /* If the uniform is built-in, fail. */
 808       if (RESOURCE_UNI(res)->builtin)
 809          return -1;
 810
 811      /* From page 79 of the OpenGL 4.2 spec:
 812       *
 813       *     "A valid name cannot be a structure, an array of structures, or any
 814       *     portion of a single vector or a matrix."
 815       */
 816       if (RESOURCE_UNI(res)->type->without_array()->is_record())
 817          return -1;
 818
 819       /* From the GL_ARB_uniform_buffer_object spec:
 820        *
 821        *     "The value -1 will be returned if <name> does not correspond to an
 822        *     active uniform variable name in <program>, if <name> is associated
 823        *     with a named uniform block, or if <name> starts with the reserved
 824        *     prefix "gl_"."
 825        */
 826       if (RESOURCE_UNI(res)->block_index != -1 ||
 827           RESOURCE_UNI(res)->atomic_buffer_index != -1)
 828          return -1;
 829
 830       /* fallthrough */
 831    case GL_VERTEX_SUBROUTINE_UNIFORM:
 832    case GL_GEOMETRY_SUBROUTINE_UNIFORM:
 833    case GL_FRAGMENT_SUBROUTINE_UNIFORM:
 834    case GL_COMPUTE_SUBROUTINE_UNIFORM:
 835    case GL_TESS_CONTROL_SUBROUTINE_UNIFORM:
 836    case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM:
 837       /* If the uniform is an array, fail if the index is out of bounds. */
 838       if (array_index > 0
 839           && array_index >= RESOURCE_UNI(res)->array_elements) {
 840          return -1;
 841       }
 842
 843       /* location in remap table + array element offset */
 844       return RESOURCE_UNI(res)->remap_location + array_index;
 845    default:
 846       return -1;
 847    }
 848 }
 849
 850 /**
 851  * Function implements following location queries:
 852  *    glGetUniformLocation
 853  */
 854 GLint
 855 _mesa_program_resource_location(struct gl_shader_program *shProg,
 856                                 GLenum programInterface, const char *name)
 857 {
 858    unsigned array_index = 0;
 859    struct gl_program_resource *res =
 860       _mesa_program_resource_find_name(shProg, programInterface, name,
 861                                        &array_index);
 862
 863    /* Resource not found. */
 864    if (!res)
 865       return -1;
 866
 867    return program_resource_location(shProg, res, name, array_index);
 868 }
 869
 870 /**
 871  * Function implements following index queries:
 872  *    glGetFragDataIndex
 873  */
 874 GLint
 875 _mesa_program_resource_location_index(struct gl_shader_program *shProg,
 876                                       GLenum programInterface, const char *name)
 877 {
 878    struct gl_program_resource *res =
 879       _mesa_program_resource_find_name(shProg, programInterface, name, NULL);
 880
 881    /* Non-existent variable or resource is not referenced by fragment stage. */
 882    if (!res || !(res->StageReferences & (1 << MESA_SHADER_FRAGMENT)))
 883       return -1;
 884
 885    return RESOURCE_VAR(res)->data.index;
 886 }
 887
 888 static uint8_t
 889 stage_from_enum(GLenum ref)
 890 {
 891    switch (ref) {
 892    case GL_REFERENCED_BY_VERTEX_SHADER:
 893       return MESA_SHADER_VERTEX;
 894    case GL_REFERENCED_BY_TESS_CONTROL_SHADER:
 895       return MESA_SHADER_TESS_CTRL;
 896    case GL_REFERENCED_BY_TESS_EVALUATION_SHADER:
 897       return MESA_SHADER_TESS_EVAL;
 898    case GL_REFERENCED_BY_GEOMETRY_SHADER:
 899       return MESA_SHADER_GEOMETRY;
 900    case GL_REFERENCED_BY_FRAGMENT_SHADER:
 901       return MESA_SHADER_FRAGMENT;
 902    case GL_REFERENCED_BY_COMPUTE_SHADER:
 903       return MESA_SHADER_COMPUTE;
 904    default:
 905       assert(!"shader stage not supported");
 906       return MESA_SHADER_STAGES;
 907    }
 908 }
 909
 910 /**
 911  * Check if resource is referenced by given 'referenced by' stage enum.
 912  * ATC and UBO resources hold stage references of their own.
 913  */
 914 static bool
 915 is_resource_referenced(struct gl_shader_program *shProg,
 916                        struct gl_program_resource *res,
 917                        GLuint index, uint8_t stage)
 918 {
 919    /* First, check if we even have such a stage active. */
 920    if (!shProg->_LinkedShaders[stage])
 921       return false;
 922
 923    if (res->Type == GL_ATOMIC_COUNTER_BUFFER)
 924       return RESOURCE_ATC(res)->StageReferences[stage];
 925
 926    if (res->Type == GL_UNIFORM_BLOCK || res->Type == GL_SHADER_STORAGE_BLOCK)
 927       return shProg->UniformBlockStageIndex[stage][index] != -1;
 928
 929    return res->StageReferences & (1 << stage);
 930 }
 931
 932 static unsigned
 933 get_buffer_property(struct gl_shader_program *shProg,
 934                     struct gl_program_resource *res, const GLenum prop,
 935                     GLint *val, const char *caller)
 936 {
 937    GET_CURRENT_CONTEXT(ctx);
 938    if (res->Type != GL_UNIFORM_BLOCK &&
 939        res->Type != GL_ATOMIC_COUNTER_BUFFER &&
 940        res->Type != GL_SHADER_STORAGE_BLOCK)
 941       goto invalid_operation;
 942
 943    if (res->Type == GL_UNIFORM_BLOCK) {
 944       switch (prop) {
 945       case GL_BUFFER_BINDING:
 946          *val = RESOURCE_UBO(res)->Binding;
 947          return 1;
 948       case GL_BUFFER_DATA_SIZE:
 949          *val = RESOURCE_UBO(res)->UniformBufferSize;
 950          return 1;
 951       case GL_NUM_ACTIVE_VARIABLES:
 952          *val = 0;
 953          for (unsigned i = 0; i < RESOURCE_UBO(res)->NumUniforms; i++) {
 954             const char *iname = RESOURCE_UBO(res)->Uniforms[i].IndexName;
 955             struct gl_program_resource *uni =
 956                _mesa_program_resource_find_name(shProg, GL_UNIFORM, iname,
 957                                                 NULL);
 958             if (!uni)
 959                continue;
 960             (*val)++;
 961          }
 962          return 1;
 963       case GL_ACTIVE_VARIABLES: {
 964          unsigned num_values = 0;
 965          for (unsigned i = 0; i < RESOURCE_UBO(res)->NumUniforms; i++) {
 966             const char *iname = RESOURCE_UBO(res)->Uniforms[i].IndexName;
 967             struct gl_program_resource *uni =
 968                _mesa_program_resource_find_name(shProg, GL_UNIFORM, iname,
 969                                                 NULL);
 970             if (!uni)
 971                continue;
 972             *val++ =
 973                _mesa_program_resource_index(shProg, uni);
 974             num_values++;
 975          }
 976          return num_values;
 977       }
 978       }
 979    } else if (res->Type == GL_SHADER_STORAGE_BLOCK) {
 980       switch (prop) {
 981       case GL_BUFFER_BINDING:
 982          *val = RESOURCE_UBO(res)->Binding;
 983          return 1;
 984       case GL_BUFFER_DATA_SIZE:
 985          *val = RESOURCE_UBO(res)->UniformBufferSize;
 986          return 1;
 987       case GL_NUM_ACTIVE_VARIABLES:
 988          *val = 0;
 989          for (unsigned i = 0; i < RESOURCE_UBO(res)->NumUniforms; i++) {
 990             const char *iname = RESOURCE_UBO(res)->Uniforms[i].IndexName;
 991             struct gl_program_resource *uni =
 992                _mesa_program_resource_find_name(shProg, GL_BUFFER_VARIABLE,
 993                                                 iname, NULL);
 994             if (!uni)
 995                continue;
 996             (*val)++;
 997          }
 998          return 1;
 999       case GL_ACTIVE_VARIABLES: {
1000          unsigned num_values = 0;
1001          for (unsigned i = 0; i < RESOURCE_UBO(res)->NumUniforms; i++) {
1002             const char *iname = RESOURCE_UBO(res)->Uniforms[i].IndexName;
1003             struct gl_program_resource *uni =
1004                _mesa_program_resource_find_name(shProg, GL_BUFFER_VARIABLE,
1005                                                 iname, NULL);
1006             if (!uni)
1007                continue;
1008             *val++ =
1009                _mesa_program_resource_index(shProg, uni);
1010             num_values++;
1011          }
1012          return num_values;
1013       }
1014       }
1015    } else if (res->Type == GL_ATOMIC_COUNTER_BUFFER) {
1016       switch (prop) {
1017       case GL_BUFFER_BINDING:
1018          *val = RESOURCE_ATC(res)->Binding;
1019          return 1;
1020       case GL_BUFFER_DATA_SIZE:
1021          *val = RESOURCE_ATC(res)->MinimumSize;
1022          return 1;
1023       case GL_NUM_ACTIVE_VARIABLES:
1024          *val = RESOURCE_ATC(res)->NumUniforms;
1025          return 1;
1026       case GL_ACTIVE_VARIABLES:
1027          for (unsigned i = 0; i < RESOURCE_ATC(res)->NumUniforms; i++)
1028             *val++ = RESOURCE_ATC(res)->Uniforms[i];
1029          return RESOURCE_ATC(res)->NumUniforms;
1030       }
1031    }
1032    assert(!"support for property type not implemented");
1033
1034 invalid_operation:
1035    _mesa_error(ctx, GL_INVALID_OPERATION, "%s(%s prop %s)", caller,
1036                _mesa_enum_to_string(res->Type),
1037                _mesa_enum_to_string(prop));
1038
1039    return 0;
1040 }
1041
1042 unsigned
1043 _mesa_program_resource_prop(struct gl_shader_program *shProg,
1044                             struct gl_program_resource *res, GLuint index,
1045                             const GLenum prop, GLint *val, const char *caller)
1046 {
1047    GET_CURRENT_CONTEXT(ctx);
1048
1049 #define VALIDATE_TYPE(type)\
1050    if (res->Type != type)\
1051       goto invalid_operation;
1052
1053 #define VALIDATE_TYPE_2(type1, type2)\
1054    if (res->Type != type1 && res->Type != type2)\
1055       goto invalid_operation;
1056
1057    switch(prop) {
1058    case GL_NAME_LENGTH:
1059       switch (res->Type) {
1060       case GL_ATOMIC_COUNTER_BUFFER:
1061          goto invalid_operation;
1062       default:
1063          /* Resource name length + terminator. */
1064          *val = _mesa_program_resource_name_len(res) + 1;
1065       }
1066       return 1;
1067    case GL_TYPE:
1068       switch (res->Type) {
1069       case GL_UNIFORM:
1070       case GL_BUFFER_VARIABLE:
1071          *val = RESOURCE_UNI(res)->type->gl_type;
1072          return 1;
1073       case GL_PROGRAM_INPUT:
1074       case GL_PROGRAM_OUTPUT:
1075          *val = RESOURCE_VAR(res)->type->gl_type;
1076          return 1;
1077       case GL_TRANSFORM_FEEDBACK_VARYING:
1078          *val = RESOURCE_XFB(res)->Type;
1079          return 1;
1080       default:
1081          goto invalid_operation;
1082       }
1083    case GL_ARRAY_SIZE:
1084       switch (res->Type) {
1085       case GL_UNIFORM:
1086       case GL_BUFFER_VARIABLE:
1087          /* Test if a buffer variable is an array or an unsized array.
1088           * Unsized arrays return zero as array size.
1089           */
1090          if (RESOURCE_UNI(res)->is_shader_storage &&
1091              RESOURCE_UNI(res)->array_stride > 0)
1092             *val = RESOURCE_UNI(res)->array_elements;
1093          else
1094             *val = MAX2(RESOURCE_UNI(res)->array_elements, 1);
1095          return 1;
1096       case GL_PROGRAM_INPUT:
1097       case GL_PROGRAM_OUTPUT:
1098          *val = MAX2(_mesa_program_resource_array_size(res), 1);
1099          return 1;
1100       case GL_TRANSFORM_FEEDBACK_VARYING:
1101          *val = MAX2(RESOURCE_XFB(res)->Size, 1);
1102          return 1;
1103       default:
1104          goto invalid_operation;
1105       }
1106    case GL_OFFSET:
1107       VALIDATE_TYPE_2(GL_UNIFORM, GL_BUFFER_VARIABLE);
1108       *val = RESOURCE_UNI(res)->offset;
1109       return 1;
1110    case GL_BLOCK_INDEX:
1111       VALIDATE_TYPE_2(GL_UNIFORM, GL_BUFFER_VARIABLE);
1112       *val = RESOURCE_UNI(res)->block_index;
1113       return 1;
1114    case GL_ARRAY_STRIDE:
1115       VALIDATE_TYPE_2(GL_UNIFORM, GL_BUFFER_VARIABLE);
1116       *val = RESOURCE_UNI(res)->array_stride;
1117       return 1;
1118    case GL_MATRIX_STRIDE:
1119       VALIDATE_TYPE_2(GL_UNIFORM, GL_BUFFER_VARIABLE);
1120       *val = RESOURCE_UNI(res)->matrix_stride;
1121       return 1;
1122    case GL_IS_ROW_MAJOR:
1123       VALIDATE_TYPE_2(GL_UNIFORM, GL_BUFFER_VARIABLE);
1124       *val = RESOURCE_UNI(res)->row_major;
1125       return 1;
1126    case GL_ATOMIC_COUNTER_BUFFER_INDEX:
1127       VALIDATE_TYPE(GL_UNIFORM);
1128       *val = RESOURCE_UNI(res)->atomic_buffer_index;
1129       return 1;
1130    case GL_BUFFER_BINDING:
1131    case GL_BUFFER_DATA_SIZE:
1132    case GL_NUM_ACTIVE_VARIABLES:
1133    case GL_ACTIVE_VARIABLES:
1134       return get_buffer_property(shProg, res, prop, val, caller);
1135    case GL_REFERENCED_BY_COMPUTE_SHADER:
1136       if (!_mesa_has_compute_shaders(ctx))
1137          goto invalid_enum;
1138       /* fallthrough */
1139    case GL_REFERENCED_BY_VERTEX_SHADER:
1140    case GL_REFERENCED_BY_TESS_CONTROL_SHADER:
1141    case GL_REFERENCED_BY_TESS_EVALUATION_SHADER:
1142    case GL_REFERENCED_BY_GEOMETRY_SHADER:
1143    case GL_REFERENCED_BY_FRAGMENT_SHADER:
1144       switch (res->Type) {
1145       case GL_UNIFORM:
1146       case GL_PROGRAM_INPUT:
1147       case GL_PROGRAM_OUTPUT:
1148       case GL_UNIFORM_BLOCK:
1149       case GL_BUFFER_VARIABLE:
1150       case GL_SHADER_STORAGE_BLOCK:
1151       case GL_ATOMIC_COUNTER_BUFFER:
1152          *val = is_resource_referenced(shProg, res, index,
1153                                        stage_from_enum(prop));
1154          return 1;
1155       default:
1156          goto invalid_operation;
1157       }
1158    case GL_LOCATION:
1159       switch (res->Type) {
1160       case GL_UNIFORM:
1161       case GL_PROGRAM_INPUT:
1162       case GL_PROGRAM_OUTPUT:
1163          *val = program_resource_location(shProg, res,
1164                                           _mesa_program_resource_name(res),
1165                                           0);
1166          return 1;
1167       default:
1168          goto invalid_operation;
1169       }
1170    case GL_LOCATION_INDEX:
1171       if (res->Type != GL_PROGRAM_OUTPUT)
1172          goto invalid_operation;
1173       *val = RESOURCE_VAR(res)->data.index;
1174       return 1;
1175
1176    case GL_NUM_COMPATIBLE_SUBROUTINES:
1177       if (res->Type != GL_VERTEX_SUBROUTINE_UNIFORM &&
1178           res->Type != GL_FRAGMENT_SUBROUTINE_UNIFORM &&
1179           res->Type != GL_GEOMETRY_SUBROUTINE_UNIFORM &&
1180           res->Type != GL_COMPUTE_SUBROUTINE_UNIFORM &&
1181           res->Type != GL_TESS_CONTROL_SUBROUTINE_UNIFORM &&
1182           res->Type != GL_TESS_EVALUATION_SUBROUTINE_UNIFORM)
1183          goto invalid_operation;
1184       *val = RESOURCE_UNI(res)->num_compatible_subroutines;
1185       return 1;
1186    case GL_COMPATIBLE_SUBROUTINES: {
1187       const struct gl_uniform_storage *uni;
1188       struct gl_shader *sh;
1189       unsigned count, i;
1190       int j;
1191
1192       if (res->Type != GL_VERTEX_SUBROUTINE_UNIFORM &&
1193           res->Type != GL_FRAGMENT_SUBROUTINE_UNIFORM &&
1194           res->Type != GL_GEOMETRY_SUBROUTINE_UNIFORM &&
1195           res->Type != GL_COMPUTE_SUBROUTINE_UNIFORM &&
1196           res->Type != GL_TESS_CONTROL_SUBROUTINE_UNIFORM &&
1197           res->Type != GL_TESS_EVALUATION_SUBROUTINE_UNIFORM)
1198          goto invalid_operation;
1199       uni = RESOURCE_UNI(res);
1200
1201       sh = shProg->_LinkedShaders[_mesa_shader_stage_from_subroutine_uniform(res->Type)];
1202       count = 0;
1203       for (i = 0; i < sh->NumSubroutineFunctions; i++) {
1204          struct gl_subroutine_function *fn = &sh->SubroutineFunctions[i];
1205          for (j = 0; j < fn->num_compat_types; j++) {
1206             if (fn->types[j] == uni->type) {
1207                val[count++] = i;
1208                break;
1209             }
1210          }
1211       }
1212       return count;
1213    }
1214
1215    case GL_TOP_LEVEL_ARRAY_SIZE:
1216       VALIDATE_TYPE(GL_BUFFER_VARIABLE);
1217       *val = RESOURCE_UNI(res)->top_level_array_size;
1218       return 1;
1219
1220    case GL_TOP_LEVEL_ARRAY_STRIDE:
1221       VALIDATE_TYPE(GL_BUFFER_VARIABLE);
1222       *val = RESOURCE_UNI(res)->top_level_array_stride;
1223       return 1;
1224
1225    /* GL_ARB_tessellation_shader */
1226    case GL_IS_PER_PATCH:
1227       switch (res->Type) {
1228       case GL_PROGRAM_INPUT:
1229       case GL_PROGRAM_OUTPUT:
1230          *val = RESOURCE_VAR(res)->data.patch;
1231          return 1;
1232       default:
1233          goto invalid_operation;
1234       }
1235    default:
1236       goto invalid_enum;
1237    }
1238
1239 #undef VALIDATE_TYPE
1240 #undef VALIDATE_TYPE_2
1241
1242 invalid_enum:
1243    _mesa_error(ctx, GL_INVALID_ENUM, "%s(%s prop %s)", caller,
1244                _mesa_enum_to_string(res->Type),
1245                _mesa_enum_to_string(prop));
1246    return 0;
1247
1248 invalid_operation:
1249    _mesa_error(ctx, GL_INVALID_OPERATION, "%s(%s prop %s)", caller,
1250                _mesa_enum_to_string(res->Type),
1251                _mesa_enum_to_string(prop));
1252    return 0;
1253 }
1254
1255 extern void
1256 _mesa_get_program_resourceiv(struct gl_shader_program *shProg,
1257                              GLenum programInterface, GLuint index, GLsizei propCount,
1258                              const GLenum *props, GLsizei bufSize,
1259                              GLsizei *length, GLint *params)
1260 {
1261    GET_CURRENT_CONTEXT(ctx);
1262    GLint *val = (GLint *) params;
1263    const GLenum *prop = props;
1264    GLsizei amount = 0;
1265
1266    struct gl_program_resource *res =
1267       _mesa_program_resource_find_index(shProg, programInterface, index);
1268
1269    /* No such resource found or bufSize negative. */
1270    if (!res || bufSize < 0) {
1271       _mesa_error(ctx, GL_INVALID_VALUE,
1272                   "glGetProgramResourceiv(%s index %d bufSize %d)",
1273                   _mesa_enum_to_string(programInterface), index, bufSize);
1274       return;
1275    }
1276
1277    /* Write propCount values until error occurs or bufSize reached. */
1278    for (int i = 0; i < propCount && i < bufSize; i++, val++, prop++) {
1279       int props_written =
1280          _mesa_program_resource_prop(shProg, res, index, *prop, val,
1281                                      "glGetProgramResourceiv");
1282
1283       /* Error happened. */
1284       if (props_written == 0)
1285          return;
1286
1287       amount += props_written;
1288    }
1289
1290    /* If <length> is not NULL, the actual number of integer values
1291     * written to <params> will be written to <length>.
1292     */
1293    if (length)
1294       *length = amount;
1295 }