1 /*
2  * Mesa 3-D graphics library
3  *
4  * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.
5  * Copyright (C) 2009-2010  VMware, Inc.  All Rights Reserved.
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a
8  * copy of this software and associated documentation files (the "Software"),
9  * to deal in the Software without restriction, including without limitation
10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11  * and/or sell copies of the Software, and to permit persons to whom the
12  * Software is furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included
15  * in all copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23  * OTHER DEALINGS IN THE SOFTWARE.
24  */
25 
26 /**
27  * \file shaderobj.c
28  * \author Brian Paul
29  *
30  */
31 
32 
33 #include "compiler/glsl/string_to_uint_map.h"
34 #include "main/glheader.h"
35 #include "main/context.h"
36 #include "main/glspirv.h"
37 #include "main/hash.h"
38 #include "main/mtypes.h"
39 #include "main/shaderapi.h"
40 #include "main/shaderobj.h"
41 #include "main/uniforms.h"
42 #include "program/program.h"
43 #include "program/prog_parameter.h"
44 #include "util/ralloc.h"
45 #include "util/u_atomic.h"
46 
47 /**********************************************************************/
48 /*** Shader object functions                                        ***/
49 /**********************************************************************/
50 
51 
52 /**
53  * Set ptr to point to sh.
54  * If ptr is pointing to another shader, decrement its refcount (and delete
55  * if refcount hits zero).
56  * Then set ptr to point to sh, incrementing its refcount.
57  */
58 void
_mesa_reference_shader(struct gl_context * ctx,struct gl_shader ** ptr,struct gl_shader * sh)59 _mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr,
60                        struct gl_shader *sh)
61 {
62    assert(ptr);
63    if (*ptr == sh) {
64       /* no-op */
65       return;
66    }
67    if (*ptr) {
68       /* Unreference the old shader */
69       struct gl_shader *old = *ptr;
70 
71       assert(old->RefCount > 0);
72 
73       if (p_atomic_dec_zero(&old->RefCount)) {
74 	 if (old->Name != 0)
75 	    _mesa_HashRemove(ctx->Shared->ShaderObjects, old->Name);
76          _mesa_delete_shader(ctx, old);
77       }
78 
79       *ptr = NULL;
80    }
81    assert(!*ptr);
82 
83    if (sh) {
84       /* reference new */
85       p_atomic_inc(&sh->RefCount);
86       *ptr = sh;
87    }
88 }
89 
90 static void
_mesa_init_shader(struct gl_shader * shader)91 _mesa_init_shader(struct gl_shader *shader)
92 {
93    shader->RefCount = 1;
94    shader->info.Geom.VerticesOut = -1;
95    shader->info.Geom.InputType = GL_TRIANGLES;
96    shader->info.Geom.OutputType = GL_TRIANGLE_STRIP;
97 }
98 
99 /**
100  * Allocate a new gl_shader object, initialize it.
101  */
102 struct gl_shader *
_mesa_new_shader(GLuint name,gl_shader_stage stage)103 _mesa_new_shader(GLuint name, gl_shader_stage stage)
104 {
105    struct gl_shader *shader;
106    shader = rzalloc(NULL, struct gl_shader);
107    if (shader) {
108       shader->Stage = stage;
109       shader->Name = name;
110 #ifdef DEBUG
111       shader->SourceChecksum = 0xa110c; /* alloc */
112 #endif
113       _mesa_init_shader(shader);
114    }
115    return shader;
116 }
117 
118 
119 /**
120  * Delete a shader object.
121  */
122 void
_mesa_delete_shader(struct gl_context * ctx,struct gl_shader * sh)123 _mesa_delete_shader(struct gl_context *ctx, struct gl_shader *sh)
124 {
125    _mesa_shader_spirv_data_reference(&sh->spirv_data, NULL);
126    free((void *)sh->Source);
127    free((void *)sh->FallbackSource);
128    free(sh->Label);
129    ralloc_free(sh);
130 }
131 
132 
133 /**
134  * Delete a shader object.
135  */
136 void
_mesa_delete_linked_shader(struct gl_context * ctx,struct gl_linked_shader * sh)137 _mesa_delete_linked_shader(struct gl_context *ctx,
138                            struct gl_linked_shader *sh)
139 {
140    _mesa_shader_spirv_data_reference(&sh->spirv_data, NULL);
141    _mesa_reference_program(ctx, &sh->Program, NULL);
142    ralloc_free(sh);
143 }
144 
145 
146 /**
147  * Lookup a GLSL shader object.
148  */
149 struct gl_shader *
_mesa_lookup_shader(struct gl_context * ctx,GLuint name)150 _mesa_lookup_shader(struct gl_context *ctx, GLuint name)
151 {
152    if (name) {
153       struct gl_shader *sh = (struct gl_shader *)
154          _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
155       /* Note that both gl_shader and gl_shader_program objects are kept
156        * in the same hash table.  Check the object's type to be sure it's
157        * what we're expecting.
158        */
159       if (sh && sh->Type == GL_SHADER_PROGRAM_MESA) {
160          return NULL;
161       }
162       return sh;
163    }
164    return NULL;
165 }
166 
167 
168 /**
169  * As above, but record an error if shader is not found.
170  */
171 struct gl_shader *
_mesa_lookup_shader_err(struct gl_context * ctx,GLuint name,const char * caller)172 _mesa_lookup_shader_err(struct gl_context *ctx, GLuint name, const char *caller)
173 {
174    if (!name) {
175       _mesa_error(ctx, GL_INVALID_VALUE, "%s", caller);
176       return NULL;
177    }
178    else {
179       struct gl_shader *sh = (struct gl_shader *)
180          _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
181       if (!sh) {
182          _mesa_error(ctx, GL_INVALID_VALUE, "%s", caller);
183          return NULL;
184       }
185       if (sh->Type == GL_SHADER_PROGRAM_MESA) {
186          _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
187          return NULL;
188       }
189       return sh;
190    }
191 }
192 
193 
194 
195 /**********************************************************************/
196 /*** Shader Program object functions                                ***/
197 /**********************************************************************/
198 
199 void
_mesa_reference_shader_program_data(struct gl_context * ctx,struct gl_shader_program_data ** ptr,struct gl_shader_program_data * data)200 _mesa_reference_shader_program_data(struct gl_context *ctx,
201                                     struct gl_shader_program_data **ptr,
202                                     struct gl_shader_program_data *data)
203 {
204    if (*ptr == data)
205       return;
206 
207    if (*ptr) {
208       struct gl_shader_program_data *oldData = *ptr;
209 
210       assert(oldData->RefCount > 0);
211 
212       if (p_atomic_dec_zero(&oldData->RefCount)) {
213          assert(ctx);
214          assert(oldData->NumUniformStorage == 0 ||
215                 oldData->UniformStorage);
216 
217          for (unsigned i = 0; i < oldData->NumUniformStorage; ++i)
218             _mesa_uniform_detach_all_driver_storage(&oldData->UniformStorage[i]);
219 
220          ralloc_free(oldData);
221       }
222 
223       *ptr = NULL;
224    }
225 
226    if (data)
227       p_atomic_inc(&data->RefCount);
228 
229    *ptr = data;
230 }
231 
232 /**
233  * Set ptr to point to shProg.
234  * If ptr is pointing to another object, decrement its refcount (and delete
235  * if refcount hits zero).
236  * Then set ptr to point to shProg, incrementing its refcount.
237  */
238 void
_mesa_reference_shader_program_(struct gl_context * ctx,struct gl_shader_program ** ptr,struct gl_shader_program * shProg)239 _mesa_reference_shader_program_(struct gl_context *ctx,
240                                 struct gl_shader_program **ptr,
241                                 struct gl_shader_program *shProg)
242 {
243    assert(ptr);
244    if (*ptr == shProg) {
245       /* no-op */
246       return;
247    }
248    if (*ptr) {
249       /* Unreference the old shader program */
250       struct gl_shader_program *old = *ptr;
251 
252       assert(old->RefCount > 0);
253 
254       if (p_atomic_dec_zero(&old->RefCount)) {
255 	 if (old->Name != 0)
256 	    _mesa_HashRemove(ctx->Shared->ShaderObjects, old->Name);
257          _mesa_delete_shader_program(ctx, old);
258       }
259 
260       *ptr = NULL;
261    }
262    assert(!*ptr);
263 
264    if (shProg) {
265       p_atomic_inc(&shProg->RefCount);
266       *ptr = shProg;
267    }
268 }
269 
270 struct gl_shader_program_data *
_mesa_create_shader_program_data()271 _mesa_create_shader_program_data()
272 {
273    struct gl_shader_program_data *data;
274    data = rzalloc(NULL, struct gl_shader_program_data);
275    if (data) {
276       data->RefCount = 1;
277       data->InfoLog = ralloc_strdup(data, "");
278    }
279 
280    return data;
281 }
282 
283 static void
init_shader_program(struct gl_shader_program * prog)284 init_shader_program(struct gl_shader_program *prog)
285 {
286    prog->Type = GL_SHADER_PROGRAM_MESA;
287    prog->RefCount = 1;
288 
289    prog->AttributeBindings = string_to_uint_map_ctor();
290    prog->FragDataBindings = string_to_uint_map_ctor();
291    prog->FragDataIndexBindings = string_to_uint_map_ctor();
292 
293    prog->Geom.UsesEndPrimitive = false;
294    prog->Geom.ActiveStreamMask = 0;
295 
296    prog->TransformFeedback.BufferMode = GL_INTERLEAVED_ATTRIBS;
297 
298    exec_list_make_empty(&prog->EmptyUniformLocations);
299 }
300 
301 /**
302  * Allocate a new gl_shader_program object, initialize it.
303  */
304 struct gl_shader_program *
_mesa_new_shader_program(GLuint name)305 _mesa_new_shader_program(GLuint name)
306 {
307    struct gl_shader_program *shProg;
308    shProg = rzalloc(NULL, struct gl_shader_program);
309    if (shProg) {
310       shProg->Name = name;
311       shProg->data = _mesa_create_shader_program_data();
312       if (!shProg->data) {
313          ralloc_free(shProg);
314          return NULL;
315       }
316       init_shader_program(shProg);
317    }
318    return shProg;
319 }
320 
321 
322 /**
323  * Clear (free) the shader program state that gets produced by linking.
324  */
325 void
_mesa_clear_shader_program_data(struct gl_context * ctx,struct gl_shader_program * shProg)326 _mesa_clear_shader_program_data(struct gl_context *ctx,
327                                 struct gl_shader_program *shProg)
328 {
329    for (gl_shader_stage sh = 0; sh < MESA_SHADER_STAGES; sh++) {
330       if (shProg->_LinkedShaders[sh] != NULL) {
331          _mesa_delete_linked_shader(ctx, shProg->_LinkedShaders[sh]);
332          shProg->_LinkedShaders[sh] = NULL;
333       }
334    }
335 
336    if (shProg->UniformRemapTable) {
337       ralloc_free(shProg->UniformRemapTable);
338       shProg->NumUniformRemapTable = 0;
339       shProg->UniformRemapTable = NULL;
340    }
341 
342    if (shProg->UniformHash) {
343       string_to_uint_map_dtor(shProg->UniformHash);
344       shProg->UniformHash = NULL;
345    }
346 
347    if (shProg->data && shProg->data->ProgramResourceHash) {
348       _mesa_hash_table_u64_destroy(shProg->data->ProgramResourceHash, NULL);
349       shProg->data->ProgramResourceHash = NULL;
350    }
351 
352    _mesa_reference_shader_program_data(ctx, &shProg->data, NULL);
353 }
354 
355 
356 /**
357  * Free all the data that hangs off a shader program object, but not the
358  * object itself.
359  */
360 void
_mesa_free_shader_program_data(struct gl_context * ctx,struct gl_shader_program * shProg)361 _mesa_free_shader_program_data(struct gl_context *ctx,
362                                struct gl_shader_program *shProg)
363 {
364    GLuint i;
365 
366    assert(shProg->Type == GL_SHADER_PROGRAM_MESA);
367 
368    _mesa_clear_shader_program_data(ctx, shProg);
369 
370    if (shProg->AttributeBindings) {
371       string_to_uint_map_dtor(shProg->AttributeBindings);
372       shProg->AttributeBindings = NULL;
373    }
374 
375    if (shProg->FragDataBindings) {
376       string_to_uint_map_dtor(shProg->FragDataBindings);
377       shProg->FragDataBindings = NULL;
378    }
379 
380    if (shProg->FragDataIndexBindings) {
381       string_to_uint_map_dtor(shProg->FragDataIndexBindings);
382       shProg->FragDataIndexBindings = NULL;
383    }
384 
385    /* detach shaders */
386    for (i = 0; i < shProg->NumShaders; i++) {
387       _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
388    }
389    shProg->NumShaders = 0;
390 
391    free(shProg->Shaders);
392    shProg->Shaders = NULL;
393 
394    /* Transform feedback varying vars */
395    for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {
396       free(shProg->TransformFeedback.VaryingNames[i]);
397    }
398    free(shProg->TransformFeedback.VaryingNames);
399    shProg->TransformFeedback.VaryingNames = NULL;
400    shProg->TransformFeedback.NumVarying = 0;
401 
402    free(shProg->Label);
403    shProg->Label = NULL;
404 }
405 
406 
407 /**
408  * Free/delete a shader program object.
409  */
410 void
_mesa_delete_shader_program(struct gl_context * ctx,struct gl_shader_program * shProg)411 _mesa_delete_shader_program(struct gl_context *ctx,
412                             struct gl_shader_program *shProg)
413 {
414    _mesa_free_shader_program_data(ctx, shProg);
415    ralloc_free(shProg);
416 }
417 
418 
419 /**
420  * Lookup a GLSL program object.
421  */
422 struct gl_shader_program *
_mesa_lookup_shader_program(struct gl_context * ctx,GLuint name)423 _mesa_lookup_shader_program(struct gl_context *ctx, GLuint name)
424 {
425    struct gl_shader_program *shProg;
426    if (name) {
427       shProg = (struct gl_shader_program *)
428          _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
429       /* Note that both gl_shader and gl_shader_program objects are kept
430        * in the same hash table.  Check the object's type to be sure it's
431        * what we're expecting.
432        */
433       if (shProg && shProg->Type != GL_SHADER_PROGRAM_MESA) {
434          return NULL;
435       }
436       return shProg;
437    }
438    return NULL;
439 }
440 
441 
442 /**
443  * As above, but record an error if program is not found.
444  */
445 struct gl_shader_program *
_mesa_lookup_shader_program_err(struct gl_context * ctx,GLuint name,const char * caller)446 _mesa_lookup_shader_program_err(struct gl_context *ctx, GLuint name,
447                                 const char *caller)
448 {
449    if (!name) {
450       _mesa_error(ctx, GL_INVALID_VALUE, "%s", caller);
451       return NULL;
452    }
453    else {
454       struct gl_shader_program *shProg = (struct gl_shader_program *)
455          _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
456       if (!shProg) {
457          _mesa_error(ctx, GL_INVALID_VALUE, "%s", caller);
458          return NULL;
459       }
460       if (shProg->Type != GL_SHADER_PROGRAM_MESA) {
461          _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
462          return NULL;
463       }
464       return shProg;
465    }
466 }
467 
468 
469 void
_mesa_init_shader_object_functions(struct dd_function_table * driver)470 _mesa_init_shader_object_functions(struct dd_function_table *driver)
471 {
472    driver->LinkShader = _mesa_ir_link_shader;
473 }
474