2 * Mesa 3-D graphics library
4 * Copyright (C) 2004-2008 Brian Paul All Rights Reserved.
5 * Copyright (C) 2009-2010 VMware, Inc. All Rights Reserved.
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:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
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.
30 * Implementation of GLSL-related API functions.
31 * The glUniform* functions are in uniforms.c
37 #include <c99_alloca.h>
39 #include "main/glheader.h"
40 #include "main/context.h"
41 #include "main/enums.h"
42 #include "main/glspirv.h"
43 #include "main/hash.h"
44 #include "main/mtypes.h"
45 #include "main/pipelineobj.h"
46 #include "main/program_binary.h"
47 #include "main/shaderapi.h"
48 #include "main/shaderobj.h"
49 #include "main/state.h"
50 #include "main/transformfeedback.h"
51 #include "main/uniforms.h"
52 #include "compiler/glsl/builtin_functions.h"
53 #include "compiler/glsl/glsl_parser_extras.h"
54 #include "compiler/glsl/ir.h"
55 #include "compiler/glsl/ir_uniform.h"
56 #include "compiler/glsl/program.h"
57 #include "program/program.h"
58 #include "program/prog_print.h"
59 #include "program/prog_parameter.h"
60 #include "util/ralloc.h"
61 #include "util/hash_table.h"
62 #include "util/mesa-sha1.h"
63 #include "util/crc32.h"
64 #include "util/os_file.h"
65 #include "util/simple_list.h"
68 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
71 _mesa_get_shader_flags(void)
73 GLbitfield flags
= 0x0;
74 const char *env
= getenv("MESA_GLSL");
77 if (strstr(env
, "dump_on_error"))
78 flags
|= GLSL_DUMP_ON_ERROR
;
79 else if (strstr(env
, "dump"))
81 if (strstr(env
, "log"))
83 if (strstr(env
, "cache_fb"))
84 flags
|= GLSL_CACHE_FALLBACK
;
85 if (strstr(env
, "cache_info"))
86 flags
|= GLSL_CACHE_INFO
;
87 if (strstr(env
, "nopvert"))
88 flags
|= GLSL_NOP_VERT
;
89 if (strstr(env
, "nopfrag"))
90 flags
|= GLSL_NOP_FRAG
;
91 if (strstr(env
, "uniform"))
92 flags
|= GLSL_UNIFORMS
;
93 if (strstr(env
, "useprog"))
94 flags
|= GLSL_USE_PROG
;
95 if (strstr(env
, "errors"))
96 flags
|= GLSL_REPORT_ERRORS
;
103 * Memoized version of getenv("MESA_SHADER_CAPTURE_PATH").
106 _mesa_get_shader_capture_path(void)
108 static bool read_env_var
= false;
109 static const char *path
= NULL
;
112 path
= getenv("MESA_SHADER_CAPTURE_PATH");
120 * Initialize context's shader state.
123 _mesa_init_shader_state(struct gl_context
*ctx
)
125 /* Device drivers may override these to control what kind of instructions
126 * are generated by the GLSL compiler.
128 struct gl_shader_compiler_options options
;
132 memset(&options
, 0, sizeof(options
));
133 options
.MaxUnrollIterations
= 32;
134 options
.MaxIfDepth
= UINT_MAX
;
136 for (sh
= 0; sh
< MESA_SHADER_STAGES
; ++sh
)
137 memcpy(&ctx
->Const
.ShaderCompilerOptions
[sh
], &options
, sizeof(options
));
139 ctx
->Shader
.Flags
= _mesa_get_shader_flags();
141 if (ctx
->Shader
.Flags
!= 0)
142 ctx
->Const
.GenerateTemporaryNames
= true;
144 /* Extended for ARB_separate_shader_objects */
145 ctx
->Shader
.RefCount
= 1;
146 ctx
->TessCtrlProgram
.patch_vertices
= 3;
147 for (i
= 0; i
< 4; ++i
)
148 ctx
->TessCtrlProgram
.patch_default_outer_level
[i
] = 1.0;
149 for (i
= 0; i
< 2; ++i
)
150 ctx
->TessCtrlProgram
.patch_default_inner_level
[i
] = 1.0;
155 * Free the per-context shader-related state.
158 _mesa_free_shader_state(struct gl_context
*ctx
)
160 for (int i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
161 _mesa_reference_program(ctx
, &ctx
->Shader
.CurrentProgram
[i
], NULL
);
162 _mesa_reference_shader_program(ctx
,
163 &ctx
->Shader
.ReferencedPrograms
[i
],
165 free(ctx
->SubroutineIndex
[i
].IndexPtr
);
166 ctx
->SubroutineIndex
[i
].IndexPtr
= NULL
;
168 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, NULL
);
170 /* Extended for ARB_separate_shader_objects */
171 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, NULL
);
173 assert(ctx
->Shader
.RefCount
== 1);
178 * Copy string from <src> to <dst>, up to maxLength characters, returning
179 * length of <dst> in <length>.
180 * \param src the strings source
181 * \param maxLength max chars to copy
182 * \param length returns number of chars copied
183 * \param dst the string destination
186 _mesa_copy_string(GLchar
*dst
, GLsizei maxLength
,
187 GLsizei
*length
, const GLchar
*src
)
190 for (len
= 0; len
< maxLength
- 1 && src
&& src
[len
]; len
++)
201 * Confirm that the a shader type is valid and supported by the implementation
203 * \param ctx Current GL context
204 * \param type Shader target
208 _mesa_validate_shader_target(const struct gl_context
*ctx
, GLenum type
)
210 /* Note: when building built-in GLSL functions, this function may be
211 * invoked with ctx == NULL. In that case, we can only validate that it's
212 * a shader target we recognize, not that it's supported in the current
213 * context. But that's fine--we don't need any further validation than
214 * that when building built-in GLSL functions.
218 case GL_FRAGMENT_SHADER
:
219 return ctx
== NULL
|| ctx
->Extensions
.ARB_fragment_shader
;
220 case GL_VERTEX_SHADER
:
221 return ctx
== NULL
|| ctx
->Extensions
.ARB_vertex_shader
;
222 case GL_GEOMETRY_SHADER_ARB
:
223 return ctx
== NULL
|| _mesa_has_geometry_shaders(ctx
);
224 case GL_TESS_CONTROL_SHADER
:
225 case GL_TESS_EVALUATION_SHADER
:
226 return ctx
== NULL
|| _mesa_has_tessellation(ctx
);
227 case GL_COMPUTE_SHADER
:
228 return ctx
== NULL
|| _mesa_has_compute_shaders(ctx
);
236 is_program(struct gl_context
*ctx
, GLuint name
)
238 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
239 return shProg
? GL_TRUE
: GL_FALSE
;
244 is_shader(struct gl_context
*ctx
, GLuint name
)
246 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
247 return shader
? GL_TRUE
: GL_FALSE
;
252 * Attach shader to a shader program.
255 attach_shader(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
256 struct gl_shader
*sh
)
258 GLuint n
= shProg
->NumShaders
;
260 shProg
->Shaders
= realloc(shProg
->Shaders
,
261 (n
+ 1) * sizeof(struct gl_shader
*));
262 if (!shProg
->Shaders
) {
263 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
268 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
269 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
270 shProg
->NumShaders
++;
274 attach_shader_err(struct gl_context
*ctx
, GLuint program
, GLuint shader
,
277 struct gl_shader_program
*shProg
;
278 struct gl_shader
*sh
;
281 const bool same_type_disallowed
= _mesa_is_gles(ctx
);
283 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, caller
);
287 sh
= _mesa_lookup_shader_err(ctx
, shader
, caller
);
292 n
= shProg
->NumShaders
;
293 for (i
= 0; i
< n
; i
++) {
294 if (shProg
->Shaders
[i
] == sh
) {
295 /* The shader is already attched to this program. The
296 * GL_ARB_shader_objects spec says:
298 * "The error INVALID_OPERATION is generated by AttachObjectARB
299 * if <obj> is already attached to <containerObj>."
301 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", caller
);
303 } else if (same_type_disallowed
&&
304 shProg
->Shaders
[i
]->Stage
== sh
->Stage
) {
305 /* Shader with the same type is already attached to this program,
306 * OpenGL ES 2.0 and 3.0 specs say:
308 * "Multiple shader objects of the same type may not be attached
309 * to a single program object. [...] The error INVALID_OPERATION
310 * is generated if [...] another shader object of the same type
311 * as shader is already attached to program."
313 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", caller
);
318 attach_shader(ctx
, shProg
, sh
);
322 attach_shader_no_error(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
324 struct gl_shader_program
*shProg
;
325 struct gl_shader
*sh
;
327 shProg
= _mesa_lookup_shader_program(ctx
, program
);
328 sh
= _mesa_lookup_shader(ctx
, shader
);
330 attach_shader(ctx
, shProg
, sh
);
334 create_shader(struct gl_context
*ctx
, GLenum type
)
336 struct gl_shader
*sh
;
339 _mesa_HashLockMutex(ctx
->Shared
->ShaderObjects
);
340 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
341 sh
= _mesa_new_shader(name
, _mesa_shader_enum_to_shader_stage(type
));
343 _mesa_HashInsertLocked(ctx
->Shared
->ShaderObjects
, name
, sh
);
344 _mesa_HashUnlockMutex(ctx
->Shared
->ShaderObjects
);
351 create_shader_err(struct gl_context
*ctx
, GLenum type
, const char *caller
)
353 if (!_mesa_validate_shader_target(ctx
, type
)) {
354 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s(%s)",
355 caller
, _mesa_enum_to_string(type
));
359 return create_shader(ctx
, type
);
364 create_shader_program(struct gl_context
*ctx
)
367 struct gl_shader_program
*shProg
;
369 _mesa_HashLockMutex(ctx
->Shared
->ShaderObjects
);
371 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
373 shProg
= _mesa_new_shader_program(name
);
375 _mesa_HashInsertLocked(ctx
->Shared
->ShaderObjects
, name
, shProg
);
377 assert(shProg
->RefCount
== 1);
379 _mesa_HashUnlockMutex(ctx
->Shared
->ShaderObjects
);
386 * Delete a shader program. Actually, just decrement the program's
387 * reference count and mark it as DeletePending.
388 * Used to implement glDeleteProgram() and glDeleteObjectARB().
391 delete_shader_program(struct gl_context
*ctx
, GLuint name
)
394 * NOTE: deleting shaders/programs works a bit differently than
395 * texture objects (and buffer objects, etc). Shader/program
396 * handles/IDs exist in the hash table until the object is really
397 * deleted (refcount==0). With texture objects, the handle/ID is
398 * removed from the hash table in glDeleteTextures() while the tex
399 * object itself might linger until its refcount goes to zero.
401 struct gl_shader_program
*shProg
;
403 shProg
= _mesa_lookup_shader_program_err(ctx
, name
, "glDeleteProgram");
407 if (!shProg
->DeletePending
) {
408 shProg
->DeletePending
= GL_TRUE
;
410 /* effectively, decr shProg's refcount */
411 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
417 delete_shader(struct gl_context
*ctx
, GLuint shader
)
419 struct gl_shader
*sh
;
421 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glDeleteShader");
425 if (!sh
->DeletePending
) {
426 sh
->DeletePending
= GL_TRUE
;
428 /* effectively, decr sh's refcount */
429 _mesa_reference_shader(ctx
, &sh
, NULL
);
434 static ALWAYS_INLINE
void
435 detach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
,
438 struct gl_shader_program
*shProg
;
443 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
447 shProg
= _mesa_lookup_shader_program(ctx
, program
);
450 n
= shProg
->NumShaders
;
452 for (i
= 0; i
< n
; i
++) {
453 if (shProg
->Shaders
[i
]->Name
== shader
) {
455 struct gl_shader
**newList
;
458 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
460 /* alloc new, smaller array */
461 newList
= malloc((n
- 1) * sizeof(struct gl_shader
*));
463 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
466 /* Copy old list entries to new list, skipping removed entry at [i] */
467 for (j
= 0; j
< i
; j
++) {
468 newList
[j
] = shProg
->Shaders
[j
];
471 newList
[j
++] = shProg
->Shaders
[i
];
474 /* Free old list and install new one */
475 free(shProg
->Shaders
);
476 shProg
->Shaders
= newList
;
477 shProg
->NumShaders
= n
- 1;
480 /* sanity check - make sure the new list's entries are sensible */
481 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
482 assert(shProg
->Shaders
[j
]->Stage
== MESA_SHADER_VERTEX
||
483 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_TESS_CTRL
||
484 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_TESS_EVAL
||
485 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_GEOMETRY
||
486 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_FRAGMENT
);
487 assert(shProg
->Shaders
[j
]->RefCount
> 0);
498 if (is_shader(ctx
, shader
) || is_program(ctx
, shader
))
499 err
= GL_INVALID_OPERATION
;
501 err
= GL_INVALID_VALUE
;
502 _mesa_error(ctx
, err
, "glDetachShader(shader)");
509 detach_shader_error(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
511 detach_shader(ctx
, program
, shader
, false);
516 detach_shader_no_error(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
518 detach_shader(ctx
, program
, shader
, true);
523 * Return list of shaders attached to shader program.
524 * \param objOut returns GLuint ids
525 * \param handleOut returns GLhandleARB handles
528 get_attached_shaders(struct gl_context
*ctx
, GLuint program
, GLsizei maxCount
,
529 GLsizei
*countOut
, GLuint
*objOut
, GLhandleARB
*handleOut
)
531 struct gl_shader_program
*shProg
;
534 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetAttachedShaders(maxCount < 0)");
539 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
543 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
545 objOut
[i
] = shProg
->Shaders
[i
]->Name
;
549 handleOut
[i
] = (GLhandleARB
) shProg
->Shaders
[i
]->Name
;
559 * glGetHandleARB() - return ID/name of currently bound shader program.
562 get_handle(struct gl_context
*ctx
, GLenum pname
)
564 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
565 if (ctx
->_Shader
->ActiveProgram
)
566 return ctx
->_Shader
->ActiveProgram
->Name
;
571 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
578 * Check if a geometry shader query is valid at this time. If not, report an
579 * error and return false.
581 * From GL 3.2 section 6.1.16 (Shader and Program Queries):
583 * "If GEOMETRY_VERTICES_OUT, GEOMETRY_INPUT_TYPE, or GEOMETRY_OUTPUT_TYPE
584 * are queried for a program which has not been linked successfully, or
585 * which does not contain objects to form a geometry shader, then an
586 * INVALID_OPERATION error is generated."
589 check_gs_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
591 if (shProg
->data
->LinkStatus
&&
592 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
] != NULL
) {
596 _mesa_error(ctx
, GL_INVALID_OPERATION
,
597 "glGetProgramv(linked geometry shader required)");
603 * Check if a tessellation control shader query is valid at this time.
604 * If not, report an error and return false.
606 * From GL 4.0 section 6.1.12 (Shader and Program Queries):
608 * "If TESS_CONTROL_OUTPUT_VERTICES is queried for a program which has
609 * not been linked successfully, or which does not contain objects to
610 * form a tessellation control shader, then an INVALID_OPERATION error is
614 check_tcs_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
616 if (shProg
->data
->LinkStatus
&&
617 shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
] != NULL
) {
621 _mesa_error(ctx
, GL_INVALID_OPERATION
,
622 "glGetProgramv(linked tessellation control shader required)");
628 * Check if a tessellation evaluation shader query is valid at this time.
629 * If not, report an error and return false.
631 * From GL 4.0 section 6.1.12 (Shader and Program Queries):
633 * "If any of the pname values in this paragraph are queried for a program
634 * which has not been linked successfully, or which does not contain
635 * objects to form a tessellation evaluation shader, then an
636 * INVALID_OPERATION error is generated."
640 check_tes_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
642 if (shProg
->data
->LinkStatus
&&
643 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
] != NULL
) {
647 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramv(linked tessellation "
648 "evaluation shader required)");
653 * Return the length of a string, or 0 if the pointer passed in is NULL
655 static size_t strlen_or_zero(const char *s
)
657 return s
? strlen(s
) : 0;
661 * glGetProgramiv() - get shader program state.
662 * Note that this is for GLSL shader programs, not ARB vertex/fragment
663 * programs (see glGetProgramivARB).
666 get_programiv(struct gl_context
*ctx
, GLuint program
, GLenum pname
,
669 struct gl_shader_program
*shProg
670 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramiv(program)");
672 /* Is transform feedback available in this context?
675 (ctx
->API
== API_OPENGL_COMPAT
&& ctx
->Extensions
.EXT_transform_feedback
)
676 || ctx
->API
== API_OPENGL_CORE
677 || _mesa_is_gles3(ctx
);
679 /* True if geometry shaders (of the form that was adopted into GLSL 1.50
680 * and GL 3.2) are available in this context
682 const bool has_gs
= _mesa_has_geometry_shaders(ctx
);
683 const bool has_tess
= _mesa_has_tessellation(ctx
);
685 /* Are uniform buffer objects available in this context?
688 (ctx
->API
== API_OPENGL_COMPAT
&&
689 ctx
->Extensions
.ARB_uniform_buffer_object
)
690 || ctx
->API
== API_OPENGL_CORE
691 || _mesa_is_gles3(ctx
);
698 case GL_DELETE_STATUS
:
699 *params
= shProg
->DeletePending
;
701 case GL_COMPLETION_STATUS_ARB
:
702 if (ctx
->Driver
.GetShaderProgramCompletionStatus
)
703 *params
= ctx
->Driver
.GetShaderProgramCompletionStatus(ctx
, shProg
);
708 *params
= shProg
->data
->LinkStatus
? GL_TRUE
: GL_FALSE
;
710 case GL_VALIDATE_STATUS
:
711 *params
= shProg
->data
->Validated
;
713 case GL_INFO_LOG_LENGTH
:
714 *params
= (shProg
->data
->InfoLog
&& shProg
->data
->InfoLog
[0] != '\0') ?
715 strlen(shProg
->data
->InfoLog
) + 1 : 0;
717 case GL_ATTACHED_SHADERS
:
718 *params
= shProg
->NumShaders
;
720 case GL_ACTIVE_ATTRIBUTES
:
721 *params
= _mesa_count_active_attribs(shProg
);
723 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
724 *params
= _mesa_longest_attribute_name_length(shProg
);
726 case GL_ACTIVE_UNIFORMS
: {
728 const unsigned num_uniforms
=
729 shProg
->data
->NumUniformStorage
- shProg
->data
->NumHiddenUniforms
;
730 for (*params
= 0, i
= 0; i
< num_uniforms
; i
++) {
731 if (!shProg
->data
->UniformStorage
[i
].is_shader_storage
)
736 case GL_ACTIVE_UNIFORM_MAX_LENGTH
: {
739 const unsigned num_uniforms
=
740 shProg
->data
->NumUniformStorage
- shProg
->data
->NumHiddenUniforms
;
742 for (i
= 0; i
< num_uniforms
; i
++) {
743 if (shProg
->data
->UniformStorage
[i
].is_shader_storage
)
746 /* From ARB_gl_spirv spec:
748 * "If pname is ACTIVE_UNIFORM_MAX_LENGTH, the length of the
749 * longest active uniform name, including a null terminator, is
750 * returned. If no active uniforms exist, zero is returned. If no
751 * name reflection information is available, one is returned."
753 * We are setting 0 here, as below it will add 1 for the NUL character.
755 const GLint base_len
=
756 strlen_or_zero(shProg
->data
->UniformStorage
[i
].name
);
758 /* Add one for the terminating NUL character for a non-array, and
759 * 4 for the "[0]" and the NUL for an array.
761 const GLint len
= base_len
+ 1 +
762 ((shProg
->data
->UniformStorage
[i
].array_elements
!= 0) ? 3 : 0);
771 case GL_TRANSFORM_FEEDBACK_VARYINGS
:
775 /* Check first if there are transform feedback varyings specified in the
776 * shader (ARB_enhanced_layouts). If there isn't any, return the number of
777 * varyings specified using the API.
779 if (shProg
->last_vert_prog
&&
780 shProg
->last_vert_prog
->sh
.LinkedTransformFeedback
->NumVarying
> 0)
782 shProg
->last_vert_prog
->sh
.LinkedTransformFeedback
->NumVarying
;
784 *params
= shProg
->TransformFeedback
.NumVarying
;
786 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
: {
789 bool in_shader_varyings
;
795 /* Check first if there are transform feedback varyings specified in the
796 * shader (ARB_enhanced_layouts). If there isn't any, use the ones
797 * specified using the API.
799 in_shader_varyings
= shProg
->last_vert_prog
&&
800 shProg
->last_vert_prog
->sh
.LinkedTransformFeedback
->NumVarying
> 0;
802 num_varying
= in_shader_varyings
?
803 shProg
->last_vert_prog
->sh
.LinkedTransformFeedback
->NumVarying
:
804 shProg
->TransformFeedback
.NumVarying
;
806 for (i
= 0; i
< num_varying
; i
++) {
807 const char *name
= in_shader_varyings
?
808 shProg
->last_vert_prog
->sh
.LinkedTransformFeedback
->Varyings
[i
].Name
809 : shProg
->TransformFeedback
.VaryingNames
[i
];
811 /* Add one for the terminating NUL character. We have to use
812 * strlen_or_zero, as for shaders constructed from SPIR-V binaries,
813 * it is possible that no name reflection information is available.
815 const GLint len
= strlen_or_zero(name
) + 1;
824 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE
:
827 *params
= shProg
->TransformFeedback
.BufferMode
;
829 case GL_GEOMETRY_VERTICES_OUT
:
832 if (check_gs_query(ctx
, shProg
)) {
833 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
834 Program
->info
.gs
.vertices_out
;
837 case GL_GEOMETRY_SHADER_INVOCATIONS
:
839 (_mesa_is_desktop_gl(ctx
) && !ctx
->Extensions
.ARB_gpu_shader5
)) {
842 if (check_gs_query(ctx
, shProg
)) {
843 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
844 Program
->info
.gs
.invocations
;
847 case GL_GEOMETRY_INPUT_TYPE
:
850 if (check_gs_query(ctx
, shProg
)) {
851 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
852 Program
->info
.gs
.input_primitive
;
855 case GL_GEOMETRY_OUTPUT_TYPE
:
858 if (check_gs_query(ctx
, shProg
)) {
859 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
860 Program
->info
.gs
.output_primitive
;
863 case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH
: {
870 for (i
= 0; i
< shProg
->data
->NumUniformBlocks
; i
++) {
871 /* Add one for the terminating NUL character. Name can be NULL, in
872 * that case, from ARB_gl_spirv:
873 * "If pname is ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, the length of
874 * the longest active uniform block name, including the null
875 * terminator, is returned. If no active uniform blocks exist,
876 * zero is returned. If no name reflection information is
877 * available, one is returned."
880 strlen_or_zero(shProg
->data
->UniformBlocks
[i
].Name
) + 1;
889 case GL_ACTIVE_UNIFORM_BLOCKS
:
893 *params
= shProg
->data
->NumUniformBlocks
;
895 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
896 /* This enum isn't part of the OES extension for OpenGL ES 2.0. It is
897 * only available with desktop OpenGL 3.0+ with the
898 * GL_ARB_get_program_binary extension or OpenGL ES 3.0.
900 * On desktop, we ignore the 3.0+ requirement because it is silly.
902 if (!_mesa_is_desktop_gl(ctx
) && !_mesa_is_gles3(ctx
))
905 *params
= shProg
->BinaryRetrievableHint
;
907 case GL_PROGRAM_BINARY_LENGTH
:
908 if (ctx
->Const
.NumProgramBinaryFormats
== 0 || !shProg
->data
->LinkStatus
) {
911 _mesa_get_program_binary_length(ctx
, shProg
, params
);
914 case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS
:
915 if (!ctx
->Extensions
.ARB_shader_atomic_counters
)
918 *params
= shProg
->data
->NumAtomicBuffers
;
920 case GL_COMPUTE_WORK_GROUP_SIZE
: {
922 if (!_mesa_has_compute_shaders(ctx
))
924 if (!shProg
->data
->LinkStatus
) {
925 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramiv(program not "
929 if (shProg
->_LinkedShaders
[MESA_SHADER_COMPUTE
] == NULL
) {
930 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramiv(no compute "
934 for (i
= 0; i
< 3; i
++)
935 params
[i
] = shProg
->_LinkedShaders
[MESA_SHADER_COMPUTE
]->
936 Program
->info
.cs
.local_size
[i
];
939 case GL_PROGRAM_SEPARABLE
:
940 /* If the program has not been linked, return initial value 0. */
941 *params
= (shProg
->data
->LinkStatus
== LINKING_FAILURE
) ? 0 : shProg
->SeparateShader
;
944 /* ARB_tessellation_shader */
945 case GL_TESS_CONTROL_OUTPUT_VERTICES
:
948 if (check_tcs_query(ctx
, shProg
)) {
949 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->
950 Program
->info
.tess
.tcs_vertices_out
;
953 case GL_TESS_GEN_MODE
:
956 if (check_tes_query(ctx
, shProg
)) {
957 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
958 Program
->info
.tess
.primitive_mode
;
961 case GL_TESS_GEN_SPACING
:
964 if (check_tes_query(ctx
, shProg
)) {
965 const struct gl_linked_shader
*tes
=
966 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
];
967 switch (tes
->Program
->info
.tess
.spacing
) {
968 case TESS_SPACING_EQUAL
:
971 case TESS_SPACING_FRACTIONAL_ODD
:
972 *params
= GL_FRACTIONAL_ODD
;
974 case TESS_SPACING_FRACTIONAL_EVEN
:
975 *params
= GL_FRACTIONAL_EVEN
;
977 case TESS_SPACING_UNSPECIFIED
:
983 case GL_TESS_GEN_VERTEX_ORDER
:
986 if (check_tes_query(ctx
, shProg
)) {
987 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
988 Program
->info
.tess
.ccw
? GL_CCW
: GL_CW
;
991 case GL_TESS_GEN_POINT_MODE
:
994 if (check_tes_query(ctx
, shProg
)) {
995 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
996 Program
->info
.tess
.point_mode
? GL_TRUE
: GL_FALSE
;
1003 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname=%s)",
1004 _mesa_enum_to_string(pname
));
1009 * glGetShaderiv() - get GLSL shader state
1012 get_shaderiv(struct gl_context
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
1014 struct gl_shader
*shader
=
1015 _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
1022 case GL_SHADER_TYPE
:
1023 *params
= shader
->Type
;
1025 case GL_DELETE_STATUS
:
1026 *params
= shader
->DeletePending
;
1028 case GL_COMPLETION_STATUS_ARB
:
1029 /* _mesa_glsl_compile_shader is not offloaded to other threads. */
1032 case GL_COMPILE_STATUS
:
1033 *params
= shader
->CompileStatus
? GL_TRUE
: GL_FALSE
;
1035 case GL_INFO_LOG_LENGTH
:
1036 *params
= (shader
->InfoLog
&& shader
->InfoLog
[0] != '\0') ?
1037 strlen(shader
->InfoLog
) + 1 : 0;
1039 case GL_SHADER_SOURCE_LENGTH
:
1040 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
1042 case GL_SPIR_V_BINARY_ARB
:
1043 *params
= (shader
->spirv_data
!= NULL
);
1046 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
1053 get_program_info_log(struct gl_context
*ctx
, GLuint program
, GLsizei bufSize
,
1054 GLsizei
*length
, GLchar
*infoLog
)
1056 struct gl_shader_program
*shProg
;
1058 /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
1059 * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
1061 * "If a negative number is provided where an argument of type sizei or
1062 * sizeiptr is specified, an INVALID_VALUE error is generated."
1065 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(bufSize < 0)");
1069 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
1070 "glGetProgramInfoLog(program)");
1075 _mesa_copy_string(infoLog
, bufSize
, length
, shProg
->data
->InfoLog
);
1080 get_shader_info_log(struct gl_context
*ctx
, GLuint shader
, GLsizei bufSize
,
1081 GLsizei
*length
, GLchar
*infoLog
)
1083 struct gl_shader
*sh
;
1085 /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
1086 * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
1088 * "If a negative number is provided where an argument of type sizei or
1089 * sizeiptr is specified, an INVALID_VALUE error is generated."
1092 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(bufSize < 0)");
1096 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderInfoLog(shader)");
1101 _mesa_copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
1106 * Return shader source code.
1109 get_shader_source(struct gl_context
*ctx
, GLuint shader
, GLsizei maxLength
,
1110 GLsizei
*length
, GLchar
*sourceOut
)
1112 struct gl_shader
*sh
;
1114 if (maxLength
< 0) {
1115 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderSource(bufSize < 0)");
1119 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
1123 _mesa_copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
1128 * Set/replace shader source code. A helper function used by
1129 * glShaderSource[ARB].
1132 set_shader_source(struct gl_shader
*sh
, const GLchar
*source
)
1136 /* The GL_ARB_gl_spirv spec adds the following to the end of the description
1139 * "If <shader> was previously associated with a SPIR-V module (via the
1140 * ShaderBinary command), that association is broken. Upon successful
1141 * completion of this command the SPIR_V_BINARY_ARB state of <shader>
1144 _mesa_shader_spirv_data_reference(&sh
->spirv_data
, NULL
);
1146 if (sh
->CompileStatus
== COMPILE_SKIPPED
&& !sh
->FallbackSource
) {
1147 /* If shader was previously compiled back-up the source in case of cache
1150 sh
->FallbackSource
= sh
->Source
;
1151 sh
->Source
= source
;
1153 /* free old shader source string and install new one */
1154 free((void *)sh
->Source
);
1155 sh
->Source
= source
;
1159 sh
->SourceChecksum
= util_hash_crc32(sh
->Source
, strlen(sh
->Source
));
1164 ensure_builtin_types(struct gl_context
*ctx
)
1166 if (!ctx
->shader_builtin_ref
) {
1167 _mesa_glsl_builtin_functions_init_or_ref();
1168 ctx
->shader_builtin_ref
= true;
1176 _mesa_compile_shader(struct gl_context
*ctx
, struct gl_shader
*sh
)
1181 /* The GL_ARB_gl_spirv spec says:
1183 * "Add a new error for the CompileShader command:
1185 * An INVALID_OPERATION error is generated if the SPIR_V_BINARY_ARB
1186 * state of <shader> is TRUE."
1188 if (sh
->spirv_data
) {
1189 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glCompileShader(SPIR-V)");
1194 /* If the user called glCompileShader without first calling
1195 * glShaderSource, we should fail to compile, but not raise a GL_ERROR.
1197 sh
->CompileStatus
= COMPILE_FAILURE
;
1199 if (ctx
->_Shader
->Flags
& GLSL_DUMP
) {
1200 _mesa_log("GLSL source for %s shader %d:\n",
1201 _mesa_shader_stage_to_string(sh
->Stage
), sh
->Name
);
1202 _mesa_log("%s\n", sh
->Source
);
1205 ensure_builtin_types(ctx
);
1207 /* this call will set the shader->CompileStatus field to indicate if
1208 * compilation was successful.
1210 _mesa_glsl_compile_shader(ctx
, sh
, false, false, false);
1212 if (ctx
->_Shader
->Flags
& GLSL_LOG
) {
1213 _mesa_write_shader_to_file(sh
);
1216 if (ctx
->_Shader
->Flags
& GLSL_DUMP
) {
1217 if (sh
->CompileStatus
) {
1219 _mesa_log("GLSL IR for shader %d:\n", sh
->Name
);
1220 _mesa_print_ir(_mesa_get_log_file(), sh
->ir
, NULL
);
1222 _mesa_log("No GLSL IR for shader %d (shader may be from "
1223 "cache)\n", sh
->Name
);
1227 _mesa_log("GLSL shader %d failed to compile.\n", sh
->Name
);
1229 if (sh
->InfoLog
&& sh
->InfoLog
[0] != 0) {
1230 _mesa_log("GLSL shader %d info log:\n", sh
->Name
);
1231 _mesa_log("%s\n", sh
->InfoLog
);
1236 if (!sh
->CompileStatus
) {
1237 if (ctx
->_Shader
->Flags
& GLSL_DUMP_ON_ERROR
) {
1238 _mesa_log("GLSL source for %s shader %d:\n",
1239 _mesa_shader_stage_to_string(sh
->Stage
), sh
->Name
);
1240 _mesa_log("%s\n", sh
->Source
);
1241 _mesa_log("Info Log:\n%s\n", sh
->InfoLog
);
1244 if (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
) {
1245 _mesa_debug(ctx
, "Error compiling shader %u:\n%s\n",
1246 sh
->Name
, sh
->InfoLog
);
1252 struct update_programs_in_pipeline_params
1254 struct gl_context
*ctx
;
1255 struct gl_shader_program
*shProg
;
1259 update_programs_in_pipeline(GLuint key
, void *data
, void *userData
)
1261 struct update_programs_in_pipeline_params
*params
=
1262 (struct update_programs_in_pipeline_params
*) userData
;
1263 struct gl_pipeline_object
*obj
= (struct gl_pipeline_object
*) data
;
1265 for (unsigned stage
= 0; stage
< MESA_SHADER_STAGES
; stage
++) {
1266 if (obj
->CurrentProgram
[stage
] &&
1267 obj
->CurrentProgram
[stage
]->Id
== params
->shProg
->Name
) {
1268 struct gl_program
*prog
= params
->shProg
->_LinkedShaders
[stage
]->Program
;
1269 _mesa_use_program(params
->ctx
, stage
, params
->shProg
, prog
, obj
);
1276 * Link a program's shaders.
1278 static ALWAYS_INLINE
void
1279 link_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
1286 /* From the ARB_transform_feedback2 specification:
1287 * "The error INVALID_OPERATION is generated by LinkProgram if <program>
1288 * is the name of a program being used by one or more transform feedback
1289 * objects, even if the objects are not currently bound or are paused."
1291 if (_mesa_transform_feedback_is_using_program(ctx
, shProg
)) {
1292 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1293 "glLinkProgram(transform feedback is using the program)");
1298 unsigned programs_in_use
= 0;
1300 for (unsigned stage
= 0; stage
< MESA_SHADER_STAGES
; stage
++) {
1301 if (ctx
->_Shader
->CurrentProgram
[stage
] &&
1302 ctx
->_Shader
->CurrentProgram
[stage
]->Id
== shProg
->Name
) {
1303 programs_in_use
|= 1 << stage
;
1307 ensure_builtin_types(ctx
);
1309 FLUSH_VERTICES(ctx
, 0);
1310 _mesa_glsl_link_shader(ctx
, shProg
);
1312 /* From section 7.3 (Program Objects) of the OpenGL 4.5 spec:
1314 * "If LinkProgram or ProgramBinary successfully re-links a program
1315 * object that is active for any shader stage, then the newly generated
1316 * executable code will be installed as part of the current rendering
1317 * state for all shader stages where the program is active.
1318 * Additionally, the newly generated executable code is made part of
1319 * the state of any program pipeline for all stages where the program
1322 if (shProg
->data
->LinkStatus
) {
1323 while (programs_in_use
) {
1324 const int stage
= u_bit_scan(&programs_in_use
);
1326 struct gl_program
*prog
= NULL
;
1327 if (shProg
->_LinkedShaders
[stage
])
1328 prog
= shProg
->_LinkedShaders
[stage
]->Program
;
1330 _mesa_use_program(ctx
, stage
, shProg
, prog
, ctx
->_Shader
);
1333 if (ctx
->Pipeline
.Objects
) {
1334 struct update_programs_in_pipeline_params params
= {
1338 _mesa_HashWalk(ctx
->Pipeline
.Objects
, update_programs_in_pipeline
,
1343 /* Capture .shader_test files. */
1344 const char *capture_path
= _mesa_get_shader_capture_path();
1345 if (shProg
->Name
!= 0 && shProg
->Name
!= ~0 && capture_path
!= NULL
) {
1346 /* Find an unused filename. */
1348 char *filename
= NULL
;
1349 for (unsigned i
= 0;; i
++) {
1351 filename
= ralloc_asprintf(NULL
, "%s/%u-%u.shader_test",
1352 capture_path
, shProg
->Name
, i
);
1354 filename
= ralloc_asprintf(NULL
, "%s/%u.shader_test",
1355 capture_path
, shProg
->Name
);
1357 file
= os_file_create_unique(filename
, 0644);
1360 /* If we are failing for another reason than "this filename already
1361 * exists", we are likely to fail again with another filename, so
1362 * let's just give up */
1363 if (errno
!= EEXIST
)
1365 ralloc_free(filename
);
1368 fprintf(file
, "[require]\nGLSL%s >= %u.%02u\n",
1369 shProg
->IsES
? " ES" : "",
1370 shProg
->data
->Version
/ 100, shProg
->data
->Version
% 100);
1371 if (shProg
->SeparateShader
)
1372 fprintf(file
, "GL_ARB_separate_shader_objects\nSSO ENABLED\n");
1373 fprintf(file
, "\n");
1375 for (unsigned i
= 0; i
< shProg
->NumShaders
; i
++) {
1376 fprintf(file
, "[%s shader]\n%s\n",
1377 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1378 shProg
->Shaders
[i
]->Source
);
1382 _mesa_warning(ctx
, "Failed to open %s", filename
);
1385 ralloc_free(filename
);
1388 if (shProg
->data
->LinkStatus
== LINKING_FAILURE
&&
1389 (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
)) {
1390 _mesa_debug(ctx
, "Error linking program %u:\n%s\n",
1391 shProg
->Name
, shProg
->data
->InfoLog
);
1394 _mesa_update_vertex_processing_mode(ctx
);
1396 shProg
->BinaryRetrievableHint
= shProg
->BinaryRetrievableHintPending
;
1402 printf("Link %u shaders in program %u: %s\n",
1403 shProg
->NumShaders
, shProg
->Name
,
1404 shProg
->data
->LinkStatus
? "Success" : "Failed");
1406 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1407 printf(" shader %u, stage %u\n",
1408 shProg
->Shaders
[i
]->Name
,
1409 shProg
->Shaders
[i
]->Stage
);
1416 link_program_error(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1418 link_program(ctx
, shProg
, false);
1423 link_program_no_error(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1425 link_program(ctx
, shProg
, true);
1430 _mesa_link_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1432 link_program_error(ctx
, shProg
);
1437 * Print basic shader info (for debug).
1440 print_shader_info(const struct gl_shader_program
*shProg
)
1444 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
1445 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1447 printf(" %s shader %u, checksum %u\n",
1448 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1449 shProg
->Shaders
[i
]->Name
,
1450 shProg
->Shaders
[i
]->SourceChecksum
);
1452 printf(" %s shader %u\n",
1453 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1454 shProg
->Shaders
[i
]->Name
);
1457 if (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
])
1458 printf(" vert prog %u\n",
1459 shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
]->Program
->Id
);
1460 if (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
])
1461 printf(" frag prog %u\n",
1462 shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->Program
->Id
);
1463 if (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
])
1464 printf(" geom prog %u\n",
1465 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->Program
->Id
);
1466 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
])
1467 printf(" tesc prog %u\n",
1468 shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->Program
->Id
);
1469 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
])
1470 printf(" tese prog %u\n",
1471 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->Program
->Id
);
1476 * Use the named shader program for subsequent glUniform calls
1479 _mesa_active_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
1482 if ((shProg
!= NULL
) && !shProg
->data
->LinkStatus
) {
1483 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1484 "%s(program %u not linked)", caller
, shProg
->Name
);
1488 if (ctx
->Shader
.ActiveProgram
!= shProg
) {
1489 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, shProg
);
1495 * Use the named shader program for subsequent rendering.
1498 _mesa_use_shader_program(struct gl_context
*ctx
,
1499 struct gl_shader_program
*shProg
)
1501 for (int i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1502 struct gl_program
*new_prog
= NULL
;
1503 if (shProg
&& shProg
->_LinkedShaders
[i
])
1504 new_prog
= shProg
->_LinkedShaders
[i
]->Program
;
1505 _mesa_use_program(ctx
, i
, shProg
, new_prog
, &ctx
->Shader
);
1507 _mesa_active_program(ctx
, shProg
, "glUseProgram");
1512 * Do validation of the given shader program.
1513 * \param errMsg returns error message if validation fails.
1514 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1517 validate_shader_program(const struct gl_shader_program
*shProg
,
1520 if (!shProg
->data
->LinkStatus
) {
1524 /* From the GL spec, a program is invalid if any of these are true:
1526 any two active samplers in the current program object are of
1527 different types, but refer to the same texture image unit,
1529 any active sampler in the current program object refers to a texture
1530 image unit where fixed-function fragment processing accesses a
1531 texture target that does not match the sampler type, or
1533 the sum of the number of active samplers in the program and the
1534 number of texture image units enabled for fixed-function fragment
1535 processing exceeds the combined limit on the total number of texture
1536 image units allowed.
1540 * Check: any two active samplers in the current program object are of
1541 * different types, but refer to the same texture image unit,
1543 if (!_mesa_sampler_uniforms_are_valid(shProg
, errMsg
, 100))
1551 * Called via glValidateProgram()
1554 validate_program(struct gl_context
*ctx
, GLuint program
)
1556 struct gl_shader_program
*shProg
;
1557 char errMsg
[100] = "";
1559 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
1564 shProg
->data
->Validated
= validate_shader_program(shProg
, errMsg
);
1565 if (!shProg
->data
->Validated
) {
1566 /* update info log */
1567 if (shProg
->data
->InfoLog
) {
1568 ralloc_free(shProg
->data
->InfoLog
);
1570 shProg
->data
->InfoLog
= ralloc_strdup(shProg
->data
, errMsg
);
1576 _mesa_AttachObjectARB_no_error(GLhandleARB program
, GLhandleARB shader
)
1578 GET_CURRENT_CONTEXT(ctx
);
1579 attach_shader_no_error(ctx
, program
, shader
);
1584 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1586 GET_CURRENT_CONTEXT(ctx
);
1587 attach_shader_err(ctx
, program
, shader
, "glAttachObjectARB");
1592 _mesa_AttachShader_no_error(GLuint program
, GLuint shader
)
1594 GET_CURRENT_CONTEXT(ctx
);
1595 attach_shader_no_error(ctx
, program
, shader
);
1600 _mesa_AttachShader(GLuint program
, GLuint shader
)
1602 GET_CURRENT_CONTEXT(ctx
);
1603 attach_shader_err(ctx
, program
, shader
, "glAttachShader");
1608 _mesa_CompileShader(GLuint shaderObj
)
1610 GET_CURRENT_CONTEXT(ctx
);
1611 if (MESA_VERBOSE
& VERBOSE_API
)
1612 _mesa_debug(ctx
, "glCompileShader %u\n", shaderObj
);
1613 _mesa_compile_shader(ctx
, _mesa_lookup_shader_err(ctx
, shaderObj
,
1614 "glCompileShader"));
1619 _mesa_CreateShader_no_error(GLenum type
)
1621 GET_CURRENT_CONTEXT(ctx
);
1622 return create_shader(ctx
, type
);
1627 _mesa_CreateShader(GLenum type
)
1629 GET_CURRENT_CONTEXT(ctx
);
1631 if (MESA_VERBOSE
& VERBOSE_API
)
1632 _mesa_debug(ctx
, "glCreateShader %s\n", _mesa_enum_to_string(type
));
1634 return create_shader_err(ctx
, type
, "glCreateShader");
1638 GLhandleARB GLAPIENTRY
1639 _mesa_CreateShaderObjectARB_no_error(GLenum type
)
1641 GET_CURRENT_CONTEXT(ctx
);
1642 return create_shader(ctx
, type
);
1646 GLhandleARB GLAPIENTRY
1647 _mesa_CreateShaderObjectARB(GLenum type
)
1649 GET_CURRENT_CONTEXT(ctx
);
1650 return create_shader_err(ctx
, type
, "glCreateShaderObjectARB");
1655 _mesa_CreateProgram(void)
1657 GET_CURRENT_CONTEXT(ctx
);
1658 if (MESA_VERBOSE
& VERBOSE_API
)
1659 _mesa_debug(ctx
, "glCreateProgram\n");
1660 return create_shader_program(ctx
);
1664 GLhandleARB GLAPIENTRY
1665 _mesa_CreateProgramObjectARB(void)
1667 GET_CURRENT_CONTEXT(ctx
);
1668 return create_shader_program(ctx
);
1673 _mesa_DeleteObjectARB(GLhandleARB obj
)
1675 if (MESA_VERBOSE
& VERBOSE_API
) {
1676 GET_CURRENT_CONTEXT(ctx
);
1677 _mesa_debug(ctx
, "glDeleteObjectARB(%lu)\n", (unsigned long)obj
);
1681 GET_CURRENT_CONTEXT(ctx
);
1682 FLUSH_VERTICES(ctx
, 0);
1683 if (is_program(ctx
, obj
)) {
1684 delete_shader_program(ctx
, obj
);
1686 else if (is_shader(ctx
, obj
)) {
1687 delete_shader(ctx
, obj
);
1697 _mesa_DeleteProgram(GLuint name
)
1700 GET_CURRENT_CONTEXT(ctx
);
1701 FLUSH_VERTICES(ctx
, 0);
1702 delete_shader_program(ctx
, name
);
1708 _mesa_DeleteShader(GLuint name
)
1711 GET_CURRENT_CONTEXT(ctx
);
1712 FLUSH_VERTICES(ctx
, 0);
1713 delete_shader(ctx
, name
);
1719 _mesa_DetachObjectARB_no_error(GLhandleARB program
, GLhandleARB shader
)
1721 GET_CURRENT_CONTEXT(ctx
);
1722 detach_shader_no_error(ctx
, program
, shader
);
1727 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1729 GET_CURRENT_CONTEXT(ctx
);
1730 detach_shader_error(ctx
, program
, shader
);
1735 _mesa_DetachShader_no_error(GLuint program
, GLuint shader
)
1737 GET_CURRENT_CONTEXT(ctx
);
1738 detach_shader_no_error(ctx
, program
, shader
);
1743 _mesa_DetachShader(GLuint program
, GLuint shader
)
1745 GET_CURRENT_CONTEXT(ctx
);
1746 detach_shader_error(ctx
, program
, shader
);
1751 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1752 GLsizei
* count
, GLhandleARB
* obj
)
1754 GET_CURRENT_CONTEXT(ctx
);
1755 get_attached_shaders(ctx
, (GLuint
)container
, maxCount
, count
, NULL
, obj
);
1760 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1761 GLsizei
*count
, GLuint
*obj
)
1763 GET_CURRENT_CONTEXT(ctx
);
1764 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
, NULL
);
1769 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1770 GLcharARB
* infoLog
)
1772 GET_CURRENT_CONTEXT(ctx
);
1773 if (is_program(ctx
, object
)) {
1774 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1776 else if (is_shader(ctx
, object
)) {
1777 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1780 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1786 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1788 GET_CURRENT_CONTEXT(ctx
);
1789 /* Implement in terms of GetProgramiv, GetShaderiv */
1790 if (is_program(ctx
, object
)) {
1791 if (pname
== GL_OBJECT_TYPE_ARB
) {
1792 *params
= GL_PROGRAM_OBJECT_ARB
;
1795 get_programiv(ctx
, object
, pname
, params
);
1798 else if (is_shader(ctx
, object
)) {
1799 if (pname
== GL_OBJECT_TYPE_ARB
) {
1800 *params
= GL_SHADER_OBJECT_ARB
;
1803 get_shaderiv(ctx
, object
, pname
, params
);
1807 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1813 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1816 GLint iparams
[1] = {0}; /* XXX is one element enough? */
1817 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1818 params
[0] = (GLfloat
) iparams
[0];
1823 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1825 GET_CURRENT_CONTEXT(ctx
);
1826 get_programiv(ctx
, program
, pname
, params
);
1831 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1833 GET_CURRENT_CONTEXT(ctx
);
1834 get_shaderiv(ctx
, shader
, pname
, params
);
1839 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1840 GLsizei
*length
, GLchar
*infoLog
)
1842 GET_CURRENT_CONTEXT(ctx
);
1843 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1848 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1849 GLsizei
*length
, GLchar
*infoLog
)
1851 GET_CURRENT_CONTEXT(ctx
);
1852 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1857 _mesa_GetShaderSource(GLuint shader
, GLsizei maxLength
,
1858 GLsizei
*length
, GLchar
*sourceOut
)
1860 GET_CURRENT_CONTEXT(ctx
);
1861 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1865 GLhandleARB GLAPIENTRY
1866 _mesa_GetHandleARB(GLenum pname
)
1868 GET_CURRENT_CONTEXT(ctx
);
1869 return get_handle(ctx
, pname
);
1873 GLboolean GLAPIENTRY
1874 _mesa_IsProgram(GLuint name
)
1876 GET_CURRENT_CONTEXT(ctx
);
1877 return is_program(ctx
, name
);
1881 GLboolean GLAPIENTRY
1882 _mesa_IsShader(GLuint name
)
1884 GET_CURRENT_CONTEXT(ctx
);
1885 return is_shader(ctx
, name
);
1890 _mesa_LinkProgram_no_error(GLuint programObj
)
1892 GET_CURRENT_CONTEXT(ctx
);
1894 struct gl_shader_program
*shProg
=
1895 _mesa_lookup_shader_program(ctx
, programObj
);
1896 link_program_no_error(ctx
, shProg
);
1901 _mesa_LinkProgram(GLuint programObj
)
1903 GET_CURRENT_CONTEXT(ctx
);
1905 if (MESA_VERBOSE
& VERBOSE_API
)
1906 _mesa_debug(ctx
, "glLinkProgram %u\n", programObj
);
1908 struct gl_shader_program
*shProg
=
1909 _mesa_lookup_shader_program_err(ctx
, programObj
, "glLinkProgram");
1910 link_program_error(ctx
, shProg
);
1913 #ifdef ENABLE_SHADER_CACHE
1915 * Generate a SHA-1 hash value string for given source string.
1918 generate_sha1(const char *source
, char sha_str
[64])
1920 unsigned char sha
[20];
1921 _mesa_sha1_compute(source
, strlen(source
), sha
);
1922 _mesa_sha1_format(sha_str
, sha
);
1926 * Construct a full path for shader replacement functionality using
1929 * <path>/<stage prefix>_<CHECKSUM>.glsl
1930 * <path>/<stage prefix>_<CHECKSUM>.arb
1933 construct_name(const gl_shader_stage stage
, const char *source
,
1937 static const char *types
[] = {
1938 "VS", "TC", "TE", "GS", "FS", "CS",
1941 const char *format
= strncmp(source
, "!!ARB", 5) ? "glsl" : "arb";
1943 generate_sha1(source
, sha
);
1944 return ralloc_asprintf(NULL
, "%s/%s_%s.%s", path
, types
[stage
], sha
, format
);
1948 * Write given shader source to a file in MESA_SHADER_DUMP_PATH.
1951 _mesa_dump_shader_source(const gl_shader_stage stage
, const char *source
)
1953 static bool path_exists
= true;
1960 dump_path
= getenv("MESA_SHADER_DUMP_PATH");
1962 path_exists
= false;
1966 char *name
= construct_name(stage
, source
, dump_path
);
1968 f
= fopen(name
, "w");
1973 GET_CURRENT_CONTEXT(ctx
);
1974 _mesa_warning(ctx
, "could not open %s for dumping shader (%s)", name
,
1981 * Read shader source code from a file.
1982 * Useful for debugging to override an app's shader.
1985 _mesa_read_shader_source(const gl_shader_stage stage
, const char *source
)
1988 static bool path_exists
= true;
1989 int len
, shader_size
= 0;
1996 read_path
= getenv("MESA_SHADER_READ_PATH");
1998 path_exists
= false;
2002 char *name
= construct_name(stage
, source
, read_path
);
2003 f
= fopen(name
, "r");
2008 /* allocate enough room for the entire shader */
2009 fseek(f
, 0, SEEK_END
);
2010 shader_size
= ftell(f
);
2012 assert(shader_size
);
2014 /* add one for terminating zero */
2017 buffer
= malloc(shader_size
);
2020 len
= fread(buffer
, 1, shader_size
, f
);
2028 #endif /* ENABLE_SHADER_CACHE */
2031 * Called via glShaderSource() and glShaderSourceARB() API functions.
2032 * Basically, concatenate the source code strings into one long string
2033 * and pass it to _mesa_shader_source().
2035 static ALWAYS_INLINE
void
2036 shader_source(struct gl_context
*ctx
, GLuint shaderObj
, GLsizei count
,
2037 const GLchar
*const *string
, const GLint
*length
, bool no_error
)
2040 GLsizei i
, totalLength
;
2042 struct gl_shader
*sh
;
2045 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glShaderSourceARB");
2049 if (string
== NULL
) {
2050 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
2054 sh
= _mesa_lookup_shader(ctx
, shaderObj
);
2058 * This array holds offsets of where the appropriate string ends, thus the
2059 * last element will be set to the total length of the source code.
2061 offsets
= malloc(count
* sizeof(GLint
));
2062 if (offsets
== NULL
) {
2063 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
2067 for (i
= 0; i
< count
; i
++) {
2068 if (!no_error
&& string
[i
] == NULL
) {
2069 free((GLvoid
*) offsets
);
2070 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2071 "glShaderSourceARB(null string)");
2074 if (length
== NULL
|| length
[i
] < 0)
2075 offsets
[i
] = strlen(string
[i
]);
2077 offsets
[i
] = length
[i
];
2078 /* accumulate string lengths */
2080 offsets
[i
] += offsets
[i
- 1];
2083 /* Total length of source string is sum off all strings plus two.
2084 * One extra byte for terminating zero, another extra byte to silence
2085 * valgrind warnings in the parser/grammer code.
2087 totalLength
= offsets
[count
- 1] + 2;
2088 source
= malloc(totalLength
* sizeof(GLcharARB
));
2089 if (source
== NULL
) {
2090 free((GLvoid
*) offsets
);
2091 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
2095 for (i
= 0; i
< count
; i
++) {
2096 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
2097 memcpy(source
+ start
, string
[i
],
2098 (offsets
[i
] - start
) * sizeof(GLcharARB
));
2100 source
[totalLength
- 1] = '\0';
2101 source
[totalLength
- 2] = '\0';
2103 #ifdef ENABLE_SHADER_CACHE
2104 GLcharARB
*replacement
;
2106 /* Dump original shader source to MESA_SHADER_DUMP_PATH and replace
2107 * if corresponding entry found from MESA_SHADER_READ_PATH.
2109 _mesa_dump_shader_source(sh
->Stage
, source
);
2111 replacement
= _mesa_read_shader_source(sh
->Stage
, source
);
2114 source
= replacement
;
2116 #endif /* ENABLE_SHADER_CACHE */
2118 set_shader_source(sh
, source
);
2125 _mesa_ShaderSource_no_error(GLuint shaderObj
, GLsizei count
,
2126 const GLchar
*const *string
, const GLint
*length
)
2128 GET_CURRENT_CONTEXT(ctx
);
2129 shader_source(ctx
, shaderObj
, count
, string
, length
, true);
2134 _mesa_ShaderSource(GLuint shaderObj
, GLsizei count
,
2135 const GLchar
*const *string
, const GLint
*length
)
2137 GET_CURRENT_CONTEXT(ctx
);
2138 shader_source(ctx
, shaderObj
, count
, string
, length
, false);
2142 static ALWAYS_INLINE
void
2143 use_program(GLuint program
, bool no_error
)
2145 GET_CURRENT_CONTEXT(ctx
);
2146 struct gl_shader_program
*shProg
= NULL
;
2148 if (MESA_VERBOSE
& VERBOSE_API
)
2149 _mesa_debug(ctx
, "glUseProgram %u\n", program
);
2153 shProg
= _mesa_lookup_shader_program(ctx
, program
);
2156 if (_mesa_is_xfb_active_and_unpaused(ctx
)) {
2157 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2158 "glUseProgram(transform feedback active)");
2164 _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
2168 if (!shProg
->data
->LinkStatus
) {
2169 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2170 "glUseProgram(program %u not linked)", program
);
2175 if (ctx
->_Shader
->Flags
& GLSL_USE_PROG
) {
2176 print_shader_info(shProg
);
2181 /* The ARB_separate_shader_object spec says:
2183 * "The executable code for an individual shader stage is taken from
2184 * the current program for that stage. If there is a current program
2185 * object established by UseProgram, that program is considered current
2186 * for all stages. Otherwise, if there is a bound program pipeline
2187 * object (section 2.14.PPO), the program bound to the appropriate
2188 * stage of the pipeline object is considered current."
2191 /* Attach shader state to the binding point */
2192 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, &ctx
->Shader
);
2193 /* Update the program */
2194 _mesa_use_shader_program(ctx
, shProg
);
2196 /* Must be done first: detach the progam */
2197 _mesa_use_shader_program(ctx
, shProg
);
2198 /* Unattach shader_state binding point */
2199 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
,
2200 ctx
->Pipeline
.Default
);
2201 /* If a pipeline was bound, rebind it */
2202 if (ctx
->Pipeline
.Current
) {
2204 _mesa_BindProgramPipeline_no_error(ctx
->Pipeline
.Current
->Name
);
2206 _mesa_BindProgramPipeline(ctx
->Pipeline
.Current
->Name
);
2210 _mesa_update_vertex_processing_mode(ctx
);
2215 _mesa_UseProgram_no_error(GLuint program
)
2217 use_program(program
, true);
2222 _mesa_UseProgram(GLuint program
)
2224 use_program(program
, false);
2229 _mesa_ValidateProgram(GLuint program
)
2231 GET_CURRENT_CONTEXT(ctx
);
2232 validate_program(ctx
, program
);
2237 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2240 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
2241 GLint
* range
, GLint
* precision
)
2243 const struct gl_program_constants
*limits
;
2244 const struct gl_precision
*p
;
2245 GET_CURRENT_CONTEXT(ctx
);
2247 switch (shadertype
) {
2248 case GL_VERTEX_SHADER
:
2249 limits
= &ctx
->Const
.Program
[MESA_SHADER_VERTEX
];
2251 case GL_FRAGMENT_SHADER
:
2252 limits
= &ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
];
2255 _mesa_error(ctx
, GL_INVALID_ENUM
,
2256 "glGetShaderPrecisionFormat(shadertype)");
2260 switch (precisiontype
) {
2262 p
= &limits
->LowFloat
;
2264 case GL_MEDIUM_FLOAT
:
2265 p
= &limits
->MediumFloat
;
2268 p
= &limits
->HighFloat
;
2271 p
= &limits
->LowInt
;
2274 p
= &limits
->MediumInt
;
2277 p
= &limits
->HighInt
;
2280 _mesa_error(ctx
, GL_INVALID_ENUM
,
2281 "glGetShaderPrecisionFormat(precisiontype)");
2285 range
[0] = p
->RangeMin
;
2286 range
[1] = p
->RangeMax
;
2287 precision
[0] = p
->Precision
;
2292 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2295 _mesa_ReleaseShaderCompiler(void)
2297 GET_CURRENT_CONTEXT(ctx
);
2299 if (ctx
->shader_builtin_ref
) {
2300 _mesa_glsl_builtin_functions_decref();
2301 ctx
->shader_builtin_ref
= false;
2307 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2310 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
2311 const void* binary
, GLint length
)
2313 GET_CURRENT_CONTEXT(ctx
);
2314 struct gl_shader
**sh
;
2316 /* Page 68, section 7.2 'Shader Binaries" of the of the OpenGL ES 3.1, and
2317 * page 88 of the OpenGL 4.5 specs state:
2319 * "An INVALID_VALUE error is generated if count or length is negative.
2320 * An INVALID_ENUM error is generated if binaryformat is not a supported
2321 * format returned in SHADER_BINARY_FORMATS."
2323 if (n
< 0 || length
< 0) {
2324 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderBinary(count or length < 0)");
2328 /* Get all shader objects at once so we can make the operation
2331 if (n
> SIZE_MAX
/ sizeof(*sh
)) {
2332 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderBinary(count)");
2336 sh
= alloca(sizeof(*sh
) * (size_t)n
);
2338 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderBinary");
2342 for (int i
= 0; i
< n
; ++i
) {
2343 sh
[i
] = _mesa_lookup_shader_err(ctx
, shaders
[i
], "glShaderBinary");
2348 if (binaryformat
== GL_SHADER_BINARY_FORMAT_SPIR_V_ARB
) {
2349 if (!ctx
->Extensions
.ARB_gl_spirv
) {
2350 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glShaderBinary(SPIR-V)");
2352 _mesa_spirv_shader_binary(ctx
, (unsigned) n
, sh
, binary
,
2359 _mesa_error(ctx
, GL_INVALID_ENUM
, "glShaderBinary(format)");
2364 _mesa_GetProgramBinary(GLuint program
, GLsizei bufSize
, GLsizei
*length
,
2365 GLenum
*binaryFormat
, GLvoid
*binary
)
2367 struct gl_shader_program
*shProg
;
2368 GLsizei length_dummy
;
2369 GET_CURRENT_CONTEXT(ctx
);
2372 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramBinary(bufSize < 0)");
2376 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramBinary");
2380 /* The ARB_get_program_binary spec says:
2382 * "If <length> is NULL, then no length is returned."
2384 * Ensure that length always points to valid storage to avoid multiple NULL
2385 * pointer checks below.
2388 length
= &length_dummy
;
2391 /* The ARB_get_program_binary spec says:
2393 * "When a program object's LINK_STATUS is FALSE, its program binary
2394 * length is zero, and a call to GetProgramBinary will generate an
2395 * INVALID_OPERATION error.
2397 if (!shProg
->data
->LinkStatus
) {
2398 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2399 "glGetProgramBinary(program %u not linked)",
2405 if (ctx
->Const
.NumProgramBinaryFormats
== 0) {
2407 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2408 "glGetProgramBinary(driver supports zero binary formats)");
2410 _mesa_get_program_binary(ctx
, shProg
, bufSize
, length
, binaryFormat
,
2412 assert(*length
== 0 || *binaryFormat
== GL_PROGRAM_BINARY_FORMAT_MESA
);
2417 _mesa_ProgramBinary(GLuint program
, GLenum binaryFormat
,
2418 const GLvoid
*binary
, GLsizei length
)
2420 struct gl_shader_program
*shProg
;
2421 GET_CURRENT_CONTEXT(ctx
);
2423 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glProgramBinary");
2427 _mesa_clear_shader_program_data(ctx
, shProg
);
2428 shProg
->data
= _mesa_create_shader_program_data();
2430 /* Section 2.3.1 (Errors) of the OpenGL 4.5 spec says:
2432 * "If a negative number is provided where an argument of type sizei or
2433 * sizeiptr is specified, an INVALID_VALUE error is generated."
2436 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramBinary(length < 0)");
2440 if (ctx
->Const
.NumProgramBinaryFormats
== 0 ||
2441 binaryFormat
!= GL_PROGRAM_BINARY_FORMAT_MESA
) {
2442 /* The ARB_get_program_binary spec says:
2444 * "<binaryFormat> and <binary> must be those returned by a previous
2445 * call to GetProgramBinary, and <length> must be the length of the
2446 * program binary as returned by GetProgramBinary or GetProgramiv with
2447 * <pname> PROGRAM_BINARY_LENGTH. Loading the program binary will fail,
2448 * setting the LINK_STATUS of <program> to FALSE, if these conditions
2451 * Since any value of binaryFormat passed "is not one of those specified as
2452 * allowable for [this] command, an INVALID_ENUM error is generated."
2454 shProg
->data
->LinkStatus
= LINKING_FAILURE
;
2455 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramBinary");
2457 _mesa_program_binary(ctx
, shProg
, binaryFormat
, binary
, length
);
2462 static ALWAYS_INLINE
void
2463 program_parameteri(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
2464 GLuint pname
, GLint value
, bool no_error
)
2467 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
2468 /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
2469 * is part of OpenGL ES 3.0. For the ES2 case, this function shouldn't
2470 * even be in the dispatch table, so we shouldn't need to expclicitly
2473 * On desktop, we ignore the 3.0+ requirement because it is silly.
2476 /* The ARB_get_program_binary extension spec says:
2478 * "An INVALID_VALUE error is generated if the <value> argument to
2479 * ProgramParameteri is not TRUE or FALSE."
2481 if (!no_error
&& value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2485 /* No need to notify the driver. Any changes will actually take effect
2486 * the next time the shader is linked.
2488 * The ARB_get_program_binary extension spec says:
2490 * "To indicate that a program binary is likely to be retrieved,
2491 * ProgramParameteri should be called with <pname>
2492 * PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
2493 * will not be in effect until the next time LinkProgram or
2494 * ProgramBinary has been called successfully."
2496 * The resolution of issue 9 in the extension spec also says:
2498 * "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
2499 * to indicate to the GL implementation that this program will
2500 * likely be saved with GetProgramBinary at some point. This will
2501 * give the GL implementation the opportunity to track any state
2502 * changes made to the program before being saved such that when it
2503 * is loaded again a recompile can be avoided."
2505 shProg
->BinaryRetrievableHintPending
= value
;
2508 case GL_PROGRAM_SEPARABLE
:
2509 /* Spec imply that the behavior is the same as ARB_get_program_binary
2510 * Chapter 7.3 Program Objects
2512 if (!no_error
&& value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2515 shProg
->SeparateShader
= value
;
2520 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteri(pname=%s)",
2521 _mesa_enum_to_string(pname
));
2527 _mesa_error(ctx
, GL_INVALID_VALUE
,
2528 "glProgramParameteri(pname=%s, value=%d): "
2529 "value must be 0 or 1.",
2530 _mesa_enum_to_string(pname
),
2536 _mesa_ProgramParameteri_no_error(GLuint program
, GLenum pname
, GLint value
)
2538 GET_CURRENT_CONTEXT(ctx
);
2540 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, program
);
2541 program_parameteri(ctx
, shProg
, pname
, value
, true);
2546 _mesa_ProgramParameteri(GLuint program
, GLenum pname
, GLint value
)
2548 struct gl_shader_program
*shProg
;
2549 GET_CURRENT_CONTEXT(ctx
);
2551 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
2552 "glProgramParameteri");
2556 program_parameteri(ctx
, shProg
, pname
, value
, false);
2561 _mesa_use_program(struct gl_context
*ctx
, gl_shader_stage stage
,
2562 struct gl_shader_program
*shProg
, struct gl_program
*prog
,
2563 struct gl_pipeline_object
*shTarget
)
2565 struct gl_program
**target
;
2567 target
= &shTarget
->CurrentProgram
[stage
];
2569 _mesa_program_init_subroutine_defaults(ctx
, prog
);
2572 if (*target
!= prog
) {
2573 /* Program is current, flush it */
2574 if (shTarget
== ctx
->_Shader
) {
2575 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
2578 _mesa_reference_shader_program(ctx
,
2579 &shTarget
->ReferencedPrograms
[stage
],
2581 _mesa_reference_program(ctx
, target
, prog
);
2582 _mesa_update_allow_draw_out_of_order(ctx
);
2583 if (stage
== MESA_SHADER_VERTEX
)
2584 _mesa_update_vertex_processing_mode(ctx
);
2592 * Copy program-specific data generated by linking from the gl_shader_program
2593 * object to the gl_program object referred to by the gl_linked_shader.
2595 * This function expects _mesa_reference_program() to have been previously
2596 * called setting the gl_linked_shaders program reference.
2599 _mesa_copy_linked_program_data(const struct gl_shader_program
*src
,
2600 struct gl_linked_shader
*dst_sh
)
2602 assert(dst_sh
->Program
);
2604 struct gl_program
*dst
= dst_sh
->Program
;
2606 dst
->info
.separate_shader
= src
->SeparateShader
;
2608 switch (dst_sh
->Stage
) {
2609 case MESA_SHADER_GEOMETRY
: {
2610 dst
->info
.gs
.vertices_in
= src
->Geom
.VerticesIn
;
2611 dst
->info
.gs
.uses_end_primitive
= src
->Geom
.UsesEndPrimitive
;
2612 dst
->info
.gs
.uses_streams
= src
->Geom
.UsesStreams
;
2615 case MESA_SHADER_FRAGMENT
: {
2616 dst
->info
.fs
.depth_layout
= src
->FragDepthLayout
;
2619 case MESA_SHADER_COMPUTE
: {
2620 dst
->info
.cs
.shared_size
= src
->Comp
.SharedSize
;
2629 * ARB_separate_shader_objects: Compile & Link Program
2632 _mesa_CreateShaderProgramv(GLenum type
, GLsizei count
,
2633 const GLchar
* const *strings
)
2635 GET_CURRENT_CONTEXT(ctx
);
2637 const GLuint shader
= create_shader_err(ctx
, type
, "glCreateShaderProgramv");
2641 * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2642 * GL_INVALID_VALUE should be generated if count < 0
2645 _mesa_error(ctx
, GL_INVALID_VALUE
, "glCreateShaderProgram (count < 0)");
2650 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
2652 _mesa_ShaderSource(shader
, count
, strings
, NULL
);
2653 _mesa_compile_shader(ctx
, sh
);
2655 program
= create_shader_program(ctx
);
2657 struct gl_shader_program
*shProg
;
2658 GLint compiled
= GL_FALSE
;
2660 shProg
= _mesa_lookup_shader_program(ctx
, program
);
2662 shProg
->SeparateShader
= GL_TRUE
;
2664 get_shaderiv(ctx
, shader
, GL_COMPILE_STATUS
, &compiled
);
2666 attach_shader_err(ctx
, program
, shader
, "glCreateShaderProgramv");
2667 _mesa_link_program(ctx
, shProg
);
2668 detach_shader_error(ctx
, program
, shader
);
2672 if (active
-user
-defined
-varyings
-in
-linked
-program
) {
2673 append
-error
-to
-info
-log
;
2674 shProg
->data
->LinkStatus
= LINKING_FAILURE
;
2679 ralloc_strcat(&shProg
->data
->InfoLog
, sh
->InfoLog
);
2682 delete_shader(ctx
, shader
);
2690 * For GL_ARB_tessellation_shader
2693 _mesa_PatchParameteri_no_error(GLenum pname
, GLint value
)
2695 GET_CURRENT_CONTEXT(ctx
);
2696 FLUSH_VERTICES(ctx
, 0);
2697 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2701 extern void GLAPIENTRY
2702 _mesa_PatchParameteri(GLenum pname
, GLint value
)
2704 GET_CURRENT_CONTEXT(ctx
);
2706 if (!_mesa_has_tessellation(ctx
)) {
2707 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameteri");
2711 if (pname
!= GL_PATCH_VERTICES
) {
2712 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameteri");
2716 if (value
<= 0 || value
> ctx
->Const
.MaxPatchVertices
) {
2717 _mesa_error(ctx
, GL_INVALID_VALUE
, "glPatchParameteri");
2721 FLUSH_VERTICES(ctx
, 0);
2722 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2726 extern void GLAPIENTRY
2727 _mesa_PatchParameterfv(GLenum pname
, const GLfloat
*values
)
2729 GET_CURRENT_CONTEXT(ctx
);
2731 if (!_mesa_has_tessellation(ctx
)) {
2732 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameterfv");
2737 case GL_PATCH_DEFAULT_OUTER_LEVEL
:
2738 FLUSH_VERTICES(ctx
, 0);
2739 memcpy(ctx
->TessCtrlProgram
.patch_default_outer_level
, values
,
2740 4 * sizeof(GLfloat
));
2741 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2743 case GL_PATCH_DEFAULT_INNER_LEVEL
:
2744 FLUSH_VERTICES(ctx
, 0);
2745 memcpy(ctx
->TessCtrlProgram
.patch_default_inner_level
, values
,
2746 2 * sizeof(GLfloat
));
2747 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2750 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameterfv");
2756 * ARB_shader_subroutine
2759 _mesa_GetSubroutineUniformLocation(GLuint program
, GLenum shadertype
,
2762 GET_CURRENT_CONTEXT(ctx
);
2763 const char *api_name
= "glGetSubroutineUniformLocation";
2764 struct gl_shader_program
*shProg
;
2765 GLenum resource_type
;
2766 gl_shader_stage stage
;
2768 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2769 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2773 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2777 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2778 if (!shProg
->_LinkedShaders
[stage
]) {
2779 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2783 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2784 return _mesa_program_resource_location(shProg
, resource_type
, name
);
2788 _mesa_GetSubroutineIndex(GLuint program
, GLenum shadertype
,
2791 GET_CURRENT_CONTEXT(ctx
);
2792 const char *api_name
= "glGetSubroutineIndex";
2793 struct gl_shader_program
*shProg
;
2794 struct gl_program_resource
*res
;
2795 GLenum resource_type
;
2796 gl_shader_stage stage
;
2798 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2799 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2803 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2807 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2808 if (!shProg
->_LinkedShaders
[stage
]) {
2809 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2813 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2814 res
= _mesa_program_resource_find_name(shProg
, resource_type
, name
, NULL
);
2819 return _mesa_program_resource_index(shProg
, res
);
2824 _mesa_GetActiveSubroutineUniformiv(GLuint program
, GLenum shadertype
,
2825 GLuint index
, GLenum pname
, GLint
*values
)
2827 GET_CURRENT_CONTEXT(ctx
);
2828 const char *api_name
= "glGetActiveSubroutineUniformiv";
2829 struct gl_shader_program
*shProg
;
2830 struct gl_linked_shader
*sh
;
2831 gl_shader_stage stage
;
2832 struct gl_program_resource
*res
;
2833 const struct gl_uniform_storage
*uni
;
2834 GLenum resource_type
;
2837 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2838 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2842 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2846 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2847 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2849 sh
= shProg
->_LinkedShaders
[stage
];
2851 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2855 struct gl_program
*p
= shProg
->_LinkedShaders
[stage
]->Program
;
2856 if (index
>= p
->sh
.NumSubroutineUniforms
) {
2857 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s: invalid index greater than GL_ACTIVE_SUBROUTINE_UNIFORMS", api_name
);
2862 case GL_NUM_COMPATIBLE_SUBROUTINES
: {
2863 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2866 values
[0] = uni
->num_compatible_subroutines
;
2870 case GL_COMPATIBLE_SUBROUTINES
: {
2871 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2875 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2876 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
2877 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
2878 if (fn
->types
[j
] == uni
->type
) {
2879 values
[count
++] = i
;
2887 case GL_UNIFORM_SIZE
:
2888 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2891 values
[0] = uni
->array_elements
? uni
->array_elements
: 1;
2894 case GL_UNIFORM_NAME_LENGTH
:
2895 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2897 values
[0] = strlen(_mesa_program_resource_name(res
)) + 1
2898 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
2902 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2909 _mesa_GetActiveSubroutineUniformName(GLuint program
, GLenum shadertype
,
2910 GLuint index
, GLsizei bufsize
,
2911 GLsizei
*length
, GLchar
*name
)
2913 GET_CURRENT_CONTEXT(ctx
);
2914 const char *api_name
= "glGetActiveSubroutineUniformName";
2915 struct gl_shader_program
*shProg
;
2916 GLenum resource_type
;
2917 gl_shader_stage stage
;
2919 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2920 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2924 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2928 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2929 if (!shProg
->_LinkedShaders
[stage
]) {
2930 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2934 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2935 /* get program resource name */
2936 _mesa_get_program_resource_name(shProg
, resource_type
,
2938 length
, name
, api_name
);
2943 _mesa_GetActiveSubroutineName(GLuint program
, GLenum shadertype
,
2944 GLuint index
, GLsizei bufsize
,
2945 GLsizei
*length
, GLchar
*name
)
2947 GET_CURRENT_CONTEXT(ctx
);
2948 const char *api_name
= "glGetActiveSubroutineName";
2949 struct gl_shader_program
*shProg
;
2950 GLenum resource_type
;
2951 gl_shader_stage stage
;
2953 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2954 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2958 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2962 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2963 if (!shProg
->_LinkedShaders
[stage
]) {
2964 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2967 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2968 _mesa_get_program_resource_name(shProg
, resource_type
,
2970 length
, name
, api_name
);
2974 _mesa_UniformSubroutinesuiv(GLenum shadertype
, GLsizei count
,
2975 const GLuint
*indices
)
2977 GET_CURRENT_CONTEXT(ctx
);
2978 const char *api_name
= "glUniformSubroutinesuiv";
2979 gl_shader_stage stage
;
2982 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2983 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2987 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2988 struct gl_program
*p
= ctx
->_Shader
->CurrentProgram
[stage
];
2990 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2994 if (count
!= p
->sh
.NumSubroutineUniformRemapTable
) {
2995 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
3000 bool flushed
= false;
3002 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
3009 _mesa_flush_vertices_for_uniforms(ctx
, uni
);
3013 int uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
3016 for (j
= i
; j
< i
+ uni_count
; j
++) {
3017 struct gl_subroutine_function
*subfn
= NULL
;
3018 if (indices
[j
] > p
->sh
.MaxSubroutineFunctionIndex
) {
3019 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
3023 for (f
= 0; f
< p
->sh
.NumSubroutineFunctions
; f
++) {
3024 if (p
->sh
.SubroutineFunctions
[f
].index
== indices
[j
])
3025 subfn
= &p
->sh
.SubroutineFunctions
[f
];
3032 for (k
= 0; k
< subfn
->num_compat_types
; k
++) {
3033 if (subfn
->types
[k
] == uni
->type
)
3036 if (k
== subfn
->num_compat_types
) {
3037 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
3041 ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[j
] = indices
[j
];
3049 _mesa_GetUniformSubroutineuiv(GLenum shadertype
, GLint location
,
3052 GET_CURRENT_CONTEXT(ctx
);
3053 const char *api_name
= "glGetUniformSubroutineuiv";
3054 gl_shader_stage stage
;
3056 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
3057 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
3061 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
3062 struct gl_program
*p
= ctx
->_Shader
->CurrentProgram
[stage
];
3064 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
3068 if (location
>= p
->sh
.NumSubroutineUniformRemapTable
) {
3069 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
3073 *params
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[location
];
3078 _mesa_GetProgramStageiv(GLuint program
, GLenum shadertype
,
3079 GLenum pname
, GLint
*values
)
3081 GET_CURRENT_CONTEXT(ctx
);
3082 const char *api_name
= "glGetProgramStageiv";
3083 struct gl_shader_program
*shProg
;
3084 struct gl_linked_shader
*sh
;
3085 gl_shader_stage stage
;
3087 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
3088 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
3092 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
3096 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
3097 sh
= shProg
->_LinkedShaders
[stage
];
3099 /* ARB_shader_subroutine doesn't ask the program to be linked, or list any
3100 * INVALID_OPERATION in the case of not be linked.
3102 * And for some pnames, like GL_ACTIVE_SUBROUTINE_UNIFORMS, you can ask the
3103 * same info using other specs (ARB_program_interface_query), without the
3104 * need of the program to be linked, being the value for that case 0.
3106 * But at the same time, some other methods require the program to be
3107 * linked for pname related to locations, so it would be inconsistent to
3108 * not do the same here. So we are:
3109 * * Return GL_INVALID_OPERATION if not linked only for locations.
3110 * * Setting a default value of 0, to be returned if not linked.
3114 if (pname
== GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
) {
3115 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
3120 struct gl_program
*p
= sh
->Program
;
3122 case GL_ACTIVE_SUBROUTINES
:
3123 values
[0] = p
->sh
.NumSubroutineFunctions
;
3125 case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
:
3126 values
[0] = p
->sh
.NumSubroutineUniformRemapTable
;
3128 case GL_ACTIVE_SUBROUTINE_UNIFORMS
:
3129 values
[0] = p
->sh
.NumSubroutineUniforms
;
3131 case GL_ACTIVE_SUBROUTINE_MAX_LENGTH
:
3135 GLenum resource_type
;
3136 struct gl_program_resource
*res
;
3138 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
3139 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
3140 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
3142 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1;
3147 values
[0] = max_len
;
3150 case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH
:
3154 GLenum resource_type
;
3155 struct gl_program_resource
*res
;
3157 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
3158 for (i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
3159 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
3161 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1
3162 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
3168 values
[0] = max_len
;
3172 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s", api_name
);
3178 /* This is simple list entry that will be used to hold a list of string
3179 * tokens of a parsed shader include path.
3181 struct sh_incl_path_entry
3183 struct sh_incl_path_entry
*next
;
3184 struct sh_incl_path_entry
*prev
;
3189 /* Nodes of the shader include tree */
3190 struct sh_incl_path_ht_entry
3192 struct hash_table
*path
;
3193 char *shader_source
;
3196 struct shader_includes
{
3197 /* Array to hold include paths given to glCompileShaderIncludeARB() */
3198 struct sh_incl_path_entry
**include_paths
;
3199 size_t num_include_paths
;
3200 size_t relative_path_cursor
;
3202 /* Root hash table holding the shader include tree */
3203 struct hash_table
*shader_include_tree
;
3207 _mesa_init_shader_includes(struct gl_shared_state
*shared
)
3209 shared
->ShaderIncludes
= calloc(1, sizeof(struct shader_includes
));
3210 shared
->ShaderIncludes
->shader_include_tree
=
3211 _mesa_hash_table_create(NULL
, _mesa_hash_string
,
3212 _mesa_key_string_equal
);
3216 _mesa_get_shader_include_cursor(struct gl_shared_state
*shared
)
3218 return shared
->ShaderIncludes
->relative_path_cursor
;
3222 _mesa_set_shader_include_cursor(struct gl_shared_state
*shared
, size_t cursor
)
3224 shared
->ShaderIncludes
->relative_path_cursor
= cursor
;
3228 destroy_shader_include(struct hash_entry
*entry
)
3230 struct sh_incl_path_ht_entry
*sh_incl_ht_entry
=
3231 (struct sh_incl_path_ht_entry
*) entry
->data
;
3233 _mesa_hash_table_destroy(sh_incl_ht_entry
->path
, destroy_shader_include
);
3234 free(sh_incl_ht_entry
->shader_source
);
3235 free(sh_incl_ht_entry
);
3239 _mesa_destroy_shader_includes(struct gl_shared_state
*shared
)
3241 _mesa_hash_table_destroy(shared
->ShaderIncludes
->shader_include_tree
,
3242 destroy_shader_include
);
3243 free(shared
->ShaderIncludes
);
3247 valid_path_format(const char *str
, bool relative_path
)
3251 if (!str
[i
] || (!relative_path
&& str
[i
] != '/'))
3257 const char c
= str
[i
++];
3258 if (('A' <= c
&& c
<= 'Z') ||
3259 ('a' <= c
&& c
<= 'z') ||
3260 ('0' <= c
&& c
<= '9'))
3264 if (str
[i
- 2] == '/')
3270 if (strchr("^. _+*%[](){}|&~=!:;,?-", c
) == NULL
)
3274 if (str
[i
- 1] == '/')
3282 validate_and_tokenise_sh_incl(struct gl_context
*ctx
,
3284 struct sh_incl_path_entry
**path_list
,
3285 char *full_path
, bool error_check
)
3287 bool relative_path
= ctx
->Shared
->ShaderIncludes
->num_include_paths
;
3289 if (!valid_path_format(full_path
, relative_path
)) {
3291 _mesa_error(ctx
, GL_INVALID_VALUE
,
3292 "glNamedStringARB(invalid name %s)", full_path
);
3297 char *save_ptr
= NULL
;
3298 char *path_str
= strtok_r(full_path
, "/", &save_ptr
);
3300 *path_list
= rzalloc(mem_ctx
, struct sh_incl_path_entry
);
3302 make_empty_list(*path_list
);
3304 while (path_str
!= NULL
) {
3305 if (strlen(path_str
) == 0) {
3307 _mesa_error(ctx
, GL_INVALID_VALUE
,
3308 "glNamedStringARB(invalid name %s)", full_path
);
3314 if (strcmp(path_str
, ".") == 0) {
3316 } else if (strcmp(path_str
, "..") == 0) {
3317 struct sh_incl_path_entry
*last
= last_elem(*path_list
);
3318 remove_from_list(last
);
3320 struct sh_incl_path_entry
*path
=
3321 rzalloc(mem_ctx
, struct sh_incl_path_entry
);
3323 path
->path
= strdup(path_str
);
3324 insert_at_tail(*path_list
, path
);
3327 path_str
= strtok_r(NULL
, "/", &save_ptr
);
3333 static struct sh_incl_path_ht_entry
*
3334 lookup_shader_include(struct gl_context
*ctx
, char *path
,
3337 void *mem_ctx
= ralloc_context(NULL
);
3338 struct sh_incl_path_entry
*path_list
;
3340 if (!validate_and_tokenise_sh_incl(ctx
, mem_ctx
, &path_list
, path
,
3342 ralloc_free(mem_ctx
);
3346 struct sh_incl_path_ht_entry
*sh_incl_ht_entry
= NULL
;
3347 struct hash_table
*path_ht
=
3348 ctx
->Shared
->ShaderIncludes
->shader_include_tree
;
3350 size_t count
= ctx
->Shared
->ShaderIncludes
->num_include_paths
;
3351 bool relative_path
= path
[0] != '/';
3353 size_t i
= ctx
->Shared
->ShaderIncludes
->relative_path_cursor
;
3354 bool use_cursor
= ctx
->Shared
->ShaderIncludes
->relative_path_cursor
;
3357 struct sh_incl_path_entry
*entry
;
3359 if (relative_path
) {
3362 struct sh_incl_path_entry
*rel_path_list
=
3363 ctx
->Shared
->ShaderIncludes
->include_paths
[i
];
3364 foreach(entry
, rel_path_list
) {
3365 struct hash_entry
*ht_entry
=
3366 _mesa_hash_table_search(path_ht
, entry
->path
);
3369 /* Reset search path and skip to the next include path */
3370 path_ht
= ctx
->Shared
->ShaderIncludes
->shader_include_tree
;
3371 sh_incl_ht_entry
= NULL
;
3376 goto next_relative_path
;
3380 goto next_relative_path
;
3385 (struct sh_incl_path_ht_entry
*) ht_entry
->data
;
3388 path_ht
= sh_incl_ht_entry
->path
;
3393 foreach(entry
, path_list
) {
3394 struct hash_entry
*ht_entry
=
3395 _mesa_hash_table_search(path_ht
, entry
->path
);
3398 /* Reset search path and skip to the next include path */
3399 path_ht
= ctx
->Shared
->ShaderIncludes
->shader_include_tree
;
3400 sh_incl_ht_entry
= NULL
;
3412 (struct sh_incl_path_ht_entry
*) ht_entry
->data
;
3415 path_ht
= sh_incl_ht_entry
->path
;
3419 (sh_incl_ht_entry
== NULL
|| !sh_incl_ht_entry
->shader_source
))
3422 /* If we get here then we have found a matching path or exahusted our
3423 * relative search paths.
3425 ctx
->Shared
->ShaderIncludes
->relative_path_cursor
= i
;
3427 } while (i
< count
);
3429 ralloc_free(mem_ctx
);
3431 return sh_incl_ht_entry
;
3435 _mesa_lookup_shader_include(struct gl_context
*ctx
, char *path
,
3438 struct sh_incl_path_ht_entry
*shader_include
=
3439 lookup_shader_include(ctx
, path
, error_check
);
3441 return shader_include
? shader_include
->shader_source
: NULL
;
3445 copy_string(struct gl_context
*ctx
, const char *str
, int str_len
,
3449 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s(NULL string)", caller
);
3457 cp
= calloc(sizeof(char), str_len
+ 1);
3458 memcpy(cp
, str
, str_len
);
3465 _mesa_NamedStringARB(GLenum type
, GLint namelen
, const GLchar
*name
,
3466 GLint stringlen
, const GLchar
*string
)
3468 GET_CURRENT_CONTEXT(ctx
);
3469 const char *caller
= "glNamedStringARB";
3471 if (type
!= GL_SHADER_INCLUDE_ARB
) {
3472 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s(invalid type)", caller
);
3476 char *name_cp
= copy_string(ctx
, name
, namelen
, caller
);
3477 char *string_cp
= copy_string(ctx
, string
, stringlen
, caller
);
3478 if (!name_cp
|| !string_cp
) {
3484 void *mem_ctx
= ralloc_context(NULL
);
3485 struct sh_incl_path_entry
*path_list
;
3487 if (!validate_and_tokenise_sh_incl(ctx
, mem_ctx
, &path_list
, name_cp
,
3491 ralloc_free(mem_ctx
);
3495 mtx_lock(&ctx
->Shared
->ShaderIncludeMutex
);
3497 struct hash_table
*path_ht
=
3498 ctx
->Shared
->ShaderIncludes
->shader_include_tree
;
3500 struct sh_incl_path_entry
*entry
;
3501 foreach(entry
, path_list
) {
3502 struct hash_entry
*ht_entry
=
3503 _mesa_hash_table_search(path_ht
, entry
->path
);
3505 struct sh_incl_path_ht_entry
*sh_incl_ht_entry
;
3507 sh_incl_ht_entry
= calloc(1, sizeof(struct sh_incl_path_ht_entry
));
3508 sh_incl_ht_entry
->path
=
3509 _mesa_hash_table_create(NULL
, _mesa_hash_string
,
3510 _mesa_key_string_equal
);
3511 _mesa_hash_table_insert(path_ht
, entry
->path
, sh_incl_ht_entry
);
3513 sh_incl_ht_entry
= (struct sh_incl_path_ht_entry
*) ht_entry
->data
;
3516 path_ht
= sh_incl_ht_entry
->path
;
3518 if (last_elem(path_list
) == entry
) {
3519 free(sh_incl_ht_entry
->shader_source
);
3520 sh_incl_ht_entry
->shader_source
= string_cp
;
3524 mtx_unlock(&ctx
->Shared
->ShaderIncludeMutex
);
3527 ralloc_free(mem_ctx
);
3531 _mesa_DeleteNamedStringARB(GLint namelen
, const GLchar
*name
)
3533 GET_CURRENT_CONTEXT(ctx
);
3534 const char *caller
= "glDeleteNamedStringARB";
3536 char *name_cp
= copy_string(ctx
, name
, namelen
, caller
);
3540 struct sh_incl_path_ht_entry
*shader_include
=
3541 lookup_shader_include(ctx
, name_cp
, true);
3543 if (!shader_include
) {
3544 _mesa_error(ctx
, GL_INVALID_OPERATION
,
3545 "%s(no string associated with path %s)", caller
, name_cp
);
3550 mtx_lock(&ctx
->Shared
->ShaderIncludeMutex
);
3552 free(shader_include
->shader_source
);
3553 shader_include
->shader_source
= NULL
;
3555 mtx_unlock(&ctx
->Shared
->ShaderIncludeMutex
);
3561 _mesa_CompileShaderIncludeARB(GLuint shader
, GLsizei count
,
3562 const GLchar
* const *path
, const GLint
*length
)
3564 GET_CURRENT_CONTEXT(ctx
);
3565 const char *caller
= "glCompileShaderIncludeARB";
3567 if (count
> 0 && path
== NULL
) {
3568 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s(count > 0 && path == NULL)",
3573 void *mem_ctx
= ralloc_context(NULL
);
3575 mtx_lock(&ctx
->Shared
->ShaderIncludeMutex
);
3577 ctx
->Shared
->ShaderIncludes
->include_paths
=
3578 ralloc_array_size(mem_ctx
, sizeof(struct sh_incl_path_entry
*), count
);
3580 for (size_t i
= 0; i
< count
; i
++) {
3581 char *path_cp
= copy_string(ctx
, path
[i
], length
? length
[i
] : -1,
3587 struct sh_incl_path_entry
*path_list
;
3589 if (!validate_and_tokenise_sh_incl(ctx
, mem_ctx
, &path_list
, path_cp
,
3595 ctx
->Shared
->ShaderIncludes
->include_paths
[i
] = path_list
;
3600 /* We must set this *after* all calls to validate_and_tokenise_sh_incl()
3601 * are done as we use this to decide if we need to check the start of the
3604 ctx
->Shared
->ShaderIncludes
->num_include_paths
= count
;
3606 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
3608 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s(shader)", caller
);
3612 _mesa_compile_shader(ctx
, sh
);
3615 ctx
->Shared
->ShaderIncludes
->num_include_paths
= 0;
3616 ctx
->Shared
->ShaderIncludes
->relative_path_cursor
= 0;
3617 ctx
->Shared
->ShaderIncludes
->include_paths
= NULL
;
3619 mtx_unlock(&ctx
->Shared
->ShaderIncludeMutex
);
3621 ralloc_free(mem_ctx
);
3624 GLboolean GLAPIENTRY
3625 _mesa_IsNamedStringARB(GLint namelen
, const GLchar
*name
)
3627 GET_CURRENT_CONTEXT(ctx
);
3632 char *name_cp
= copy_string(ctx
, name
, namelen
, "");
3634 const char *source
= _mesa_lookup_shader_include(ctx
, name_cp
, false);
3644 _mesa_GetNamedStringARB(GLint namelen
, const GLchar
*name
, GLsizei bufSize
,
3645 GLint
*stringlen
, GLchar
*string
)
3647 GET_CURRENT_CONTEXT(ctx
);
3648 const char *caller
= "glGetNamedStringARB";
3650 char *name_cp
= copy_string(ctx
, name
, namelen
, caller
);
3654 const char *source
= _mesa_lookup_shader_include(ctx
, name_cp
, true);
3656 _mesa_error(ctx
, GL_INVALID_OPERATION
,
3657 "%s(no string associated with path %s)", caller
, name_cp
);
3662 size_t size
= MIN2(strlen(source
), bufSize
- 1);
3663 memcpy(string
, source
, size
);
3664 string
[size
] = '\0';
3672 _mesa_GetNamedStringivARB(GLint namelen
, const GLchar
*name
,
3673 GLenum pname
, GLint
*params
)
3675 GET_CURRENT_CONTEXT(ctx
);
3676 const char *caller
= "glGetNamedStringivARB";
3678 char *name_cp
= copy_string(ctx
, name
, namelen
, caller
);
3682 const char *source
= _mesa_lookup_shader_include(ctx
, name_cp
, true);
3684 _mesa_error(ctx
, GL_INVALID_OPERATION
,
3685 "%s(no string associated with path %s)", caller
, name_cp
);
3691 case GL_NAMED_STRING_LENGTH_ARB
:
3692 *params
= strlen(source
) + 1;
3694 case GL_NAMED_STRING_TYPE_ARB
:
3695 *params
= GL_SHADER_INCLUDE_ARB
;
3698 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s(pname)", caller
);
3706 find_compat_subroutine(struct gl_program
*p
, const struct glsl_type
*type
)
3710 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
3711 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
3712 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
3713 if (fn
->types
[j
] == type
)
3721 _mesa_shader_write_subroutine_index(struct gl_context
*ctx
,
3722 struct gl_program
*p
)
3726 if (p
->sh
.NumSubroutineUniformRemapTable
== 0)
3731 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
3740 uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
3741 for (j
= 0; j
< uni_count
; j
++) {
3742 val
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[i
+ j
];
3743 memcpy(&uni
->storage
[j
], &val
, sizeof(int));
3746 _mesa_propagate_uniforms_to_driver_storage(uni
, 0, uni_count
);
3748 } while(i
< p
->sh
.NumSubroutineUniformRemapTable
);
3752 _mesa_shader_write_subroutine_indices(struct gl_context
*ctx
,
3753 gl_shader_stage stage
)
3755 if (ctx
->_Shader
->CurrentProgram
[stage
])
3756 _mesa_shader_write_subroutine_index(ctx
,
3757 ctx
->_Shader
->CurrentProgram
[stage
]);
3761 _mesa_program_init_subroutine_defaults(struct gl_context
*ctx
,
3762 struct gl_program
*p
)
3766 struct gl_subroutine_index_binding
*binding
= &ctx
->SubroutineIndex
[p
->info
.stage
];
3767 if (binding
->NumIndex
!= p
->sh
.NumSubroutineUniformRemapTable
) {
3768 binding
->IndexPtr
= realloc(binding
->IndexPtr
,
3769 p
->sh
.NumSubroutineUniformRemapTable
* (sizeof(GLuint
)));
3770 binding
->NumIndex
= p
->sh
.NumSubroutineUniformRemapTable
;
3773 for (int i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
3774 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
3779 binding
->IndexPtr
[i
] = find_compat_subroutine(p
, uni
->type
);