src/gallium/drivers/etnaviv/etnaviv_shader.c - platform/external/mesa3d - Git at Google

 /*
  * Copyright (c) 2012-2015 Etnaviv Project
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sub license,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice (including the
  * next paragraph) shall be included in all copies or substantial portions
  * of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
  *
  * Authors:
  *    Wladimir J. van der Laan <laanwj@gmail.com>
  */

 #include "etnaviv_shader.h"

 #include "etnaviv_compiler.h"
 #include "etnaviv_context.h"
 #include "etnaviv_debug.h"
 #include "etnaviv_screen.h"
 #include "etnaviv_util.h"

 #include "tgsi/tgsi_parse.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"

 /* Upload shader code to bo, if not already done */
 static bool etna_icache_upload_shader(struct etna_context *ctx, struct etna_shader_variant *v)
 {
    if (v->bo)
       return true;
    v->bo = etna_bo_new(ctx->screen->dev, v->code_size*4, DRM_ETNA_GEM_CACHE_WC);
    if (!v->bo)
       return false;

    void *buf = etna_bo_map(v->bo);
    etna_bo_cpu_prep(v->bo, DRM_ETNA_PREP_WRITE);
    memcpy(buf, v->code, v->code_size*4);
    etna_bo_cpu_fini(v->bo);
    DBG("Uploaded %s of %u words to bo %p", v->processor == PIPE_SHADER_FRAGMENT ? "fs":"vs", v->code_size, v->bo);
    return true;
 }

 /* Link vs and fs together: fill in shader_state from vs and fs
  * as this function is called every time a new fs or vs is bound, the goal is to
  * do little processing as possible here, and to precompute as much as possible in
  * the vs/fs shader_object.
  *
  * XXX we could cache the link result for a certain set of VS/PS; usually a pair
  * of VS and PS will be used together anyway.
  */
 static bool
 etna_link_shaders(struct etna_context *ctx, struct compiled_shader_state *cs,
                   struct etna_shader_variant *vs, struct etna_shader_variant *fs)
 {
    struct etna_shader_link_info link = { };

    assert(vs->processor == PIPE_SHADER_VERTEX);
    assert(fs->processor == PIPE_SHADER_FRAGMENT);

 #ifdef DEBUG
    if (DBG_ENABLED(ETNA_DBG_DUMP_SHADERS)) {
       etna_dump_shader(vs);
       etna_dump_shader(fs);
    }
 #endif

    if (etna_link_shader(&link, vs, fs)) {
       /* linking failed: some fs inputs do not have corresponding
        * vs outputs */
       assert(0);

       return false;
    }

    if (DBG_ENABLED(ETNA_DBG_LINKER_MSGS)) {
       debug_printf("link result:\n");
       debug_printf("  vs  -> fs  comps use     pa_attr\n");

       for (int idx = 0; idx < link.num_varyings; ++idx)
          debug_printf("  t%-2u -> t%-2u %-5.*s %u,%u,%u,%u 0x%08x\n",
                       link.varyings[idx].reg, idx + 1,
                       link.varyings[idx].num_components, "xyzw",
                       link.varyings[idx].use[0], link.varyings[idx].use[1],
                       link.varyings[idx].use[2], link.varyings[idx].use[3],
                       link.varyings[idx].pa_attributes);
    }

    /* set last_varying_2x flag if the last varying has 1 or 2 components */
    bool last_varying_2x = false;
    if (link.num_varyings > 0 && link.varyings[link.num_varyings - 1].num_components <= 2)
       last_varying_2x = true;

    cs->RA_CONTROL = VIVS_RA_CONTROL_UNK0 |
                     COND(last_varying_2x, VIVS_RA_CONTROL_LAST_VARYING_2X);

    cs->PA_ATTRIBUTE_ELEMENT_COUNT = VIVS_PA_ATTRIBUTE_ELEMENT_COUNT_COUNT(link.num_varyings);
    for (int idx = 0; idx < link.num_varyings; ++idx)
       cs->PA_SHADER_ATTRIBUTES[idx] = link.varyings[idx].pa_attributes;

    cs->VS_END_PC = vs->code_size / 4;
    cs->VS_OUTPUT_COUNT = 1 + link.num_varyings; /* position + varyings */

    /* vs outputs (varyings) */
    DEFINE_ETNA_BITARRAY(vs_output, 16, 8) = {0};
    int varid = 0;
    etna_bitarray_set(vs_output, 8, varid++, vs->vs_pos_out_reg);
    for (int idx = 0; idx < link.num_varyings; ++idx)
       etna_bitarray_set(vs_output, 8, varid++, link.varyings[idx].reg);
    if (vs->vs_pointsize_out_reg >= 0)
       etna_bitarray_set(vs_output, 8, varid++, vs->vs_pointsize_out_reg); /* pointsize is last */

    for (int idx = 0; idx < ARRAY_SIZE(cs->VS_OUTPUT); ++idx)
       cs->VS_OUTPUT[idx] = vs_output[idx];

    if (vs->vs_pointsize_out_reg != -1) {
       /* vertex shader outputs point coordinate, provide extra output and make
        * sure PA config is
        * not masked */
       cs->PA_CONFIG = ~0;
       cs->VS_OUTPUT_COUNT_PSIZE = cs->VS_OUTPUT_COUNT + 1;
    } else {
       /* vertex shader does not output point coordinate, make sure thate
        * POINT_SIZE_ENABLE is masked
        * and no extra output is given */
       cs->PA_CONFIG = ~VIVS_PA_CONFIG_POINT_SIZE_ENABLE;
       cs->VS_OUTPUT_COUNT_PSIZE = cs->VS_OUTPUT_COUNT;
    }

    cs->VS_LOAD_BALANCING = vs->vs_load_balancing;
    cs->VS_START_PC = 0;

    cs->PS_END_PC = fs->code_size / 4;
    cs->PS_OUTPUT_REG = fs->ps_color_out_reg;
    cs->PS_INPUT_COUNT =
       VIVS_PS_INPUT_COUNT_COUNT(link.num_varyings + 1) | /* Number of inputs plus position */
       VIVS_PS_INPUT_COUNT_UNK8(fs->input_count_unk8);
    cs->PS_TEMP_REGISTER_CONTROL =
       VIVS_PS_TEMP_REGISTER_CONTROL_NUM_TEMPS(MAX2(fs->num_temps, link.num_varyings + 1));
    cs->PS_CONTROL = VIVS_PS_CONTROL_UNK1; /* XXX when can we set BYPASS? */
    cs->PS_START_PC = 0;

    /* Precompute PS_INPUT_COUNT and TEMP_REGISTER_CONTROL in the case of MSAA
     * mode, avoids some fumbling in sync_context. */
    cs->PS_INPUT_COUNT_MSAA =
       VIVS_PS_INPUT_COUNT_COUNT(link.num_varyings + 2) | /* MSAA adds another input */
       VIVS_PS_INPUT_COUNT_UNK8(fs->input_count_unk8);
    cs->PS_TEMP_REGISTER_CONTROL_MSAA =
       VIVS_PS_TEMP_REGISTER_CONTROL_NUM_TEMPS(MAX2(fs->num_temps, link.num_varyings + 2));

    uint32_t total_components = 0;
    DEFINE_ETNA_BITARRAY(num_components, ETNA_NUM_VARYINGS, 4) = {0};
    DEFINE_ETNA_BITARRAY(component_use, 4 * ETNA_NUM_VARYINGS, 2) = {0};
    for (int idx = 0; idx < link.num_varyings; ++idx) {
       const struct etna_varying *varying = &link.varyings[idx];

       etna_bitarray_set(num_components, 4, idx, varying->num_components);
       for (int comp = 0; comp < varying->num_components; ++comp) {
          etna_bitarray_set(component_use, 2, total_components, varying->use[comp]);
          total_components += 1;
       }
    }

    cs->GL_VARYING_TOTAL_COMPONENTS =
       VIVS_GL_VARYING_TOTAL_COMPONENTS_NUM(align(total_components, 2));
    cs->GL_VARYING_NUM_COMPONENTS = num_components[0];
    cs->GL_VARYING_COMPONENT_USE[0] = component_use[0];
    cs->GL_VARYING_COMPONENT_USE[1] = component_use[1];

    cs->GL_HALTI5_SH_SPECIALS =
       0x7f7f0000 | /* unknown bits, probably other PS inputs */
       /* pointsize is last (see above) */
       VIVS_GL_HALTI5_SH_SPECIALS_VS_PSIZE_OUT((vs->vs_pointsize_out_reg != -1) ?
                                               cs->VS_OUTPUT_COUNT * 4 : 0x00) |
       VIVS_GL_HALTI5_SH_SPECIALS_PS_PCOORD_IN((link.pcoord_varying_comp_ofs != -1) ?
                                               link.pcoord_varying_comp_ofs : 0x7f);

    /* reference instruction memory */
    cs->vs_inst_mem_size = vs->code_size;
    cs->VS_INST_MEM = vs->code;

    cs->ps_inst_mem_size = fs->code_size;
    cs->PS_INST_MEM = fs->code;

    if (vs->needs_icache | fs->needs_icache) {
       /* If either of the shaders needs ICACHE, we use it for both. It is
        * either switched on or off for the entire shader processor.
        */
       if (!etna_icache_upload_shader(ctx, vs) ||
           !etna_icache_upload_shader(ctx, fs)) {
          assert(0);
          return false;
       }

       cs->VS_INST_ADDR.bo = vs->bo;
       cs->VS_INST_ADDR.offset = 0;
       cs->VS_INST_ADDR.flags = ETNA_RELOC_READ;
       cs->PS_INST_ADDR.bo = fs->bo;
       cs->PS_INST_ADDR.offset = 0;
       cs->PS_INST_ADDR.flags = ETNA_RELOC_READ;
    } else {
       /* clear relocs */
       memset(&cs->VS_INST_ADDR, 0, sizeof(cs->VS_INST_ADDR));
       memset(&cs->PS_INST_ADDR, 0, sizeof(cs->PS_INST_ADDR));
    }

    return true;
 }

 bool
 etna_shader_link(struct etna_context *ctx)
 {
    if (!ctx->shader.vs || !ctx->shader.fs)
       return false;

    /* re-link vs and fs if needed */
    return etna_link_shaders(ctx, &ctx->shader_state, ctx->shader.vs, ctx->shader.fs);
 }

 static bool
 etna_shader_update_vs_inputs(struct compiled_shader_state *cs,
                              const struct etna_shader_variant *vs,
                              const struct compiled_vertex_elements_state *ves)
 {
    unsigned num_temps, cur_temp, num_vs_inputs;

    if (!vs)
       return false;

    /* Number of vertex elements determines number of VS inputs. Otherwise,
     * the GPU crashes. Allocate any unused vertex elements to VS temporary
     * registers. */
    num_vs_inputs = MAX2(ves->num_elements, vs->infile.num_reg);
    if (num_vs_inputs != ves->num_elements) {
       BUG("Number of elements %u does not match the number of VS inputs %zu",
           ves->num_elements, vs->infile.num_reg);
       return false;
    }

    cur_temp = vs->num_temps;
    num_temps = num_vs_inputs - vs->infile.num_reg + cur_temp;

    cs->VS_INPUT_COUNT = VIVS_VS_INPUT_COUNT_COUNT(num_vs_inputs) |
                         VIVS_VS_INPUT_COUNT_UNK8(vs->input_count_unk8);
    cs->VS_TEMP_REGISTER_CONTROL =
       VIVS_VS_TEMP_REGISTER_CONTROL_NUM_TEMPS(num_temps);

    /* vs inputs (attributes) */
    DEFINE_ETNA_BITARRAY(vs_input, 16, 8) = {0};
    for (int idx = 0; idx < num_vs_inputs; ++idx) {
       if (idx < vs->infile.num_reg)
          etna_bitarray_set(vs_input, 8, idx, vs->infile.reg[idx].reg);
       else
          etna_bitarray_set(vs_input, 8, idx, cur_temp++);
    }

    for (int idx = 0; idx < ARRAY_SIZE(cs->VS_INPUT); ++idx)
       cs->VS_INPUT[idx] = vs_input[idx];

    return true;
 }

 static inline const char *
 etna_shader_stage(struct etna_shader_variant *shader)
 {
    switch (shader->processor) {
    case PIPE_SHADER_VERTEX:     return "VERT";
    case PIPE_SHADER_FRAGMENT:   return "FRAG";
    case PIPE_SHADER_COMPUTE:    return "CL";
    default:
       unreachable("invalid type");
       return NULL;
    }
 }

 static void
 dump_shader_info(struct etna_shader_variant *v, struct pipe_debug_callback *debug)
 {
    if (!unlikely(etna_mesa_debug & ETNA_DBG_SHADERDB))
       return;

    pipe_debug_message(debug, SHADER_INFO, "\n"
          "SHADER-DB: %s prog %d/%d: %u instructions %u temps\n"
          "SHADER-DB: %s prog %d/%d: %u immediates %u consts\n"
          "SHADER-DB: %s prog %d/%d: %u loops\n",
          etna_shader_stage(v),
          v->shader->id, v->id,
          v->code_size,
          v->num_temps,
          etna_shader_stage(v),
          v->shader->id, v->id,
          v->uniforms.imm_count,
          v->uniforms.const_count,
          etna_shader_stage(v),
          v->shader->id, v->id,
          v->num_loops);
 }

 bool
 etna_shader_update_vertex(struct etna_context *ctx)
 {
    return etna_shader_update_vs_inputs(&ctx->shader_state, ctx->shader.vs,
                                        ctx->vertex_elements);
 }

 static struct etna_shader_variant *
 create_variant(struct etna_shader *shader, struct etna_shader_key key)
 {
    struct etna_shader_variant *v = CALLOC_STRUCT(etna_shader_variant);
    int ret;

    if (!v)
       return NULL;

    v->shader = shader;
    v->key = key;

    ret = etna_compile_shader(v);
    if (!ret) {
       debug_error("compile failed!");
       goto fail;
    }

    v->id = ++shader->variant_count;

    return v;

 fail:
    FREE(v);
    return NULL;
 }

 struct etna_shader_variant *
 etna_shader_variant(struct etna_shader *shader, struct etna_shader_key key,
                    struct pipe_debug_callback *debug)
 {
    struct etna_shader_variant *v;

    for (v = shader->variants; v; v = v->next)
       if (etna_shader_key_equal(&key, &v->key))
          return v;

    /* compile new variant if it doesn't exist already */
    v = create_variant(shader, key);
    if (v) {
       v->next = shader->variants;
       shader->variants = v;
       dump_shader_info(v, debug);
    }

    return v;
 }

 static void *
 etna_create_shader_state(struct pipe_context *pctx,
                          const struct pipe_shader_state *pss)
 {
    struct etna_context *ctx = etna_context(pctx);
    struct etna_shader *shader = CALLOC_STRUCT(etna_shader);

    if (!shader)
       return NULL;

    static uint32_t id;
    shader->id = id++;
    shader->specs = &ctx->specs;
    shader->tokens = tgsi_dup_tokens(pss->tokens);

    if (etna_mesa_debug & ETNA_DBG_SHADERDB) {
       /* if shader-db run, create a standard variant immediately
        * (as otherwise nothing will trigger the shader to be
        * actually compiled).
        */
       struct etna_shader_key key = {};
       etna_shader_variant(shader, key, &ctx->debug);
    }

    return shader;
 }

 static void
 etna_delete_shader_state(struct pipe_context *pctx, void *ss)
 {
    struct etna_shader *shader = ss;
    struct etna_shader_variant *v, *t;

    v = shader->variants;
    while (v) {
       t = v;
       v = v->next;
       if (t->bo)
          etna_bo_del(t->bo);
       etna_destroy_shader(t);
    }

    FREE(shader->tokens);
    FREE(shader);
 }

 static void
 etna_bind_fs_state(struct pipe_context *pctx, void *hwcso)
 {
    struct etna_context *ctx = etna_context(pctx);

    ctx->shader.bind_fs = hwcso;
    ctx->dirty |= ETNA_DIRTY_SHADER;
 }

 static void
 etna_bind_vs_state(struct pipe_context *pctx, void *hwcso)
 {
    struct etna_context *ctx = etna_context(pctx);

    ctx->shader.bind_vs = hwcso;
    ctx->dirty |= ETNA_DIRTY_SHADER;
 }

 void
 etna_shader_init(struct pipe_context *pctx)
 {
    pctx->create_fs_state = etna_create_shader_state;
    pctx->bind_fs_state = etna_bind_fs_state;
    pctx->delete_fs_state = etna_delete_shader_state;
    pctx->create_vs_state = etna_create_shader_state;
    pctx->bind_vs_state = etna_bind_vs_state;
    pctx->delete_vs_state = etna_delete_shader_state;
 }
	/*
	* Copyright (c) 2012-2015 Etnaviv Project
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the "Software"),
	* to deal in the Software without restriction, including without limitation
	* the rights to use, copy, modify, merge, publish, distribute, sub license,
	* and/or sell copies of the Software, and to permit persons to whom the
	* Software is furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice (including the
	* next paragraph) shall be included in all copies or substantial portions
	* of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	* DEALINGS IN THE SOFTWARE.
	*
	* Authors:
	* Wladimir J. van der Laan <laanwj@gmail.com>
	*/

	#include "etnaviv_shader.h"

	#include "etnaviv_compiler.h"
	#include "etnaviv_context.h"
	#include "etnaviv_debug.h"
	#include "etnaviv_screen.h"
	#include "etnaviv_util.h"

	#include "tgsi/tgsi_parse.h"
	#include "util/u_math.h"
	#include "util/u_memory.h"

	/* Upload shader code to bo, if not already done */
	static bool etna_icache_upload_shader(struct etna_context ctx, struct etna_shader_variant v)
	{
	if (v->bo)
	return true;
	v->bo = etna_bo_new(ctx->screen->dev, v->code_size*4, DRM_ETNA_GEM_CACHE_WC);
	if (!v->bo)
	return false;

	void *buf = etna_bo_map(v->bo);
	etna_bo_cpu_prep(v->bo, DRM_ETNA_PREP_WRITE);
	memcpy(buf, v->code, v->code_size*4);
	etna_bo_cpu_fini(v->bo);
	DBG("Uploaded %s of %u words to bo %p", v->processor == PIPE_SHADER_FRAGMENT ? "fs":"vs", v->code_size, v->bo);
	return true;
	}

	/* Link vs and fs together: fill in shader_state from vs and fs
	* as this function is called every time a new fs or vs is bound, the goal is to
	* do little processing as possible here, and to precompute as much as possible in
	* the vs/fs shader_object.
	*
	* XXX we could cache the link result for a certain set of VS/PS; usually a pair
	* of VS and PS will be used together anyway.
	*/
	static bool
	etna_link_shaders(struct etna_context ctx, struct compiled_shader_state cs,
	struct etna_shader_variant vs, struct etna_shader_variant fs)
	{
	struct etna_shader_link_info link = { };

	assert(vs->processor == PIPE_SHADER_VERTEX);
	assert(fs->processor == PIPE_SHADER_FRAGMENT);

	#ifdef DEBUG
	if (DBG_ENABLED(ETNA_DBG_DUMP_SHADERS)) {
	etna_dump_shader(vs);
	etna_dump_shader(fs);
	}
	#endif

	if (etna_link_shader(&link, vs, fs)) {
	/* linking failed: some fs inputs do not have corresponding
	* vs outputs */
	assert(0);

	return false;
	}

	if (DBG_ENABLED(ETNA_DBG_LINKER_MSGS)) {
	debug_printf("link result:\n");
	debug_printf(" vs -> fs comps use pa_attr\n");

	for (int idx = 0; idx < link.num_varyings; ++idx)
	debug_printf(" t%-2u -> t%-2u %-5.*s %u,%u,%u,%u 0x%08x\n",
	link.varyings[idx].reg, idx + 1,
	link.varyings[idx].num_components, "xyzw",
	link.varyings[idx].use[0], link.varyings[idx].use[1],
	link.varyings[idx].use[2], link.varyings[idx].use[3],
	link.varyings[idx].pa_attributes);
	}

	/* set last_varying_2x flag if the last varying has 1 or 2 components */
	bool last_varying_2x = false;
	if (link.num_varyings > 0 && link.varyings[link.num_varyings - 1].num_components <= 2)
	last_varying_2x = true;

	cs->RA_CONTROL = VIVS_RA_CONTROL_UNK0 \|
	COND(last_varying_2x, VIVS_RA_CONTROL_LAST_VARYING_2X);

	cs->PA_ATTRIBUTE_ELEMENT_COUNT = VIVS_PA_ATTRIBUTE_ELEMENT_COUNT_COUNT(link.num_varyings);
	for (int idx = 0; idx < link.num_varyings; ++idx)
	cs->PA_SHADER_ATTRIBUTES[idx] = link.varyings[idx].pa_attributes;

	cs->VS_END_PC = vs->code_size / 4;
	cs->VS_OUTPUT_COUNT = 1 + link.num_varyings; /* position + varyings */

	/* vs outputs (varyings) */
	DEFINE_ETNA_BITARRAY(vs_output, 16, 8) = {0};
	int varid = 0;
	etna_bitarray_set(vs_output, 8, varid++, vs->vs_pos_out_reg);
	for (int idx = 0; idx < link.num_varyings; ++idx)
	etna_bitarray_set(vs_output, 8, varid++, link.varyings[idx].reg);
	if (vs->vs_pointsize_out_reg >= 0)
	etna_bitarray_set(vs_output, 8, varid++, vs->vs_pointsize_out_reg); /* pointsize is last */

	for (int idx = 0; idx < ARRAY_SIZE(cs->VS_OUTPUT); ++idx)
	cs->VS_OUTPUT[idx] = vs_output[idx];

	if (vs->vs_pointsize_out_reg != -1) {
	/* vertex shader outputs point coordinate, provide extra output and make
	* sure PA config is
	* not masked */
	cs->PA_CONFIG = ~0;
	cs->VS_OUTPUT_COUNT_PSIZE = cs->VS_OUTPUT_COUNT + 1;
	} else {
	/* vertex shader does not output point coordinate, make sure thate
	* POINT_SIZE_ENABLE is masked
	* and no extra output is given */
	cs->PA_CONFIG = ~VIVS_PA_CONFIG_POINT_SIZE_ENABLE;
	cs->VS_OUTPUT_COUNT_PSIZE = cs->VS_OUTPUT_COUNT;
	}

	cs->VS_LOAD_BALANCING = vs->vs_load_balancing;
	cs->VS_START_PC = 0;

	cs->PS_END_PC = fs->code_size / 4;
	cs->PS_OUTPUT_REG = fs->ps_color_out_reg;
	cs->PS_INPUT_COUNT =
	VIVS_PS_INPUT_COUNT_COUNT(link.num_varyings + 1) \| /* Number of inputs plus position */
	VIVS_PS_INPUT_COUNT_UNK8(fs->input_count_unk8);
	cs->PS_TEMP_REGISTER_CONTROL =
	VIVS_PS_TEMP_REGISTER_CONTROL_NUM_TEMPS(MAX2(fs->num_temps, link.num_varyings + 1));
	cs->PS_CONTROL = VIVS_PS_CONTROL_UNK1; /* XXX when can we set BYPASS? */
	cs->PS_START_PC = 0;

	/* Precompute PS_INPUT_COUNT and TEMP_REGISTER_CONTROL in the case of MSAA
	* mode, avoids some fumbling in sync_context. */
	cs->PS_INPUT_COUNT_MSAA =
	VIVS_PS_INPUT_COUNT_COUNT(link.num_varyings + 2) \| /* MSAA adds another input */
	VIVS_PS_INPUT_COUNT_UNK8(fs->input_count_unk8);
	cs->PS_TEMP_REGISTER_CONTROL_MSAA =
	VIVS_PS_TEMP_REGISTER_CONTROL_NUM_TEMPS(MAX2(fs->num_temps, link.num_varyings + 2));

	uint32_t total_components = 0;
	DEFINE_ETNA_BITARRAY(num_components, ETNA_NUM_VARYINGS, 4) = {0};
	DEFINE_ETNA_BITARRAY(component_use, 4 * ETNA_NUM_VARYINGS, 2) = {0};
	for (int idx = 0; idx < link.num_varyings; ++idx) {
	const struct etna_varying *varying = &link.varyings[idx];

	etna_bitarray_set(num_components, 4, idx, varying->num_components);
	for (int comp = 0; comp < varying->num_components; ++comp) {
	etna_bitarray_set(component_use, 2, total_components, varying->use[comp]);
	total_components += 1;
	}
	}

	cs->GL_VARYING_TOTAL_COMPONENTS =
	VIVS_GL_VARYING_TOTAL_COMPONENTS_NUM(align(total_components, 2));
	cs->GL_VARYING_NUM_COMPONENTS = num_components[0];
	cs->GL_VARYING_COMPONENT_USE[0] = component_use[0];
	cs->GL_VARYING_COMPONENT_USE[1] = component_use[1];

	cs->GL_HALTI5_SH_SPECIALS =
	0x7f7f0000 \| /* unknown bits, probably other PS inputs */
	/* pointsize is last (see above) */
	VIVS_GL_HALTI5_SH_SPECIALS_VS_PSIZE_OUT((vs->vs_pointsize_out_reg != -1) ?
	cs->VS_OUTPUT_COUNT * 4 : 0x00) \|
	VIVS_GL_HALTI5_SH_SPECIALS_PS_PCOORD_IN((link.pcoord_varying_comp_ofs != -1) ?
	link.pcoord_varying_comp_ofs : 0x7f);

	/* reference instruction memory */
	cs->vs_inst_mem_size = vs->code_size;
	cs->VS_INST_MEM = vs->code;

	cs->ps_inst_mem_size = fs->code_size;
	cs->PS_INST_MEM = fs->code;

	if (vs->needs_icache \| fs->needs_icache) {
	/* If either of the shaders needs ICACHE, we use it for both. It is
	* either switched on or off for the entire shader processor.
	*/
	if (!etna_icache_upload_shader(ctx, vs) \|\|
	!etna_icache_upload_shader(ctx, fs)) {
	assert(0);
	return false;
	}

	cs->VS_INST_ADDR.bo = vs->bo;
	cs->VS_INST_ADDR.offset = 0;
	cs->VS_INST_ADDR.flags = ETNA_RELOC_READ;
	cs->PS_INST_ADDR.bo = fs->bo;
	cs->PS_INST_ADDR.offset = 0;
	cs->PS_INST_ADDR.flags = ETNA_RELOC_READ;
	} else {
	/* clear relocs */
	memset(&cs->VS_INST_ADDR, 0, sizeof(cs->VS_INST_ADDR));
	memset(&cs->PS_INST_ADDR, 0, sizeof(cs->PS_INST_ADDR));
	}

	return true;
	}

	bool
	etna_shader_link(struct etna_context *ctx)
	{
	if (!ctx->shader.vs \|\| !ctx->shader.fs)
	return false;

	/* re-link vs and fs if needed */
	return etna_link_shaders(ctx, &ctx->shader_state, ctx->shader.vs, ctx->shader.fs);
	}

	static bool
	etna_shader_update_vs_inputs(struct compiled_shader_state *cs,
	const struct etna_shader_variant *vs,
	const struct compiled_vertex_elements_state *ves)
	{
	unsigned num_temps, cur_temp, num_vs_inputs;

	if (!vs)
	return false;

	/* Number of vertex elements determines number of VS inputs. Otherwise,
	* the GPU crashes. Allocate any unused vertex elements to VS temporary
	* registers. */
	num_vs_inputs = MAX2(ves->num_elements, vs->infile.num_reg);
	if (num_vs_inputs != ves->num_elements) {
	BUG("Number of elements %u does not match the number of VS inputs %zu",
	ves->num_elements, vs->infile.num_reg);
	return false;
	}

	cur_temp = vs->num_temps;
	num_temps = num_vs_inputs - vs->infile.num_reg + cur_temp;

	cs->VS_INPUT_COUNT = VIVS_VS_INPUT_COUNT_COUNT(num_vs_inputs) \|
	VIVS_VS_INPUT_COUNT_UNK8(vs->input_count_unk8);
	cs->VS_TEMP_REGISTER_CONTROL =
	VIVS_VS_TEMP_REGISTER_CONTROL_NUM_TEMPS(num_temps);

	/* vs inputs (attributes) */
	DEFINE_ETNA_BITARRAY(vs_input, 16, 8) = {0};
	for (int idx = 0; idx < num_vs_inputs; ++idx) {
	if (idx < vs->infile.num_reg)
	etna_bitarray_set(vs_input, 8, idx, vs->infile.reg[idx].reg);
	else
	etna_bitarray_set(vs_input, 8, idx, cur_temp++);
	}

	for (int idx = 0; idx < ARRAY_SIZE(cs->VS_INPUT); ++idx)
	cs->VS_INPUT[idx] = vs_input[idx];

	return true;
	}

	static inline const char *
	etna_shader_stage(struct etna_shader_variant *shader)
	{
	switch (shader->processor) {
	case PIPE_SHADER_VERTEX: return "VERT";
	case PIPE_SHADER_FRAGMENT: return "FRAG";
	case PIPE_SHADER_COMPUTE: return "CL";
	default:
	unreachable("invalid type");
	return NULL;
	}
	}

	static void
	dump_shader_info(struct etna_shader_variant v, struct pipe_debug_callback debug)
	{
	if (!unlikely(etna_mesa_debug & ETNA_DBG_SHADERDB))
	return;

	pipe_debug_message(debug, SHADER_INFO, "\n"
	"SHADER-DB: %s prog %d/%d: %u instructions %u temps\n"
	"SHADER-DB: %s prog %d/%d: %u immediates %u consts\n"
	"SHADER-DB: %s prog %d/%d: %u loops\n",
	etna_shader_stage(v),
	v->shader->id, v->id,
	v->code_size,
	v->num_temps,
	etna_shader_stage(v),
	v->shader->id, v->id,
	v->uniforms.imm_count,
	v->uniforms.const_count,
	etna_shader_stage(v),
	v->shader->id, v->id,
	v->num_loops);
	}

	bool
	etna_shader_update_vertex(struct etna_context *ctx)
	{
	return etna_shader_update_vs_inputs(&ctx->shader_state, ctx->shader.vs,
	ctx->vertex_elements);
	}

	static struct etna_shader_variant *
	create_variant(struct etna_shader *shader, struct etna_shader_key key)
	{
	struct etna_shader_variant *v = CALLOC_STRUCT(etna_shader_variant);
	int ret;

	if (!v)
	return NULL;

	v->shader = shader;
	v->key = key;

	ret = etna_compile_shader(v);
	if (!ret) {
	debug_error("compile failed!");
	goto fail;
	}

	v->id = ++shader->variant_count;

	return v;

	fail:
	FREE(v);
	return NULL;
	}

	struct etna_shader_variant *
	etna_shader_variant(struct etna_shader *shader, struct etna_shader_key key,
	struct pipe_debug_callback *debug)
	{
	struct etna_shader_variant *v;

	for (v = shader->variants; v; v = v->next)
	if (etna_shader_key_equal(&key, &v->key))
	return v;

	/* compile new variant if it doesn't exist already */
	v = create_variant(shader, key);
	if (v) {
	v->next = shader->variants;
	shader->variants = v;
	dump_shader_info(v, debug);
	}

	return v;
	}

	static void *
	etna_create_shader_state(struct pipe_context *pctx,
	const struct pipe_shader_state *pss)
	{
	struct etna_context *ctx = etna_context(pctx);
	struct etna_shader *shader = CALLOC_STRUCT(etna_shader);

	if (!shader)
	return NULL;

	static uint32_t id;
	shader->id = id++;
	shader->specs = &ctx->specs;
	shader->tokens = tgsi_dup_tokens(pss->tokens);

	if (etna_mesa_debug & ETNA_DBG_SHADERDB) {
	/* if shader-db run, create a standard variant immediately
	* (as otherwise nothing will trigger the shader to be
	* actually compiled).
	*/
	struct etna_shader_key key = {};
	etna_shader_variant(shader, key, &ctx->debug);
	}

	return shader;
	}

	static void
	etna_delete_shader_state(struct pipe_context pctx, void ss)
	{
	struct etna_shader *shader = ss;
	struct etna_shader_variant v, t;

	v = shader->variants;
	while (v) {
	t = v;
	v = v->next;
	if (t->bo)
	etna_bo_del(t->bo);
	etna_destroy_shader(t);
	}

	FREE(shader->tokens);
	FREE(shader);
	}

	static void
	etna_bind_fs_state(struct pipe_context pctx, void hwcso)
	{
	struct etna_context *ctx = etna_context(pctx);

	ctx->shader.bind_fs = hwcso;
	ctx->dirty \|= ETNA_DIRTY_SHADER;
	}

	static void
	etna_bind_vs_state(struct pipe_context pctx, void hwcso)
	{
	struct etna_context *ctx = etna_context(pctx);

	ctx->shader.bind_vs = hwcso;
	ctx->dirty \|= ETNA_DIRTY_SHADER;
	}

	void
	etna_shader_init(struct pipe_context *pctx)
	{
	pctx->create_fs_state = etna_create_shader_state;
	pctx->bind_fs_state = etna_bind_fs_state;
	pctx->delete_fs_state = etna_delete_shader_state;
	pctx->create_vs_state = etna_create_shader_state;
	pctx->bind_vs_state = etna_bind_vs_state;
	pctx->delete_vs_state = etna_delete_shader_state;
	}