← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/compiler/glsl/standalone_scaffolding.cpp

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/compiler/glsl/standalone_scaffolding.cpp
1
 
/*
2
 
 * Copyright © 2011 Intel Corporation
3
 
 *
4
 
 * Permission is hereby granted, free of charge, to any person obtaining a
5
 
 * copy of this software and associated documentation files (the "Software"),
6
 
 * to deal in the Software without restriction, including without limitation
7
 
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8
 
 * and/or sell copies of the Software, and to permit persons to whom the
9
 
 * Software is furnished to do so, subject to the following conditions:
10
 
 *
11
 
 * The above copyright notice and this permission notice (including the next
12
 
 * paragraph) shall be included in all copies or substantial portions of the
13
 
 * Software.
14
 
 *
15
 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18
 
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20
 
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21
 
 * DEALINGS IN THE SOFTWARE.
22
 
 */
23
 
 
24
 
/* This file declares stripped-down versions of functions that
25
 
 * normally exist outside of the glsl folder, so that they can be used
26
 
 * when running the GLSL compiler standalone (for unit testing or
27
 
 * compiling builtins).
28
 
 */
29
 
 
30
 
#include "standalone_scaffolding.h"
31
 
 
32
 
#include <assert.h>
33
 
#include <stdio.h>
34
 
#include <string.h>
35
 
#include "util/ralloc.h"
36
 
#include "util/strtod.h"
37
 
#include "main/mtypes.h"
38
 
 
39
 
void
40
 
_mesa_warning(struct gl_context *ctx, const char *fmt, ...)
41
 
{
42
 
    va_list vargs;
43
 
    (void) ctx;
44
 
 
45
 
    va_start(vargs, fmt);
46
 
 
47
 
    /* This output is not thread-safe, but that's good enough for the
48
 
     * standalone compiler.
49
 
     */
50
 
    fprintf(stderr, "Mesa warning: ");
51
 
    vfprintf(stderr, fmt, vargs);
52
 
    fprintf(stderr, "\n");
53
 
 
54
 
    va_end(vargs);
55
 
}
56
 
 
57
 
void
58
 
_mesa_problem(struct gl_context *ctx, const char *fmt, ...)
59
 
{
60
 
    va_list vargs;
61
 
    (void) ctx;
62
 
 
63
 
    va_start(vargs, fmt);
64
 
 
65
 
    /* This output is not thread-safe, but that's good enough for the
66
 
     * standalone compiler.
67
 
     */
68
 
    fprintf(stderr, "Mesa problem: ");
69
 
    vfprintf(stderr, fmt, vargs);
70
 
    fprintf(stderr, "\n");
71
 
 
72
 
    va_end(vargs);
73
 
}
74
 
 
75
 
void
76
 
_mesa_reference_shader_program_data(struct gl_context *ctx,
77
 
                                    struct gl_shader_program_data **ptr,
78
 
                                    struct gl_shader_program_data *data)
79
 
{
80
 
   (void) ctx;
81
 
   *ptr = data;
82
 
}
83
 
 
84
 
void
85
 
_mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr,
86
 
                       struct gl_shader *sh)
87
 
{
88
 
   (void) ctx;
89
 
   *ptr = sh;
90
 
}
91
 
 
92
 
void
93
 
_mesa_reference_program_(struct gl_context *ctx, struct gl_program **ptr,
94
 
                         struct gl_program *prog)
95
 
{
96
 
   (void) ctx;
97
 
   *ptr = prog;
98
 
}
99
 
 
100
 
void
101
 
_mesa_shader_debug(struct gl_context *, GLenum, GLuint *,
102
 
                   const char *)
103
 
{
104
 
}
105
 
 
106
 
struct gl_shader *
107
 
_mesa_new_shader(GLuint name, gl_shader_stage stage)
108
 
{
109
 
   struct gl_shader *shader;
110
 
 
111
 
   assert(stage == MESA_SHADER_FRAGMENT || stage == MESA_SHADER_VERTEX);
112
 
   shader = rzalloc(NULL, struct gl_shader);
113
 
   if (shader) {
114
 
      shader->Stage = stage;
115
 
      shader->Name = name;
116
 
      shader->RefCount = 1;
117
 
   }
118
 
   return shader;
119
 
}
120
 
 
121
 
GLbitfield
122
 
_mesa_program_state_flags(UNUSED const gl_state_index16 state[STATE_LENGTH])
123
 
{
124
 
   return 0;
125
 
}
126
 
 
127
 
char *
128
 
_mesa_program_state_string(UNUSED const gl_state_index16 state[STATE_LENGTH])
129
 
{
130
 
   return NULL;
131
 
}
132
 
 
133
 
void
134
 
_mesa_delete_shader(struct gl_context *, struct gl_shader *sh)
135
 
{
136
 
   free((void *)sh->Source);
137
 
   free(sh->Label);
138
 
   ralloc_free(sh);
139
 
}
140
 
 
141
 
void
142
 
_mesa_delete_linked_shader(struct gl_context *,
143
 
                           struct gl_linked_shader *sh)
144
 
{
145
 
   ralloc_free(sh->Program);
146
 
   ralloc_free(sh);
147
 
}
148
 
 
149
 
void
150
 
_mesa_clear_shader_program_data(struct gl_context *ctx,
151
 
                                struct gl_shader_program *shProg)
152
 
{
153
 
   for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
154
 
      if (shProg->_LinkedShaders[i] != NULL) {
155
 
         _mesa_delete_linked_shader(ctx, shProg->_LinkedShaders[i]);
156
 
         shProg->_LinkedShaders[i] = NULL;
157
 
      }
158
 
   }
159
 
 
160
 
   shProg->data->NumUniformStorage = 0;
161
 
   shProg->data->UniformStorage = NULL;
162
 
   shProg->NumUniformRemapTable = 0;
163
 
   shProg->UniformRemapTable = NULL;
164
 
   shProg->UniformHash = NULL;
165
 
 
166
 
   ralloc_free(shProg->data->InfoLog);
167
 
   shProg->data->InfoLog = ralloc_strdup(shProg->data, "");
168
 
 
169
 
   ralloc_free(shProg->data->UniformBlocks);
170
 
   shProg->data->UniformBlocks = NULL;
171
 
   shProg->data->NumUniformBlocks = 0;
172
 
 
173
 
   ralloc_free(shProg->data->ShaderStorageBlocks);
174
 
   shProg->data->ShaderStorageBlocks = NULL;
175
 
   shProg->data->NumShaderStorageBlocks = 0;
176
 
 
177
 
   ralloc_free(shProg->data->AtomicBuffers);
178
 
   shProg->data->AtomicBuffers = NULL;
179
 
   shProg->data->NumAtomicBuffers = 0;
180
 
}
181
 
 
182
 
void initialize_context_to_defaults(struct gl_context *ctx, gl_api api)
183
 
{
184
 
   memset(ctx, 0, sizeof(*ctx));
185
 
 
186
 
   ctx->API = api;
187
 
 
188
 
   ctx->Extensions.dummy_true = true;
189
 
   ctx->Extensions.ARB_compute_shader = true;
190
 
   ctx->Extensions.ARB_compute_variable_group_size = true;
191
 
   ctx->Extensions.ARB_conservative_depth = true;
192
 
   ctx->Extensions.ARB_draw_instanced = true;
193
 
   ctx->Extensions.ARB_ES2_compatibility = true;
194
 
   ctx->Extensions.ARB_ES3_compatibility = true;
195
 
   ctx->Extensions.ARB_explicit_attrib_location = true;
196
 
   ctx->Extensions.ARB_fragment_coord_conventions = true;
197
 
   ctx->Extensions.ARB_fragment_layer_viewport = true;
198
 
   ctx->Extensions.ARB_gpu_shader5 = true;
199
 
   ctx->Extensions.ARB_gpu_shader_fp64 = true;
200
 
   ctx->Extensions.ARB_gpu_shader_int64 = true;
201
 
   ctx->Extensions.ARB_sample_shading = true;
202
 
   ctx->Extensions.ARB_shader_bit_encoding = true;
203
 
   ctx->Extensions.ARB_shader_draw_parameters = true;
204
 
   ctx->Extensions.ARB_shader_stencil_export = true;
205
 
   ctx->Extensions.ARB_shader_texture_lod = true;
206
 
   ctx->Extensions.ARB_shading_language_420pack = true;
207
 
   ctx->Extensions.ARB_shading_language_packing = true;
208
 
   ctx->Extensions.ARB_tessellation_shader = true;
209
 
   ctx->Extensions.ARB_texture_cube_map_array = true;
210
 
   ctx->Extensions.ARB_texture_gather = true;
211
 
   ctx->Extensions.ARB_texture_multisample = true;
212
 
   ctx->Extensions.ARB_texture_query_levels = true;
213
 
   ctx->Extensions.ARB_texture_query_lod = true;
214
 
   ctx->Extensions.ARB_uniform_buffer_object = true;
215
 
   ctx->Extensions.ARB_viewport_array = true;
216
 
   ctx->Extensions.ARB_cull_distance = true;
217
 
   ctx->Extensions.ARB_bindless_texture = true;
218
 
 
219
 
   ctx->Extensions.OES_EGL_image_external = true;
220
 
   ctx->Extensions.OES_standard_derivatives = true;
221
 
 
222
 
   ctx->Extensions.EXT_gpu_shader4 = true;
223
 
   ctx->Extensions.EXT_shader_integer_mix = true;
224
 
   ctx->Extensions.EXT_texture_array = true;
225
 
 
226
 
   ctx->Extensions.MESA_shader_integer_functions = true;
227
 
 
228
 
   ctx->Extensions.NV_texture_rectangle = true;
229
 
 
230
 
   ctx->Const.GLSLVersion = 120;
231
 
 
232
 
   /* 1.20 minimums. */
233
 
   ctx->Const.MaxLights = 8;
234
 
   ctx->Const.MaxClipPlanes = 6;
235
 
   ctx->Const.MaxTextureUnits = 2;
236
 
   ctx->Const.MaxTextureCoordUnits = 2;
237
 
   ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 16;
238
 
 
239
 
   ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 512;
240
 
   ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 32;
241
 
   ctx->Const.MaxVarying = 8; /* == gl_MaxVaryingFloats / 4 */
242
 
   ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 0;
243
 
   ctx->Const.MaxCombinedTextureImageUnits = 2;
244
 
   ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = 2;
245
 
   ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 64;
246
 
   ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents = 32;
247
 
 
248
 
   ctx->Const.MaxDrawBuffers = 1;
249
 
   ctx->Const.MaxComputeWorkGroupCount[0] = 65535;
250
 
   ctx->Const.MaxComputeWorkGroupCount[1] = 65535;
251
 
   ctx->Const.MaxComputeWorkGroupCount[2] = 65535;
252
 
   ctx->Const.MaxComputeWorkGroupSize[0] = 1024;
253
 
   ctx->Const.MaxComputeWorkGroupSize[1] = 1024;
254
 
   ctx->Const.MaxComputeWorkGroupSize[2] = 64;
255
 
   ctx->Const.MaxComputeWorkGroupInvocations = 1024;
256
 
   ctx->Const.MaxComputeVariableGroupSize[0] = 512;
257
 
   ctx->Const.MaxComputeVariableGroupSize[1] = 512;
258
 
   ctx->Const.MaxComputeVariableGroupSize[2] = 64;
259
 
   ctx->Const.MaxComputeVariableGroupInvocations = 512;
260
 
   ctx->Const.Program[MESA_SHADER_COMPUTE].MaxTextureImageUnits = 16;
261
 
   ctx->Const.Program[MESA_SHADER_COMPUTE].MaxUniformComponents = 1024;
262
 
   ctx->Const.Program[MESA_SHADER_COMPUTE].MaxInputComponents = 0; /* not used */
263
 
   ctx->Const.Program[MESA_SHADER_COMPUTE].MaxOutputComponents = 0; /* not used */
264
 
 
265
 
   /* Set up default shader compiler options. */
266
 
   struct gl_shader_compiler_options options;
267
 
   memset(&options, 0, sizeof(options));
268
 
   options.MaxUnrollIterations = 32;
269
 
   options.MaxIfDepth = UINT_MAX;
270
 
 
271
 
   for (int sh = 0; sh < MESA_SHADER_STAGES; ++sh)
272
 
      memcpy(&ctx->Const.ShaderCompilerOptions[sh], &options, sizeof(options));
273
 
 
274
 
   _mesa_locale_init();
275
 
}