*/
#include <stdio.h>
-#include "main/compiler.h"
#include "main/macros.h"
#include "main/mtypes.h"
#include "main/shaderapi.h"
#include "main/shaderobj.h"
#include "main/uniforms.h"
+#include "main/glspirv.h"
#include "compiler/glsl/ast.h"
#include "compiler/glsl/ir.h"
#include "compiler/glsl/ir_expression_flattening.h"
#include "compiler/glsl/linker.h"
#include "compiler/glsl/program.h"
#include "compiler/glsl/shader_cache.h"
+#include "compiler/glsl/string_to_uint_map.h"
#include "program/prog_instruction.h"
#include "program/prog_optimize.h"
#include "program/prog_print.h"
#include "program/program.h"
#include "program/prog_parameter.h"
-#include "util/string_to_uint_map.h"
static int swizzle_for_size(int size);
}
static int
-type_size(const struct glsl_type *type)
+storage_type_size(const struct glsl_type *type, bool bindless)
{
unsigned int i;
int size;
switch (type->base_type) {
case GLSL_TYPE_UINT:
case GLSL_TYPE_INT:
+ case GLSL_TYPE_UINT8:
+ case GLSL_TYPE_INT8:
+ case GLSL_TYPE_UINT16:
+ case GLSL_TYPE_INT16:
case GLSL_TYPE_FLOAT:
+ case GLSL_TYPE_FLOAT16:
case GLSL_TYPE_BOOL:
if (type->is_matrix()) {
return type->matrix_columns;
return 1;
case GLSL_TYPE_ARRAY:
assert(type->length > 0);
- return type_size(type->fields.array) * type->length;
+ return storage_type_size(type->fields.array, bindless) * type->length;
case GLSL_TYPE_STRUCT:
size = 0;
for (i = 0; i < type->length; i++) {
- size += type_size(type->fields.structure[i].type);
+ size += storage_type_size(type->fields.structure[i].type, bindless);
}
return size;
case GLSL_TYPE_SAMPLER:
case GLSL_TYPE_IMAGE:
+ if (!bindless)
+ return 0;
+ /* fall through */
case GLSL_TYPE_SUBROUTINE:
- /* Samplers take up one slot in UNIFORMS[], but they're baked in
- * at link time.
- */
return 1;
case GLSL_TYPE_ATOMIC_UINT:
case GLSL_TYPE_VOID:
return 0;
}
+static int
+type_size(const struct glsl_type *type)
+{
+ return storage_type_size(type, false);
+}
+
/**
* In the initial pass of codegen, we assign temporary numbers to
* intermediate results. (not SSA -- variable assignments will reuse
for (unsigned int i = 0; i < ir->get_num_state_slots(); i++) {
int index = _mesa_add_state_reference(this->prog->Parameters,
- (gl_state_index *)slots[i].tokens);
+ slots[i].tokens);
if (storage->file == PROGRAM_STATE_VAR) {
if (storage->index == -1) {
return;
}
- for (operand = 0; operand < ir->get_num_operands(); operand++) {
+ for (operand = 0; operand < ir->num_operands; operand++) {
this->result.file = PROGRAM_UNDEFINED;
ir->operands[operand]->accept(this);
if (this->result.file == PROGRAM_UNDEFINED) {
case ir_binop_less:
emit(ir, OPCODE_SLT, result_dst, op[0], op[1]);
break;
- case ir_binop_greater:
- /* Negating the operands (as opposed to switching the order of the
- * operands) produces the correct result when both are +/-Inf.
- */
- op[0].negate = ~op[0].negate;
- op[1].negate = ~op[1].negate;
- emit(ir, OPCODE_SLT, result_dst, op[0], op[1]);
- break;
- case ir_binop_lequal:
- /* Negating the operands (as opposed to switching the order of the
- * operands) produces the correct result when both are +/-Inf.
- */
- op[0].negate = ~op[0].negate;
- op[1].negate = ~op[1].negate;
- emit(ir, OPCODE_SGE, result_dst, op[0], op[1]);
- break;
case ir_binop_gequal:
emit(ir, OPCODE_SGE, result_dst, op[0], op[1]);
break;
src_reg src;
int element_size = type_size(ir->type);
- index = ir->array_index->constant_expression_value();
+ index = ir->array_index->constant_expression_value(ralloc_parent(ir));
ir->array->accept(this);
src = this->result;
ir->record->accept(this);
+ assert(ir->field_idx >= 0);
for (i = 0; i < struct_type->length; i++) {
- if (strcmp(struct_type->fields.structure[i].name, ir->field) == 0)
+ if (i == (unsigned) ir->field_idx)
break;
offset += type_size(struct_type->fields.structure[i].type);
}
switch (deref->ir_type) {
case ir_type_dereference_array: {
ir_dereference_array *deref_arr = deref->as_dereference_array();
+
+ void *mem_ctx = ralloc_parent(deref_arr);
ir_constant *array_index =
- deref_arr->array_index->constant_expression_value();
+ deref_arr->array_index->constant_expression_value(mem_ctx);
if (!array_index) {
/* GLSL 1.10 and 1.20 allowed variable sampler array indices,
case ir_type_dereference_record: {
ir_dereference_record *deref_record = deref->as_dereference_record();
- unsigned field_index =
- deref_record->record->type->field_index(deref_record->field);
+ unsigned field_index = deref_record->field_idx;
*location +=
deref_record->record->type->record_location_offset(field_index);
calc_sampler_offsets(prog, deref_record->record->as_dereference(),
bool switch_order = false;
ir_expression *const expr = ir->as_expression();
- if ((expr != NULL) && (expr->get_num_operands() == 2)) {
+ if ((expr != NULL) && (expr->num_operands == 2)) {
bool zero_on_left = false;
if (expr->operands[0]->is_zero()) {
/* a is - 0 + - 0 +
* (a < 0) T F F ( a < 0) T F F
* (0 < a) F F T (-a < 0) F F T
- * (a <= 0) T T F (-a < 0) F F T (swap order of other operands)
- * (0 <= a) F T T ( a < 0) T F F (swap order of other operands)
- * (a > 0) F F T (-a < 0) F F T
- * (0 > a) T F F ( a < 0) T F F
* (a >= 0) F T T ( a < 0) T F F (swap order of other operands)
* (0 >= a) T T F (-a < 0) F F T (swap order of other operands)
*
negate = zero_on_left;
break;
- case ir_binop_greater:
- switch_order = false;
- negate = !zero_on_left;
- break;
-
- case ir_binop_lequal:
- switch_order = true;
- negate = !zero_on_left;
- break;
-
case ir_binop_gequal:
switch_order = true;
negate = zero_on_left;
src_reg temp_base = get_temp(ir->type);
dst_reg temp = dst_reg(temp_base);
- foreach_in_list(ir_constant, field_value, &ir->components) {
+ for (i = 0; i < ir->type->length; i++) {
+ ir_constant *const field_value = ir->get_record_field(i);
int size = type_size(field_value->type);
assert(size > 0);
field_value->accept(this);
src = this->result;
- for (i = 0; i < (unsigned int)size; i++) {
+ for (unsigned j = 0; j < (unsigned int)size; j++) {
emit(ir, OPCODE_MOV, temp, src);
src.index++;
assert(size > 0);
for (i = 0; i < ir->type->length; i++) {
- ir->array_elements[i]->accept(this);
+ ir->const_elements[i]->accept(this);
src = this->result;
for (int j = 0; j < size; j++) {
emit(ir, OPCODE_MOV, temp, src);
class add_uniform_to_shader : public program_resource_visitor {
public:
- add_uniform_to_shader(struct gl_shader_program *shader_program,
- struct gl_program_parameter_list *params,
- gl_shader_stage shader_type)
- : shader_program(shader_program), params(params), idx(-1),
- shader_type(shader_type)
+ add_uniform_to_shader(struct gl_context *ctx,
+ struct gl_shader_program *shader_program,
+ struct gl_program_parameter_list *params)
+ : ctx(ctx), params(params), idx(-1)
{
/* empty */
}
{
this->idx = -1;
this->var = var;
- this->program_resource_visitor::process(var);
+ this->program_resource_visitor::process(var,
+ ctx->Const.UseSTD430AsDefaultPacking);
var->data.param_index = this->idx;
}
const enum glsl_interface_packing packing,
bool last_field);
- struct gl_shader_program *shader_program;
+ struct gl_context *ctx;
struct gl_program_parameter_list *params;
int idx;
ir_variable *var;
- gl_shader_stage shader_type;
};
} /* anonymous namespace */
const enum glsl_interface_packing,
bool /* last_field */)
{
- /* atomics don't get real storage */
- if (type->contains_atomic())
+ /* opaque types don't use storage in the param list unless they are
+ * bindless samplers or images.
+ */
+ if (type->contains_opaque() && !var->data.bindless)
return;
- gl_register_file file;
- if (type->without_array()->is_sampler() && !var->data.bindless) {
- file = PROGRAM_SAMPLER;
- } else {
- file = PROGRAM_UNIFORM;
- }
-
+ /* Add the uniform to the param list */
+ assert(_mesa_lookup_parameter_index(params, name) < 0);
int index = _mesa_lookup_parameter_index(params, name);
- if (index < 0) {
- unsigned size = type_size(type) * 4;
-
- index = _mesa_add_parameter(params, file, name, size, type->gl_type,
- NULL, NULL);
-
- /* Sampler uniform values are stored in prog->SamplerUnits,
- * and the entry in that array is selected by this index we
- * store in ParameterValues[].
- */
- if (file == PROGRAM_SAMPLER) {
- unsigned location;
- const bool found =
- this->shader_program->UniformHash->get(location,
- params->Parameters[index].Name);
- assert(found);
-
- if (!found)
- return;
-
- struct gl_uniform_storage *storage =
- &this->shader_program->data->UniformStorage[location];
- assert(storage->type->is_sampler() &&
- storage->opaque[shader_type].active);
+ unsigned num_params = type->arrays_of_arrays_size();
+ num_params = MAX2(num_params, 1);
+ num_params *= type->without_array()->matrix_columns;
+
+ bool is_dual_slot = type->without_array()->is_dual_slot();
+ if (is_dual_slot)
+ num_params *= 2;
+
+ _mesa_reserve_parameter_storage(params, num_params);
+ index = params->NumParameters;
+
+ if (ctx->Const.PackedDriverUniformStorage) {
+ for (unsigned i = 0; i < num_params; i++) {
+ unsigned dmul = type->without_array()->is_64bit() ? 2 : 1;
+ unsigned comps = type->without_array()->vector_elements * dmul;
+ if (is_dual_slot) {
+ if (i & 0x1)
+ comps -= 4;
+ else
+ comps = 4;
+ }
- for (unsigned int j = 0; j < size / 4; j++)
- params->ParameterValues[index + j][0].f =
- storage->opaque[shader_type].index + j;
+ _mesa_add_parameter(params, PROGRAM_UNIFORM, name, comps,
+ type->gl_type, NULL, NULL, false);
+ }
+ } else {
+ for (unsigned i = 0; i < num_params; i++) {
+ _mesa_add_parameter(params, PROGRAM_UNIFORM, name, 4,
+ type->gl_type, NULL, NULL, true);
}
}
* \param params Parameter list to be filled in.
*/
void
-_mesa_generate_parameters_list_for_uniforms(struct gl_shader_program
+_mesa_generate_parameters_list_for_uniforms(struct gl_context *ctx,
+ struct gl_shader_program
*shader_program,
struct gl_linked_shader *sh,
struct gl_program_parameter_list
*params)
{
- add_uniform_to_shader add(shader_program, params, sh->Stage);
+ add_uniform_to_shader add(ctx, shader_program, params);
foreach_in_list(ir_instruction, node, sh->ir) {
ir_variable *var = node->as_variable();
bool propagate_to_storage)
{
struct gl_program_parameter_list *params = prog->Parameters;
+ gl_shader_stage shader_type = prog->info.stage;
/* After adding each uniform to the parameter list, connect the storage for
* the parameter with the tracking structure used by the API for the
if (location != last_location) {
enum gl_uniform_driver_format format = uniform_native;
unsigned columns = 0;
- int dmul = 4 * sizeof(float);
+
+ int dmul;
+ if (ctx->Const.PackedDriverUniformStorage && !prog->is_arb_asm) {
+ dmul = storage->type->vector_elements * sizeof(float);
+ } else {
+ dmul = 4 * sizeof(float);
+ }
switch (storage->type->base_type) {
case GLSL_TYPE_UINT64:
dmul *= 2;
/* fallthrough */
case GLSL_TYPE_UINT:
+ case GLSL_TYPE_UINT16:
+ case GLSL_TYPE_UINT8:
assert(ctx->Const.NativeIntegers);
format = uniform_native;
columns = 1;
dmul *= 2;
/* fallthrough */
case GLSL_TYPE_INT:
+ case GLSL_TYPE_INT16:
+ case GLSL_TYPE_INT8:
format =
(ctx->Const.NativeIntegers) ? uniform_native : uniform_int_float;
columns = 1;
dmul *= 2;
/* fallthrough */
case GLSL_TYPE_FLOAT:
+ case GLSL_TYPE_FLOAT16:
format = uniform_native;
columns = storage->type->matrix_columns;
break;
break;
}
+ unsigned pvo = params->ParameterValueOffset[i];
_mesa_uniform_attach_driver_storage(storage, dmul * columns, dmul,
format,
- ¶ms->ParameterValues[i]);
+ ¶ms->ParameterValues[pvo]);
+
+ /* When a bindless sampler/image is bound to a texture/image unit, we
+ * have to overwrite the constant value by the resident handle
+ * directly in the constant buffer before the next draw. One solution
+ * is to keep track a pointer to the base of the data.
+ */
+ if (storage->is_bindless && (prog->sh.NumBindlessSamplers ||
+ prog->sh.NumBindlessImages)) {
+ unsigned array_elements = MAX2(1, storage->array_elements);
+
+ for (unsigned j = 0; j < array_elements; ++j) {
+ unsigned unit = storage->opaque[shader_type].index + j;
+
+ if (storage->type->without_array()->is_sampler()) {
+ assert(unit >= 0 && unit < prog->sh.NumBindlessSamplers);
+ prog->sh.BindlessSamplers[unit].data =
+ ¶ms->ParameterValues[pvo] + 4 * j;
+ } else if (storage->type->without_array()->is_image()) {
+ assert(unit >= 0 && unit < prog->sh.NumBindlessImages);
+ prog->sh.BindlessImages[unit].data =
+ ¶ms->ParameterValues[pvo] + 4 * j;
+ }
+ }
+ }
/* After attaching the driver's storage to the uniform, propagate any
* data from the linker's backing store. This will cause values from
*/
if (propagate_to_storage) {
unsigned array_elements = MAX2(1, storage->array_elements);
- _mesa_propagate_uniforms_to_driver_storage(storage, 0,
- array_elements);
+ if (ctx->Const.PackedDriverUniformStorage && !prog->is_arb_asm &&
+ (storage->is_bindless || !storage->type->contains_opaque())) {
+ const int dmul = storage->type->is_64bit() ? 2 : 1;
+ const unsigned components =
+ storage->type->vector_elements *
+ storage->type->matrix_columns;
+
+ for (unsigned s = 0; s < storage->num_driver_storage; s++) {
+ gl_constant_value *uni_storage = (gl_constant_value *)
+ storage->driver_storage[s].data;
+ memcpy(uni_storage, storage->storage,
+ sizeof(storage->storage[0]) * components *
+ array_elements * dmul);
+ }
+ } else {
+ _mesa_propagate_uniforms_to_driver_storage(storage, 0,
+ array_elements);
+ }
}
last_location = location;
v.shader_program = shader_program;
v.options = options;
- _mesa_generate_parameters_list_for_uniforms(shader_program, shader,
+ _mesa_generate_parameters_list_for_uniforms(ctx, shader_program, shader,
prog->Parameters);
/* Emit Mesa IR for main(). */
prog->info.fs.depth_layout = shader_program->FragDepthLayout;
}
- _mesa_optimize_program(ctx, prog, prog);
+ _mesa_optimize_program(prog, prog);
/* This has to be done last. Any operation that can cause
* prog->ParameterValues to get reallocated (e.g., anything that adds a
_mesa_glsl_link_shader(struct gl_context *ctx, struct gl_shader_program *prog)
{
unsigned int i;
+ bool spirv;
_mesa_clear_shader_program_data(ctx, prog);
- prog->data->LinkStatus = linking_success;
+ prog->data = _mesa_create_shader_program_data();
+
+ prog->data->LinkStatus = LINKING_SUCCESS;
for (i = 0; i < prog->NumShaders; i++) {
if (!prog->Shaders[i]->CompileStatus) {
- linker_error(prog, "linking with uncompiled shader");
+ linker_error(prog, "linking with uncompiled/unspecialized shader");
+ }
+
+ if (!i) {
+ spirv = (prog->Shaders[i]->spirv_data != NULL);
+ } else if (spirv && !prog->Shaders[i]->spirv_data) {
+ /* The GL_ARB_gl_spirv spec adds a new bullet point to the list of
+ * reasons LinkProgram can fail:
+ *
+ * "All the shader objects attached to <program> do not have the
+ * same value for the SPIR_V_BINARY_ARB state."
+ */
+ linker_error(prog,
+ "not all attached shaders have the same "
+ "SPIR_V_BINARY_ARB state");
}
}
if (prog->data->LinkStatus) {
- link_shaders(ctx, prog);
+ if (!spirv)
+ link_shaders(ctx, prog);
+ else
+ _mesa_spirv_link_shaders(ctx, prog);
}
- if (prog->data->LinkStatus) {
- /* Reset sampler validated to true, validation happens via the
- * LinkShader call below.
- */
+ /* If LinkStatus is LINKING_SUCCESS, then reset sampler validated to true.
+ * Validation happens via the LinkShader call below. If LinkStatus is
+ * LINKING_SKIPPED, then SamplersValidated will have been restored from the
+ * shader cache.
+ */
+ if (prog->data->LinkStatus == LINKING_SUCCESS) {
prog->SamplersValidated = GL_TRUE;
+ }
- if (!ctx->Driver.LinkShader(ctx, prog)) {
- prog->data->LinkStatus = linking_failure;
- }
+ if (prog->data->LinkStatus && !ctx->Driver.LinkShader(ctx, prog)) {
+ prog->data->LinkStatus = LINKING_FAILURE;
}
/* Return early if we are loading the shader from on-disk cache */
- if (prog->data->LinkStatus == linking_skipped)
+ if (prog->data->LinkStatus == LINKING_SKIPPED)
return;
if (ctx->_Shader->Flags & GLSL_DUMP) {
projects / mesa.git / blobdiff