nir_var_local,
nir_var_uniform,
nir_var_shader_storage,
- nir_var_shared,
nir_var_system_value,
nir_var_param,
+ nir_var_shared,
} nir_variable_mode;
/**
atomic->const_index[0] =
intrin->variables[0]->var->data.driver_location;
- nir_src_copy(&atomic->src[1], &intrin->src[0], atomic);
-
- if (intrin->intrinsic == nir_intrinsic_var_atomic_comp_swap)
- nir_src_copy(&atomic->src[2], &intrin->src[1], atomic);
+ for (unsigned i = 0;
+ i < nir_op_infos[intrin->intrinsic].num_inputs;
+ i++) {
+ nir_src_copy(&atomic->src[i+1], &intrin->src[i], atomic);
+ }
if (intrin->dest.is_ssa) {
nir_ssa_dest_init(&atomic->instr, &atomic->dest,
/* Whether we're eliminating texture setup currently. */
bool dce_tex = false;
- struct list_head *node, *t;
- for (node = c->instructions.prev, t = node->prev;
- &c->instructions != node;
- node = t, t = t->prev) {
- struct qinst *inst = (struct qinst *)node;
-
+ list_for_each_entry_safe_rev(struct qinst, inst, &c->instructions,
+ link) {
if (inst->dst.file == QFILE_TEMP &&
!used[inst->dst.index] &&
!inst->sf &&
color = qir_uniform_ui(c, 0);
}
- if (c->discard.file != QFILE_NULL)
- qir_TLB_DISCARD_SETUP(c, c->discard);
+ uint32_t discard_cond = QPU_COND_ALWAYS;
+ if (c->discard.file != QFILE_NULL) {
+ qir_SF(c, c->discard);
+ discard_cond = QPU_COND_ZS;
+ }
if (c->fs_key->stencil_enabled) {
qir_TLB_STENCIL_SETUP(c, qir_uniform(c, QUNIFORM_STENCIL, 0));
} else {
z = qir_FRAG_Z(c);
}
- qir_TLB_Z_WRITE(c, z);
+ struct qinst *inst = qir_TLB_Z_WRITE(c, z);
+ inst->cond = discard_cond;
}
if (!c->msaa_per_sample_output) {
- qir_TLB_COLOR_WRITE(c, color);
+ struct qinst *inst = qir_TLB_COLOR_WRITE(c, color);
+ inst->cond = discard_cond;
} else {
- for (int i = 0; i < VC4_MAX_SAMPLES; i++)
- qir_TLB_COLOR_WRITE_MS(c, c->sample_colors[i]);
+ for (int i = 0; i < VC4_MAX_SAMPLES; i++) {
+ struct qinst *inst = qir_TLB_COLOR_WRITE_MS(c, c->sample_colors[i]);
+ inst->cond = discard_cond;
+ }
}
}
[QOP_RSQ] = { "rsq", 1, 1, false, true },
[QOP_EXP2] = { "exp2", 1, 2, false, true },
[QOP_LOG2] = { "log2", 1, 2, false, true },
- [QOP_TLB_DISCARD_SETUP] = { "discard", 0, 1, true },
[QOP_TLB_STENCIL_SETUP] = { "tlb_stencil_setup", 0, 1, true },
[QOP_TLB_Z_WRITE] = { "tlb_z", 0, 1, true },
[QOP_TLB_COLOR_WRITE] = { "tlb_color", 0, 1, true },
if (!list_empty(&c->instructions))
last_inst = (struct qinst *)c->instructions.prev;
+ /* We don't have any way to guess which kind of MOV is implied. */
+ assert(!src.pack);
+
if (src.file != QFILE_TEMP ||
!c->defs[src.index] ||
last_inst != c->defs[src.index] ||
qir_is_multi_instruction(last_inst)) {
- src = qir_MOV(c, src);
+ struct qreg null = { QFILE_NULL, 0 };
+ last_inst = qir_MOV_dest(c, null, src);
last_inst = (struct qinst *)c->instructions.prev;
}
last_inst->sf = true;
QOP_LOG2,
QOP_VW_SETUP,
QOP_VR_SETUP,
- QOP_TLB_DISCARD_SETUP,
QOP_TLB_STENCIL_SETUP,
QOP_TLB_Z_WRITE,
QOP_TLB_COLOR_WRITE,
}
#define QIR_NODST_1(name) \
-static inline void \
+static inline struct qinst * \
qir_##name(struct vc4_compile *c, struct qreg a) \
{ \
- qir_emit(c, qir_inst(QOP_##name, c->undef, a, c->undef)); \
+ struct qinst *inst = qir_inst(QOP_##name, c->undef, \
+ a, c->undef); \
+ qir_emit(c, inst); \
+ return inst; \
}
#define QIR_NODST_2(name) \
-static inline void \
+static inline struct qinst * \
qir_##name(struct vc4_compile *c, struct qreg a, struct qreg b) \
{ \
- qir_emit(c, qir_inst(QOP_##name, c->undef, a, b)); \
+ struct qinst *inst = qir_inst(QOP_##name, c->undef, \
+ a, b); \
+ qir_emit(c, inst); \
+ return inst; \
}
#define QIR_PACK(name) \
QIR_NODST_1(TLB_COLOR_WRITE)
QIR_NODST_1(TLB_COLOR_WRITE_MS)
QIR_NODST_1(TLB_Z_WRITE)
-QIR_NODST_1(TLB_DISCARD_SETUP)
QIR_NODST_1(TLB_STENCIL_SETUP)
QIR_NODST_1(MS_MASK)
add_write_dep(dir, &state->last_tlb, n);
break;
- case QOP_TLB_DISCARD_SETUP:
- add_write_dep(dir, &state->last_sf, n);
- add_write_dep(dir, &state->last_tlb, n);
- break;
-
default:
break;
}
vc4_generate_code(struct vc4_context *vc4, struct vc4_compile *c)
{
struct qpu_reg *temp_registers = vc4_register_allocate(vc4, c);
- bool discard = false;
uint32_t inputs_remaining = c->num_inputs;
uint32_t vpm_read_fifo_count = 0;
uint32_t vpm_read_offset = 0;
*/
break;
- case QOP_TLB_DISCARD_SETUP:
- discard = true;
- queue(c, qpu_a_MOV(src[0], src[0]) | unpack);
- *last_inst(c) |= QPU_SF;
- break;
-
case QOP_TLB_STENCIL_SETUP:
assert(!unpack);
queue(c, qpu_a_MOV(qpu_ra(QPU_W_TLB_STENCIL_SETUP),
case QOP_TLB_Z_WRITE:
queue(c, qpu_a_MOV(qpu_ra(QPU_W_TLB_Z),
src[0]) | unpack);
- if (discard) {
- set_last_cond_add(c, QPU_COND_ZS);
- }
+ set_last_cond_add(c, qinst->cond);
+ handled_qinst_cond = true;
break;
case QOP_TLB_COLOR_READ:
case QOP_TLB_COLOR_WRITE:
queue(c, qpu_a_MOV(qpu_tlbc(), src[0]) | unpack);
- if (discard) {
- set_last_cond_add(c, QPU_COND_ZS);
- }
+ set_last_cond_add(c, qinst->cond);
+ handled_qinst_cond = true;
break;
case QOP_TLB_COLOR_WRITE_MS:
queue(c, qpu_a_MOV(qpu_tlbc_ms(), src[0]));
- if (discard) {
- set_last_cond_add(c, QPU_COND_ZS);
- }
+ set_last_cond_add(c, qinst->cond);
+ handled_qinst_cond = true;
break;
case QOP_VARY_ADD_C:
if (pipeline->layout)
anv_nir_apply_pipeline_layout(pipeline, nir, prog_data, map);
- /* Finish the optimization and compilation process */
- if (nir->stage == MESA_SHADER_COMPUTE)
- brw_nir_lower_shared(nir);
-
/* nir_lower_io will only handle the push constants; we need to set this
* to the full number of possible uniforms.
*/
anv_fill_binding_table(&prog_data.base, 1);
- prog_data.base.total_shared = nir->num_shared;
-
void *mem_ctx = ralloc_context(NULL);
if (module->nir == NULL)
level, layer, false, __func__);
}
-GLuint
+struct gl_shader *
_mesa_meta_compile_shader_with_debug(struct gl_context *ctx, GLenum target,
const GLcharARB *source)
{
- GLuint shader;
- GLint ok, size;
- GLchar *info;
-
- shader = _mesa_CreateShader(target);
- _mesa_ShaderSource(shader, 1, &source, NULL);
- _mesa_CompileShader(shader);
-
- _mesa_GetShaderiv(shader, GL_COMPILE_STATUS, &ok);
- if (ok)
- return shader;
-
- _mesa_GetShaderiv(shader, GL_INFO_LOG_LENGTH, &size);
- if (size == 0) {
- _mesa_DeleteShader(shader);
- return 0;
- }
+ const GLuint name = ~0;
+ struct gl_shader *sh;
+
+ sh = ctx->Driver.NewShader(ctx, name, target);
+ sh->Source = strdup(source);
+ sh->CompileStatus = false;
+ _mesa_compile_shader(ctx, sh);
+
+ if (!sh->CompileStatus) {
+ if (sh->InfoLog) {
+ _mesa_problem(ctx,
+ "meta program compile failed:\n%s\nsource:\n%s\n",
+ sh->InfoLog, source);
+ }
- info = malloc(size);
- if (!info) {
- _mesa_DeleteShader(shader);
- return 0;
+ _mesa_reference_shader(ctx, &sh, NULL);
}
- _mesa_GetShaderInfoLog(shader, size, NULL, info);
- _mesa_problem(ctx,
- "meta program compile failed:\n%s\n"
- "source:\n%s\n",
- info, source);
-
- free(info);
- _mesa_DeleteShader(shader);
-
- return 0;
+ return sh;
}
-GLuint
-_mesa_meta_link_program_with_debug(struct gl_context *ctx, GLuint program)
+void
+_mesa_meta_link_program_with_debug(struct gl_context *ctx,
+ struct gl_shader_program *sh_prog)
{
- GLint ok, size;
- GLchar *info;
-
- _mesa_LinkProgram(program);
-
- _mesa_GetProgramiv(program, GL_LINK_STATUS, &ok);
- if (ok)
- return program;
+ _mesa_link_program(ctx, sh_prog);
- _mesa_GetProgramiv(program, GL_INFO_LOG_LENGTH, &size);
- if (size == 0)
- return 0;
-
- info = malloc(size);
- if (!info)
- return 0;
-
- _mesa_GetProgramInfoLog(program, size, NULL, info);
- _mesa_problem(ctx, "meta program link failed:\n%s", info);
+ if (!sh_prog->LinkStatus) {
+ _mesa_problem(ctx, "meta program link failed:\n%s", sh_prog->InfoLog);
+ }
+}
- free(info);
+void
+_mesa_meta_use_program(struct gl_context *ctx,
+ struct gl_shader_program *sh_prog)
+{
+ /* Attach shader state to the binding point */
+ _mesa_reference_pipeline_object(ctx, &ctx->_Shader, &ctx->Shader);
- return 0;
+ /* Update the program */
+ _mesa_use_program(ctx, sh_prog);
}
void
const char *vs_source,
const char *fs_source,
const char *name,
- GLuint *program)
+ struct gl_shader_program **out_sh_prog)
{
- GLuint vs = _mesa_meta_compile_shader_with_debug(ctx, GL_VERTEX_SHADER,
- vs_source);
- GLuint fs = _mesa_meta_compile_shader_with_debug(ctx, GL_FRAGMENT_SHADER,
- fs_source);
-
- *program = _mesa_CreateProgram();
- _mesa_ObjectLabel(GL_PROGRAM, *program, -1, name);
- _mesa_AttachShader(*program, fs);
- _mesa_DeleteShader(fs);
- _mesa_AttachShader(*program, vs);
- _mesa_DeleteShader(vs);
- _mesa_BindAttribLocation(*program, 0, "position");
- _mesa_BindAttribLocation(*program, 1, "texcoords");
- _mesa_meta_link_program_with_debug(ctx, *program);
-
- _mesa_UseProgram(*program);
+ struct gl_shader_program *sh_prog;
+ const GLuint id = ~0;
+
+ sh_prog = _mesa_new_shader_program(id);
+ sh_prog->Label = strdup(name);
+ sh_prog->NumShaders = 2;
+ sh_prog->Shaders = malloc(2 * sizeof(struct gl_shader *));
+ sh_prog->Shaders[0] =
+ _mesa_meta_compile_shader_with_debug(ctx, GL_VERTEX_SHADER, vs_source);
+ sh_prog->Shaders[1] =
+ _mesa_meta_compile_shader_with_debug(ctx, GL_FRAGMENT_SHADER, fs_source);
+
+ _mesa_meta_link_program_with_debug(ctx, sh_prog);
+
+ _mesa_meta_use_program(ctx, sh_prog);
+
+ *out_sh_prog = sh_prog;
}
/**
{
char *vs_source, *fs_source;
struct blit_shader *shader = choose_blit_shader(target, table);
- const char *vs_input, *vs_output, *fs_input, *vs_preprocess, *fs_preprocess;
+ const char *fs_input, *vs_preprocess, *fs_preprocess;
void *mem_ctx;
if (ctx->Const.GLSLVersion < 130) {
vs_preprocess = "";
- vs_input = "attribute";
- vs_output = "varying";
fs_preprocess = "#extension GL_EXT_texture_array : enable";
fs_input = "varying";
} else {
vs_preprocess = "#version 130";
- vs_input = "in";
- vs_output = "out";
fs_preprocess = "#version 130";
fs_input = "in";
shader->func = "texture";
assert(shader != NULL);
- if (shader->shader_prog != 0) {
- _mesa_UseProgram(shader->shader_prog);
+ if (shader->shader_prog != NULL) {
+ _mesa_meta_use_program(ctx, shader->shader_prog);
return;
}
vs_source = ralloc_asprintf(mem_ctx,
"%s\n"
- "%s vec2 position;\n"
- "%s vec4 textureCoords;\n"
- "%s vec4 texCoords;\n"
+ "#extension GL_ARB_explicit_attrib_location: enable\n"
+ "layout(location = 0) in vec2 position;\n"
+ "layout(location = 1) in vec4 textureCoords;\n"
+ "out vec4 texCoords;\n"
"void main()\n"
"{\n"
" texCoords = textureCoords;\n"
" gl_Position = vec4(position, 0.0, 1.0);\n"
"}\n",
- vs_preprocess, vs_input, vs_input, vs_output);
+ vs_preprocess);
fs_source = ralloc_asprintf(mem_ctx,
"%s\n"
"{\n"
" gl_FragColor = color;\n"
"}\n";
- GLuint vs, fs;
bool has_integer_textures;
_mesa_meta_setup_vertex_objects(ctx, &clear->VAO, &clear->buf_obj, true,
if (clear->ShaderProg != 0)
return;
- vs = _mesa_CreateShader(GL_VERTEX_SHADER);
- _mesa_ShaderSource(vs, 1, &vs_source, NULL);
- _mesa_CompileShader(vs);
-
- fs = _mesa_CreateShader(GL_FRAGMENT_SHADER);
- _mesa_ShaderSource(fs, 1, &fs_source, NULL);
- _mesa_CompileShader(fs);
-
- clear->ShaderProg = _mesa_CreateProgram();
- _mesa_AttachShader(clear->ShaderProg, fs);
- _mesa_DeleteShader(fs);
- _mesa_AttachShader(clear->ShaderProg, vs);
- _mesa_DeleteShader(vs);
- _mesa_ObjectLabel(GL_PROGRAM, clear->ShaderProg, -1, "meta clear");
- _mesa_LinkProgram(clear->ShaderProg);
+ _mesa_meta_compile_and_link_program(ctx, vs_source, fs_source, "meta clear",
+ &clear->ShaderProg);
has_integer_textures = _mesa_is_gles3(ctx) ||
(_mesa_is_desktop_gl(ctx) && ctx->Const.GLSLVersion >= 130);
" out_color = color;\n"
"}\n");
- vs = _mesa_meta_compile_shader_with_debug(ctx, GL_VERTEX_SHADER,
- vs_int_source);
- fs = _mesa_meta_compile_shader_with_debug(ctx, GL_FRAGMENT_SHADER,
- fs_int_source);
+ _mesa_meta_compile_and_link_program(ctx, vs_int_source, fs_int_source,
+ "integer clear",
+ &clear->IntegerShaderProg);
ralloc_free(shader_source_mem_ctx);
- clear->IntegerShaderProg = _mesa_CreateProgram();
- _mesa_AttachShader(clear->IntegerShaderProg, fs);
- _mesa_DeleteShader(fs);
- _mesa_AttachShader(clear->IntegerShaderProg, vs);
- _mesa_DeleteShader(vs);
-
/* Note that user-defined out attributes get automatically assigned
* locations starting from 0, so we don't need to explicitly
* BindFragDataLocation to 0.
*/
-
- _mesa_ObjectLabel(GL_PROGRAM, clear->IntegerShaderProg, -1,
- "integer clear");
- _mesa_meta_link_program_with_debug(ctx, clear->IntegerShaderProg);
}
}
_mesa_DeleteVertexArrays(1, &clear->VAO);
clear->VAO = 0;
_mesa_reference_buffer_object(ctx, &clear->buf_obj, NULL);
- _mesa_DeleteProgram(clear->ShaderProg);
- clear->ShaderProg = 0;
+ _mesa_reference_shader_program(ctx, &clear->ShaderProg, NULL);
if (clear->IntegerShaderProg) {
- _mesa_DeleteProgram(clear->IntegerShaderProg);
- clear->IntegerShaderProg = 0;
+ _mesa_reference_shader_program(ctx, &clear->IntegerShaderProg, NULL);
}
}
if (fb->_IntegerColor) {
assert(glsl);
- _mesa_UseProgram(clear->IntegerShaderProg);
+ _mesa_meta_use_program(ctx, clear->IntegerShaderProg);
_mesa_Uniform4iv(0, 1, ctx->Color.ClearColor.i);
} else if (glsl) {
- _mesa_UseProgram(clear->ShaderProg);
+ _mesa_meta_use_program(ctx, clear->ShaderProg);
_mesa_Uniform4fv(0, 1, ctx->Color.ClearColor.f);
}
}
void
-_mesa_meta_blit_shader_table_cleanup(struct blit_shader_table *table)
+_mesa_meta_blit_shader_table_cleanup(struct gl_context *ctx,
+ struct blit_shader_table *table)
{
- _mesa_DeleteProgram(table->sampler_1d.shader_prog);
- _mesa_DeleteProgram(table->sampler_2d.shader_prog);
- _mesa_DeleteProgram(table->sampler_3d.shader_prog);
- _mesa_DeleteProgram(table->sampler_rect.shader_prog);
- _mesa_DeleteProgram(table->sampler_cubemap.shader_prog);
- _mesa_DeleteProgram(table->sampler_1d_array.shader_prog);
- _mesa_DeleteProgram(table->sampler_2d_array.shader_prog);
- _mesa_DeleteProgram(table->sampler_cubemap_array.shader_prog);
-
- table->sampler_1d.shader_prog = 0;
- table->sampler_2d.shader_prog = 0;
- table->sampler_3d.shader_prog = 0;
- table->sampler_rect.shader_prog = 0;
- table->sampler_cubemap.shader_prog = 0;
- table->sampler_1d_array.shader_prog = 0;
- table->sampler_2d_array.shader_prog = 0;
- table->sampler_cubemap_array.shader_prog = 0;
+ _mesa_reference_shader_program(ctx, &table->sampler_1d.shader_prog, NULL);
+ _mesa_reference_shader_program(ctx, &table->sampler_2d.shader_prog, NULL);
+ _mesa_reference_shader_program(ctx, &table->sampler_3d.shader_prog, NULL);
+ _mesa_reference_shader_program(ctx, &table->sampler_rect.shader_prog, NULL);
+ _mesa_reference_shader_program(ctx, &table->sampler_cubemap.shader_prog, NULL);
+ _mesa_reference_shader_program(ctx, &table->sampler_1d_array.shader_prog, NULL);
+ _mesa_reference_shader_program(ctx, &table->sampler_2d_array.shader_prog, NULL);
+ _mesa_reference_shader_program(ctx, &table->sampler_cubemap_array.shader_prog, NULL);
}
/**
const char *type;
const char *func;
const char *texcoords;
- GLuint shader_prog;
+ struct gl_shader_program *shader_prog;
};
/**
struct gl_buffer_object *buf_obj;
struct blit_shader_table shaders_with_depth;
struct blit_shader_table shaders_without_depth;
- GLuint msaa_shaders[BLIT_MSAA_SHADER_COUNT];
+ struct gl_shader_program *msaa_shaders[BLIT_MSAA_SHADER_COUNT];
struct temp_texture depthTex;
bool no_ctsi_fallback;
};
{
GLuint VAO;
struct gl_buffer_object *buf_obj;
- GLuint ShaderProg;
- GLuint IntegerShaderProg;
+ struct gl_shader_program *ShaderProg;
+ struct gl_shader_program *IntegerShaderProg;
};
void
_mesa_meta_drawbuffers_from_bitfield(GLbitfield bits);
-GLuint
+struct gl_shader *
_mesa_meta_compile_shader_with_debug(struct gl_context *ctx, GLenum target,
const GLcharARB *source);
-GLuint
-_mesa_meta_link_program_with_debug(struct gl_context *ctx, GLuint program);
+void
+_mesa_meta_link_program_with_debug(struct gl_context *ctx,
+ struct gl_shader_program *sh_prog);
void
_mesa_meta_compile_and_link_program(struct gl_context *ctx,
const char *vs_source,
const char *fs_source,
const char *name,
- GLuint *program);
+ struct gl_shader_program **sh_prog_ptr);
+
+extern void
+_mesa_meta_use_program(struct gl_context *ctx,
+ struct gl_shader_program *sh_prog);
GLboolean
_mesa_meta_alloc_texture(struct temp_texture *tex,
_mesa_meta_glsl_blit_cleanup(struct gl_context *ctx, struct blit_state *blit);
void
-_mesa_meta_blit_shader_table_cleanup(struct blit_shader_table *table);
+_mesa_meta_blit_shader_table_cleanup(struct gl_context *ctx,
+ struct blit_shader_table *table);
void
_mesa_meta_glsl_generate_mipmap_cleanup(struct gl_context *ctx,
}
if (blit->msaa_shaders[shader_index]) {
- _mesa_UseProgram(blit->msaa_shaders[shader_index]);
+ _mesa_meta_use_program(ctx, blit->msaa_shaders[shader_index]);
/* Update the uniform values. */
loc_src_width =
- _mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_width");
+ _mesa_program_resource_location(blit->msaa_shaders[shader_index], GL_UNIFORM, "src_width");
loc_src_height =
- _mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_height");
+ _mesa_program_resource_location(blit->msaa_shaders[shader_index], GL_UNIFORM, "src_height");
_mesa_Uniform1f(loc_src_width, src_rb->Width);
_mesa_Uniform1f(loc_src_height, src_rb->Height);
return;
static const char vs_source[] =
"#version 130\n"
- "in vec2 position;\n"
- "in vec3 textureCoords;\n"
+ "#extension GL_ARB_explicit_attrib_location: enable\n"
+ "layout(location = 0) in vec2 position;\n"
+ "layout(location = 1) in vec3 textureCoords;\n"
"out vec2 texCoords;\n"
"flat out int layer;\n"
"void main()\n"
_mesa_meta_compile_and_link_program(ctx, vs_source, fs_source, name,
&blit->msaa_shaders[shader_index]);
loc_src_width =
- _mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_width");
+ _mesa_program_resource_location(blit->msaa_shaders[shader_index], GL_UNIFORM, "src_width");
loc_src_height =
- _mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_height");
+ _mesa_program_resource_location(blit->msaa_shaders[shader_index], GL_UNIFORM, "src_height");
_mesa_Uniform1f(loc_src_width, src_rb->Width);
_mesa_Uniform1f(loc_src_height, src_rb->Height);
}
if (blit->msaa_shaders[shader_index]) {
- _mesa_UseProgram(blit->msaa_shaders[shader_index]);
+ _mesa_meta_use_program(ctx, blit->msaa_shaders[shader_index]);
return;
}
vs_source = ralloc_asprintf(mem_ctx,
"#version 130\n"
- "in vec2 position;\n"
- "in %s textureCoords;\n"
+ "#extension GL_ARB_explicit_attrib_location: enable\n"
+ "layout(location = 0) in vec2 position;\n"
+ "layout(location = 1) in %s textureCoords;\n"
"out %s texCoords;\n"
"void main()\n"
"{\n"
vs_source = ralloc_asprintf(mem_ctx,
"#version 130\n"
- "in vec2 position;\n"
- "in %s textureCoords;\n"
+ "#extension GL_ARB_explicit_attrib_location: enable\n"
+ "layout(location = 0) in vec2 position;\n"
+ "layout(location = 1) in %s textureCoords;\n"
"out %s texCoords;\n"
"void main()\n"
"{\n"
_mesa_reference_buffer_object(ctx, &blit->buf_obj, NULL);
}
- _mesa_meta_blit_shader_table_cleanup(&blit->shaders_with_depth);
- _mesa_meta_blit_shader_table_cleanup(&blit->shaders_without_depth);
+ _mesa_meta_blit_shader_table_cleanup(ctx, &blit->shaders_with_depth);
+ _mesa_meta_blit_shader_table_cleanup(ctx, &blit->shaders_without_depth);
_mesa_DeleteTextures(1, &blit->depthTex.TexObj);
blit->depthTex.TexObj = 0;
_mesa_reference_sampler_object(ctx, &mipmap->samp_obj, NULL);
_mesa_reference_framebuffer(&mipmap->fb, NULL);
- _mesa_meta_blit_shader_table_cleanup(&mipmap->shaders);
+ _mesa_meta_blit_shader_table_cleanup(ctx, &mipmap->shaders);
}
static GLboolean
struct brw_cache cache;
/** IDs for meta stencil blit shader programs. */
- unsigned meta_stencil_blit_programs[2];
+ struct gl_shader_program *meta_stencil_blit_programs[2];
/* Whether a meta-operation is in progress. */
bool meta_in_progress;
/* Generators should set a default exec_size of either 8 (SIMD4x2 or SIMD8)
* or 16 (SIMD16), as that's normally correct. However, when dealing with
* small registers, we automatically reduce it to match the register size.
+ *
+ * In platforms that support fp64 we can emit instructions with a width of
+ * 4 that need two SIMD8 registers and an exec_size of 8 or 16. In these
+ * cases we need to make sure that these instructions have their exec sizes
+ * set properly when they are emitted and we can't rely on this code to fix
+ * it.
*/
- if (dest.width < BRW_EXECUTE_8)
+ bool fix_exec_size;
+ if (devinfo->gen >= 6)
+ fix_exec_size = dest.width < BRW_EXECUTE_4;
+ else
+ fix_exec_size = dest.width < BRW_EXECUTE_8;
+
+ if (fix_exec_size)
brw_inst_set_exec_size(devinfo, inst, dest.width);
}
void brw_NOP(struct brw_codegen *p)
{
brw_inst *insn = next_insn(p, BRW_OPCODE_NOP);
- brw_set_dest(p, insn, retype(brw_vec4_grf(0,0), BRW_REGISTER_TYPE_UD));
- brw_set_src0(p, insn, retype(brw_vec4_grf(0,0), BRW_REGISTER_TYPE_UD));
+ brw_inst_set_exec_size(p->devinfo, insn, BRW_EXECUTE_1);
+ brw_set_dest(p, insn, retype(brw_vec1_grf(0,0), BRW_REGISTER_TYPE_UD));
+ brw_set_src0(p, insn, retype(brw_vec1_grf(0,0), BRW_REGISTER_TYPE_UD));
brw_set_src1(p, insn, brw_imm_ud(0x0));
}
brw_set_src1(p, send, addr);
}
+ if (dst.width < BRW_EXECUTE_8)
+ brw_inst_set_exec_size(devinfo, send, dst.width);
+
brw_set_dest(p, send, dst);
brw_set_src0(p, send, retype(payload, BRW_REGISTER_TYPE_UD));
brw_inst_set_sfid(devinfo, send, sfid);
/* Overwrite the destination without and with execution masking to
* find out which of the channels is active.
*/
+ brw_push_insn_state(p);
+ brw_set_default_exec_size(p, BRW_EXECUTE_4);
brw_MOV(p, brw_writemask(vec4(dst), WRITEMASK_X),
brw_imm_ud(1));
inst = brw_MOV(p, brw_writemask(vec4(dst), WRITEMASK_X),
brw_imm_ud(0));
+ brw_pop_insn_state(p);
brw_inst_set_mask_control(devinfo, inst, BRW_MASK_ENABLE);
}
}
: 0x00020001)); /* (1, 0, 2) */
brw_inst_set_pred_control(p->devinfo, inst, BRW_PREDICATE_NORMAL);
}
+
+ assert(c->reg.destination_indices.width == BRW_EXECUTE_4);
+ brw_push_insn_state(p);
+ brw_set_default_exec_size(p, BRW_EXECUTE_4);
brw_ADD(p, c->reg.destination_indices,
c->reg.destination_indices, get_element_ud(c->reg.SVBI, 0));
-
+ brw_pop_insn_state(p);
/* For each vertex, generate code to output each varying using the
* appropriate binding table entry.
*/
vertex_slot.swizzle = varying == VARYING_SLOT_PSIZ
? BRW_SWIZZLE_WWWW : key->transform_feedback_swizzles[binding];
brw_set_default_access_mode(p, BRW_ALIGN_16);
+ brw_push_insn_state(p);
+ brw_set_default_exec_size(p, BRW_EXECUTE_4);
+
brw_MOV(p, stride(c->reg.header, 4, 4, 1),
retype(vertex_slot, BRW_REGISTER_TYPE_UD));
+ brw_pop_insn_state(p);
+
brw_set_default_access_mode(p, BRW_ALIGN_1);
brw_svb_write(p,
final_write ? c->reg.temp : brw_null_reg(), /* dest */
nir_shader *shader = nir_shader_clone(mem_ctx, src_shader);
shader = brw_nir_apply_sampler_key(shader, compiler->devinfo, &key->tex,
true);
+ brw_nir_lower_cs_shared(shader);
+ prog_data->base.total_shared += shader->num_shared;
shader = brw_postprocess_nir(shader, compiler->devinfo, true);
prog_data->local_size[0] = shader->info.cs.local_size[0];
brw_set_default_compression_control(p, BRW_COMPRESSION_NONE);
brw_set_default_mask_control(p, BRW_MASK_DISABLE);
brw_inst *send = brw_next_insn(p, BRW_OPCODE_SEND);
+ brw_inst_set_exec_size(devinfo, send, BRW_EXECUTE_4);
brw_pop_insn_state(p);
brw_set_dest(p, send, dst);
#include "main/context.h"
#include "main/objectlabel.h"
#include "main/shaderapi.h"
+#include "main/shaderobj.h"
#include "main/arrayobj.h"
#include "main/bufferobj.h"
#include "main/buffers.h"
struct brw_fast_clear_state {
struct gl_buffer_object *buf_obj;
struct gl_vertex_array_object *array_obj;
+ struct gl_shader_program *shader_prog;
GLuint vao;
- GLuint shader_prog;
GLint color_location;
};
const char *vs_source =
"#extension GL_AMD_vertex_shader_layer : enable\n"
"#extension GL_ARB_draw_instanced : enable\n"
- "attribute vec4 position;\n"
+ "#extension GL_ARB_explicit_attrib_location : enable\n"
+ "layout(location = 0) in vec4 position;\n"
"uniform int layer;\n"
"void main()\n"
"{\n"
" gl_FragColor = color;\n"
"}\n";
- GLuint vs, fs;
struct brw_fast_clear_state *clear = brw->fast_clear_state;
struct gl_context *ctx = &brw->ctx;
if (clear->shader_prog) {
- _mesa_UseProgram(clear->shader_prog);
+ _mesa_meta_use_program(ctx, clear->shader_prog);
_mesa_Uniform4fv(clear->color_location, 1, color);
return;
}
- vs = _mesa_meta_compile_shader_with_debug(ctx, GL_VERTEX_SHADER, vs_source);
- fs = _mesa_meta_compile_shader_with_debug(ctx, GL_FRAGMENT_SHADER, fs_source);
-
- clear->shader_prog = _mesa_CreateProgram();
- _mesa_AttachShader(clear->shader_prog, fs);
- _mesa_DeleteShader(fs);
- _mesa_AttachShader(clear->shader_prog, vs);
- _mesa_DeleteShader(vs);
- _mesa_BindAttribLocation(clear->shader_prog, 0, "position");
- _mesa_ObjectLabel(GL_PROGRAM, clear->shader_prog, -1, "meta repclear");
- _mesa_LinkProgram(clear->shader_prog);
+ _mesa_meta_compile_and_link_program(ctx, vs_source, fs_source,
+ "meta repclear",
+ &clear->shader_prog);
clear->color_location =
- _mesa_GetUniformLocation(clear->shader_prog, "color");
+ _mesa_program_resource_location(clear->shader_prog, GL_UNIFORM, "color");
- _mesa_UseProgram(clear->shader_prog);
+ _mesa_meta_use_program(ctx, clear->shader_prog);
_mesa_Uniform4fv(clear->color_location, 1, color);
}
_mesa_DeleteVertexArrays(1, &clear->vao);
_mesa_reference_buffer_object(&brw->ctx, &clear->buf_obj, NULL);
- _mesa_DeleteProgram(clear->shader_prog);
+ _mesa_reference_shader_program(&brw->ctx, &clear->shader_prog, NULL);
free(clear);
if (old_context)
" %s;\n"
"}\n";
+#define get_uniform_loc(sh_prog, name) \
+ _mesa_program_resource_location(sh_prog, GL_UNIFORM, name)
+
/**
* Setup uniforms telling the coordinates of the destination rectangle in the
* native w-tiled space. These are needed to ignore pixels that lie outside.
* 16x2 y-tiled).
*/
static void
-setup_bounding_rect(GLuint prog, const struct blit_dims *dims)
+setup_bounding_rect(struct gl_shader_program *sh_prog,
+ const struct blit_dims *dims)
{
- _mesa_Uniform1i(_mesa_GetUniformLocation(prog, "dst_x0"), dims->dst_x0);
- _mesa_Uniform1i(_mesa_GetUniformLocation(prog, "dst_x1"), dims->dst_x1);
- _mesa_Uniform1i(_mesa_GetUniformLocation(prog, "dst_y0"), dims->dst_y0);
- _mesa_Uniform1i(_mesa_GetUniformLocation(prog, "dst_y1"), dims->dst_y1);
+ _mesa_Uniform1i(get_uniform_loc(sh_prog, "dst_x0"), dims->dst_x0);
+ _mesa_Uniform1i(get_uniform_loc(sh_prog, "dst_x1"), dims->dst_x1);
+ _mesa_Uniform1i(get_uniform_loc(sh_prog, "dst_y0"), dims->dst_y0);
+ _mesa_Uniform1i(get_uniform_loc(sh_prog, "dst_y1"), dims->dst_y1);
}
/**
* between destination and source that may have differing offsets.
*/
static void
-setup_drawing_rect(GLuint prog, const struct blit_dims *dims)
+setup_drawing_rect(struct gl_shader_program *sh_prog,
+ const struct blit_dims *dims)
{
- _mesa_Uniform1f(_mesa_GetUniformLocation(prog, "draw_rect_w"),
+ _mesa_Uniform1f(get_uniform_loc(sh_prog, "draw_rect_w"),
dims->dst_x1 - dims->dst_x0);
- _mesa_Uniform1f(_mesa_GetUniformLocation(prog, "draw_rect_h"),
+ _mesa_Uniform1f(get_uniform_loc(sh_prog, "draw_rect_h"),
dims->dst_y1 - dims->dst_y0);
- _mesa_Uniform1f(_mesa_GetUniformLocation(prog, "dst_x_off"), dims->dst_x0);
- _mesa_Uniform1f(_mesa_GetUniformLocation(prog, "dst_y_off"), dims->dst_y0);
+ _mesa_Uniform1f(get_uniform_loc(sh_prog, "dst_x_off"), dims->dst_x0);
+ _mesa_Uniform1f(get_uniform_loc(sh_prog, "dst_y_off"), dims->dst_y0);
}
/**
* src_x = src_x0 + (dst_x1 -dst_x - 0.5) * scale
*/
static void
-setup_coord_coeff(GLuint prog, GLuint multiplier, GLuint offset,
+setup_coord_coeff(GLuint multiplier, GLuint offset,
int src_0, int src_1, int dst_0, int dst_1, bool mirror)
{
const float scale = ((float)(src_1 - src_0)) / (dst_1 - dst_0);
* destination rectangle is adjusted for possible msaa and Y-tiling.
*/
static void
-setup_coord_transform(GLuint prog, const struct blit_dims *dims)
+setup_coord_transform(struct gl_shader_program *sh_prog,
+ const struct blit_dims *dims)
{
- setup_coord_coeff(prog,
- _mesa_GetUniformLocation(prog, "src_x_scale"),
- _mesa_GetUniformLocation(prog, "src_x_off"),
+ setup_coord_coeff(get_uniform_loc(sh_prog, "src_x_scale"),
+ get_uniform_loc(sh_prog, "src_x_off"),
dims->src_x0, dims->src_x1, dims->dst_x0, dims->dst_x1,
dims->mirror_x);
- setup_coord_coeff(prog,
- _mesa_GetUniformLocation(prog, "src_y_scale"),
- _mesa_GetUniformLocation(prog, "src_y_off"),
+ setup_coord_coeff(get_uniform_loc(sh_prog, "src_y_scale"),
+ get_uniform_loc(sh_prog, "src_y_off"),
dims->src_y0, dims->src_y1, dims->dst_y0, dims->dst_y1,
dims->mirror_y);
}
-static GLuint
+static struct gl_shader_program *
setup_program(struct brw_context *brw, bool msaa_tex)
{
struct gl_context *ctx = &brw->ctx;
_mesa_meta_setup_vertex_objects(&brw->ctx, &blit->VAO, &blit->buf_obj, true,
2, 2, 0);
- GLuint *prog_id = &brw->meta_stencil_blit_programs[msaa_tex];
+ struct gl_shader_program **sh_prog_p =
+ &brw->meta_stencil_blit_programs[msaa_tex];
- if (*prog_id) {
- _mesa_UseProgram(*prog_id);
- return *prog_id;
+ if (*sh_prog_p) {
+ _mesa_meta_use_program(ctx, *sh_prog_p);
+ return *sh_prog_p;
}
fs_source = ralloc_asprintf(NULL, fs_tmpl, sampler->sampler,
sampler->fetch);
_mesa_meta_compile_and_link_program(ctx, vs_source, fs_source,
"i965 stencil blit",
- prog_id);
+ sh_prog_p);
ralloc_free(fs_source);
- return *prog_id;
+ return *sh_prog_p;
}
/**
struct gl_context *ctx = &brw->ctx;
struct blit_dims dims = *orig_dims;
struct fb_tex_blit_state blit;
- GLuint prog;
+ struct gl_shader_program *prog;
struct gl_framebuffer *drawFb = NULL;
struct gl_renderbuffer *rb = NULL;
GLenum target;
setup_drawing_rect(prog, &dims);
setup_coord_transform(prog, orig_dims);
- _mesa_Uniform1i(_mesa_GetUniformLocation(prog, "dst_num_samples"),
+ _mesa_Uniform1i(get_uniform_loc(prog, "dst_num_samples"),
dst_mt->num_samples);
prepare_vertex_data(ctx, ctx->Meta->Blit.buf_obj);
}
void
-brw_nir_lower_shared(nir_shader *nir)
+brw_nir_lower_cs_shared(nir_shader *nir)
{
nir_assign_var_locations(&nir->shared, &nir->num_shared,
type_size_scalar_bytes);
OPT_V(nir_lower_atomics, shader_prog);
}
- if (nir->stage == MESA_SHADER_COMPUTE)
- OPT_V(brw_nir_lower_shared);
-
return nir;
}
nir_shader *brw_preprocess_nir(nir_shader *nir, bool is_scalar);
-void brw_nir_lower_shared(nir_shader *nir);
void brw_nir_lower_vs_inputs(nir_shader *nir,
const struct brw_device_info *devinfo,
bool is_scalar,
void brw_nir_lower_vue_outputs(nir_shader *nir, bool is_scalar);
void brw_nir_lower_tcs_outputs(nir_shader *nir, const struct brw_vue_map *vue);
void brw_nir_lower_fs_outputs(nir_shader *nir);
+void brw_nir_lower_cs_shared(nir_shader *nir);
nir_shader *brw_postprocess_nir(nir_shader *nir,
const struct brw_device_info *devinfo,
bool final_write = inst->sol_final_write;
brw_push_insn_state(p);
+ brw_set_default_exec_size(p, BRW_EXECUTE_4);
/* Copy Vertex data into M0.x */
brw_MOV(p, stride(dst, 4, 4, 1),
stride(retype(src0, BRW_REGISTER_TYPE_UD), 4, 4, 1));
+ brw_pop_insn_state(p);
+ brw_push_insn_state(p);
/* Send SVB Write */
brw_svb_write(p,
final_write ? src1 : brw_null_reg(), /* dest == src1 */
brw_MOV(p, get_element_ud(header, 0), get_element_ud(dst, 0));
/* src1 is not an immediate when we use transform feedback */
- if (src1.file != BRW_IMMEDIATE_VALUE)
+ if (src1.file != BRW_IMMEDIATE_VALUE) {
+ brw_set_default_exec_size(p, BRW_EXECUTE_4);
brw_MOV(p, brw_vec4_grf(src1.nr, 0), brw_vec4_grf(dst.nr, 1));
+ }
brw_pop_insn_state(p);
}
assert(inst->mlen <= BRW_MAX_MSG_LENGTH);
unsigned pre_emit_nr_insn = p->nr_insn;
+ bool fix_exec_size = false;
if (dst.width == BRW_WIDTH_4) {
/* This happens in attribute fixups for "dual instanced" geometry
if (src[i].file == BRW_GENERAL_REGISTER_FILE)
src[i] = stride(src[i], 4, 4, 1);
}
+ brw_set_default_exec_size(p, BRW_EXECUTE_4);
+ fix_exec_size = true;
}
switch (inst->opcode) {
unreachable("Unsupported opcode");
}
+ if (fix_exec_size)
+ brw_set_default_exec_size(p, BRW_EXECUTE_8);
+
if (inst->opcode == VEC4_OPCODE_PACK_BYTES) {
/* Handled dependency hints in the generator. */
case GL_POINT_SIZE_ARRAY_OES:
var = &vao->VertexAttrib[VERT_ATTRIB_POINT_SIZE].Enabled;
flag = VERT_BIT_POINT_SIZE;
+ FLUSH_VERTICES(ctx, _NEW_PROGRAM);
+ ctx->VertexProgram.PointSizeEnabled = state;
break;
/* GL_NV_primitive_restart */
/**
* Compile a shader.
*/
-static void
-compile_shader(struct gl_context *ctx, GLuint shaderObj)
+void
+_mesa_compile_shader(struct gl_context *ctx, struct gl_shader *sh)
{
- struct gl_shader *sh;
-
- sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");
if (!sh)
return;
/**
* Link a program's shaders.
*/
-static void
-link_program(struct gl_context *ctx, GLuint program)
+void
+_mesa_link_program(struct gl_context *ctx, struct gl_shader_program *shProg)
{
- struct gl_shader_program *shProg;
-
- shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");
if (!shProg)
return;
GET_CURRENT_CONTEXT(ctx);
if (MESA_VERBOSE & VERBOSE_API)
_mesa_debug(ctx, "glCompileShader %u\n", shaderObj);
- compile_shader(ctx, shaderObj);
+ _mesa_compile_shader(ctx, _mesa_lookup_shader_err(ctx, shaderObj,
+ "glCompileShader"));
}
GET_CURRENT_CONTEXT(ctx);
if (MESA_VERBOSE & VERBOSE_API)
_mesa_debug(ctx, "glLinkProgram %u\n", programObj);
- link_program(ctx, programObj);
+ _mesa_link_program(ctx, _mesa_lookup_shader_program_err(ctx, programObj,
+ "glLinkProgram"));
}
#if defined(HAVE_SHA1)
}
if (shader) {
- _mesa_ShaderSource(shader, count, strings, NULL);
+ struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
- compile_shader(ctx, shader);
+ _mesa_ShaderSource(shader, count, strings, NULL);
+ _mesa_compile_shader(ctx, sh);
program = create_shader_program(ctx);
if (program) {
struct gl_shader_program *shProg;
- struct gl_shader *sh;
GLint compiled = GL_FALSE;
shProg = _mesa_lookup_shader_program(ctx, program);
- sh = _mesa_lookup_shader(ctx, shader);
shProg->SeparateShader = GL_TRUE;
get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
if (compiled) {
attach_shader(ctx, program, shader);
- link_program(ctx, program);
+ _mesa_link_program(ctx, shProg);
detach_shader(ctx, program, shader);
#if 0
_mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
const char *caller);
+extern void
+_mesa_compile_shader(struct gl_context *ctx, struct gl_shader *sh);
+
+extern void
+_mesa_link_program(struct gl_context *ctx, struct gl_shader_program *sh_prog);
+
extern unsigned
_mesa_count_active_attribs(struct gl_shader_program *shProg);
OSDN Git Service
