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
);
1253 * Link a program's shaders.
1255 static ALWAYS_INLINE
void
1256 link_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
1263 /* From the ARB_transform_feedback2 specification:
1264 * "The error INVALID_OPERATION is generated by LinkProgram if <program>
1265 * is the name of a program being used by one or more transform feedback
1266 * objects, even if the objects are not currently bound or are paused."
1268 if (_mesa_transform_feedback_is_using_program(ctx
, shProg
)) {
1269 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1270 "glLinkProgram(transform feedback is using the program)");
1275 unsigned programs_in_use
= 0;
1277 for (unsigned stage
= 0; stage
< MESA_SHADER_STAGES
; stage
++) {
1278 if (ctx
->_Shader
->CurrentProgram
[stage
] &&
1279 ctx
->_Shader
->CurrentProgram
[stage
]->Id
== shProg
->Name
) {
1280 programs_in_use
|= 1 << stage
;
1284 ensure_builtin_types(ctx
);
1286 FLUSH_VERTICES(ctx
, 0);
1287 _mesa_glsl_link_shader(ctx
, shProg
);
1289 /* From section 7.3 (Program Objects) of the OpenGL 4.5 spec:
1291 * "If LinkProgram or ProgramBinary successfully re-links a program
1292 * object that is active for any shader stage, then the newly generated
1293 * executable code will be installed as part of the current rendering
1294 * state for all shader stages where the program is active.
1295 * Additionally, the newly generated executable code is made part of
1296 * the state of any program pipeline for all stages where the program
1299 if (shProg
->data
->LinkStatus
&& programs_in_use
) {
1300 while (programs_in_use
) {
1301 const int stage
= u_bit_scan(&programs_in_use
);
1303 struct gl_program
*prog
= NULL
;
1304 if (shProg
->_LinkedShaders
[stage
])
1305 prog
= shProg
->_LinkedShaders
[stage
]->Program
;
1307 _mesa_use_program(ctx
, stage
, shProg
, prog
, ctx
->_Shader
);
1311 /* Capture .shader_test files. */
1312 const char *capture_path
= _mesa_get_shader_capture_path();
1313 if (shProg
->Name
!= 0 && shProg
->Name
!= ~0 && capture_path
!= NULL
) {
1314 /* Find an unused filename. */
1316 char *filename
= NULL
;
1317 for (unsigned i
= 0;; i
++) {
1319 filename
= ralloc_asprintf(NULL
, "%s/%u-%u.shader_test",
1320 capture_path
, shProg
->Name
, i
);
1322 filename
= ralloc_asprintf(NULL
, "%s/%u.shader_test",
1323 capture_path
, shProg
->Name
);
1325 file
= os_file_create_unique(filename
, 0644);
1328 /* If we are failing for another reason than "this filename already
1329 * exists", we are likely to fail again with another filename, so
1330 * let's just give up */
1331 if (errno
!= EEXIST
)
1333 ralloc_free(filename
);
1336 fprintf(file
, "[require]\nGLSL%s >= %u.%02u\n",
1337 shProg
->IsES
? " ES" : "",
1338 shProg
->data
->Version
/ 100, shProg
->data
->Version
% 100);
1339 if (shProg
->SeparateShader
)
1340 fprintf(file
, "GL_ARB_separate_shader_objects\nSSO ENABLED\n");
1341 fprintf(file
, "\n");
1343 for (unsigned i
= 0; i
< shProg
->NumShaders
; i
++) {
1344 fprintf(file
, "[%s shader]\n%s\n",
1345 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1346 shProg
->Shaders
[i
]->Source
);
1350 _mesa_warning(ctx
, "Failed to open %s", filename
);
1353 ralloc_free(filename
);
1356 if (shProg
->data
->LinkStatus
== LINKING_FAILURE
&&
1357 (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
)) {
1358 _mesa_debug(ctx
, "Error linking program %u:\n%s\n",
1359 shProg
->Name
, shProg
->data
->InfoLog
);
1362 _mesa_update_vertex_processing_mode(ctx
);
1364 shProg
->BinaryRetrievableHint
= shProg
->BinaryRetrievableHintPending
;
1370 printf("Link %u shaders in program %u: %s\n",
1371 shProg
->NumShaders
, shProg
->Name
,
1372 shProg
->data
->LinkStatus
? "Success" : "Failed");
1374 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1375 printf(" shader %u, stage %u\n",
1376 shProg
->Shaders
[i
]->Name
,
1377 shProg
->Shaders
[i
]->Stage
);
1384 link_program_error(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1386 link_program(ctx
, shProg
, false);
1391 link_program_no_error(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1393 link_program(ctx
, shProg
, true);
1398 _mesa_link_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1400 link_program_error(ctx
, shProg
);
1405 * Print basic shader info (for debug).
1408 print_shader_info(const struct gl_shader_program
*shProg
)
1412 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
1413 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1415 printf(" %s shader %u, checksum %u\n",
1416 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1417 shProg
->Shaders
[i
]->Name
,
1418 shProg
->Shaders
[i
]->SourceChecksum
);
1420 printf(" %s shader %u\n",
1421 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1422 shProg
->Shaders
[i
]->Name
);
1425 if (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
])
1426 printf(" vert prog %u\n",
1427 shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
]->Program
->Id
);
1428 if (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
])
1429 printf(" frag prog %u\n",
1430 shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->Program
->Id
);
1431 if (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
])
1432 printf(" geom prog %u\n",
1433 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->Program
->Id
);
1434 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
])
1435 printf(" tesc prog %u\n",
1436 shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->Program
->Id
);
1437 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
])
1438 printf(" tese prog %u\n",
1439 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->Program
->Id
);
1444 * Use the named shader program for subsequent glUniform calls
1447 _mesa_active_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
1450 if ((shProg
!= NULL
) && !shProg
->data
->LinkStatus
) {
1451 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1452 "%s(program %u not linked)", caller
, shProg
->Name
);
1456 if (ctx
->Shader
.ActiveProgram
!= shProg
) {
1457 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, shProg
);
1463 * Use the named shader program for subsequent rendering.
1466 _mesa_use_shader_program(struct gl_context
*ctx
,
1467 struct gl_shader_program
*shProg
)
1469 for (int i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1470 struct gl_program
*new_prog
= NULL
;
1471 if (shProg
&& shProg
->_LinkedShaders
[i
])
1472 new_prog
= shProg
->_LinkedShaders
[i
]->Program
;
1473 _mesa_use_program(ctx
, i
, shProg
, new_prog
, &ctx
->Shader
);
1475 _mesa_active_program(ctx
, shProg
, "glUseProgram");
1480 * Do validation of the given shader program.
1481 * \param errMsg returns error message if validation fails.
1482 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1485 validate_shader_program(const struct gl_shader_program
*shProg
,
1488 if (!shProg
->data
->LinkStatus
) {
1492 /* From the GL spec, a program is invalid if any of these are true:
1494 any two active samplers in the current program object are of
1495 different types, but refer to the same texture image unit,
1497 any active sampler in the current program object refers to a texture
1498 image unit where fixed-function fragment processing accesses a
1499 texture target that does not match the sampler type, or
1501 the sum of the number of active samplers in the program and the
1502 number of texture image units enabled for fixed-function fragment
1503 processing exceeds the combined limit on the total number of texture
1504 image units allowed.
1508 * Check: any two active samplers in the current program object are of
1509 * different types, but refer to the same texture image unit,
1511 if (!_mesa_sampler_uniforms_are_valid(shProg
, errMsg
, 100))
1519 * Called via glValidateProgram()
1522 validate_program(struct gl_context
*ctx
, GLuint program
)
1524 struct gl_shader_program
*shProg
;
1525 char errMsg
[100] = "";
1527 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
1532 shProg
->data
->Validated
= validate_shader_program(shProg
, errMsg
);
1533 if (!shProg
->data
->Validated
) {
1534 /* update info log */
1535 if (shProg
->data
->InfoLog
) {
1536 ralloc_free(shProg
->data
->InfoLog
);
1538 shProg
->data
->InfoLog
= ralloc_strdup(shProg
->data
, errMsg
);
1544 _mesa_AttachObjectARB_no_error(GLhandleARB program
, GLhandleARB shader
)
1546 GET_CURRENT_CONTEXT(ctx
);
1547 attach_shader_no_error(ctx
, program
, shader
);
1552 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1554 GET_CURRENT_CONTEXT(ctx
);
1555 attach_shader_err(ctx
, program
, shader
, "glAttachObjectARB");
1560 _mesa_AttachShader_no_error(GLuint program
, GLuint shader
)
1562 GET_CURRENT_CONTEXT(ctx
);
1563 attach_shader_no_error(ctx
, program
, shader
);
1568 _mesa_AttachShader(GLuint program
, GLuint shader
)
1570 GET_CURRENT_CONTEXT(ctx
);
1571 attach_shader_err(ctx
, program
, shader
, "glAttachShader");
1576 _mesa_CompileShader(GLuint shaderObj
)
1578 GET_CURRENT_CONTEXT(ctx
);
1579 if (MESA_VERBOSE
& VERBOSE_API
)
1580 _mesa_debug(ctx
, "glCompileShader %u\n", shaderObj
);
1581 _mesa_compile_shader(ctx
, _mesa_lookup_shader_err(ctx
, shaderObj
,
1582 "glCompileShader"));
1587 _mesa_CreateShader_no_error(GLenum type
)
1589 GET_CURRENT_CONTEXT(ctx
);
1590 return create_shader(ctx
, type
);
1595 _mesa_CreateShader(GLenum type
)
1597 GET_CURRENT_CONTEXT(ctx
);
1599 if (MESA_VERBOSE
& VERBOSE_API
)
1600 _mesa_debug(ctx
, "glCreateShader %s\n", _mesa_enum_to_string(type
));
1602 return create_shader_err(ctx
, type
, "glCreateShader");
1606 GLhandleARB GLAPIENTRY
1607 _mesa_CreateShaderObjectARB_no_error(GLenum type
)
1609 GET_CURRENT_CONTEXT(ctx
);
1610 return create_shader(ctx
, type
);
1614 GLhandleARB GLAPIENTRY
1615 _mesa_CreateShaderObjectARB(GLenum type
)
1617 GET_CURRENT_CONTEXT(ctx
);
1618 return create_shader_err(ctx
, type
, "glCreateShaderObjectARB");
1623 _mesa_CreateProgram(void)
1625 GET_CURRENT_CONTEXT(ctx
);
1626 if (MESA_VERBOSE
& VERBOSE_API
)
1627 _mesa_debug(ctx
, "glCreateProgram\n");
1628 return create_shader_program(ctx
);
1632 GLhandleARB GLAPIENTRY
1633 _mesa_CreateProgramObjectARB(void)
1635 GET_CURRENT_CONTEXT(ctx
);
1636 return create_shader_program(ctx
);
1641 _mesa_DeleteObjectARB(GLhandleARB obj
)
1643 if (MESA_VERBOSE
& VERBOSE_API
) {
1644 GET_CURRENT_CONTEXT(ctx
);
1645 _mesa_debug(ctx
, "glDeleteObjectARB(%lu)\n", (unsigned long)obj
);
1649 GET_CURRENT_CONTEXT(ctx
);
1650 FLUSH_VERTICES(ctx
, 0);
1651 if (is_program(ctx
, obj
)) {
1652 delete_shader_program(ctx
, obj
);
1654 else if (is_shader(ctx
, obj
)) {
1655 delete_shader(ctx
, obj
);
1665 _mesa_DeleteProgram(GLuint name
)
1668 GET_CURRENT_CONTEXT(ctx
);
1669 FLUSH_VERTICES(ctx
, 0);
1670 delete_shader_program(ctx
, name
);
1676 _mesa_DeleteShader(GLuint name
)
1679 GET_CURRENT_CONTEXT(ctx
);
1680 FLUSH_VERTICES(ctx
, 0);
1681 delete_shader(ctx
, name
);
1687 _mesa_DetachObjectARB_no_error(GLhandleARB program
, GLhandleARB shader
)
1689 GET_CURRENT_CONTEXT(ctx
);
1690 detach_shader_no_error(ctx
, program
, shader
);
1695 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1697 GET_CURRENT_CONTEXT(ctx
);
1698 detach_shader_error(ctx
, program
, shader
);
1703 _mesa_DetachShader_no_error(GLuint program
, GLuint shader
)
1705 GET_CURRENT_CONTEXT(ctx
);
1706 detach_shader_no_error(ctx
, program
, shader
);
1711 _mesa_DetachShader(GLuint program
, GLuint shader
)
1713 GET_CURRENT_CONTEXT(ctx
);
1714 detach_shader_error(ctx
, program
, shader
);
1719 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1720 GLsizei
* count
, GLhandleARB
* obj
)
1722 GET_CURRENT_CONTEXT(ctx
);
1723 get_attached_shaders(ctx
, (GLuint
)container
, maxCount
, count
, NULL
, obj
);
1728 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1729 GLsizei
*count
, GLuint
*obj
)
1731 GET_CURRENT_CONTEXT(ctx
);
1732 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
, NULL
);
1737 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1738 GLcharARB
* infoLog
)
1740 GET_CURRENT_CONTEXT(ctx
);
1741 if (is_program(ctx
, object
)) {
1742 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1744 else if (is_shader(ctx
, object
)) {
1745 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1748 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1754 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1756 GET_CURRENT_CONTEXT(ctx
);
1757 /* Implement in terms of GetProgramiv, GetShaderiv */
1758 if (is_program(ctx
, object
)) {
1759 if (pname
== GL_OBJECT_TYPE_ARB
) {
1760 *params
= GL_PROGRAM_OBJECT_ARB
;
1763 get_programiv(ctx
, object
, pname
, params
);
1766 else if (is_shader(ctx
, object
)) {
1767 if (pname
== GL_OBJECT_TYPE_ARB
) {
1768 *params
= GL_SHADER_OBJECT_ARB
;
1771 get_shaderiv(ctx
, object
, pname
, params
);
1775 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1781 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1784 GLint iparams
[1] = {0}; /* XXX is one element enough? */
1785 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1786 params
[0] = (GLfloat
) iparams
[0];
1791 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1793 GET_CURRENT_CONTEXT(ctx
);
1794 get_programiv(ctx
, program
, pname
, params
);
1799 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1801 GET_CURRENT_CONTEXT(ctx
);
1802 get_shaderiv(ctx
, shader
, pname
, params
);
1807 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1808 GLsizei
*length
, GLchar
*infoLog
)
1810 GET_CURRENT_CONTEXT(ctx
);
1811 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1816 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1817 GLsizei
*length
, GLchar
*infoLog
)
1819 GET_CURRENT_CONTEXT(ctx
);
1820 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1825 _mesa_GetShaderSource(GLuint shader
, GLsizei maxLength
,
1826 GLsizei
*length
, GLchar
*sourceOut
)
1828 GET_CURRENT_CONTEXT(ctx
);
1829 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1833 GLhandleARB GLAPIENTRY
1834 _mesa_GetHandleARB(GLenum pname
)
1836 GET_CURRENT_CONTEXT(ctx
);
1837 return get_handle(ctx
, pname
);
1841 GLboolean GLAPIENTRY
1842 _mesa_IsProgram(GLuint name
)
1844 GET_CURRENT_CONTEXT(ctx
);
1845 return is_program(ctx
, name
);
1849 GLboolean GLAPIENTRY
1850 _mesa_IsShader(GLuint name
)
1852 GET_CURRENT_CONTEXT(ctx
);
1853 return is_shader(ctx
, name
);
1858 _mesa_LinkProgram_no_error(GLuint programObj
)
1860 GET_CURRENT_CONTEXT(ctx
);
1862 struct gl_shader_program
*shProg
=
1863 _mesa_lookup_shader_program(ctx
, programObj
);
1864 link_program_no_error(ctx
, shProg
);
1869 _mesa_LinkProgram(GLuint programObj
)
1871 GET_CURRENT_CONTEXT(ctx
);
1873 if (MESA_VERBOSE
& VERBOSE_API
)
1874 _mesa_debug(ctx
, "glLinkProgram %u\n", programObj
);
1876 struct gl_shader_program
*shProg
=
1877 _mesa_lookup_shader_program_err(ctx
, programObj
, "glLinkProgram");
1878 link_program_error(ctx
, shProg
);
1881 #ifdef ENABLE_SHADER_CACHE
1883 * Generate a SHA-1 hash value string for given source string.
1886 generate_sha1(const char *source
, char sha_str
[64])
1888 unsigned char sha
[20];
1889 _mesa_sha1_compute(source
, strlen(source
), sha
);
1890 _mesa_sha1_format(sha_str
, sha
);
1894 * Construct a full path for shader replacement functionality using
1897 * <path>/<stage prefix>_<CHECKSUM>.glsl
1898 * <path>/<stage prefix>_<CHECKSUM>.arb
1901 construct_name(const gl_shader_stage stage
, const char *source
,
1905 static const char *types
[] = {
1906 "VS", "TC", "TE", "GS", "FS", "CS",
1909 const char *format
= strncmp(source
, "!!ARB", 5) ? "glsl" : "arb";
1911 generate_sha1(source
, sha
);
1912 return ralloc_asprintf(NULL
, "%s/%s_%s.%s", path
, types
[stage
], sha
, format
);
1916 * Write given shader source to a file in MESA_SHADER_DUMP_PATH.
1919 _mesa_dump_shader_source(const gl_shader_stage stage
, const char *source
)
1921 static bool path_exists
= true;
1928 dump_path
= getenv("MESA_SHADER_DUMP_PATH");
1930 path_exists
= false;
1934 char *name
= construct_name(stage
, source
, dump_path
);
1936 f
= fopen(name
, "w");
1941 GET_CURRENT_CONTEXT(ctx
);
1942 _mesa_warning(ctx
, "could not open %s for dumping shader (%s)", name
,
1949 * Read shader source code from a file.
1950 * Useful for debugging to override an app's shader.
1953 _mesa_read_shader_source(const gl_shader_stage stage
, const char *source
)
1956 static bool path_exists
= true;
1957 int len
, shader_size
= 0;
1964 read_path
= getenv("MESA_SHADER_READ_PATH");
1966 path_exists
= false;
1970 char *name
= construct_name(stage
, source
, read_path
);
1971 f
= fopen(name
, "r");
1976 /* allocate enough room for the entire shader */
1977 fseek(f
, 0, SEEK_END
);
1978 shader_size
= ftell(f
);
1980 assert(shader_size
);
1982 /* add one for terminating zero */
1985 buffer
= malloc(shader_size
);
1988 len
= fread(buffer
, 1, shader_size
, f
);
1996 #endif /* ENABLE_SHADER_CACHE */
1999 * Called via glShaderSource() and glShaderSourceARB() API functions.
2000 * Basically, concatenate the source code strings into one long string
2001 * and pass it to _mesa_shader_source().
2003 static ALWAYS_INLINE
void
2004 shader_source(struct gl_context
*ctx
, GLuint shaderObj
, GLsizei count
,
2005 const GLchar
*const *string
, const GLint
*length
, bool no_error
)
2008 GLsizei i
, totalLength
;
2010 struct gl_shader
*sh
;
2013 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glShaderSourceARB");
2017 if (string
== NULL
) {
2018 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
2022 sh
= _mesa_lookup_shader(ctx
, shaderObj
);
2026 * This array holds offsets of where the appropriate string ends, thus the
2027 * last element will be set to the total length of the source code.
2029 offsets
= malloc(count
* sizeof(GLint
));
2030 if (offsets
== NULL
) {
2031 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
2035 for (i
= 0; i
< count
; i
++) {
2036 if (!no_error
&& string
[i
] == NULL
) {
2037 free((GLvoid
*) offsets
);
2038 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2039 "glShaderSourceARB(null string)");
2042 if (length
== NULL
|| length
[i
] < 0)
2043 offsets
[i
] = strlen(string
[i
]);
2045 offsets
[i
] = length
[i
];
2046 /* accumulate string lengths */
2048 offsets
[i
] += offsets
[i
- 1];
2051 /* Total length of source string is sum off all strings plus two.
2052 * One extra byte for terminating zero, another extra byte to silence
2053 * valgrind warnings in the parser/grammer code.
2055 totalLength
= offsets
[count
- 1] + 2;
2056 source
= malloc(totalLength
* sizeof(GLcharARB
));
2057 if (source
== NULL
) {
2058 free((GLvoid
*) offsets
);
2059 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
2063 for (i
= 0; i
< count
; i
++) {
2064 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
2065 memcpy(source
+ start
, string
[i
],
2066 (offsets
[i
] - start
) * sizeof(GLcharARB
));
2068 source
[totalLength
- 1] = '\0';
2069 source
[totalLength
- 2] = '\0';
2071 #ifdef ENABLE_SHADER_CACHE
2072 GLcharARB
*replacement
;
2074 /* Dump original shader source to MESA_SHADER_DUMP_PATH and replace
2075 * if corresponding entry found from MESA_SHADER_READ_PATH.
2077 _mesa_dump_shader_source(sh
->Stage
, source
);
2079 replacement
= _mesa_read_shader_source(sh
->Stage
, source
);
2082 source
= replacement
;
2084 #endif /* ENABLE_SHADER_CACHE */
2086 set_shader_source(sh
, source
);
2093 _mesa_ShaderSource_no_error(GLuint shaderObj
, GLsizei count
,
2094 const GLchar
*const *string
, const GLint
*length
)
2096 GET_CURRENT_CONTEXT(ctx
);
2097 shader_source(ctx
, shaderObj
, count
, string
, length
, true);
2102 _mesa_ShaderSource(GLuint shaderObj
, GLsizei count
,
2103 const GLchar
*const *string
, const GLint
*length
)
2105 GET_CURRENT_CONTEXT(ctx
);
2106 shader_source(ctx
, shaderObj
, count
, string
, length
, false);
2110 static ALWAYS_INLINE
void
2111 use_program(GLuint program
, bool no_error
)
2113 GET_CURRENT_CONTEXT(ctx
);
2114 struct gl_shader_program
*shProg
= NULL
;
2116 if (MESA_VERBOSE
& VERBOSE_API
)
2117 _mesa_debug(ctx
, "glUseProgram %u\n", program
);
2121 shProg
= _mesa_lookup_shader_program(ctx
, program
);
2124 if (_mesa_is_xfb_active_and_unpaused(ctx
)) {
2125 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2126 "glUseProgram(transform feedback active)");
2132 _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
2136 if (!shProg
->data
->LinkStatus
) {
2137 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2138 "glUseProgram(program %u not linked)", program
);
2143 if (ctx
->_Shader
->Flags
& GLSL_USE_PROG
) {
2144 print_shader_info(shProg
);
2149 /* The ARB_separate_shader_object spec says:
2151 * "The executable code for an individual shader stage is taken from
2152 * the current program for that stage. If there is a current program
2153 * object established by UseProgram, that program is considered current
2154 * for all stages. Otherwise, if there is a bound program pipeline
2155 * object (section 2.14.PPO), the program bound to the appropriate
2156 * stage of the pipeline object is considered current."
2159 /* Attach shader state to the binding point */
2160 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, &ctx
->Shader
);
2161 /* Update the program */
2162 _mesa_use_shader_program(ctx
, shProg
);
2164 /* Must be done first: detach the progam */
2165 _mesa_use_shader_program(ctx
, shProg
);
2166 /* Unattach shader_state binding point */
2167 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
,
2168 ctx
->Pipeline
.Default
);
2169 /* If a pipeline was bound, rebind it */
2170 if (ctx
->Pipeline
.Current
) {
2172 _mesa_BindProgramPipeline_no_error(ctx
->Pipeline
.Current
->Name
);
2174 _mesa_BindProgramPipeline(ctx
->Pipeline
.Current
->Name
);
2178 _mesa_update_vertex_processing_mode(ctx
);
2183 _mesa_UseProgram_no_error(GLuint program
)
2185 use_program(program
, true);
2190 _mesa_UseProgram(GLuint program
)
2192 use_program(program
, false);
2197 _mesa_ValidateProgram(GLuint program
)
2199 GET_CURRENT_CONTEXT(ctx
);
2200 validate_program(ctx
, program
);
2205 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2208 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
2209 GLint
* range
, GLint
* precision
)
2211 const struct gl_program_constants
*limits
;
2212 const struct gl_precision
*p
;
2213 GET_CURRENT_CONTEXT(ctx
);
2215 switch (shadertype
) {
2216 case GL_VERTEX_SHADER
:
2217 limits
= &ctx
->Const
.Program
[MESA_SHADER_VERTEX
];
2219 case GL_FRAGMENT_SHADER
:
2220 limits
= &ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
];
2223 _mesa_error(ctx
, GL_INVALID_ENUM
,
2224 "glGetShaderPrecisionFormat(shadertype)");
2228 switch (precisiontype
) {
2230 p
= &limits
->LowFloat
;
2232 case GL_MEDIUM_FLOAT
:
2233 p
= &limits
->MediumFloat
;
2236 p
= &limits
->HighFloat
;
2239 p
= &limits
->LowInt
;
2242 p
= &limits
->MediumInt
;
2245 p
= &limits
->HighInt
;
2248 _mesa_error(ctx
, GL_INVALID_ENUM
,
2249 "glGetShaderPrecisionFormat(precisiontype)");
2253 range
[0] = p
->RangeMin
;
2254 range
[1] = p
->RangeMax
;
2255 precision
[0] = p
->Precision
;
2260 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2263 _mesa_ReleaseShaderCompiler(void)
2265 GET_CURRENT_CONTEXT(ctx
);
2267 if (ctx
->shader_builtin_ref
) {
2268 _mesa_glsl_builtin_functions_decref();
2269 ctx
->shader_builtin_ref
= false;
2275 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2278 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
2279 const void* binary
, GLint length
)
2281 GET_CURRENT_CONTEXT(ctx
);
2282 struct gl_shader
**sh
;
2284 /* Page 68, section 7.2 'Shader Binaries" of the of the OpenGL ES 3.1, and
2285 * page 88 of the OpenGL 4.5 specs state:
2287 * "An INVALID_VALUE error is generated if count or length is negative.
2288 * An INVALID_ENUM error is generated if binaryformat is not a supported
2289 * format returned in SHADER_BINARY_FORMATS."
2291 if (n
< 0 || length
< 0) {
2292 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderBinary(count or length < 0)");
2296 /* Get all shader objects at once so we can make the operation
2299 if (n
> SIZE_MAX
/ sizeof(*sh
)) {
2300 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderBinary(count)");
2304 sh
= alloca(sizeof(*sh
) * (size_t)n
);
2306 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderBinary");
2310 for (int i
= 0; i
< n
; ++i
) {
2311 sh
[i
] = _mesa_lookup_shader_err(ctx
, shaders
[i
], "glShaderBinary");
2316 if (binaryformat
== GL_SHADER_BINARY_FORMAT_SPIR_V_ARB
) {
2317 if (!ctx
->Extensions
.ARB_gl_spirv
) {
2318 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glShaderBinary(SPIR-V)");
2320 _mesa_spirv_shader_binary(ctx
, (unsigned) n
, sh
, binary
,
2327 _mesa_error(ctx
, GL_INVALID_ENUM
, "glShaderBinary(format)");
2332 _mesa_GetProgramBinary(GLuint program
, GLsizei bufSize
, GLsizei
*length
,
2333 GLenum
*binaryFormat
, GLvoid
*binary
)
2335 struct gl_shader_program
*shProg
;
2336 GLsizei length_dummy
;
2337 GET_CURRENT_CONTEXT(ctx
);
2340 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramBinary(bufSize < 0)");
2344 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramBinary");
2348 /* The ARB_get_program_binary spec says:
2350 * "If <length> is NULL, then no length is returned."
2352 * Ensure that length always points to valid storage to avoid multiple NULL
2353 * pointer checks below.
2356 length
= &length_dummy
;
2359 /* The ARB_get_program_binary spec says:
2361 * "When a program object's LINK_STATUS is FALSE, its program binary
2362 * length is zero, and a call to GetProgramBinary will generate an
2363 * INVALID_OPERATION error.
2365 if (!shProg
->data
->LinkStatus
) {
2366 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2367 "glGetProgramBinary(program %u not linked)",
2373 if (ctx
->Const
.NumProgramBinaryFormats
== 0) {
2375 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2376 "glGetProgramBinary(driver supports zero binary formats)");
2378 _mesa_get_program_binary(ctx
, shProg
, bufSize
, length
, binaryFormat
,
2380 assert(*length
== 0 || *binaryFormat
== GL_PROGRAM_BINARY_FORMAT_MESA
);
2385 _mesa_ProgramBinary(GLuint program
, GLenum binaryFormat
,
2386 const GLvoid
*binary
, GLsizei length
)
2388 struct gl_shader_program
*shProg
;
2389 GET_CURRENT_CONTEXT(ctx
);
2391 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glProgramBinary");
2395 _mesa_clear_shader_program_data(ctx
, shProg
);
2396 shProg
->data
= _mesa_create_shader_program_data();
2398 /* Section 2.3.1 (Errors) of the OpenGL 4.5 spec says:
2400 * "If a negative number is provided where an argument of type sizei or
2401 * sizeiptr is specified, an INVALID_VALUE error is generated."
2404 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramBinary(length < 0)");
2408 if (ctx
->Const
.NumProgramBinaryFormats
== 0 ||
2409 binaryFormat
!= GL_PROGRAM_BINARY_FORMAT_MESA
) {
2410 /* The ARB_get_program_binary spec says:
2412 * "<binaryFormat> and <binary> must be those returned by a previous
2413 * call to GetProgramBinary, and <length> must be the length of the
2414 * program binary as returned by GetProgramBinary or GetProgramiv with
2415 * <pname> PROGRAM_BINARY_LENGTH. Loading the program binary will fail,
2416 * setting the LINK_STATUS of <program> to FALSE, if these conditions
2419 * Since any value of binaryFormat passed "is not one of those specified as
2420 * allowable for [this] command, an INVALID_ENUM error is generated."
2422 shProg
->data
->LinkStatus
= LINKING_FAILURE
;
2423 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramBinary");
2425 _mesa_program_binary(ctx
, shProg
, binaryFormat
, binary
, length
);
2430 static ALWAYS_INLINE
void
2431 program_parameteri(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
2432 GLuint pname
, GLint value
, bool no_error
)
2435 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
2436 /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
2437 * is part of OpenGL ES 3.0. For the ES2 case, this function shouldn't
2438 * even be in the dispatch table, so we shouldn't need to expclicitly
2441 * On desktop, we ignore the 3.0+ requirement because it is silly.
2444 /* The ARB_get_program_binary extension spec says:
2446 * "An INVALID_VALUE error is generated if the <value> argument to
2447 * ProgramParameteri is not TRUE or FALSE."
2449 if (!no_error
&& value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2453 /* No need to notify the driver. Any changes will actually take effect
2454 * the next time the shader is linked.
2456 * The ARB_get_program_binary extension spec says:
2458 * "To indicate that a program binary is likely to be retrieved,
2459 * ProgramParameteri should be called with <pname>
2460 * PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
2461 * will not be in effect until the next time LinkProgram or
2462 * ProgramBinary has been called successfully."
2464 * The resolution of issue 9 in the extension spec also says:
2466 * "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
2467 * to indicate to the GL implementation that this program will
2468 * likely be saved with GetProgramBinary at some point. This will
2469 * give the GL implementation the opportunity to track any state
2470 * changes made to the program before being saved such that when it
2471 * is loaded again a recompile can be avoided."
2473 shProg
->BinaryRetrievableHintPending
= value
;
2476 case GL_PROGRAM_SEPARABLE
:
2477 /* Spec imply that the behavior is the same as ARB_get_program_binary
2478 * Chapter 7.3 Program Objects
2480 if (!no_error
&& value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2483 shProg
->SeparateShader
= value
;
2488 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteri(pname=%s)",
2489 _mesa_enum_to_string(pname
));
2495 _mesa_error(ctx
, GL_INVALID_VALUE
,
2496 "glProgramParameteri(pname=%s, value=%d): "
2497 "value must be 0 or 1.",
2498 _mesa_enum_to_string(pname
),
2504 _mesa_ProgramParameteri_no_error(GLuint program
, GLenum pname
, GLint value
)
2506 GET_CURRENT_CONTEXT(ctx
);
2508 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, program
);
2509 program_parameteri(ctx
, shProg
, pname
, value
, true);
2514 _mesa_ProgramParameteri(GLuint program
, GLenum pname
, GLint value
)
2516 struct gl_shader_program
*shProg
;
2517 GET_CURRENT_CONTEXT(ctx
);
2519 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
2520 "glProgramParameteri");
2524 program_parameteri(ctx
, shProg
, pname
, value
, false);
2529 _mesa_use_program(struct gl_context
*ctx
, gl_shader_stage stage
,
2530 struct gl_shader_program
*shProg
, struct gl_program
*prog
,
2531 struct gl_pipeline_object
*shTarget
)
2533 struct gl_program
**target
;
2535 target
= &shTarget
->CurrentProgram
[stage
];
2537 _mesa_program_init_subroutine_defaults(ctx
, prog
);
2540 if (*target
!= prog
) {
2541 /* Program is current, flush it */
2542 if (shTarget
== ctx
->_Shader
) {
2543 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
2546 _mesa_reference_shader_program(ctx
,
2547 &shTarget
->ReferencedPrograms
[stage
],
2549 _mesa_reference_program(ctx
, target
, prog
);
2550 if (stage
== MESA_SHADER_VERTEX
)
2551 _mesa_update_vertex_processing_mode(ctx
);
2559 * Copy program-specific data generated by linking from the gl_shader_program
2560 * object to the gl_program object referred to by the gl_linked_shader.
2562 * This function expects _mesa_reference_program() to have been previously
2563 * called setting the gl_linked_shaders program reference.
2566 _mesa_copy_linked_program_data(const struct gl_shader_program
*src
,
2567 struct gl_linked_shader
*dst_sh
)
2569 assert(dst_sh
->Program
);
2571 struct gl_program
*dst
= dst_sh
->Program
;
2573 dst
->info
.separate_shader
= src
->SeparateShader
;
2575 switch (dst_sh
->Stage
) {
2576 case MESA_SHADER_GEOMETRY
: {
2577 dst
->info
.gs
.vertices_in
= src
->Geom
.VerticesIn
;
2578 dst
->info
.gs
.uses_end_primitive
= src
->Geom
.UsesEndPrimitive
;
2579 dst
->info
.gs
.uses_streams
= src
->Geom
.UsesStreams
;
2582 case MESA_SHADER_FRAGMENT
: {
2583 dst
->info
.fs
.depth_layout
= src
->FragDepthLayout
;
2586 case MESA_SHADER_COMPUTE
: {
2587 dst
->info
.cs
.shared_size
= src
->Comp
.SharedSize
;
2596 * ARB_separate_shader_objects: Compile & Link Program
2599 _mesa_CreateShaderProgramv(GLenum type
, GLsizei count
,
2600 const GLchar
* const *strings
)
2602 GET_CURRENT_CONTEXT(ctx
);
2604 const GLuint shader
= create_shader_err(ctx
, type
, "glCreateShaderProgramv");
2608 * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2609 * GL_INVALID_VALUE should be generated if count < 0
2612 _mesa_error(ctx
, GL_INVALID_VALUE
, "glCreateShaderProgram (count < 0)");
2617 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
2619 _mesa_ShaderSource(shader
, count
, strings
, NULL
);
2620 _mesa_compile_shader(ctx
, sh
);
2622 program
= create_shader_program(ctx
);
2624 struct gl_shader_program
*shProg
;
2625 GLint compiled
= GL_FALSE
;
2627 shProg
= _mesa_lookup_shader_program(ctx
, program
);
2629 shProg
->SeparateShader
= GL_TRUE
;
2631 get_shaderiv(ctx
, shader
, GL_COMPILE_STATUS
, &compiled
);
2633 attach_shader_err(ctx
, program
, shader
, "glCreateShaderProgramv");
2634 _mesa_link_program(ctx
, shProg
);
2635 detach_shader_error(ctx
, program
, shader
);
2639 if (active
-user
-defined
-varyings
-in
-linked
-program
) {
2640 append
-error
-to
-info
-log
;
2641 shProg
->data
->LinkStatus
= LINKING_FAILURE
;
2646 ralloc_strcat(&shProg
->data
->InfoLog
, sh
->InfoLog
);
2649 delete_shader(ctx
, shader
);
2657 * For GL_ARB_tessellation_shader
2660 _mesa_PatchParameteri_no_error(GLenum pname
, GLint value
)
2662 GET_CURRENT_CONTEXT(ctx
);
2663 FLUSH_VERTICES(ctx
, 0);
2664 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2668 extern void GLAPIENTRY
2669 _mesa_PatchParameteri(GLenum pname
, GLint value
)
2671 GET_CURRENT_CONTEXT(ctx
);
2673 if (!_mesa_has_tessellation(ctx
)) {
2674 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameteri");
2678 if (pname
!= GL_PATCH_VERTICES
) {
2679 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameteri");
2683 if (value
<= 0 || value
> ctx
->Const
.MaxPatchVertices
) {
2684 _mesa_error(ctx
, GL_INVALID_VALUE
, "glPatchParameteri");
2688 FLUSH_VERTICES(ctx
, 0);
2689 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2693 extern void GLAPIENTRY
2694 _mesa_PatchParameterfv(GLenum pname
, const GLfloat
*values
)
2696 GET_CURRENT_CONTEXT(ctx
);
2698 if (!_mesa_has_tessellation(ctx
)) {
2699 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameterfv");
2704 case GL_PATCH_DEFAULT_OUTER_LEVEL
:
2705 FLUSH_VERTICES(ctx
, 0);
2706 memcpy(ctx
->TessCtrlProgram
.patch_default_outer_level
, values
,
2707 4 * sizeof(GLfloat
));
2708 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2710 case GL_PATCH_DEFAULT_INNER_LEVEL
:
2711 FLUSH_VERTICES(ctx
, 0);
2712 memcpy(ctx
->TessCtrlProgram
.patch_default_inner_level
, values
,
2713 2 * sizeof(GLfloat
));
2714 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2717 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameterfv");
2723 * ARB_shader_subroutine
2726 _mesa_GetSubroutineUniformLocation(GLuint program
, GLenum shadertype
,
2729 GET_CURRENT_CONTEXT(ctx
);
2730 const char *api_name
= "glGetSubroutineUniformLocation";
2731 struct gl_shader_program
*shProg
;
2732 GLenum resource_type
;
2733 gl_shader_stage stage
;
2735 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2736 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2740 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2744 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2745 if (!shProg
->_LinkedShaders
[stage
]) {
2746 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2750 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2751 return _mesa_program_resource_location(shProg
, resource_type
, name
);
2755 _mesa_GetSubroutineIndex(GLuint program
, GLenum shadertype
,
2758 GET_CURRENT_CONTEXT(ctx
);
2759 const char *api_name
= "glGetSubroutineIndex";
2760 struct gl_shader_program
*shProg
;
2761 struct gl_program_resource
*res
;
2762 GLenum resource_type
;
2763 gl_shader_stage stage
;
2765 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2766 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2770 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2774 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2775 if (!shProg
->_LinkedShaders
[stage
]) {
2776 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2780 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2781 res
= _mesa_program_resource_find_name(shProg
, resource_type
, name
, NULL
);
2786 return _mesa_program_resource_index(shProg
, res
);
2791 _mesa_GetActiveSubroutineUniformiv(GLuint program
, GLenum shadertype
,
2792 GLuint index
, GLenum pname
, GLint
*values
)
2794 GET_CURRENT_CONTEXT(ctx
);
2795 const char *api_name
= "glGetActiveSubroutineUniformiv";
2796 struct gl_shader_program
*shProg
;
2797 struct gl_linked_shader
*sh
;
2798 gl_shader_stage stage
;
2799 struct gl_program_resource
*res
;
2800 const struct gl_uniform_storage
*uni
;
2801 GLenum resource_type
;
2804 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2805 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2809 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2813 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2814 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2816 sh
= shProg
->_LinkedShaders
[stage
];
2818 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2822 struct gl_program
*p
= shProg
->_LinkedShaders
[stage
]->Program
;
2823 if (index
>= p
->sh
.NumSubroutineUniforms
) {
2824 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s: invalid index greater than GL_ACTIVE_SUBROUTINE_UNIFORMS", api_name
);
2829 case GL_NUM_COMPATIBLE_SUBROUTINES
: {
2830 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2833 values
[0] = uni
->num_compatible_subroutines
;
2837 case GL_COMPATIBLE_SUBROUTINES
: {
2838 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2842 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2843 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
2844 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
2845 if (fn
->types
[j
] == uni
->type
) {
2846 values
[count
++] = i
;
2854 case GL_UNIFORM_SIZE
:
2855 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2858 values
[0] = uni
->array_elements
? uni
->array_elements
: 1;
2861 case GL_UNIFORM_NAME_LENGTH
:
2862 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2864 values
[0] = strlen(_mesa_program_resource_name(res
)) + 1
2865 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
2869 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2876 _mesa_GetActiveSubroutineUniformName(GLuint program
, GLenum shadertype
,
2877 GLuint index
, GLsizei bufsize
,
2878 GLsizei
*length
, GLchar
*name
)
2880 GET_CURRENT_CONTEXT(ctx
);
2881 const char *api_name
= "glGetActiveSubroutineUniformName";
2882 struct gl_shader_program
*shProg
;
2883 GLenum resource_type
;
2884 gl_shader_stage stage
;
2886 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2887 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2891 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2895 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2896 if (!shProg
->_LinkedShaders
[stage
]) {
2897 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2901 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2902 /* get program resource name */
2903 _mesa_get_program_resource_name(shProg
, resource_type
,
2905 length
, name
, api_name
);
2910 _mesa_GetActiveSubroutineName(GLuint program
, GLenum shadertype
,
2911 GLuint index
, GLsizei bufsize
,
2912 GLsizei
*length
, GLchar
*name
)
2914 GET_CURRENT_CONTEXT(ctx
);
2915 const char *api_name
= "glGetActiveSubroutineName";
2916 struct gl_shader_program
*shProg
;
2917 GLenum resource_type
;
2918 gl_shader_stage stage
;
2920 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2921 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2925 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2929 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2930 if (!shProg
->_LinkedShaders
[stage
]) {
2931 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2934 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2935 _mesa_get_program_resource_name(shProg
, resource_type
,
2937 length
, name
, api_name
);
2941 _mesa_UniformSubroutinesuiv(GLenum shadertype
, GLsizei count
,
2942 const GLuint
*indices
)
2944 GET_CURRENT_CONTEXT(ctx
);
2945 const char *api_name
= "glUniformSubroutinesuiv";
2946 gl_shader_stage stage
;
2949 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2950 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2954 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2955 struct gl_program
*p
= ctx
->_Shader
->CurrentProgram
[stage
];
2957 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2961 if (count
!= p
->sh
.NumSubroutineUniformRemapTable
) {
2962 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2967 bool flushed
= false;
2969 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
2976 _mesa_flush_vertices_for_uniforms(ctx
, uni
);
2980 int uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
2983 for (j
= i
; j
< i
+ uni_count
; j
++) {
2984 struct gl_subroutine_function
*subfn
= NULL
;
2985 if (indices
[j
] > p
->sh
.MaxSubroutineFunctionIndex
) {
2986 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2990 for (f
= 0; f
< p
->sh
.NumSubroutineFunctions
; f
++) {
2991 if (p
->sh
.SubroutineFunctions
[f
].index
== indices
[j
])
2992 subfn
= &p
->sh
.SubroutineFunctions
[f
];
2999 for (k
= 0; k
< subfn
->num_compat_types
; k
++) {
3000 if (subfn
->types
[k
] == uni
->type
)
3003 if (k
== subfn
->num_compat_types
) {
3004 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
3008 ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[j
] = indices
[j
];
3016 _mesa_GetUniformSubroutineuiv(GLenum shadertype
, GLint location
,
3019 GET_CURRENT_CONTEXT(ctx
);
3020 const char *api_name
= "glGetUniformSubroutineuiv";
3021 gl_shader_stage stage
;
3023 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
3024 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
3028 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
3029 struct gl_program
*p
= ctx
->_Shader
->CurrentProgram
[stage
];
3031 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
3035 if (location
>= p
->sh
.NumSubroutineUniformRemapTable
) {
3036 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
3040 *params
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[location
];
3045 _mesa_GetProgramStageiv(GLuint program
, GLenum shadertype
,
3046 GLenum pname
, GLint
*values
)
3048 GET_CURRENT_CONTEXT(ctx
);
3049 const char *api_name
= "glGetProgramStageiv";
3050 struct gl_shader_program
*shProg
;
3051 struct gl_linked_shader
*sh
;
3052 gl_shader_stage stage
;
3054 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
3055 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
3059 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
3063 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
3064 sh
= shProg
->_LinkedShaders
[stage
];
3066 /* ARB_shader_subroutine doesn't ask the program to be linked, or list any
3067 * INVALID_OPERATION in the case of not be linked.
3069 * And for some pnames, like GL_ACTIVE_SUBROUTINE_UNIFORMS, you can ask the
3070 * same info using other specs (ARB_program_interface_query), without the
3071 * need of the program to be linked, being the value for that case 0.
3073 * But at the same time, some other methods require the program to be
3074 * linked for pname related to locations, so it would be inconsistent to
3075 * not do the same here. So we are:
3076 * * Return GL_INVALID_OPERATION if not linked only for locations.
3077 * * Setting a default value of 0, to be returned if not linked.
3081 if (pname
== GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
) {
3082 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
3087 struct gl_program
*p
= sh
->Program
;
3089 case GL_ACTIVE_SUBROUTINES
:
3090 values
[0] = p
->sh
.NumSubroutineFunctions
;
3092 case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
:
3093 values
[0] = p
->sh
.NumSubroutineUniformRemapTable
;
3095 case GL_ACTIVE_SUBROUTINE_UNIFORMS
:
3096 values
[0] = p
->sh
.NumSubroutineUniforms
;
3098 case GL_ACTIVE_SUBROUTINE_MAX_LENGTH
:
3102 GLenum resource_type
;
3103 struct gl_program_resource
*res
;
3105 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
3106 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
3107 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
3109 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1;
3114 values
[0] = max_len
;
3117 case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH
:
3121 GLenum resource_type
;
3122 struct gl_program_resource
*res
;
3124 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
3125 for (i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
3126 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
3128 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1
3129 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
3135 values
[0] = max_len
;
3139 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s", api_name
);
3145 /* This is simple list entry that will be used to hold a list of string
3146 * tokens of a parsed shader include path.
3148 struct sh_incl_path_entry
3150 struct sh_incl_path_entry
*next
;
3151 struct sh_incl_path_entry
*prev
;
3156 /* Nodes of the shader include tree */
3157 struct sh_incl_path_ht_entry
3159 struct hash_table
*path
;
3160 char *shader_source
;
3163 struct shader_includes
{
3164 /* Array to hold include paths given to glCompileShaderIncludeARB() */
3165 struct sh_incl_path_entry
**include_paths
;
3166 size_t num_include_paths
;
3167 size_t relative_path_cursor
;
3169 /* Root hash table holding the shader include tree */
3170 struct hash_table
*shader_include_tree
;
3174 _mesa_init_shader_includes(struct gl_shared_state
*shared
)
3176 shared
->ShaderIncludes
= calloc(1, sizeof(struct shader_includes
));
3177 shared
->ShaderIncludes
->shader_include_tree
=
3178 _mesa_hash_table_create(NULL
, _mesa_hash_string
,
3179 _mesa_key_string_equal
);
3183 _mesa_get_shader_include_cursor(struct gl_shared_state
*shared
)
3185 return shared
->ShaderIncludes
->relative_path_cursor
;
3189 _mesa_set_shader_include_cursor(struct gl_shared_state
*shared
, size_t cursor
)
3191 shared
->ShaderIncludes
->relative_path_cursor
= cursor
;
3195 destroy_shader_include(struct hash_entry
*entry
)
3197 struct sh_incl_path_ht_entry
*sh_incl_ht_entry
=
3198 (struct sh_incl_path_ht_entry
*) entry
->data
;
3200 _mesa_hash_table_destroy(sh_incl_ht_entry
->path
, destroy_shader_include
);
3201 free(sh_incl_ht_entry
->shader_source
);
3202 free(sh_incl_ht_entry
);
3206 _mesa_destroy_shader_includes(struct gl_shared_state
*shared
)
3208 _mesa_hash_table_destroy(shared
->ShaderIncludes
->shader_include_tree
,
3209 destroy_shader_include
);
3210 free(shared
->ShaderIncludes
);
3214 valid_path_format(const char *str
, bool relative_path
)
3218 if (!str
[i
] || (!relative_path
&& str
[i
] != '/'))
3224 const char c
= str
[i
++];
3225 if (('A' <= c
&& c
<= 'Z') ||
3226 ('a' <= c
&& c
<= 'z') ||
3227 ('0' <= c
&& c
<= '9'))
3231 if (str
[i
- 2] == '/')
3237 if (strchr("^. _+*%[](){}|&~=!:;,?-", c
) == NULL
)
3241 if (str
[i
- 1] == '/')
3249 validate_and_tokenise_sh_incl(struct gl_context
*ctx
,
3251 struct sh_incl_path_entry
**path_list
,
3252 char *full_path
, bool error_check
)
3254 bool relative_path
= ctx
->Shared
->ShaderIncludes
->num_include_paths
;
3256 if (!valid_path_format(full_path
, relative_path
)) {
3258 _mesa_error(ctx
, GL_INVALID_VALUE
,
3259 "glNamedStringARB(invalid name %s)", full_path
);
3264 char *save_ptr
= NULL
;
3265 char *path_str
= strtok_r(full_path
, "/", &save_ptr
);
3267 *path_list
= rzalloc(mem_ctx
, struct sh_incl_path_entry
);
3269 make_empty_list(*path_list
);
3271 while (path_str
!= NULL
) {
3272 if (strlen(path_str
) == 0) {
3274 _mesa_error(ctx
, GL_INVALID_VALUE
,
3275 "glNamedStringARB(invalid name %s)", full_path
);
3281 if (strcmp(path_str
, ".") == 0) {
3283 } else if (strcmp(path_str
, "..") == 0) {
3284 struct sh_incl_path_entry
*last
= last_elem(*path_list
);
3285 remove_from_list(last
);
3287 struct sh_incl_path_entry
*path
=
3288 rzalloc(mem_ctx
, struct sh_incl_path_entry
);
3290 path
->path
= strdup(path_str
);
3291 insert_at_tail(*path_list
, path
);
3294 path_str
= strtok_r(NULL
, "/", &save_ptr
);
3300 static struct sh_incl_path_ht_entry
*
3301 lookup_shader_include(struct gl_context
*ctx
, char *path
,
3304 void *mem_ctx
= ralloc_context(NULL
);
3305 struct sh_incl_path_entry
*path_list
;
3307 if (!validate_and_tokenise_sh_incl(ctx
, mem_ctx
, &path_list
, path
,
3309 ralloc_free(mem_ctx
);
3313 struct sh_incl_path_ht_entry
*sh_incl_ht_entry
= NULL
;
3314 struct hash_table
*path_ht
=
3315 ctx
->Shared
->ShaderIncludes
->shader_include_tree
;
3317 size_t count
= ctx
->Shared
->ShaderIncludes
->num_include_paths
;
3318 bool relative_path
= path
[0] != '/';
3320 size_t i
= ctx
->Shared
->ShaderIncludes
->relative_path_cursor
;
3321 bool use_cursor
= ctx
->Shared
->ShaderIncludes
->relative_path_cursor
;
3324 struct sh_incl_path_entry
*entry
;
3326 if (relative_path
) {
3329 struct sh_incl_path_entry
*rel_path_list
=
3330 ctx
->Shared
->ShaderIncludes
->include_paths
[i
];
3331 foreach(entry
, rel_path_list
) {
3332 struct hash_entry
*ht_entry
=
3333 _mesa_hash_table_search(path_ht
, entry
->path
);
3336 /* Reset search path and skip to the next include path */
3337 path_ht
= ctx
->Shared
->ShaderIncludes
->shader_include_tree
;
3338 sh_incl_ht_entry
= NULL
;
3343 goto next_relative_path
;
3347 goto next_relative_path
;
3352 (struct sh_incl_path_ht_entry
*) ht_entry
->data
;
3355 path_ht
= sh_incl_ht_entry
->path
;
3360 foreach(entry
, path_list
) {
3361 struct hash_entry
*ht_entry
=
3362 _mesa_hash_table_search(path_ht
, entry
->path
);
3365 /* Reset search path and skip to the next include path */
3366 path_ht
= ctx
->Shared
->ShaderIncludes
->shader_include_tree
;
3367 sh_incl_ht_entry
= NULL
;
3379 (struct sh_incl_path_ht_entry
*) ht_entry
->data
;
3382 path_ht
= sh_incl_ht_entry
->path
;
3386 (sh_incl_ht_entry
== NULL
|| !sh_incl_ht_entry
->shader_source
))
3389 /* If we get here then we have found a matching path or exahusted our
3390 * relative search paths.
3392 ctx
->Shared
->ShaderIncludes
->relative_path_cursor
= i
;
3394 } while (i
< count
);
3396 ralloc_free(mem_ctx
);
3398 return sh_incl_ht_entry
;
3402 _mesa_lookup_shader_include(struct gl_context
*ctx
, char *path
,
3405 struct sh_incl_path_ht_entry
*shader_include
=
3406 lookup_shader_include(ctx
, path
, error_check
);
3408 return shader_include
? shader_include
->shader_source
: NULL
;
3412 copy_string(struct gl_context
*ctx
, const char *str
, int str_len
,
3416 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s(NULL string)", caller
);
3424 cp
= calloc(sizeof(char), str_len
+ 1);
3425 memcpy(cp
, str
, str_len
);
3432 _mesa_NamedStringARB(GLenum type
, GLint namelen
, const GLchar
*name
,
3433 GLint stringlen
, const GLchar
*string
)
3435 GET_CURRENT_CONTEXT(ctx
);
3436 const char *caller
= "glNamedStringARB";
3438 if (type
!= GL_SHADER_INCLUDE_ARB
) {
3439 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s(invalid type)", caller
);
3443 char *name_cp
= copy_string(ctx
, name
, namelen
, caller
);
3444 char *string_cp
= copy_string(ctx
, string
, stringlen
, caller
);
3445 if (!name_cp
|| !string_cp
) {
3451 void *mem_ctx
= ralloc_context(NULL
);
3452 struct sh_incl_path_entry
*path_list
;
3454 if (!validate_and_tokenise_sh_incl(ctx
, mem_ctx
, &path_list
, name_cp
,
3458 ralloc_free(mem_ctx
);
3462 mtx_lock(&ctx
->Shared
->ShaderIncludeMutex
);
3464 struct hash_table
*path_ht
=
3465 ctx
->Shared
->ShaderIncludes
->shader_include_tree
;
3467 struct sh_incl_path_entry
*entry
;
3468 foreach(entry
, path_list
) {
3469 struct hash_entry
*ht_entry
=
3470 _mesa_hash_table_search(path_ht
, entry
->path
);
3472 struct sh_incl_path_ht_entry
*sh_incl_ht_entry
;
3474 sh_incl_ht_entry
= calloc(1, sizeof(struct sh_incl_path_ht_entry
));
3475 sh_incl_ht_entry
->path
=
3476 _mesa_hash_table_create(NULL
, _mesa_hash_string
,
3477 _mesa_key_string_equal
);
3478 _mesa_hash_table_insert(path_ht
, entry
->path
, sh_incl_ht_entry
);
3480 sh_incl_ht_entry
= (struct sh_incl_path_ht_entry
*) ht_entry
->data
;
3483 path_ht
= sh_incl_ht_entry
->path
;
3485 if (last_elem(path_list
) == entry
) {
3486 free(sh_incl_ht_entry
->shader_source
);
3487 sh_incl_ht_entry
->shader_source
= string_cp
;
3491 mtx_unlock(&ctx
->Shared
->ShaderIncludeMutex
);
3494 ralloc_free(mem_ctx
);
3498 _mesa_DeleteNamedStringARB(GLint namelen
, const GLchar
*name
)
3500 GET_CURRENT_CONTEXT(ctx
);
3501 const char *caller
= "glDeleteNamedStringARB";
3503 char *name_cp
= copy_string(ctx
, name
, namelen
, caller
);
3507 struct sh_incl_path_ht_entry
*shader_include
=
3508 lookup_shader_include(ctx
, name_cp
, true);
3510 if (!shader_include
) {
3511 _mesa_error(ctx
, GL_INVALID_OPERATION
,
3512 "%s(no string associated with path %s)", caller
, name_cp
);
3517 mtx_lock(&ctx
->Shared
->ShaderIncludeMutex
);
3519 free(shader_include
->shader_source
);
3520 shader_include
->shader_source
= NULL
;
3522 mtx_unlock(&ctx
->Shared
->ShaderIncludeMutex
);
3528 _mesa_CompileShaderIncludeARB(GLuint shader
, GLsizei count
,
3529 const GLchar
* const *path
, const GLint
*length
)
3531 GET_CURRENT_CONTEXT(ctx
);
3532 const char *caller
= "glCompileShaderIncludeARB";
3534 if (count
> 0 && path
== NULL
) {
3535 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s(count > 0 && path == NULL)",
3540 void *mem_ctx
= ralloc_context(NULL
);
3542 mtx_lock(&ctx
->Shared
->ShaderIncludeMutex
);
3544 ctx
->Shared
->ShaderIncludes
->include_paths
=
3545 ralloc_array_size(mem_ctx
, sizeof(struct sh_incl_path_entry
*), count
);
3547 for (size_t i
= 0; i
< count
; i
++) {
3548 char *path_cp
= copy_string(ctx
, path
[i
], length
? length
[i
] : -1,
3554 struct sh_incl_path_entry
*path_list
;
3556 if (!validate_and_tokenise_sh_incl(ctx
, mem_ctx
, &path_list
, path_cp
,
3562 ctx
->Shared
->ShaderIncludes
->include_paths
[i
] = path_list
;
3567 /* We must set this *after* all calls to validate_and_tokenise_sh_incl()
3568 * are done as we use this to decide if we need to check the start of the
3571 ctx
->Shared
->ShaderIncludes
->num_include_paths
= count
;
3573 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
3575 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s(shader)", caller
);
3579 _mesa_compile_shader(ctx
, sh
);
3582 ctx
->Shared
->ShaderIncludes
->num_include_paths
= 0;
3583 ctx
->Shared
->ShaderIncludes
->relative_path_cursor
= 0;
3584 ctx
->Shared
->ShaderIncludes
->include_paths
= NULL
;
3586 mtx_unlock(&ctx
->Shared
->ShaderIncludeMutex
);
3588 ralloc_free(mem_ctx
);
3591 GLboolean GLAPIENTRY
3592 _mesa_IsNamedStringARB(GLint namelen
, const GLchar
*name
)
3594 GET_CURRENT_CONTEXT(ctx
);
3599 char *name_cp
= copy_string(ctx
, name
, namelen
, "");
3601 const char *source
= _mesa_lookup_shader_include(ctx
, name_cp
, false);
3611 _mesa_GetNamedStringARB(GLint namelen
, const GLchar
*name
, GLsizei bufSize
,
3612 GLint
*stringlen
, GLchar
*string
)
3614 GET_CURRENT_CONTEXT(ctx
);
3615 const char *caller
= "glGetNamedStringARB";
3617 char *name_cp
= copy_string(ctx
, name
, namelen
, caller
);
3621 const char *source
= _mesa_lookup_shader_include(ctx
, name_cp
, true);
3623 _mesa_error(ctx
, GL_INVALID_OPERATION
,
3624 "%s(no string associated with path %s)", caller
, name_cp
);
3629 size_t size
= MIN2(strlen(source
), bufSize
- 1);
3630 memcpy(string
, source
, size
);
3631 string
[size
] = '\0';
3639 _mesa_GetNamedStringivARB(GLint namelen
, const GLchar
*name
,
3640 GLenum pname
, GLint
*params
)
3642 GET_CURRENT_CONTEXT(ctx
);
3643 const char *caller
= "glGetNamedStringivARB";
3645 char *name_cp
= copy_string(ctx
, name
, namelen
, caller
);
3649 const char *source
= _mesa_lookup_shader_include(ctx
, name_cp
, true);
3651 _mesa_error(ctx
, GL_INVALID_OPERATION
,
3652 "%s(no string associated with path %s)", caller
, name_cp
);
3658 case GL_NAMED_STRING_LENGTH_ARB
:
3659 *params
= strlen(source
) + 1;
3661 case GL_NAMED_STRING_TYPE_ARB
:
3662 *params
= GL_SHADER_INCLUDE_ARB
;
3665 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s(pname)", caller
);
3673 find_compat_subroutine(struct gl_program
*p
, const struct glsl_type
*type
)
3677 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
3678 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
3679 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
3680 if (fn
->types
[j
] == type
)
3688 _mesa_shader_write_subroutine_index(struct gl_context
*ctx
,
3689 struct gl_program
*p
)
3693 if (p
->sh
.NumSubroutineUniformRemapTable
== 0)
3698 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
3707 uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
3708 for (j
= 0; j
< uni_count
; j
++) {
3709 val
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[i
+ j
];
3710 memcpy(&uni
->storage
[j
], &val
, sizeof(int));
3713 _mesa_propagate_uniforms_to_driver_storage(uni
, 0, uni_count
);
3715 } while(i
< p
->sh
.NumSubroutineUniformRemapTable
);
3719 _mesa_shader_write_subroutine_indices(struct gl_context
*ctx
,
3720 gl_shader_stage stage
)
3722 if (ctx
->_Shader
->CurrentProgram
[stage
])
3723 _mesa_shader_write_subroutine_index(ctx
,
3724 ctx
->_Shader
->CurrentProgram
[stage
]);
3728 _mesa_program_init_subroutine_defaults(struct gl_context
*ctx
,
3729 struct gl_program
*p
)
3733 struct gl_subroutine_index_binding
*binding
= &ctx
->SubroutineIndex
[p
->info
.stage
];
3734 if (binding
->NumIndex
!= p
->sh
.NumSubroutineUniformRemapTable
) {
3735 binding
->IndexPtr
= realloc(binding
->IndexPtr
,
3736 p
->sh
.NumSubroutineUniformRemapTable
* (sizeof(GLuint
)));
3737 binding
->NumIndex
= p
->sh
.NumSubroutineUniformRemapTable
;
3740 for (int i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
3741 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
3746 binding
->IndexPtr
[i
] = find_compat_subroutine(p
, uni
->type
);