src/mesa/main/glspirv.c

   1 /*
   2  * Copyright 2017 Advanced Micro Devices, Inc.
   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  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the 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 NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include "glspirv.h"
  25 #include "errors.h"
  26 #include "shaderobj.h"
  27 #include "mtypes.h"
  28
  29 #include "compiler/nir/nir.h"
  30 #include "compiler/spirv/nir_spirv.h"
  31
  32 #include "program/program.h"
  33
  34 #include "util/u_atomic.h"
  35
  36 void
  37 _mesa_spirv_module_reference(struct gl_spirv_module **dest,
  38                              struct gl_spirv_module *src)
  39 {
  40    struct gl_spirv_module *old = *dest;
  41
  42    if (old && p_atomic_dec_zero(&old->RefCount))
  43       free(old);
  44
  45    *dest = src;
  46
  47    if (src)
  48       p_atomic_inc(&src->RefCount);
  49 }
  50
  51 void
  52 _mesa_shader_spirv_data_reference(struct gl_shader_spirv_data **dest,
  53                                   struct gl_shader_spirv_data *src)
  54 {
  55    struct gl_shader_spirv_data *old = *dest;
  56
  57    if (old && p_atomic_dec_zero(&old->RefCount)) {
  58       _mesa_spirv_module_reference(&(*dest)->SpirVModule, NULL);
  59       ralloc_free(old);
  60    }
  61
  62    *dest = src;
  63
  64    if (src)
  65       p_atomic_inc(&src->RefCount);
  66 }
  67
  68 void
  69 _mesa_spirv_shader_binary(struct gl_context *ctx,
  70                           unsigned n, struct gl_shader **shaders,
  71                           const void* binary, size_t length)
  72 {
  73    struct gl_spirv_module *module;
  74    struct gl_shader_spirv_data *spirv_data;
  75
  76    assert(length >= 0);
  77
  78    module = malloc(sizeof(*module) + length);
  79    if (!module) {
  80       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderBinary");
  81       return;
  82    }
  83
  84    p_atomic_set(&module->RefCount, 0);
  85    module->Length = length;
  86    memcpy(&module->Binary[0], binary, length);
  87
  88    for (int i = 0; i < n; ++i) {
  89       struct gl_shader *sh = shaders[i];
  90
  91       spirv_data = rzalloc(NULL, struct gl_shader_spirv_data);
  92       _mesa_shader_spirv_data_reference(&sh->spirv_data, spirv_data);
  93       _mesa_spirv_module_reference(&spirv_data->SpirVModule, module);
  94
  95       sh->CompileStatus = COMPILE_FAILURE;
  96
  97       free((void *)sh->Source);
  98       sh->Source = NULL;
  99       free((void *)sh->FallbackSource);
 100       sh->FallbackSource = NULL;
 101
 102       ralloc_free(sh->ir);
 103       sh->ir = NULL;
 104       ralloc_free(sh->symbols);
 105       sh->symbols = NULL;
 106    }
 107 }
 108
 109 /**
 110  * This is the equivalent to compiler/glsl/linker.cpp::link_shaders()
 111  * but for SPIR-V programs.
 112  *
 113  * This method just creates the gl_linked_shader structs with a reference to
 114  * the SPIR-V data collected during previous steps.
 115  *
 116  * The real linking happens later in the driver-specifc call LinkShader().
 117  * This is so backends can implement different linking strategies for
 118  * SPIR-V programs.
 119  */
 120 void
 121 _mesa_spirv_link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
 122 {
 123    prog->data->LinkStatus = LINKING_SUCCESS;
 124    prog->data->Validated = false;
 125
 126    for (unsigned i = 0; i < prog->NumShaders; i++) {
 127       struct gl_shader *shader = prog->Shaders[i];
 128       gl_shader_stage shader_type = shader->Stage;
 129
 130       /* We only support one shader per stage. The gl_spirv spec doesn't seem
 131        * to prevent this, but the way the API is designed, requiring all shaders
 132        * to be specialized with an entry point, makes supporting this quite
 133        * undefined.
 134        *
 135        * TODO: Turn this into a proper error once the spec bug
 136        * <https://gitlab.khronos.org/opengl/API/issues/58> is resolved.
 137        */
 138       if (prog->_LinkedShaders[shader_type]) {
 139          ralloc_strcat(&prog->data->InfoLog,
 140                        "\nError trying to link more than one SPIR-V shader "
 141                        "per stage.\n");
 142          prog->data->LinkStatus = LINKING_FAILURE;
 143          return;
 144       }
 145
 146       assert(shader->spirv_data);
 147
 148       struct gl_linked_shader *linked = rzalloc(NULL, struct gl_linked_shader);
 149       linked->Stage = shader_type;
 150
 151       /* Create program and attach it to the linked shader */
 152       struct gl_program *gl_prog =
 153          ctx->Driver.NewProgram(ctx,
 154                                 _mesa_shader_stage_to_program(shader_type),
 155                                 prog->Name, false);
 156       if (!gl_prog) {
 157          prog->data->LinkStatus = LINKING_FAILURE;
 158          _mesa_delete_linked_shader(ctx, linked);
 159          return;
 160       }
 161
 162       _mesa_reference_shader_program_data(ctx,
 163                                           &gl_prog->sh.data,
 164                                           prog->data);
 165
 166       /* Don't use _mesa_reference_program() just take ownership */
 167       linked->Program = gl_prog;
 168
 169       /* Reference the SPIR-V data from shader to the linked shader */
 170       _mesa_shader_spirv_data_reference(&linked->spirv_data,
 171                                         shader->spirv_data);
 172
 173       prog->_LinkedShaders[shader_type] = linked;
 174       prog->data->linked_stages |= 1 << shader_type;
 175    }
 176 }
 177
 178 nir_shader *
 179 _mesa_spirv_to_nir(struct gl_context *ctx,
 180                    const struct gl_shader_program *prog,
 181                    gl_shader_stage stage,
 182                    const nir_shader_compiler_options *options)
 183 {
 184    nir_shader *nir = NULL;
 185
 186    struct gl_linked_shader *linked_shader = prog->_LinkedShaders[stage];
 187    assert (linked_shader);
 188
 189    struct gl_shader_spirv_data *spirv_data = linked_shader->spirv_data;
 190    assert(spirv_data);
 191
 192    struct gl_spirv_module *spirv_module = spirv_data->SpirVModule;
 193    assert (spirv_module != NULL);
 194
 195    const char *entry_point_name = spirv_data->SpirVEntryPoint;
 196    assert(entry_point_name);
 197
 198    struct nir_spirv_specialization *spec_entries =
 199       calloc(sizeof(*spec_entries),
 200              spirv_data->NumSpecializationConstants);
 201
 202    for (unsigned i = 0; i < spirv_data->NumSpecializationConstants; ++i) {
 203       spec_entries[i].id = spirv_data->SpecializationConstantsIndex[i];
 204       spec_entries[i].data32 = spirv_data->SpecializationConstantsValue[i];
 205       spec_entries[i].defined_on_module = false;
 206    }
 207
 208    const struct spirv_to_nir_options spirv_options = {
 209       .caps = ctx->Const.SpirVCapabilities
 210    };
 211
 212    nir_function *entry_point =
 213       spirv_to_nir((const uint32_t *) &spirv_module->Binary[0],
 214                    spirv_module->Length / 4,
 215                    spec_entries, spirv_data->NumSpecializationConstants,
 216                    stage, entry_point_name,
 217                    &spirv_options,
 218                    options);
 219    free(spec_entries);
 220
 221    assert (entry_point);
 222    nir = entry_point->shader;
 223    assert(nir->info.stage == stage);
 224
 225    nir->options = options;
 226
 227    nir->info.name =
 228       ralloc_asprintf(nir, "SPIRV:%s:%d",
 229                       _mesa_shader_stage_to_abbrev(nir->info.stage),
 230                       prog->Name);
 231    nir_validate_shader(nir);
 232
 233    return nir;
 234 }
 235
 236 void GLAPIENTRY
 237 _mesa_SpecializeShaderARB(GLuint shader,
 238                           const GLchar *pEntryPoint,
 239                           GLuint numSpecializationConstants,
 240                           const GLuint *pConstantIndex,
 241                           const GLuint *pConstantValue)
 242 {
 243    GET_CURRENT_CONTEXT(ctx);
 244    struct gl_shader *sh;
 245    bool has_entry_point;
 246    struct nir_spirv_specialization *spec_entries = NULL;
 247
 248    if (!ctx->Extensions.ARB_gl_spirv) {
 249       _mesa_error(ctx, GL_INVALID_OPERATION, "glSpecializeShaderARB");
 250       return;
 251    }
 252
 253    sh = _mesa_lookup_shader_err(ctx, shader, "glSpecializeShaderARB");
 254    if (!sh)
 255       return;
 256
 257    if (!sh->spirv_data) {
 258       _mesa_error(ctx, GL_INVALID_OPERATION,
 259                   "glSpecializeShaderARB(not SPIR-V)");
 260       return;
 261    }
 262
 263    if (sh->CompileStatus) {
 264       _mesa_error(ctx, GL_INVALID_OPERATION,
 265                   "glSpecializeShaderARB(already specialized)");
 266       return;
 267    }
 268
 269    struct gl_shader_spirv_data *spirv_data = sh->spirv_data;
 270
 271    /* From the GL_ARB_gl_spirv spec:
 272     *
 273     *    "The OpenGL API expects the SPIR-V module to have already been
 274     *     validated, and can return an error if it discovers anything invalid
 275     *     in the module. An invalid SPIR-V module is allowed to result in
 276     *     undefined behavior."
 277     *
 278     * However, the following errors still need to be detected (from the same
 279     * spec):
 280     *
 281     *    "INVALID_VALUE is generated if <pEntryPoint> does not name a valid
 282     *     entry point for <shader>.
 283     *
 284     *     INVALID_VALUE is generated if any element of <pConstantIndex>
 285     *     refers to a specialization constant that does not exist in the
 286     *     shader module contained in <shader>."
 287     *
 288     * We cannot flag those errors a-priori because detecting them requires
 289     * parsing the module. However, flagging them during specialization is okay,
 290     * since it makes no difference in terms of application-visible state.
 291     */
 292    spec_entries = calloc(sizeof(*spec_entries), numSpecializationConstants);
 293
 294    for (unsigned i = 0; i < numSpecializationConstants; ++i) {
 295       spec_entries[i].id = pConstantIndex[i];
 296       spec_entries[i].data32 = pConstantValue[i];
 297       spec_entries[i].defined_on_module = false;
 298    }
 299
 300    has_entry_point =
 301       gl_spirv_validation((uint32_t *)&spirv_data->SpirVModule->Binary[0],
 302                           spirv_data->SpirVModule->Length / 4,
 303                           spec_entries, numSpecializationConstants,
 304                           sh->Stage, pEntryPoint);
 305
 306    /* See previous spec comment */
 307    if (!has_entry_point) {
 308       _mesa_error(ctx, GL_INVALID_VALUE,
 309                   "glSpecializeShaderARB(\"%s\" is not a valid entry point"
 310                   " for shader)", pEntryPoint);
 311       goto end;
 312    }
 313
 314    for (unsigned i = 0; i < numSpecializationConstants; ++i) {
 315       if (spec_entries[i].defined_on_module == false) {
 316          _mesa_error(ctx, GL_INVALID_VALUE,
 317                      "glSpecializeShaderARB(constant \"%i\" does not exist "
 318                      "in shader)", spec_entries[i].id);
 319          goto end;
 320       }
 321    }
 322
 323    spirv_data->SpirVEntryPoint = ralloc_strdup(spirv_data, pEntryPoint);
 324
 325    /* Note that we didn't make a real compilation of the module (spirv_to_nir),
 326     * but just checked some error conditions. Real "compilation" will be done
 327     * later, upon linking.
 328     */
 329    sh->CompileStatus = COMPILE_SUCCESS;
 330
 331    spirv_data->NumSpecializationConstants = numSpecializationConstants;
 332    spirv_data->SpecializationConstantsIndex =
 333       rzalloc_array_size(spirv_data, sizeof(GLuint),
 334                          numSpecializationConstants);
 335    spirv_data->SpecializationConstantsValue =
 336       rzalloc_array_size(spirv_data, sizeof(GLuint),
 337                          numSpecializationConstants);
 338    for (unsigned i = 0; i < numSpecializationConstants; ++i) {
 339       spirv_data->SpecializationConstantsIndex[i] = pConstantIndex[i];
 340       spirv_data->SpecializationConstantsValue[i] = pConstantValue[i];
 341    }
 342
 343  end:
 344    free(spec_entries);
 345 }