src/mesa/state_tracker/st_atifs_to_nir.c - third_party/mesa - Git at Google

 /*
  * Copyright (C) 2016 Miklós Máté
  * Copyright (C) 2020 Google LLC
  *
  * 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, sublicense,
  * 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 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 NONINFRINGEMENT.  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.
  */

 #include "main/mtypes.h"
 #include "main/atifragshader.h"
 #include "main/errors.h"
 #include "program/prog_parameter.h"
 #include "program/prog_instruction.h"
 #include "program/prog_to_nir.h"

 #include "st_program.h"
 #include "st_atifs_to_nir.h"
 #include "compiler/nir/nir_builder.h"

 /**
  * Intermediate state used during shader translation.
  */
 struct st_translate {
    nir_builder *b;
    struct ati_fragment_shader *atifs;

    nir_def *temps[MAX_PROGRAM_TEMPS];

    nir_variable *fragcolor;
    nir_variable *constants;
    nir_variable *samplers[MAX_TEXTURE_UNITS];

    nir_def *inputs[VARYING_SLOT_MAX];

    unsigned current_pass;

    bool regs_written[MAX_NUM_PASSES_ATI][MAX_NUM_FRAGMENT_REGISTERS_ATI];

    bool error;
 };

 static nir_def *
 nir_channel_vec4(nir_builder *b, nir_def *src, unsigned channel)
 {
    unsigned swizzle[4] = { channel, channel, channel, channel };
    return nir_swizzle(b, src, swizzle, 4);
 }

 static nir_def *
 nir_imm_vec4_float(nir_builder *b, float f)
 {
    return nir_imm_vec4(b, f, f, f, f);
 }

 static nir_def *
 get_temp(struct st_translate *t, unsigned index)
 {
    if (!t->temps[index])
       t->temps[index] = nir_undef(t->b, 4, 32);
    return t->temps[index];
 }

 static nir_def *
 apply_swizzle(struct st_translate *t,
               struct nir_def *src, GLuint swizzle)
 {
    /* From the ATI_fs spec:
     *
     *     "Table 3.20 shows the <swizzle> modes:
     *
     *                           Coordinates Used for 1D or      Coordinates Used for
     *      Swizzle              2D SampleMap and PassTexCoord   3D or cubemap SampleMap
     *      -------              -----------------------------   -----------------------
     *      SWIZZLE_STR_ATI      (s, t, r, undefined)            (s, t, r, undefined)
     *      SWIZZLE_STQ_ATI      (s, t, q, undefined)            (s, t, q, undefined)
     *      SWIZZLE_STR_DR_ATI   (s/r, t/r, 1/r, undefined)      (undefined)
     *      SWIZZLE_STQ_DQ_ATI   (s/q, t/q, 1/q, undefined)      (undefined)
     */
    if (swizzle == GL_SWIZZLE_STR_ATI) {
       return src;
    } else if (swizzle == GL_SWIZZLE_STQ_ATI) {
       static unsigned xywz[4] = { 0, 1, 3, 2 };
       return nir_swizzle(t->b, src, xywz, 4);
    } else {
       nir_def *rcp = nir_frcp(t->b, nir_channel(t->b, src,
                                                     swizzle == GL_SWIZZLE_STR_DR_ATI ? 2 : 3));

       nir_def *st_mul = nir_fmul(t->b, nir_trim_vector(t->b, src, 2), rcp);

       return nir_vec4(t->b,
                       nir_channel(t->b, st_mul, 0),
                       nir_channel(t->b, st_mul, 1),
                       rcp,
                       rcp);
    }
 }

 static nir_def *
 load_input(struct st_translate *t, gl_varying_slot slot)
 {
    if (!t->inputs[slot]) {
       nir_variable *var = nir_create_variable_with_location(t->b->shader, nir_var_shader_in, slot,
                                                             glsl_vec4_type());
       var->data.interpolation = INTERP_MODE_NONE;

       t->inputs[slot] = nir_load_var(t->b, var);
    }

    return t->inputs[slot];
 }

 static nir_def *
 atifs_load_uniform(struct st_translate *t, int index)
 {
    nir_deref_instr *deref = nir_build_deref_array(t->b,
                                                   nir_build_deref_var(t->b, t->constants),
                                                   nir_imm_int(t->b, index));
    return nir_load_deref(t->b, deref);
 }

 static struct nir_def *
 get_source(struct st_translate *t, GLenum src_type)
 {
    if (src_type >= GL_REG_0_ATI && src_type <= GL_REG_5_ATI) {
       if (t->regs_written[t->current_pass][src_type - GL_REG_0_ATI]) {
          return get_temp(t, src_type - GL_REG_0_ATI);
       } else {
          return nir_imm_vec4_float(t->b, 0.0);
       }
    } else if (src_type >= GL_CON_0_ATI && src_type <= GL_CON_7_ATI) {
       int index = src_type - GL_CON_0_ATI;
       if (t->atifs->LocalConstDef & (1 << index)) {
          return nir_imm_vec4(t->b,
                              t->atifs->Constants[index][0],
                              t->atifs->Constants[index][1],
                              t->atifs->Constants[index][2],
                              t->atifs->Constants[index][3]);
       } else {
          return atifs_load_uniform(t, index);
       }
    } else if (src_type == GL_ZERO) {
       return nir_imm_vec4_float(t->b, 0.0);
    } else if (src_type == GL_ONE) {
       return nir_imm_vec4_float(t->b, 1.0);
    } else if (src_type == GL_PRIMARY_COLOR_ARB) {
       return load_input(t, VARYING_SLOT_COL0);
    } else if (src_type == GL_SECONDARY_INTERPOLATOR_ATI) {
       return load_input(t, VARYING_SLOT_COL1);
    } else {
       /* frontend prevents this */
       unreachable("unknown source");
    }
 }

 static nir_def *
 prepare_argument(struct st_translate *t, const struct atifs_instruction *inst,
                  const unsigned argId, bool alpha)
 {
    if (argId >= inst->ArgCount[alpha]) {
       _mesa_warning(0, "Using 0 for missing argument %d\n", argId);
       return nir_imm_vec4_float(t->b, 0.0f);
    }

    const struct atifragshader_src_register *srcReg = &inst->SrcReg[alpha][argId];

    nir_def *src = get_source(t, srcReg->Index);

    switch (srcReg->argRep) {
    case GL_NONE:
       break;
    case GL_RED:
       src = nir_channel_vec4(t->b, src, 0);
       break;
    case GL_GREEN:
       src = nir_channel_vec4(t->b, src, 1);
       break;
    case GL_BLUE:
       src = nir_channel_vec4(t->b, src, 2);
       break;
    case GL_ALPHA:
       src = nir_channel_vec4(t->b, src, 3);
       break;
    }

    t->temps[MAX_NUM_FRAGMENT_REGISTERS_ATI + argId] = src;

    if (srcReg->argMod & GL_COMP_BIT_ATI)
       src = nir_fsub_imm(t->b, 1.0, src);
    if (srcReg->argMod & GL_BIAS_BIT_ATI)
       src = nir_fadd_imm(t->b, src, -0.5);
    if (srcReg->argMod & GL_2X_BIT_ATI)
       src = nir_fadd(t->b, src, src);
    if (srcReg->argMod & GL_NEGATE_BIT_ATI)
       src = nir_fneg(t->b, src);

    return src;
 }

 static nir_def *
 emit_arith_inst(struct st_translate *t,
                 const struct atifs_instruction *inst,
                 bool alpha)
 {
    nir_def *src[3] = {0};
    for (int i = 0; i < inst->ArgCount[alpha]; i++)
       src[i] = prepare_argument(t, inst, i, alpha);

    switch (inst->Opcode[alpha]) {
    case GL_MOV_ATI:
       return src[0];

    case GL_ADD_ATI:
       return nir_fadd(t->b, src[0], src[1]);

    case GL_SUB_ATI:
       return nir_fsub(t->b, src[0], src[1]);

    case GL_MUL_ATI:
       return nir_fmul(t->b, src[0], src[1]);

    case GL_MAD_ATI:
       return nir_ffma(t->b, src[0], src[1], src[2]);

    case GL_LERP_ATI:
       return nir_flrp(t->b, src[2], src[1], src[0]);

    case GL_CND_ATI:
       return nir_bcsel(t->b,
                        nir_fle_imm(t->b, src[2], 0.5),
                        src[1],
                        src[0]);

    case GL_CND0_ATI:
       return nir_bcsel(t->b,
                        nir_fge_imm(t->b, src[2], 0.0),
                        src[0],
                        src[1]);

    case GL_DOT2_ADD_ATI:
       return nir_channel_vec4(t->b,
                               nir_fadd(t->b,
                                        nir_fdot2(t->b, src[0], src[1]),
                                        nir_channel(t->b, src[1], 2)),
                               0);

    case GL_DOT3_ATI:
       return nir_channel_vec4(t->b, nir_fdot3(t->b,src[0], src[1]), 0);

    case GL_DOT4_ATI:
       return nir_channel_vec4(t->b, nir_fdot4(t->b,src[0], src[1]), 0);

    default:
       unreachable("Unknown ATI_fs opcode");
    }
 }

 static nir_def *
 emit_dstmod(struct st_translate *t,
             struct nir_def *dst, GLuint dstMod)
 {
    switch (dstMod & ~GL_SATURATE_BIT_ATI) {
    case GL_2X_BIT_ATI:
       dst = nir_fmul_imm(t->b, dst, 2.0f);
       break;
    case GL_4X_BIT_ATI:
       dst = nir_fmul_imm(t->b, dst, 4.0f);
       break;
    case GL_8X_BIT_ATI:
       dst = nir_fmul_imm(t->b, dst, 8.0f);
       break;
    case GL_HALF_BIT_ATI:
       dst = nir_fmul_imm(t->b, dst, 0.5f);
       break;
    case GL_QUARTER_BIT_ATI:
       dst = nir_fmul_imm(t->b, dst, 0.25f);
       break;
    case GL_EIGHTH_BIT_ATI:
       dst = nir_fmul_imm(t->b, dst, 0.125f);
       break;
    default:
       break;
    }

    if (dstMod & GL_SATURATE_BIT_ATI)
       dst = nir_fsat(t->b, dst);

    return dst;
 }

 /**
  * Compile one setup instruction to NIR instructions.
  */
 static void
 compile_setupinst(struct st_translate *t,
                   const unsigned r,
                   const struct atifs_setupinst *texinst)
 {
    if (!texinst->Opcode)
       return;

    GLuint pass_tex = texinst->src;

    nir_def *coord;

    if (pass_tex >= GL_TEXTURE0_ARB && pass_tex <= GL_TEXTURE7_ARB) {
       unsigned attr = pass_tex - GL_TEXTURE0_ARB;

       coord = load_input(t, VARYING_SLOT_TEX0 + attr);
    } else if (pass_tex >= GL_REG_0_ATI && pass_tex <= GL_REG_5_ATI) {
       unsigned reg = pass_tex - GL_REG_0_ATI;

       /* the frontend already validated that REG is only allowed in second pass */
       if (t->regs_written[0][reg]) {
          coord = t->temps[reg];
       } else {
          coord = nir_imm_vec4_float(t->b, 0.0f);
       }
    } else {
       coord = nir_undef(t->b, 4, 32);
    }
    coord = apply_swizzle(t, coord, texinst->swizzle);

    if (texinst->Opcode == ATI_FRAGMENT_SHADER_SAMPLE_OP) {
       nir_variable *tex_var = t->samplers[r];
       if (!tex_var) {
          /* The actual sampler dim will be determined at draw time and lowered
           * by st_nir_update_atifs_samplers. Setting it to 3D for now means we
           * don't optimize out coordinate channels we may need later.
           */
          const struct glsl_type *sampler_type =
              glsl_sampler_type(GLSL_SAMPLER_DIM_3D, false, false, GLSL_TYPE_FLOAT);

          tex_var = nir_variable_create(t->b->shader, nir_var_uniform, sampler_type, "tex");
          tex_var->data.binding = r;
          tex_var->data.explicit_binding = true;
          t->samplers[r] = tex_var;
       }
       nir_deref_instr *tex_deref = nir_build_deref_var(t->b, t->samplers[r]);

       nir_tex_instr *tex = nir_tex_instr_create(t->b->shader, 3);
       tex->op = nir_texop_tex;
       tex->sampler_dim = glsl_get_sampler_dim(tex_var->type);
       tex->dest_type = nir_type_float32;
       tex->coord_components =
          glsl_get_sampler_dim_coordinate_components(tex->sampler_dim);

       tex->src[0] = nir_tex_src_for_ssa(nir_tex_src_texture_deref,
                                         &tex_deref->def);
       tex->src[1] = nir_tex_src_for_ssa(nir_tex_src_sampler_deref,
                                         &tex_deref->def);
       tex->src[2] = nir_tex_src_for_ssa(nir_tex_src_coord,
                                         nir_trim_vector(t->b, coord, tex->coord_components));

       nir_def_init(&tex->instr, &tex->def, 4, 32);
       nir_builder_instr_insert(t->b, &tex->instr);

       t->temps[r] = &tex->def;
    } else if (texinst->Opcode == ATI_FRAGMENT_SHADER_PASS_OP) {
       t->temps[r] = coord;
    }

    t->regs_written[t->current_pass][r] = true;
 }

 /**
  * Compile one arithmetic operation COLOR&ALPHA pair into NIR instructions.
  */
 static void
 compile_instruction(struct st_translate *t,
                     const struct atifs_instruction *inst)
 {
    unsigned optype;

    for (optype = 0; optype < 2; optype++) { /* color, alpha */
       unsigned dstreg = inst->DstReg[optype].Index - GL_REG_0_ATI;

       if (!inst->Opcode[optype])
          continue;

       /* Execute the op */
       nir_def *result = emit_arith_inst(t, inst, optype);
       result = emit_dstmod(t, result, inst->DstReg[optype].dstMod);

       /* Do the writemask */
       nir_const_value wrmask[4];
       for (int i = 0; i < 4; i++) {
          bool bit = inst->DstReg[optype].dstMask & (1 << i);
          wrmask[i] = nir_const_value_for_bool(bit, 1);
       }

       t->temps[dstreg] = nir_bcsel(t->b,
                                    nir_build_imm(t->b, 4, 1, wrmask),
                                    result,
                                    get_temp(t, dstreg));
       t->regs_written[t->current_pass][dstreg] = true;
    }
 }


 /* Creates the uniform variable referencing the ATI_fragment_shader constants.
  */
 static void
 st_atifs_setup_uniforms(struct st_translate *t, struct gl_program *program)
 {
    const struct glsl_type *type =
       glsl_array_type(glsl_vec4_type(), program->Parameters->NumParameters, 0);
    t->constants =
       nir_variable_create(t->b->shader, nir_var_uniform, type,
                           "gl_ATI_fragment_shader_constants");
 }

 /**
  * Called when a new variant is needed, we need to translate
  * the ATI fragment shader to NIR
  */
 nir_shader *
 st_translate_atifs_program(struct ati_fragment_shader *atifs,
                            struct gl_program *program,
                            const nir_shader_compiler_options *options)
 {
    nir_builder b = nir_builder_init_simple_shader(MESA_SHADER_FRAGMENT, options, "ATI_fs");

    struct st_translate translate = {
       .atifs = atifs,
       .b = &b,
    };
    struct st_translate *t = &translate;

    /* Copy the shader_info from the gl_program */
    t->b->shader->info = program->info;

    nir_shader *s = t->b->shader;
    s->info.name = ralloc_asprintf(s, "ATIFS%d", program->Id);
    s->info.internal = false;

    t->fragcolor = nir_create_variable_with_location(b.shader, nir_var_shader_out,
                                                     FRAG_RESULT_COLOR, glsl_vec4_type());

    st_atifs_setup_uniforms(t, program);

    /* emit instructions */
    for (unsigned pass = 0; pass < atifs->NumPasses; pass++) {
       t->current_pass = pass;
       for (unsigned r = 0; r < MAX_NUM_FRAGMENT_REGISTERS_ATI; r++) {
          struct atifs_setupinst *texinst = &atifs->SetupInst[pass][r];
          compile_setupinst(t, r, texinst);
       }
       for (unsigned i = 0; i < atifs->numArithInstr[pass]; i++) {
          struct atifs_instruction *inst = &atifs->Instructions[pass][i];
          compile_instruction(t, inst);
       }
    }

    if (t->regs_written[atifs->NumPasses-1][0])
       nir_store_var(t->b, t->fragcolor, t->temps[0], 0xf);

    return b.shader;
 }

 static bool
 st_nir_lower_atifs_samplers_instr(nir_builder *b, nir_instr *instr, void *data)
 {
    const uint8_t *texture_index = data;

    /* Can't just do this in tex handling below, as llvmpipe leaves dead code
     * derefs around.
     */
    if (instr->type == nir_instr_type_deref) {
       nir_deref_instr *deref = nir_instr_as_deref(instr);
       nir_variable *var = nir_deref_instr_get_variable(deref);
       if (glsl_type_is_sampler(var->type))
          deref->type = var->type;
    }

    if (instr->type != nir_instr_type_tex)
       return false;

    b->cursor = nir_before_instr(instr);

    nir_tex_instr *tex = nir_instr_as_tex(instr);

    unsigned unit;
    int sampler_src_idx = nir_tex_instr_src_index(tex, nir_tex_src_sampler_deref);
    if (sampler_src_idx >= 0) {
       nir_deref_instr *deref = nir_src_as_deref(tex->src[sampler_src_idx].src);
       nir_variable *var = nir_deref_instr_get_variable(deref);
       unit = var->data.binding;
    } else {
       unit = tex->sampler_index;
    }

    bool is_array;
    tex->sampler_dim =
        _mesa_texture_index_to_sampler_dim(texture_index[unit], &is_array);

    int coords_idx = nir_tex_instr_src_index(tex, nir_tex_src_coord);
    assert(coords_idx >= 0);
    int coord_components =
        glsl_get_sampler_dim_coordinate_components(tex->sampler_dim);
    /* Trim unused coords, or append undefs as necessary (if someone
     * accidentally enables a cube array).
     */
    if (coord_components != tex->coord_components) {
       nir_def *coords = tex->src[coords_idx].src.ssa;
       nir_src_rewrite(&tex->src[coords_idx].src,
                       nir_resize_vector(b, coords, coord_components));
       tex->coord_components = coord_components;
    }

    return true;
 }

 /**
  * Rewrites sampler dimensions and coordinate components for the currently
  * active texture unit at draw time.
  */
 bool
 st_nir_lower_atifs_samplers(struct nir_shader *s, const uint8_t *texture_index)
 {
    nir_foreach_uniform_variable(var, s) {
       if (!glsl_type_is_sampler(var->type))
          continue;
       bool is_array;
       enum glsl_sampler_dim sampler_dim =
           _mesa_texture_index_to_sampler_dim(texture_index[var->data.binding], &is_array);
       var->type = glsl_sampler_type(sampler_dim, false, is_array, GLSL_TYPE_FLOAT);
    }

    return nir_shader_instructions_pass(s, st_nir_lower_atifs_samplers_instr,\
                                        nir_metadata_control_flow,
                                        (void *)texture_index);
 }
	/*
	* Copyright (C) 2016 Miklós Máté
	* Copyright (C) 2020 Google LLC
	*
	* 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, sublicense,
	* 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 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 NONINFRINGEMENT. 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.
	*/

	#include "main/mtypes.h"
	#include "main/atifragshader.h"
	#include "main/errors.h"
	#include "program/prog_parameter.h"
	#include "program/prog_instruction.h"
	#include "program/prog_to_nir.h"

	#include "st_program.h"
	#include "st_atifs_to_nir.h"
	#include "compiler/nir/nir_builder.h"

	/**
	* Intermediate state used during shader translation.
	*/
	struct st_translate {
	nir_builder *b;
	struct ati_fragment_shader *atifs;

	nir_def *temps[MAX_PROGRAM_TEMPS];

	nir_variable *fragcolor;
	nir_variable *constants;
	nir_variable *samplers[MAX_TEXTURE_UNITS];

	nir_def *inputs[VARYING_SLOT_MAX];

	unsigned current_pass;

	bool regs_written[MAX_NUM_PASSES_ATI][MAX_NUM_FRAGMENT_REGISTERS_ATI];

	bool error;
	};

	static nir_def *
	nir_channel_vec4(nir_builder b, nir_def src, unsigned channel)
	{
	unsigned swizzle[4] = { channel, channel, channel, channel };
	return nir_swizzle(b, src, swizzle, 4);
	}

	static nir_def *
	nir_imm_vec4_float(nir_builder *b, float f)
	{
	return nir_imm_vec4(b, f, f, f, f);
	}

	static nir_def *
	get_temp(struct st_translate *t, unsigned index)
	{
	if (!t->temps[index])
	t->temps[index] = nir_undef(t->b, 4, 32);
	return t->temps[index];
	}

	static nir_def *
	apply_swizzle(struct st_translate *t,
	struct nir_def *src, GLuint swizzle)
	{
	/* From the ATI_fs spec:
	*
	* "Table 3.20 shows the <swizzle> modes:
	*
	* Coordinates Used for 1D or Coordinates Used for
	* Swizzle 2D SampleMap and PassTexCoord 3D or cubemap SampleMap
	* ------- ----------------------------- -----------------------
	* SWIZZLE_STR_ATI (s, t, r, undefined) (s, t, r, undefined)
	* SWIZZLE_STQ_ATI (s, t, q, undefined) (s, t, q, undefined)
	* SWIZZLE_STR_DR_ATI (s/r, t/r, 1/r, undefined) (undefined)
	* SWIZZLE_STQ_DQ_ATI (s/q, t/q, 1/q, undefined) (undefined)
	*/
	if (swizzle == GL_SWIZZLE_STR_ATI) {
	return src;
	} else if (swizzle == GL_SWIZZLE_STQ_ATI) {
	static unsigned xywz[4] = { 0, 1, 3, 2 };
	return nir_swizzle(t->b, src, xywz, 4);
	} else {
	nir_def *rcp = nir_frcp(t->b, nir_channel(t->b, src,
	swizzle == GL_SWIZZLE_STR_DR_ATI ? 2 : 3));

	nir_def *st_mul = nir_fmul(t->b, nir_trim_vector(t->b, src, 2), rcp);

	return nir_vec4(t->b,
	nir_channel(t->b, st_mul, 0),
	nir_channel(t->b, st_mul, 1),
	rcp,
	rcp);
	}
	}

	static nir_def *
	load_input(struct st_translate *t, gl_varying_slot slot)
	{
	if (!t->inputs[slot]) {
	nir_variable *var = nir_create_variable_with_location(t->b->shader, nir_var_shader_in, slot,
	glsl_vec4_type());
	var->data.interpolation = INTERP_MODE_NONE;

	t->inputs[slot] = nir_load_var(t->b, var);
	}

	return t->inputs[slot];
	}

	static nir_def *
	atifs_load_uniform(struct st_translate *t, int index)
	{
	nir_deref_instr *deref = nir_build_deref_array(t->b,
	nir_build_deref_var(t->b, t->constants),
	nir_imm_int(t->b, index));
	return nir_load_deref(t->b, deref);
	}

	static struct nir_def *
	get_source(struct st_translate *t, GLenum src_type)
	{
	if (src_type >= GL_REG_0_ATI && src_type <= GL_REG_5_ATI) {
	if (t->regs_written[t->current_pass][src_type - GL_REG_0_ATI]) {
	return get_temp(t, src_type - GL_REG_0_ATI);
	} else {
	return nir_imm_vec4_float(t->b, 0.0);
	}
	} else if (src_type >= GL_CON_0_ATI && src_type <= GL_CON_7_ATI) {
	int index = src_type - GL_CON_0_ATI;
	if (t->atifs->LocalConstDef & (1 << index)) {
	return nir_imm_vec4(t->b,
	t->atifs->Constants[index][0],
	t->atifs->Constants[index][1],
	t->atifs->Constants[index][2],
	t->atifs->Constants[index][3]);
	} else {
	return atifs_load_uniform(t, index);
	}
	} else if (src_type == GL_ZERO) {
	return nir_imm_vec4_float(t->b, 0.0);
	} else if (src_type == GL_ONE) {
	return nir_imm_vec4_float(t->b, 1.0);
	} else if (src_type == GL_PRIMARY_COLOR_ARB) {
	return load_input(t, VARYING_SLOT_COL0);
	} else if (src_type == GL_SECONDARY_INTERPOLATOR_ATI) {
	return load_input(t, VARYING_SLOT_COL1);
	} else {
	/* frontend prevents this */
	unreachable("unknown source");
	}
	}

	static nir_def *
	prepare_argument(struct st_translate t, const struct atifs_instruction inst,
	const unsigned argId, bool alpha)
	{
	if (argId >= inst->ArgCount[alpha]) {
	_mesa_warning(0, "Using 0 for missing argument %d\n", argId);
	return nir_imm_vec4_float(t->b, 0.0f);
	}

	const struct atifragshader_src_register *srcReg = &inst->SrcReg[alpha][argId];

	nir_def *src = get_source(t, srcReg->Index);

	switch (srcReg->argRep) {
	case GL_NONE:
	break;
	case GL_RED:
	src = nir_channel_vec4(t->b, src, 0);
	break;
	case GL_GREEN:
	src = nir_channel_vec4(t->b, src, 1);
	break;
	case GL_BLUE:
	src = nir_channel_vec4(t->b, src, 2);
	break;
	case GL_ALPHA:
	src = nir_channel_vec4(t->b, src, 3);
	break;
	}

	t->temps[MAX_NUM_FRAGMENT_REGISTERS_ATI + argId] = src;

	if (srcReg->argMod & GL_COMP_BIT_ATI)
	src = nir_fsub_imm(t->b, 1.0, src);
	if (srcReg->argMod & GL_BIAS_BIT_ATI)
	src = nir_fadd_imm(t->b, src, -0.5);
	if (srcReg->argMod & GL_2X_BIT_ATI)
	src = nir_fadd(t->b, src, src);
	if (srcReg->argMod & GL_NEGATE_BIT_ATI)
	src = nir_fneg(t->b, src);

	return src;
	}

	static nir_def *
	emit_arith_inst(struct st_translate *t,
	const struct atifs_instruction *inst,
	bool alpha)
	{
	nir_def *src[3] = {0};
	for (int i = 0; i < inst->ArgCount[alpha]; i++)
	src[i] = prepare_argument(t, inst, i, alpha);

	switch (inst->Opcode[alpha]) {
	case GL_MOV_ATI:
	return src[0];

	case GL_ADD_ATI:
	return nir_fadd(t->b, src[0], src[1]);

	case GL_SUB_ATI:
	return nir_fsub(t->b, src[0], src[1]);

	case GL_MUL_ATI:
	return nir_fmul(t->b, src[0], src[1]);

	case GL_MAD_ATI:
	return nir_ffma(t->b, src[0], src[1], src[2]);

	case GL_LERP_ATI:
	return nir_flrp(t->b, src[2], src[1], src[0]);

	case GL_CND_ATI:
	return nir_bcsel(t->b,
	nir_fle_imm(t->b, src[2], 0.5),
	src[1],
	src[0]);

	case GL_CND0_ATI:
	return nir_bcsel(t->b,
	nir_fge_imm(t->b, src[2], 0.0),
	src[0],
	src[1]);

	case GL_DOT2_ADD_ATI:
	return nir_channel_vec4(t->b,
	nir_fadd(t->b,
	nir_fdot2(t->b, src[0], src[1]),
	nir_channel(t->b, src[1], 2)),
	0);

	case GL_DOT3_ATI:
	return nir_channel_vec4(t->b, nir_fdot3(t->b,src[0], src[1]), 0);

	case GL_DOT4_ATI:
	return nir_channel_vec4(t->b, nir_fdot4(t->b,src[0], src[1]), 0);

	default:
	unreachable("Unknown ATI_fs opcode");
	}
	}

	static nir_def *
	emit_dstmod(struct st_translate *t,
	struct nir_def *dst, GLuint dstMod)
	{
	switch (dstMod & ~GL_SATURATE_BIT_ATI) {
	case GL_2X_BIT_ATI:
	dst = nir_fmul_imm(t->b, dst, 2.0f);
	break;
	case GL_4X_BIT_ATI:
	dst = nir_fmul_imm(t->b, dst, 4.0f);
	break;
	case GL_8X_BIT_ATI:
	dst = nir_fmul_imm(t->b, dst, 8.0f);
	break;
	case GL_HALF_BIT_ATI:
	dst = nir_fmul_imm(t->b, dst, 0.5f);
	break;
	case GL_QUARTER_BIT_ATI:
	dst = nir_fmul_imm(t->b, dst, 0.25f);
	break;
	case GL_EIGHTH_BIT_ATI:
	dst = nir_fmul_imm(t->b, dst, 0.125f);
	break;
	default:
	break;
	}

	if (dstMod & GL_SATURATE_BIT_ATI)
	dst = nir_fsat(t->b, dst);

	return dst;
	}

	/**
	* Compile one setup instruction to NIR instructions.
	*/
	static void
	compile_setupinst(struct st_translate *t,
	const unsigned r,
	const struct atifs_setupinst *texinst)
	{
	if (!texinst->Opcode)
	return;

	GLuint pass_tex = texinst->src;

	nir_def *coord;

	if (pass_tex >= GL_TEXTURE0_ARB && pass_tex <= GL_TEXTURE7_ARB) {
	unsigned attr = pass_tex - GL_TEXTURE0_ARB;

	coord = load_input(t, VARYING_SLOT_TEX0 + attr);
	} else if (pass_tex >= GL_REG_0_ATI && pass_tex <= GL_REG_5_ATI) {
	unsigned reg = pass_tex - GL_REG_0_ATI;

	/* the frontend already validated that REG is only allowed in second pass */
	if (t->regs_written[0][reg]) {
	coord = t->temps[reg];
	} else {
	coord = nir_imm_vec4_float(t->b, 0.0f);
	}
	} else {
	coord = nir_undef(t->b, 4, 32);
	}
	coord = apply_swizzle(t, coord, texinst->swizzle);

	if (texinst->Opcode == ATI_FRAGMENT_SHADER_SAMPLE_OP) {
	nir_variable *tex_var = t->samplers[r];
	if (!tex_var) {
	/* The actual sampler dim will be determined at draw time and lowered
	* by st_nir_update_atifs_samplers. Setting it to 3D for now means we
	* don't optimize out coordinate channels we may need later.
	*/
	const struct glsl_type *sampler_type =
	glsl_sampler_type(GLSL_SAMPLER_DIM_3D, false, false, GLSL_TYPE_FLOAT);

	tex_var = nir_variable_create(t->b->shader, nir_var_uniform, sampler_type, "tex");
	tex_var->data.binding = r;
	tex_var->data.explicit_binding = true;
	t->samplers[r] = tex_var;
	}
	nir_deref_instr *tex_deref = nir_build_deref_var(t->b, t->samplers[r]);

	nir_tex_instr *tex = nir_tex_instr_create(t->b->shader, 3);
	tex->op = nir_texop_tex;
	tex->sampler_dim = glsl_get_sampler_dim(tex_var->type);
	tex->dest_type = nir_type_float32;
	tex->coord_components =
	glsl_get_sampler_dim_coordinate_components(tex->sampler_dim);

	tex->src[0] = nir_tex_src_for_ssa(nir_tex_src_texture_deref,
	&tex_deref->def);
	tex->src[1] = nir_tex_src_for_ssa(nir_tex_src_sampler_deref,
	&tex_deref->def);
	tex->src[2] = nir_tex_src_for_ssa(nir_tex_src_coord,
	nir_trim_vector(t->b, coord, tex->coord_components));

	nir_def_init(&tex->instr, &tex->def, 4, 32);
	nir_builder_instr_insert(t->b, &tex->instr);

	t->temps[r] = &tex->def;
	} else if (texinst->Opcode == ATI_FRAGMENT_SHADER_PASS_OP) {
	t->temps[r] = coord;
	}

	t->regs_written[t->current_pass][r] = true;
	}

	/**
	* Compile one arithmetic operation COLOR&ALPHA pair into NIR instructions.
	*/
	static void
	compile_instruction(struct st_translate *t,
	const struct atifs_instruction *inst)
	{
	unsigned optype;

	for (optype = 0; optype < 2; optype++) { /* color, alpha */
	unsigned dstreg = inst->DstReg[optype].Index - GL_REG_0_ATI;

	if (!inst->Opcode[optype])
	continue;

	/* Execute the op */
	nir_def *result = emit_arith_inst(t, inst, optype);
	result = emit_dstmod(t, result, inst->DstReg[optype].dstMod);

	/* Do the writemask */
	nir_const_value wrmask[4];
	for (int i = 0; i < 4; i++) {
	bool bit = inst->DstReg[optype].dstMask & (1 << i);
	wrmask[i] = nir_const_value_for_bool(bit, 1);
	}

	t->temps[dstreg] = nir_bcsel(t->b,
	nir_build_imm(t->b, 4, 1, wrmask),
	result,
	get_temp(t, dstreg));
	t->regs_written[t->current_pass][dstreg] = true;
	}
	}


	/* Creates the uniform variable referencing the ATI_fragment_shader constants.
	*/
	static void
	st_atifs_setup_uniforms(struct st_translate t, struct gl_program program)
	{
	const struct glsl_type *type =
	glsl_array_type(glsl_vec4_type(), program->Parameters->NumParameters, 0);
	t->constants =
	nir_variable_create(t->b->shader, nir_var_uniform, type,
	"gl_ATI_fragment_shader_constants");
	}

	/**
	* Called when a new variant is needed, we need to translate
	* the ATI fragment shader to NIR
	*/
	nir_shader *
	st_translate_atifs_program(struct ati_fragment_shader *atifs,
	struct gl_program *program,
	const nir_shader_compiler_options *options)
	{
	nir_builder b = nir_builder_init_simple_shader(MESA_SHADER_FRAGMENT, options, "ATI_fs");

	struct st_translate translate = {
	.atifs = atifs,
	.b = &b,
	};
	struct st_translate *t = &translate;

	/* Copy the shader_info from the gl_program */
	t->b->shader->info = program->info;

	nir_shader *s = t->b->shader;
	s->info.name = ralloc_asprintf(s, "ATIFS%d", program->Id);
	s->info.internal = false;

	t->fragcolor = nir_create_variable_with_location(b.shader, nir_var_shader_out,
	FRAG_RESULT_COLOR, glsl_vec4_type());

	st_atifs_setup_uniforms(t, program);

	/* emit instructions */
	for (unsigned pass = 0; pass < atifs->NumPasses; pass++) {
	t->current_pass = pass;
	for (unsigned r = 0; r < MAX_NUM_FRAGMENT_REGISTERS_ATI; r++) {
	struct atifs_setupinst *texinst = &atifs->SetupInst[pass][r];
	compile_setupinst(t, r, texinst);
	}
	for (unsigned i = 0; i < atifs->numArithInstr[pass]; i++) {
	struct atifs_instruction *inst = &atifs->Instructions[pass][i];
	compile_instruction(t, inst);
	}
	}

	if (t->regs_written[atifs->NumPasses-1][0])
	nir_store_var(t->b, t->fragcolor, t->temps[0], 0xf);

	return b.shader;
	}

	static bool
	st_nir_lower_atifs_samplers_instr(nir_builder b, nir_instr instr, void *data)
	{
	const uint8_t *texture_index = data;

	/* Can't just do this in tex handling below, as llvmpipe leaves dead code
	* derefs around.
	*/
	if (instr->type == nir_instr_type_deref) {
	nir_deref_instr *deref = nir_instr_as_deref(instr);
	nir_variable *var = nir_deref_instr_get_variable(deref);
	if (glsl_type_is_sampler(var->type))
	deref->type = var->type;
	}

	if (instr->type != nir_instr_type_tex)
	return false;

	b->cursor = nir_before_instr(instr);

	nir_tex_instr *tex = nir_instr_as_tex(instr);

	unsigned unit;
	int sampler_src_idx = nir_tex_instr_src_index(tex, nir_tex_src_sampler_deref);
	if (sampler_src_idx >= 0) {
	nir_deref_instr *deref = nir_src_as_deref(tex->src[sampler_src_idx].src);
	nir_variable *var = nir_deref_instr_get_variable(deref);
	unit = var->data.binding;
	} else {
	unit = tex->sampler_index;
	}

	bool is_array;
	tex->sampler_dim =
	_mesa_texture_index_to_sampler_dim(texture_index[unit], &is_array);

	int coords_idx = nir_tex_instr_src_index(tex, nir_tex_src_coord);
	assert(coords_idx >= 0);
	int coord_components =
	glsl_get_sampler_dim_coordinate_components(tex->sampler_dim);
	/* Trim unused coords, or append undefs as necessary (if someone
	* accidentally enables a cube array).
	*/
	if (coord_components != tex->coord_components) {
	nir_def *coords = tex->src[coords_idx].src.ssa;
	nir_src_rewrite(&tex->src[coords_idx].src,
	nir_resize_vector(b, coords, coord_components));
	tex->coord_components = coord_components;
	}

	return true;
	}

	/**
	* Rewrites sampler dimensions and coordinate components for the currently
	* active texture unit at draw time.
	*/
	bool
	st_nir_lower_atifs_samplers(struct nir_shader s, const uint8_t texture_index)
	{
	nir_foreach_uniform_variable(var, s) {
	if (!glsl_type_is_sampler(var->type))
	continue;
	bool is_array;
	enum glsl_sampler_dim sampler_dim =
	_mesa_texture_index_to_sampler_dim(texture_index[var->data.binding], &is_array);
	var->type = glsl_sampler_type(sampler_dim, false, is_array, GLSL_TYPE_FLOAT);
	}

	return nir_shader_instructions_pass(s, st_nir_lower_atifs_samplers_instr,\
	nir_metadata_control_flow,
	(void *)texture_index);
	}