*/
#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"
virtual void visit(ir_call *);
virtual void visit(ir_return *);
virtual void visit(ir_discard *);
+ virtual void visit(ir_demote *);
virtual void visit(ir_texture *);
virtual void visit(ir_if *);
virtual void visit(ir_emit_vertex *);
return src;
}
-static int
-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_FLOAT:
- case GLSL_TYPE_BOOL:
- if (type->is_matrix()) {
- return type->matrix_columns;
- } else {
- /* Regardless of size of vector, it gets a vec4. This is bad
- * packing for things like floats, but otherwise arrays become a
- * mess. Hopefully a later pass over the code can pack scalars
- * down if appropriate.
- */
- return 1;
- }
- break;
- case GLSL_TYPE_DOUBLE:
- if (type->is_matrix()) {
- if (type->vector_elements > 2)
- return type->matrix_columns * 2;
- else
- return type->matrix_columns;
- } else {
- if (type->vector_elements > 2)
- return 2;
- else
- return 1;
- }
- break;
- case GLSL_TYPE_UINT64:
- case GLSL_TYPE_INT64:
- if (type->vector_elements > 2)
- return 2;
- else
- return 1;
- case GLSL_TYPE_ARRAY:
- assert(type->length > 0);
- return storage_type_size(type->fields.array, bindless) * type->length;
- case GLSL_TYPE_STRUCT:
- size = 0;
- for (i = 0; i < type->length; i++) {
- 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:
- return 1;
- case GLSL_TYPE_ATOMIC_UINT:
- case GLSL_TYPE_VOID:
- case GLSL_TYPE_ERROR:
- case GLSL_TYPE_INTERFACE:
- case GLSL_TYPE_FUNCTION:
- assert(!"Invalid type in type_size");
- break;
- }
-
- return 0;
-}
-
static int
type_size(const struct glsl_type *type)
{
- return storage_type_size(type, false);
+ return type->count_vec4_slots(false, false);
}
/**
src.reladdr = NULL;
next_temp += type_size(type);
- if (type->is_array() || type->is_record()) {
+ if (type->is_array() || type->is_struct()) {
src.swizzle = SWIZZLE_NOOP;
} else {
src.swizzle = swizzle_for_size(type->vector_elements);
void
ir_to_mesa_visitor::visit(ir_variable *ir)
{
- if (strcmp(ir->name, "gl_FragCoord") == 0) {
- this->prog->OriginUpperLeft = ir->data.origin_upper_left;
- this->prog->PixelCenterInteger = ir->data.pixel_center_integer;
- }
-
if (ir->data.mode == ir_var_uniform && strncmp(ir->name, "gl_", 3) == 0) {
unsigned int i;
const ir_state_slot *const slots = ir->get_state_slots();
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) {
break;
case ir_binop_mod:
/* Floating point should be lowered by MOD_TO_FLOOR in the compiler. */
- assert(ir->type->is_integer());
+ assert(ir->type->is_integer_32());
emit(ir, OPCODE_MUL, result_dst, op[0], op[1]);
break;
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;
case ir_unop_unpack_sampler_2x32:
case ir_unop_pack_image_2x32:
case ir_unop_unpack_image_2x32:
+ case ir_unop_atan:
+ case ir_binop_atan2:
assert(!"not supported");
break;
ir_dereference_record *deref_record = deref->as_dereference_record();
unsigned field_index = deref_record->field_idx;
*location +=
- deref_record->record->type->record_location_offset(field_index);
+ deref_record->record->type->struct_location_offset(field_index);
calc_sampler_offsets(prog, deref_record->record->as_dereference(),
offset, array_elements, location);
break;
/* 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;
* get lucky, copy propagation will eliminate the extra moves.
*/
- if (ir->type->is_record()) {
+ if (ir->type->is_struct()) {
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++;
emit(ir, OPCODE_KIL, undef_dst, this->result);
}
+void
+ir_to_mesa_visitor::visit(ir_demote *ir)
+{
+ assert(!"demote statement unsupported");
+}
+
void
ir_to_mesa_visitor::visit(ir_if *ir)
{
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)
+ : ctx(ctx), shader_program(shader_program), params(params), idx(-1)
{
/* empty */
}
bool last_field);
struct gl_context *ctx;
+ struct gl_shader_program *shader_program;
struct gl_program_parameter_list *params;
int idx;
ir_variable *var;
if (type->contains_opaque() && !var->data.bindless)
return;
+ /* Add the uniform to the param list */
assert(_mesa_lookup_parameter_index(params, name) < 0);
+ int index = _mesa_lookup_parameter_index(params, name);
+
+ 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;
+ }
- unsigned size = storage_type_size(type, var->data.bindless) * 4;
-
- int index = _mesa_add_parameter(params, PROGRAM_UNIFORM, name, size,
- type->gl_type, NULL, NULL);
+ _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);
+ }
+ }
/* The first part of the uniform that's processed determines the base
* location of the whole uniform (for structures).
*/
if (this->idx < 0)
this->idx = index;
+
+ /* Each Parameter will hold the index to the backing uniform storage.
+ * This avoids relying on names to match parameters and uniform
+ * storages later when associating uniform storage.
+ */
+ unsigned location;
+ const bool found =
+ shader_program->UniformHash->get(location, params->Parameters[index].Name);
+ assert(found);
+
+ for (unsigned i = 0; i < num_params; i++) {
+ struct gl_program_parameter *param = ¶ms->Parameters[index + i];
+ param->UniformStorageIndex = location;
+ param->MainUniformStorageIndex = params->Parameters[this->idx].UniformStorageIndex;
+ }
}
/**
void
_mesa_associate_uniform_storage(struct gl_context *ctx,
struct gl_shader_program *shader_program,
- struct gl_program *prog,
- bool propagate_to_storage)
+ struct gl_program *prog)
{
struct gl_program_parameter_list *params = prog->Parameters;
gl_shader_stage shader_type = prog->info.stage;
if (params->Parameters[i].Type != PROGRAM_UNIFORM)
continue;
- unsigned location;
- const bool found =
- shader_program->UniformHash->get(location, params->Parameters[i].Name);
- assert(found);
-
- if (!found)
- continue;
+ unsigned location = params->Parameters[i].UniformStorageIndex;
struct gl_uniform_storage *storage =
&shader_program->data->UniformStorage[location];
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
if (storage->type->without_array()->is_sampler()) {
assert(unit >= 0 && unit < prog->sh.NumBindlessSamplers);
prog->sh.BindlessSamplers[unit].data =
- ¶ms->ParameterValues[i] + j;
+ ¶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[i] + j;
+ ¶ms->ParameterValues[pvo] + 4 * j;
}
}
}
* data from the linker's backing store. This will cause values from
* initializers in the source code to be copied over.
*/
- if (propagate_to_storage) {
- unsigned array_elements = MAX2(1, storage->array_elements);
+ unsigned array_elements = MAX2(1, storage->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);
}
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
* program constant) has to happen before creating this linkage.
*/
- _mesa_associate_uniform_storage(ctx, shader_program, prog, true);
+ _mesa_associate_uniform_storage(ctx, shader_program, prog);
if (!shader_program->data->LinkStatus) {
goto fail_exit;
}
do_mat_op_to_vec(ir);
lower_instructions(ir, (MOD_TO_FLOOR | DIV_TO_MUL_RCP | EXP_TO_EXP2
| LOG_TO_LOG2 | INT_DIV_TO_MUL_RCP
+ | MUL64_TO_MUL_AND_MUL_HIGH
| ((options->EmitNoPow) ? POW_TO_EXP2 : 0)));
progress = do_common_optimization(ir, true, true,
}
}
- build_program_resource_list(ctx, prog);
+ build_program_resource_list(ctx, prog, false);
return prog->data->LinkStatus;
}
_mesa_glsl_link_shader(struct gl_context *ctx, struct gl_shader_program *prog)
{
unsigned int i;
+ bool spirv = false;
_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");
}
}
+ prog->data->spirv = spirv;
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;
}
+ if (prog->data->LinkStatus != LINKING_FAILURE)
+ _mesa_create_program_resource_hash(prog);
+
/* 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