| /* |
| * Copyright (C) 2005-2007 Brian Paul All Rights Reserved. |
| * Copyright (C) 2008 VMware, Inc. All Rights Reserved. |
| * Copyright © 2010 Intel Corporation |
| * Copyright © 2011 Bryan Cain |
| * |
| * 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 (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 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. |
| */ |
| |
| /** |
| * \file glsl_to_tgsi.cpp |
| * |
| * Translate GLSL IR to TGSI. |
| */ |
| |
| #include <stdio.h> |
| #include "main/compiler.h" |
| #include "ir.h" |
| #include "ir_visitor.h" |
| #include "ir_print_visitor.h" |
| #include "ir_expression_flattening.h" |
| #include "glsl_types.h" |
| #include "glsl_parser_extras.h" |
| #include "../glsl/program.h" |
| #include "ir_optimization.h" |
| #include "ast.h" |
| |
| #include "main/mtypes.h" |
| #include "main/shaderobj.h" |
| #include "program/hash_table.h" |
| |
| extern "C" { |
| #include "main/shaderapi.h" |
| #include "main/uniforms.h" |
| #include "program/prog_instruction.h" |
| #include "program/prog_optimize.h" |
| #include "program/prog_print.h" |
| #include "program/program.h" |
| #include "program/prog_parameter.h" |
| #include "program/sampler.h" |
| |
| #include "pipe/p_compiler.h" |
| #include "pipe/p_context.h" |
| #include "pipe/p_screen.h" |
| #include "pipe/p_shader_tokens.h" |
| #include "pipe/p_state.h" |
| #include "util/u_math.h" |
| #include "tgsi/tgsi_ureg.h" |
| #include "tgsi/tgsi_info.h" |
| #include "st_context.h" |
| #include "st_program.h" |
| #include "st_glsl_to_tgsi.h" |
| #include "st_mesa_to_tgsi.h" |
| } |
| |
| #define PROGRAM_IMMEDIATE PROGRAM_FILE_MAX |
| #define PROGRAM_ANY_CONST ((1 << PROGRAM_LOCAL_PARAM) | \ |
| (1 << PROGRAM_ENV_PARAM) | \ |
| (1 << PROGRAM_STATE_VAR) | \ |
| (1 << PROGRAM_NAMED_PARAM) | \ |
| (1 << PROGRAM_CONSTANT) | \ |
| (1 << PROGRAM_UNIFORM)) |
| |
| /** |
| * Maximum number of temporary registers. |
| * |
| * It is too big for stack allocated arrays -- it will cause stack overflow on |
| * Windows and likely Mac OS X. |
| */ |
| #define MAX_TEMPS 4096 |
| |
| /* will be 4 for GLSL 4.00 */ |
| #define MAX_GLSL_TEXTURE_OFFSET 1 |
| |
| class st_src_reg; |
| class st_dst_reg; |
| |
| static int swizzle_for_size(int size); |
| |
| /** |
| * This struct is a corresponding struct to TGSI ureg_src. |
| */ |
| class st_src_reg { |
| public: |
| st_src_reg(gl_register_file file, int index, const glsl_type *type) |
| { |
| this->file = file; |
| this->index = index; |
| if (type && (type->is_scalar() || type->is_vector() || type->is_matrix())) |
| this->swizzle = swizzle_for_size(type->vector_elements); |
| else |
| this->swizzle = SWIZZLE_XYZW; |
| this->negate = 0; |
| this->type = type ? type->base_type : GLSL_TYPE_ERROR; |
| this->reladdr = NULL; |
| } |
| |
| st_src_reg(gl_register_file file, int index, int type) |
| { |
| this->type = type; |
| this->file = file; |
| this->index = index; |
| this->swizzle = SWIZZLE_XYZW; |
| this->negate = 0; |
| this->reladdr = NULL; |
| } |
| |
| st_src_reg() |
| { |
| this->type = GLSL_TYPE_ERROR; |
| this->file = PROGRAM_UNDEFINED; |
| this->index = 0; |
| this->swizzle = 0; |
| this->negate = 0; |
| this->reladdr = NULL; |
| } |
| |
| explicit st_src_reg(st_dst_reg reg); |
| |
| gl_register_file file; /**< PROGRAM_* from Mesa */ |
| int index; /**< temporary index, VERT_ATTRIB_*, FRAG_ATTRIB_*, etc. */ |
| GLuint swizzle; /**< SWIZZLE_XYZWONEZERO swizzles from Mesa. */ |
| int negate; /**< NEGATE_XYZW mask from mesa */ |
| int type; /** GLSL_TYPE_* from GLSL IR (enum glsl_base_type) */ |
| /** Register index should be offset by the integer in this reg. */ |
| st_src_reg *reladdr; |
| }; |
| |
| class st_dst_reg { |
| public: |
| st_dst_reg(gl_register_file file, int writemask, int type) |
| { |
| this->file = file; |
| this->index = 0; |
| this->writemask = writemask; |
| this->cond_mask = COND_TR; |
| this->reladdr = NULL; |
| this->type = type; |
| } |
| |
| st_dst_reg() |
| { |
| this->type = GLSL_TYPE_ERROR; |
| this->file = PROGRAM_UNDEFINED; |
| this->index = 0; |
| this->writemask = 0; |
| this->cond_mask = COND_TR; |
| this->reladdr = NULL; |
| } |
| |
| explicit st_dst_reg(st_src_reg reg); |
| |
| gl_register_file file; /**< PROGRAM_* from Mesa */ |
| int index; /**< temporary index, VERT_ATTRIB_*, FRAG_ATTRIB_*, etc. */ |
| int writemask; /**< Bitfield of WRITEMASK_[XYZW] */ |
| GLuint cond_mask:4; |
| int type; /** GLSL_TYPE_* from GLSL IR (enum glsl_base_type) */ |
| /** Register index should be offset by the integer in this reg. */ |
| st_src_reg *reladdr; |
| }; |
| |
| st_src_reg::st_src_reg(st_dst_reg reg) |
| { |
| this->type = reg.type; |
| this->file = reg.file; |
| this->index = reg.index; |
| this->swizzle = SWIZZLE_XYZW; |
| this->negate = 0; |
| this->reladdr = reg.reladdr; |
| } |
| |
| st_dst_reg::st_dst_reg(st_src_reg reg) |
| { |
| this->type = reg.type; |
| this->file = reg.file; |
| this->index = reg.index; |
| this->writemask = WRITEMASK_XYZW; |
| this->cond_mask = COND_TR; |
| this->reladdr = reg.reladdr; |
| } |
| |
| class glsl_to_tgsi_instruction : public exec_node { |
| public: |
| /* Callers of this ralloc-based new need not call delete. It's |
| * easier to just ralloc_free 'ctx' (or any of its ancestors). */ |
| static void* operator new(size_t size, void *ctx) |
| { |
| void *node; |
| |
| node = rzalloc_size(ctx, size); |
| assert(node != NULL); |
| |
| return node; |
| } |
| |
| unsigned op; |
| st_dst_reg dst; |
| st_src_reg src[3]; |
| /** Pointer to the ir source this tree came from for debugging */ |
| ir_instruction *ir; |
| GLboolean cond_update; |
| bool saturate; |
| int sampler; /**< sampler index */ |
| int tex_target; /**< One of TEXTURE_*_INDEX */ |
| GLboolean tex_shadow; |
| struct tgsi_texture_offset tex_offsets[MAX_GLSL_TEXTURE_OFFSET]; |
| unsigned tex_offset_num_offset; |
| int dead_mask; /**< Used in dead code elimination */ |
| |
| class function_entry *function; /* Set on TGSI_OPCODE_CAL or TGSI_OPCODE_BGNSUB */ |
| }; |
| |
| class variable_storage : public exec_node { |
| public: |
| variable_storage(ir_variable *var, gl_register_file file, int index) |
| : file(file), index(index), var(var) |
| { |
| /* empty */ |
| } |
| |
| gl_register_file file; |
| int index; |
| ir_variable *var; /* variable that maps to this, if any */ |
| }; |
| |
| class immediate_storage : public exec_node { |
| public: |
| immediate_storage(gl_constant_value *values, int size, int type) |
| { |
| memcpy(this->values, values, size * sizeof(gl_constant_value)); |
| this->size = size; |
| this->type = type; |
| } |
| |
| gl_constant_value values[4]; |
| int size; /**< Number of components (1-4) */ |
| int type; /**< GL_FLOAT, GL_INT, GL_BOOL, or GL_UNSIGNED_INT */ |
| }; |
| |
| class function_entry : public exec_node { |
| public: |
| ir_function_signature *sig; |
| |
| /** |
| * identifier of this function signature used by the program. |
| * |
| * At the point that TGSI instructions for function calls are |
| * generated, we don't know the address of the first instruction of |
| * the function body. So we make the BranchTarget that is called a |
| * small integer and rewrite them during set_branchtargets(). |
| */ |
| int sig_id; |
| |
| /** |
| * Pointer to first instruction of the function body. |
| * |
| * Set during function body emits after main() is processed. |
| */ |
| glsl_to_tgsi_instruction *bgn_inst; |
| |
| /** |
| * Index of the first instruction of the function body in actual TGSI. |
| * |
| * Set after conversion from glsl_to_tgsi_instruction to TGSI. |
| */ |
| int inst; |
| |
| /** Storage for the return value. */ |
| st_src_reg return_reg; |
| }; |
| |
| class glsl_to_tgsi_visitor : public ir_visitor { |
| public: |
| glsl_to_tgsi_visitor(); |
| ~glsl_to_tgsi_visitor(); |
| |
| function_entry *current_function; |
| |
| struct gl_context *ctx; |
| struct gl_program *prog; |
| struct gl_shader_program *shader_program; |
| struct gl_shader_compiler_options *options; |
| |
| int next_temp; |
| |
| int num_address_regs; |
| int samplers_used; |
| bool indirect_addr_temps; |
| bool indirect_addr_consts; |
| |
| int glsl_version; |
| bool native_integers; |
| |
| variable_storage *find_variable_storage(ir_variable *var); |
| |
| int add_constant(gl_register_file file, gl_constant_value values[4], |
| int size, int datatype, GLuint *swizzle_out); |
| |
| function_entry *get_function_signature(ir_function_signature *sig); |
| |
| st_src_reg get_temp(const glsl_type *type); |
| void reladdr_to_temp(ir_instruction *ir, st_src_reg *reg, int *num_reladdr); |
| |
| st_src_reg st_src_reg_for_float(float val); |
| st_src_reg st_src_reg_for_int(int val); |
| st_src_reg st_src_reg_for_type(int type, int val); |
| |
| /** |
| * \name Visit methods |
| * |
| * As typical for the visitor pattern, there must be one \c visit method for |
| * each concrete subclass of \c ir_instruction. Virtual base classes within |
| * the hierarchy should not have \c visit methods. |
| */ |
| /*@{*/ |
| virtual void visit(ir_variable *); |
| virtual void visit(ir_loop *); |
| virtual void visit(ir_loop_jump *); |
| virtual void visit(ir_function_signature *); |
| virtual void visit(ir_function *); |
| virtual void visit(ir_expression *); |
| virtual void visit(ir_swizzle *); |
| virtual void visit(ir_dereference_variable *); |
| virtual void visit(ir_dereference_array *); |
| virtual void visit(ir_dereference_record *); |
| virtual void visit(ir_assignment *); |
| virtual void visit(ir_constant *); |
| virtual void visit(ir_call *); |
| virtual void visit(ir_return *); |
| virtual void visit(ir_discard *); |
| virtual void visit(ir_texture *); |
| virtual void visit(ir_if *); |
| /*@}*/ |
| |
| st_src_reg result; |
| |
| /** List of variable_storage */ |
| exec_list variables; |
| |
| /** List of immediate_storage */ |
| exec_list immediates; |
| unsigned num_immediates; |
| |
| /** List of function_entry */ |
| exec_list function_signatures; |
| int next_signature_id; |
| |
| /** List of glsl_to_tgsi_instruction */ |
| exec_list instructions; |
| |
| glsl_to_tgsi_instruction *emit(ir_instruction *ir, unsigned op); |
| |
| glsl_to_tgsi_instruction *emit(ir_instruction *ir, unsigned op, |
| st_dst_reg dst, st_src_reg src0); |
| |
| glsl_to_tgsi_instruction *emit(ir_instruction *ir, unsigned op, |
| st_dst_reg dst, st_src_reg src0, st_src_reg src1); |
| |
| glsl_to_tgsi_instruction *emit(ir_instruction *ir, unsigned op, |
| st_dst_reg dst, |
| st_src_reg src0, st_src_reg src1, st_src_reg src2); |
| |
| unsigned get_opcode(ir_instruction *ir, unsigned op, |
| st_dst_reg dst, |
| st_src_reg src0, st_src_reg src1); |
| |
| /** |
| * Emit the correct dot-product instruction for the type of arguments |
| */ |
| glsl_to_tgsi_instruction *emit_dp(ir_instruction *ir, |
| st_dst_reg dst, |
| st_src_reg src0, |
| st_src_reg src1, |
| unsigned elements); |
| |
| void emit_scalar(ir_instruction *ir, unsigned op, |
| st_dst_reg dst, st_src_reg src0); |
| |
| void emit_scalar(ir_instruction *ir, unsigned op, |
| st_dst_reg dst, st_src_reg src0, st_src_reg src1); |
| |
| void try_emit_float_set(ir_instruction *ir, unsigned op, st_dst_reg dst); |
| |
| void emit_arl(ir_instruction *ir, st_dst_reg dst, st_src_reg src0); |
| |
| void emit_scs(ir_instruction *ir, unsigned op, |
| st_dst_reg dst, const st_src_reg &src); |
| |
| bool try_emit_mad(ir_expression *ir, |
| int mul_operand); |
| bool try_emit_mad_for_and_not(ir_expression *ir, |
| int mul_operand); |
| bool try_emit_sat(ir_expression *ir); |
| |
| void emit_swz(ir_expression *ir); |
| |
| bool process_move_condition(ir_rvalue *ir); |
| |
| void simplify_cmp(void); |
| |
| void rename_temp_register(int index, int new_index); |
| int get_first_temp_read(int index); |
| int get_first_temp_write(int index); |
| int get_last_temp_read(int index); |
| int get_last_temp_write(int index); |
| |
| void copy_propagate(void); |
| void eliminate_dead_code(void); |
| int eliminate_dead_code_advanced(void); |
| void merge_registers(void); |
| void renumber_registers(void); |
| |
| void *mem_ctx; |
| }; |
| |
| static st_src_reg undef_src = st_src_reg(PROGRAM_UNDEFINED, 0, GLSL_TYPE_ERROR); |
| |
| static st_dst_reg undef_dst = st_dst_reg(PROGRAM_UNDEFINED, SWIZZLE_NOOP, GLSL_TYPE_ERROR); |
| |
| static st_dst_reg address_reg = st_dst_reg(PROGRAM_ADDRESS, WRITEMASK_X, GLSL_TYPE_FLOAT); |
| |
| static void |
| fail_link(struct gl_shader_program *prog, const char *fmt, ...) PRINTFLIKE(2, 3); |
| |
| static void |
| fail_link(struct gl_shader_program *prog, const char *fmt, ...) |
| { |
| va_list args; |
| va_start(args, fmt); |
| ralloc_vasprintf_append(&prog->InfoLog, fmt, args); |
| va_end(args); |
| |
| prog->LinkStatus = GL_FALSE; |
| } |
| |
| static int |
| swizzle_for_size(int size) |
| { |
| int size_swizzles[4] = { |
| MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), |
| MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y), |
| MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z), |
| MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W), |
| }; |
| |
| assert((size >= 1) && (size <= 4)); |
| return size_swizzles[size - 1]; |
| } |
| |
| static bool |
| is_tex_instruction(unsigned opcode) |
| { |
| const tgsi_opcode_info* info = tgsi_get_opcode_info(opcode); |
| return info->is_tex; |
| } |
| |
| static unsigned |
| num_inst_dst_regs(unsigned opcode) |
| { |
| const tgsi_opcode_info* info = tgsi_get_opcode_info(opcode); |
| return info->num_dst; |
| } |
| |
| static unsigned |
| num_inst_src_regs(unsigned opcode) |
| { |
| const tgsi_opcode_info* info = tgsi_get_opcode_info(opcode); |
| return info->is_tex ? info->num_src - 1 : info->num_src; |
| } |
| |
| glsl_to_tgsi_instruction * |
| glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op, |
| st_dst_reg dst, |
| st_src_reg src0, st_src_reg src1, st_src_reg src2) |
| { |
| glsl_to_tgsi_instruction *inst = new(mem_ctx) glsl_to_tgsi_instruction(); |
| int num_reladdr = 0, i; |
| |
| op = get_opcode(ir, op, dst, src0, src1); |
| |
| /* If we have to do relative addressing, we want to load the ARL |
| * reg directly for one of the regs, and preload the other reladdr |
| * sources into temps. |
| */ |
| num_reladdr += dst.reladdr != NULL; |
| num_reladdr += src0.reladdr != NULL; |
| num_reladdr += src1.reladdr != NULL; |
| num_reladdr += src2.reladdr != NULL; |
| |
| reladdr_to_temp(ir, &src2, &num_reladdr); |
| reladdr_to_temp(ir, &src1, &num_reladdr); |
| reladdr_to_temp(ir, &src0, &num_reladdr); |
| |
| if (dst.reladdr) { |
| emit_arl(ir, address_reg, *dst.reladdr); |
| num_reladdr--; |
| } |
| assert(num_reladdr == 0); |
| |
| inst->op = op; |
| inst->dst = dst; |
| inst->src[0] = src0; |
| inst->src[1] = src1; |
| inst->src[2] = src2; |
| inst->ir = ir; |
| inst->dead_mask = 0; |
| |
| inst->function = NULL; |
| |
| if (op == TGSI_OPCODE_ARL || op == TGSI_OPCODE_UARL) |
| this->num_address_regs = 1; |
| |
| /* Update indirect addressing status used by TGSI */ |
| if (dst.reladdr) { |
| switch(dst.file) { |
| case PROGRAM_TEMPORARY: |
| this->indirect_addr_temps = true; |
| break; |
| case PROGRAM_LOCAL_PARAM: |
| case PROGRAM_ENV_PARAM: |
| case PROGRAM_STATE_VAR: |
| case PROGRAM_NAMED_PARAM: |
| case PROGRAM_CONSTANT: |
| case PROGRAM_UNIFORM: |
| this->indirect_addr_consts = true; |
| break; |
| case PROGRAM_IMMEDIATE: |
| assert(!"immediates should not have indirect addressing"); |
| break; |
| default: |
| break; |
| } |
| } |
| else { |
| for (i=0; i<3; i++) { |
| if(inst->src[i].reladdr) { |
| switch(inst->src[i].file) { |
| case PROGRAM_TEMPORARY: |
| this->indirect_addr_temps = true; |
| break; |
| case PROGRAM_LOCAL_PARAM: |
| case PROGRAM_ENV_PARAM: |
| case PROGRAM_STATE_VAR: |
| case PROGRAM_NAMED_PARAM: |
| case PROGRAM_CONSTANT: |
| case PROGRAM_UNIFORM: |
| this->indirect_addr_consts = true; |
| break; |
| case PROGRAM_IMMEDIATE: |
| assert(!"immediates should not have indirect addressing"); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| } |
| |
| this->instructions.push_tail(inst); |
| |
| if (native_integers) |
| try_emit_float_set(ir, op, dst); |
| |
| return inst; |
| } |
| |
| |
| glsl_to_tgsi_instruction * |
| glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op, |
| st_dst_reg dst, st_src_reg src0, st_src_reg src1) |
| { |
| return emit(ir, op, dst, src0, src1, undef_src); |
| } |
| |
| glsl_to_tgsi_instruction * |
| glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op, |
| st_dst_reg dst, st_src_reg src0) |
| { |
| assert(dst.writemask != 0); |
| return emit(ir, op, dst, src0, undef_src, undef_src); |
| } |
| |
| glsl_to_tgsi_instruction * |
| glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op) |
| { |
| return emit(ir, op, undef_dst, undef_src, undef_src, undef_src); |
| } |
| |
| /** |
| * Emits the code to convert the result of float SET instructions to integers. |
| */ |
| void |
| glsl_to_tgsi_visitor::try_emit_float_set(ir_instruction *ir, unsigned op, |
| st_dst_reg dst) |
| { |
| if ((op == TGSI_OPCODE_SEQ || |
| op == TGSI_OPCODE_SNE || |
| op == TGSI_OPCODE_SGE || |
| op == TGSI_OPCODE_SLT)) |
| { |
| st_src_reg src = st_src_reg(dst); |
| src.negate = ~src.negate; |
| dst.type = GLSL_TYPE_FLOAT; |
| emit(ir, TGSI_OPCODE_F2I, dst, src); |
| } |
| } |
| |
| /** |
| * Determines whether to use an integer, unsigned integer, or float opcode |
| * based on the operands and input opcode, then emits the result. |
| */ |
| unsigned |
| glsl_to_tgsi_visitor::get_opcode(ir_instruction *ir, unsigned op, |
| st_dst_reg dst, |
| st_src_reg src0, st_src_reg src1) |
| { |
| int type = GLSL_TYPE_FLOAT; |
| |
| assert(src0.type != GLSL_TYPE_ARRAY); |
| assert(src0.type != GLSL_TYPE_STRUCT); |
| assert(src1.type != GLSL_TYPE_ARRAY); |
| assert(src1.type != GLSL_TYPE_STRUCT); |
| |
| if (src0.type == GLSL_TYPE_FLOAT || src1.type == GLSL_TYPE_FLOAT) |
| type = GLSL_TYPE_FLOAT; |
| else if (native_integers) |
| type = src0.type == GLSL_TYPE_BOOL ? GLSL_TYPE_INT : src0.type; |
| |
| #define case4(c, f, i, u) \ |
| case TGSI_OPCODE_##c: \ |
| if (type == GLSL_TYPE_INT) op = TGSI_OPCODE_##i; \ |
| else if (type == GLSL_TYPE_UINT) op = TGSI_OPCODE_##u; \ |
| else op = TGSI_OPCODE_##f; \ |
| break; |
| #define case3(f, i, u) case4(f, f, i, u) |
| #define case2fi(f, i) case4(f, f, i, i) |
| #define case2iu(i, u) case4(i, LAST, i, u) |
| |
| switch(op) { |
| case2fi(ADD, UADD); |
| case2fi(MUL, UMUL); |
| case2fi(MAD, UMAD); |
| case3(DIV, IDIV, UDIV); |
| case3(MAX, IMAX, UMAX); |
| case3(MIN, IMIN, UMIN); |
| case2iu(MOD, UMOD); |
| |
| case2fi(SEQ, USEQ); |
| case2fi(SNE, USNE); |
| case3(SGE, ISGE, USGE); |
| case3(SLT, ISLT, USLT); |
| |
| case2iu(ISHR, USHR); |
| |
| case2fi(SSG, ISSG); |
| case3(ABS, IABS, IABS); |
| |
| default: break; |
| } |
| |
| assert(op != TGSI_OPCODE_LAST); |
| return op; |
| } |
| |
| glsl_to_tgsi_instruction * |
| glsl_to_tgsi_visitor::emit_dp(ir_instruction *ir, |
| st_dst_reg dst, st_src_reg src0, st_src_reg src1, |
| unsigned elements) |
| { |
| static const unsigned dot_opcodes[] = { |
| TGSI_OPCODE_DP2, TGSI_OPCODE_DP3, TGSI_OPCODE_DP4 |
| }; |
| |
| return emit(ir, dot_opcodes[elements - 2], dst, src0, src1); |
| } |
| |
| /** |
| * Emits TGSI scalar opcodes to produce unique answers across channels. |
| * |
| * Some TGSI opcodes are scalar-only, like ARB_fp/vp. The src X |
| * channel determines the result across all channels. So to do a vec4 |
| * of this operation, we want to emit a scalar per source channel used |
| * to produce dest channels. |
| */ |
| void |
| glsl_to_tgsi_visitor::emit_scalar(ir_instruction *ir, unsigned op, |
| st_dst_reg dst, |
| st_src_reg orig_src0, st_src_reg orig_src1) |
| { |
| int i, j; |
| int done_mask = ~dst.writemask; |
| |
| /* TGSI RCP is a scalar operation splatting results to all channels, |
| * like ARB_fp/vp. So emit as many RCPs as necessary to cover our |
| * dst channels. |
| */ |
| for (i = 0; i < 4; i++) { |
| GLuint this_mask = (1 << i); |
| glsl_to_tgsi_instruction *inst; |
| st_src_reg src0 = orig_src0; |
| st_src_reg src1 = orig_src1; |
| |
| if (done_mask & this_mask) |
| continue; |
| |
| GLuint src0_swiz = GET_SWZ(src0.swizzle, i); |
| GLuint src1_swiz = GET_SWZ(src1.swizzle, i); |
| for (j = i + 1; j < 4; j++) { |
| /* If there is another enabled component in the destination that is |
| * derived from the same inputs, generate its value on this pass as |
| * well. |
| */ |
| if (!(done_mask & (1 << j)) && |
| GET_SWZ(src0.swizzle, j) == src0_swiz && |
| GET_SWZ(src1.swizzle, j) == src1_swiz) { |
| this_mask |= (1 << j); |
| } |
| } |
| src0.swizzle = MAKE_SWIZZLE4(src0_swiz, src0_swiz, |
| src0_swiz, src0_swiz); |
| src1.swizzle = MAKE_SWIZZLE4(src1_swiz, src1_swiz, |
| src1_swiz, src1_swiz); |
| |
| inst = emit(ir, op, dst, src0, src1); |
| inst->dst.writemask = this_mask; |
| done_mask |= this_mask; |
| } |
| } |
| |
| void |
| glsl_to_tgsi_visitor::emit_scalar(ir_instruction *ir, unsigned op, |
| st_dst_reg dst, st_src_reg src0) |
| { |
| st_src_reg undef = undef_src; |
| |
| undef.swizzle = SWIZZLE_XXXX; |
| |
| emit_scalar(ir, op, dst, src0, undef); |
| } |
| |
| void |
| glsl_to_tgsi_visitor::emit_arl(ir_instruction *ir, |
| st_dst_reg dst, st_src_reg src0) |
| { |
| int op = TGSI_OPCODE_ARL; |
| |
| if (src0.type == GLSL_TYPE_INT || src0.type == GLSL_TYPE_UINT) |
| op = TGSI_OPCODE_UARL; |
| |
| emit(NULL, op, dst, src0); |
| } |
| |
| /** |
| * Emit an TGSI_OPCODE_SCS instruction |
| * |
| * The \c SCS opcode functions a bit differently than the other TGSI opcodes. |
| * Instead of splatting its result across all four components of the |
| * destination, it writes one value to the \c x component and another value to |
| * the \c y component. |
| * |
| * \param ir IR instruction being processed |
| * \param op Either \c TGSI_OPCODE_SIN or \c TGSI_OPCODE_COS depending |
| * on which value is desired. |
| * \param dst Destination register |
| * \param src Source register |
| */ |
| void |
| glsl_to_tgsi_visitor::emit_scs(ir_instruction *ir, unsigned op, |
| st_dst_reg dst, |
| const st_src_reg &src) |
| { |
| /* Vertex programs cannot use the SCS opcode. |
| */ |
| if (this->prog->Target == GL_VERTEX_PROGRAM_ARB) { |
| emit_scalar(ir, op, dst, src); |
| return; |
| } |
| |
| const unsigned component = (op == TGSI_OPCODE_SIN) ? 0 : 1; |
| const unsigned scs_mask = (1U << component); |
| int done_mask = ~dst.writemask; |
| st_src_reg tmp; |
| |
| assert(op == TGSI_OPCODE_SIN || op == TGSI_OPCODE_COS); |
| |
| /* If there are compnents in the destination that differ from the component |
| * that will be written by the SCS instrution, we'll need a temporary. |
| */ |
| if (scs_mask != unsigned(dst.writemask)) { |
| tmp = get_temp(glsl_type::vec4_type); |
| } |
| |
| for (unsigned i = 0; i < 4; i++) { |
| unsigned this_mask = (1U << i); |
| st_src_reg src0 = src; |
| |
| if ((done_mask & this_mask) != 0) |
| continue; |
| |
| /* The source swizzle specified which component of the source generates |
| * sine / cosine for the current component in the destination. The SCS |
| * instruction requires that this value be swizzle to the X component. |
| * Replace the current swizzle with a swizzle that puts the source in |
| * the X component. |
| */ |
| unsigned src0_swiz = GET_SWZ(src.swizzle, i); |
| |
| src0.swizzle = MAKE_SWIZZLE4(src0_swiz, src0_swiz, |
| src0_swiz, src0_swiz); |
| for (unsigned j = i + 1; j < 4; j++) { |
| /* If there is another enabled component in the destination that is |
| * derived from the same inputs, generate its value on this pass as |
| * well. |
| */ |
| if (!(done_mask & (1 << j)) && |
| GET_SWZ(src0.swizzle, j) == src0_swiz) { |
| this_mask |= (1 << j); |
| } |
| } |
| |
| if (this_mask != scs_mask) { |
| glsl_to_tgsi_instruction *inst; |
| st_dst_reg tmp_dst = st_dst_reg(tmp); |
| |
| /* Emit the SCS instruction. |
| */ |
| inst = emit(ir, TGSI_OPCODE_SCS, tmp_dst, src0); |
| inst->dst.writemask = scs_mask; |
| |
| /* Move the result of the SCS instruction to the desired location in |
| * the destination. |
| */ |
| tmp.swizzle = MAKE_SWIZZLE4(component, component, |
| component, component); |
| inst = emit(ir, TGSI_OPCODE_SCS, dst, tmp); |
| inst->dst.writemask = this_mask; |
| } else { |
| /* Emit the SCS instruction to write directly to the destination. |
| */ |
| glsl_to_tgsi_instruction *inst = emit(ir, TGSI_OPCODE_SCS, dst, src0); |
| inst->dst.writemask = scs_mask; |
| } |
| |
| done_mask |= this_mask; |
| } |
| } |
| |
| int |
| glsl_to_tgsi_visitor::add_constant(gl_register_file file, |
| gl_constant_value values[4], int size, int datatype, |
| GLuint *swizzle_out) |
| { |
| if (file == PROGRAM_CONSTANT) { |
| return _mesa_add_typed_unnamed_constant(this->prog->Parameters, values, |
| size, datatype, swizzle_out); |
| } else { |
| int index = 0; |
| immediate_storage *entry; |
| assert(file == PROGRAM_IMMEDIATE); |
| |
| /* Search immediate storage to see if we already have an identical |
| * immediate that we can use instead of adding a duplicate entry. |
| */ |
| foreach_iter(exec_list_iterator, iter, this->immediates) { |
| entry = (immediate_storage *)iter.get(); |
| |
| if (entry->size == size && |
| entry->type == datatype && |
| !memcmp(entry->values, values, size * sizeof(gl_constant_value))) { |
| return index; |
| } |
| index++; |
| } |
| |
| /* Add this immediate to the list. */ |
| entry = new(mem_ctx) immediate_storage(values, size, datatype); |
| this->immediates.push_tail(entry); |
| this->num_immediates++; |
| return index; |
| } |
| } |
| |
| st_src_reg |
| glsl_to_tgsi_visitor::st_src_reg_for_float(float val) |
| { |
| st_src_reg src(PROGRAM_IMMEDIATE, -1, GLSL_TYPE_FLOAT); |
| union gl_constant_value uval; |
| |
| uval.f = val; |
| src.index = add_constant(src.file, &uval, 1, GL_FLOAT, &src.swizzle); |
| |
| return src; |
| } |
| |
| st_src_reg |
| glsl_to_tgsi_visitor::st_src_reg_for_int(int val) |
| { |
| st_src_reg src(PROGRAM_IMMEDIATE, -1, GLSL_TYPE_INT); |
| union gl_constant_value uval; |
| |
| assert(native_integers); |
| |
| uval.i = val; |
| src.index = add_constant(src.file, &uval, 1, GL_INT, &src.swizzle); |
| |
| return src; |
| } |
| |
| st_src_reg |
| glsl_to_tgsi_visitor::st_src_reg_for_type(int type, int val) |
| { |
| if (native_integers) |
| return type == GLSL_TYPE_FLOAT ? st_src_reg_for_float(val) : |
| st_src_reg_for_int(val); |
| else |
| return st_src_reg_for_float(val); |
| } |
| |
| static int |
| type_size(const struct glsl_type *type) |
| { |
| unsigned int i; |
| int size; |
| |
| switch (type->base_type) { |
| case GLSL_TYPE_UINT: |
| case GLSL_TYPE_INT: |
| case GLSL_TYPE_FLOAT: |
| case GLSL_TYPE_BOOL: |
| if (type->is_matrix()) { |
| return type->matrix_columns; |
| } else { |
| /* Regardless of size of vector, it gets a vec4. This is bad |
| * packing for things like floats, but otherwise arrays become a |
| * mess. Hopefully a later pass over the code can pack scalars |
| * down if appropriate. |
| */ |
| return 1; |
| } |
| case GLSL_TYPE_ARRAY: |
| assert(type->length > 0); |
| return type_size(type->fields.array) * type->length; |
| case GLSL_TYPE_STRUCT: |
| size = 0; |
| for (i = 0; i < type->length; i++) { |
| size += type_size(type->fields.structure[i].type); |
| } |
| return size; |
| case GLSL_TYPE_SAMPLER: |
| /* Samplers take up one slot in UNIFORMS[], but they're baked in |
| * at link time. |
| */ |
| return 1; |
| default: |
| assert(0); |
| return 0; |
| } |
| } |
| |
| /** |
| * In the initial pass of codegen, we assign temporary numbers to |
| * intermediate results. (not SSA -- variable assignments will reuse |
| * storage). |
| */ |
| st_src_reg |
| glsl_to_tgsi_visitor::get_temp(const glsl_type *type) |
| { |
| st_src_reg src; |
| |
| src.type = native_integers ? type->base_type : GLSL_TYPE_FLOAT; |
| src.file = PROGRAM_TEMPORARY; |
| src.index = next_temp; |
| src.reladdr = NULL; |
| next_temp += type_size(type); |
| |
| if (type->is_array() || type->is_record()) { |
| src.swizzle = SWIZZLE_NOOP; |
| } else { |
| src.swizzle = swizzle_for_size(type->vector_elements); |
| } |
| src.negate = 0; |
| |
| return src; |
| } |
| |
| variable_storage * |
| glsl_to_tgsi_visitor::find_variable_storage(ir_variable *var) |
| { |
| |
| variable_storage *entry; |
| |
| foreach_iter(exec_list_iterator, iter, this->variables) { |
| entry = (variable_storage *)iter.get(); |
| |
| if (entry->var == var) |
| return entry; |
| } |
| |
| return NULL; |
| } |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_variable *ir) |
| { |
| if (strcmp(ir->name, "gl_FragCoord") == 0) { |
| struct gl_fragment_program *fp = (struct gl_fragment_program *)this->prog; |
| |
| fp->OriginUpperLeft = ir->origin_upper_left; |
| fp->PixelCenterInteger = ir->pixel_center_integer; |
| } |
| |
| if (ir->mode == ir_var_uniform && strncmp(ir->name, "gl_", 3) == 0) { |
| unsigned int i; |
| const ir_state_slot *const slots = ir->state_slots; |
| assert(ir->state_slots != NULL); |
| |
| /* Check if this statevar's setup in the STATE file exactly |
| * matches how we'll want to reference it as a |
| * struct/array/whatever. If not, then we need to move it into |
| * temporary storage and hope that it'll get copy-propagated |
| * out. |
| */ |
| for (i = 0; i < ir->num_state_slots; i++) { |
| if (slots[i].swizzle != SWIZZLE_XYZW) { |
| break; |
| } |
| } |
| |
| variable_storage *storage; |
| st_dst_reg dst; |
| if (i == ir->num_state_slots) { |
| /* We'll set the index later. */ |
| storage = new(mem_ctx) variable_storage(ir, PROGRAM_STATE_VAR, -1); |
| this->variables.push_tail(storage); |
| |
| dst = undef_dst; |
| } else { |
| /* The variable_storage constructor allocates slots based on the size |
| * of the type. However, this had better match the number of state |
| * elements that we're going to copy into the new temporary. |
| */ |
| assert((int) ir->num_state_slots == type_size(ir->type)); |
| |
| storage = new(mem_ctx) variable_storage(ir, PROGRAM_TEMPORARY, |
| this->next_temp); |
| this->variables.push_tail(storage); |
| this->next_temp += type_size(ir->type); |
| |
| dst = st_dst_reg(st_src_reg(PROGRAM_TEMPORARY, storage->index, |
| native_integers ? ir->type->base_type : GLSL_TYPE_FLOAT)); |
| } |
| |
| |
| for (unsigned int i = 0; i < ir->num_state_slots; i++) { |
| int index = _mesa_add_state_reference(this->prog->Parameters, |
| (gl_state_index *)slots[i].tokens); |
| |
| if (storage->file == PROGRAM_STATE_VAR) { |
| if (storage->index == -1) { |
| storage->index = index; |
| } else { |
| assert(index == storage->index + (int)i); |
| } |
| } else { |
| /* We use GLSL_TYPE_FLOAT here regardless of the actual type of |
| * the data being moved since MOV does not care about the type of |
| * data it is moving, and we don't want to declare registers with |
| * array or struct types. |
| */ |
| st_src_reg src(PROGRAM_STATE_VAR, index, GLSL_TYPE_FLOAT); |
| src.swizzle = slots[i].swizzle; |
| emit(ir, TGSI_OPCODE_MOV, dst, src); |
| /* even a float takes up a whole vec4 reg in a struct/array. */ |
| dst.index++; |
| } |
| } |
| |
| if (storage->file == PROGRAM_TEMPORARY && |
| dst.index != storage->index + (int) ir->num_state_slots) { |
| fail_link(this->shader_program, |
| "failed to load builtin uniform `%s' (%d/%d regs loaded)\n", |
| ir->name, dst.index - storage->index, |
| type_size(ir->type)); |
| } |
| } |
| } |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_loop *ir) |
| { |
| ir_dereference_variable *counter = NULL; |
| |
| if (ir->counter != NULL) |
| counter = new(ir) ir_dereference_variable(ir->counter); |
| |
| if (ir->from != NULL) { |
| assert(ir->counter != NULL); |
| |
| ir_assignment *a = new(ir) ir_assignment(counter, ir->from, NULL); |
| |
| a->accept(this); |
| delete a; |
| } |
| |
| emit(NULL, TGSI_OPCODE_BGNLOOP); |
| |
| if (ir->to) { |
| ir_expression *e = |
| new(ir) ir_expression(ir->cmp, glsl_type::bool_type, |
| counter, ir->to); |
| ir_if *if_stmt = new(ir) ir_if(e); |
| |
| ir_loop_jump *brk = new(ir) ir_loop_jump(ir_loop_jump::jump_break); |
| |
| if_stmt->then_instructions.push_tail(brk); |
| |
| if_stmt->accept(this); |
| |
| delete if_stmt; |
| delete e; |
| delete brk; |
| } |
| |
| visit_exec_list(&ir->body_instructions, this); |
| |
| if (ir->increment) { |
| ir_expression *e = |
| new(ir) ir_expression(ir_binop_add, counter->type, |
| counter, ir->increment); |
| |
| ir_assignment *a = new(ir) ir_assignment(counter, e, NULL); |
| |
| a->accept(this); |
| delete a; |
| delete e; |
| } |
| |
| emit(NULL, TGSI_OPCODE_ENDLOOP); |
| } |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_loop_jump *ir) |
| { |
| switch (ir->mode) { |
| case ir_loop_jump::jump_break: |
| emit(NULL, TGSI_OPCODE_BRK); |
| break; |
| case ir_loop_jump::jump_continue: |
| emit(NULL, TGSI_OPCODE_CONT); |
| break; |
| } |
| } |
| |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_function_signature *ir) |
| { |
| assert(0); |
| (void)ir; |
| } |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_function *ir) |
| { |
| /* Ignore function bodies other than main() -- we shouldn't see calls to |
| * them since they should all be inlined before we get to glsl_to_tgsi. |
| */ |
| if (strcmp(ir->name, "main") == 0) { |
| const ir_function_signature *sig; |
| exec_list empty; |
| |
| sig = ir->matching_signature(&empty); |
| |
| assert(sig); |
| |
| foreach_iter(exec_list_iterator, iter, sig->body) { |
| ir_instruction *ir = (ir_instruction *)iter.get(); |
| |
| ir->accept(this); |
| } |
| } |
| } |
| |
| bool |
| glsl_to_tgsi_visitor::try_emit_mad(ir_expression *ir, int mul_operand) |
| { |
| int nonmul_operand = 1 - mul_operand; |
| st_src_reg a, b, c; |
| st_dst_reg result_dst; |
| |
| ir_expression *expr = ir->operands[mul_operand]->as_expression(); |
| if (!expr || expr->operation != ir_binop_mul) |
| return false; |
| |
| expr->operands[0]->accept(this); |
| a = this->result; |
| expr->operands[1]->accept(this); |
| b = this->result; |
| ir->operands[nonmul_operand]->accept(this); |
| c = this->result; |
| |
| this->result = get_temp(ir->type); |
| result_dst = st_dst_reg(this->result); |
| result_dst.writemask = (1 << ir->type->vector_elements) - 1; |
| emit(ir, TGSI_OPCODE_MAD, result_dst, a, b, c); |
| |
| return true; |
| } |
| |
| /** |
| * Emit MAD(a, -b, a) instead of AND(a, NOT(b)) |
| * |
| * The logic values are 1.0 for true and 0.0 for false. Logical-and is |
| * implemented using multiplication, and logical-or is implemented using |
| * addition. Logical-not can be implemented as (true - x), or (1.0 - x). |
| * As result, the logical expression (a & !b) can be rewritten as: |
| * |
| * - a * !b |
| * - a * (1 - b) |
| * - (a * 1) - (a * b) |
| * - a + -(a * b) |
| * - a + (a * -b) |
| * |
| * This final expression can be implemented as a single MAD(a, -b, a) |
| * instruction. |
| */ |
| bool |
| glsl_to_tgsi_visitor::try_emit_mad_for_and_not(ir_expression *ir, int try_operand) |
| { |
| const int other_operand = 1 - try_operand; |
| st_src_reg a, b; |
| |
| ir_expression *expr = ir->operands[try_operand]->as_expression(); |
| if (!expr || expr->operation != ir_unop_logic_not) |
| return false; |
| |
| ir->operands[other_operand]->accept(this); |
| a = this->result; |
| expr->operands[0]->accept(this); |
| b = this->result; |
| |
| b.negate = ~b.negate; |
| |
| this->result = get_temp(ir->type); |
| emit(ir, TGSI_OPCODE_MAD, st_dst_reg(this->result), a, b, a); |
| |
| return true; |
| } |
| |
| bool |
| glsl_to_tgsi_visitor::try_emit_sat(ir_expression *ir) |
| { |
| /* Saturates were only introduced to vertex programs in |
| * NV_vertex_program3, so don't give them to drivers in the VP. |
| */ |
| if (this->prog->Target == GL_VERTEX_PROGRAM_ARB) |
| return false; |
| |
| ir_rvalue *sat_src = ir->as_rvalue_to_saturate(); |
| if (!sat_src) |
| return false; |
| |
| sat_src->accept(this); |
| st_src_reg src = this->result; |
| |
| /* If we generated an expression instruction into a temporary in |
| * processing the saturate's operand, apply the saturate to that |
| * instruction. Otherwise, generate a MOV to do the saturate. |
| * |
| * Note that we have to be careful to only do this optimization if |
| * the instruction in question was what generated src->result. For |
| * example, ir_dereference_array might generate a MUL instruction |
| * to create the reladdr, and return us a src reg using that |
| * reladdr. That MUL result is not the value we're trying to |
| * saturate. |
| */ |
| ir_expression *sat_src_expr = sat_src->as_expression(); |
| if (sat_src_expr && (sat_src_expr->operation == ir_binop_mul || |
| sat_src_expr->operation == ir_binop_add || |
| sat_src_expr->operation == ir_binop_dot)) { |
| glsl_to_tgsi_instruction *new_inst; |
| new_inst = (glsl_to_tgsi_instruction *)this->instructions.get_tail(); |
| new_inst->saturate = true; |
| } else { |
| this->result = get_temp(ir->type); |
| st_dst_reg result_dst = st_dst_reg(this->result); |
| result_dst.writemask = (1 << ir->type->vector_elements) - 1; |
| glsl_to_tgsi_instruction *inst; |
| inst = emit(ir, TGSI_OPCODE_MOV, result_dst, src); |
| inst->saturate = true; |
| } |
| |
| return true; |
| } |
| |
| void |
| glsl_to_tgsi_visitor::reladdr_to_temp(ir_instruction *ir, |
| st_src_reg *reg, int *num_reladdr) |
| { |
| if (!reg->reladdr) |
| return; |
| |
| emit_arl(ir, address_reg, *reg->reladdr); |
| |
| if (*num_reladdr != 1) { |
| st_src_reg temp = get_temp(glsl_type::vec4_type); |
| |
| emit(ir, TGSI_OPCODE_MOV, st_dst_reg(temp), *reg); |
| *reg = temp; |
| } |
| |
| (*num_reladdr)--; |
| } |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_expression *ir) |
| { |
| unsigned int operand; |
| st_src_reg op[Elements(ir->operands)]; |
| st_src_reg result_src; |
| st_dst_reg result_dst; |
| |
| /* Quick peephole: Emit MAD(a, b, c) instead of ADD(MUL(a, b), c) |
| */ |
| if (ir->operation == ir_binop_add) { |
| if (try_emit_mad(ir, 1)) |
| return; |
| if (try_emit_mad(ir, 0)) |
| return; |
| } |
| |
| /* Quick peephole: Emit OPCODE_MAD(-a, -b, a) instead of AND(a, NOT(b)) |
| */ |
| if (ir->operation == ir_binop_logic_and) { |
| if (try_emit_mad_for_and_not(ir, 1)) |
| return; |
| if (try_emit_mad_for_and_not(ir, 0)) |
| return; |
| } |
| |
| if (try_emit_sat(ir)) |
| return; |
| |
| if (ir->operation == ir_quadop_vector) |
| assert(!"ir_quadop_vector should have been lowered"); |
| |
| for (operand = 0; operand < ir->get_num_operands(); operand++) { |
| this->result.file = PROGRAM_UNDEFINED; |
| ir->operands[operand]->accept(this); |
| if (this->result.file == PROGRAM_UNDEFINED) { |
| ir_print_visitor v; |
| printf("Failed to get tree for expression operand:\n"); |
| ir->operands[operand]->accept(&v); |
| exit(1); |
| } |
| op[operand] = this->result; |
| |
| /* Matrix expression operands should have been broken down to vector |
| * operations already. |
| */ |
| assert(!ir->operands[operand]->type->is_matrix()); |
| } |
| |
| int vector_elements = ir->operands[0]->type->vector_elements; |
| if (ir->operands[1]) { |
| vector_elements = MAX2(vector_elements, |
| ir->operands[1]->type->vector_elements); |
| } |
| |
| this->result.file = PROGRAM_UNDEFINED; |
| |
| /* Storage for our result. Ideally for an assignment we'd be using |
| * the actual storage for the result here, instead. |
| */ |
| result_src = get_temp(ir->type); |
| /* convenience for the emit functions below. */ |
| result_dst = st_dst_reg(result_src); |
| /* Limit writes to the channels that will be used by result_src later. |
| * This does limit this temp's use as a temporary for multi-instruction |
| * sequences. |
| */ |
| result_dst.writemask = (1 << ir->type->vector_elements) - 1; |
| |
| switch (ir->operation) { |
| case ir_unop_logic_not: |
| if (result_dst.type != GLSL_TYPE_FLOAT) |
| emit(ir, TGSI_OPCODE_NOT, result_dst, op[0]); |
| else { |
| /* Previously 'SEQ dst, src, 0.0' was used for this. However, many |
| * older GPUs implement SEQ using multiple instructions (i915 uses two |
| * SGE instructions and a MUL instruction). Since our logic values are |
| * 0.0 and 1.0, 1-x also implements !x. |
| */ |
| op[0].negate = ~op[0].negate; |
| emit(ir, TGSI_OPCODE_ADD, result_dst, op[0], st_src_reg_for_float(1.0)); |
| } |
| break; |
| case ir_unop_neg: |
| if (result_dst.type == GLSL_TYPE_INT || result_dst.type == GLSL_TYPE_UINT) |
| emit(ir, TGSI_OPCODE_INEG, result_dst, op[0]); |
| else { |
| op[0].negate = ~op[0].negate; |
| result_src = op[0]; |
| } |
| break; |
| case ir_unop_abs: |
| emit(ir, TGSI_OPCODE_ABS, result_dst, op[0]); |
| break; |
| case ir_unop_sign: |
| emit(ir, TGSI_OPCODE_SSG, result_dst, op[0]); |
| break; |
| case ir_unop_rcp: |
| emit_scalar(ir, TGSI_OPCODE_RCP, result_dst, op[0]); |
| break; |
| |
| case ir_unop_exp2: |
| emit_scalar(ir, TGSI_OPCODE_EX2, result_dst, op[0]); |
| break; |
| case ir_unop_exp: |
| case ir_unop_log: |
| assert(!"not reached: should be handled by ir_explog_to_explog2"); |
| break; |
| case ir_unop_log2: |
| emit_scalar(ir, TGSI_OPCODE_LG2, result_dst, op[0]); |
| break; |
| case ir_unop_sin: |
| emit_scalar(ir, TGSI_OPCODE_SIN, result_dst, op[0]); |
| break; |
| case ir_unop_cos: |
| emit_scalar(ir, TGSI_OPCODE_COS, result_dst, op[0]); |
| break; |
| case ir_unop_sin_reduced: |
| emit_scs(ir, TGSI_OPCODE_SIN, result_dst, op[0]); |
| break; |
| case ir_unop_cos_reduced: |
| emit_scs(ir, TGSI_OPCODE_COS, result_dst, op[0]); |
| break; |
| |
| case ir_unop_dFdx: |
| emit(ir, TGSI_OPCODE_DDX, result_dst, op[0]); |
| break; |
| case ir_unop_dFdy: |
| { |
| /* The X component contains 1 or -1 depending on whether the framebuffer |
| * is a FBO or the window system buffer, respectively. |
| * It is then multiplied with the source operand of DDY. |
| */ |
| static const gl_state_index transform_y_state[STATE_LENGTH] |
| = { STATE_INTERNAL, STATE_FB_WPOS_Y_TRANSFORM }; |
| |
| unsigned transform_y_index = |
| _mesa_add_state_reference(this->prog->Parameters, |
| transform_y_state); |
| |
| st_src_reg transform_y = st_src_reg(PROGRAM_STATE_VAR, |
| transform_y_index, |
| glsl_type::vec4_type); |
| transform_y.swizzle = SWIZZLE_XXXX; |
| |
| st_src_reg temp = get_temp(glsl_type::vec4_type); |
| |
| emit(ir, TGSI_OPCODE_MUL, st_dst_reg(temp), transform_y, op[0]); |
| emit(ir, TGSI_OPCODE_DDY, result_dst, temp); |
| break; |
| } |
| |
| case ir_unop_noise: { |
| /* At some point, a motivated person could add a better |
| * implementation of noise. Currently not even the nvidia |
| * binary drivers do anything more than this. In any case, the |
| * place to do this is in the GL state tracker, not the poor |
| * driver. |
| */ |
| emit(ir, TGSI_OPCODE_MOV, result_dst, st_src_reg_for_float(0.5)); |
| break; |
| } |
| |
| case ir_binop_add: |
| emit(ir, TGSI_OPCODE_ADD, result_dst, op[0], op[1]); |
| break; |
| case ir_binop_sub: |
| emit(ir, TGSI_OPCODE_SUB, result_dst, op[0], op[1]); |
| break; |
| |
| case ir_binop_mul: |
| emit(ir, TGSI_OPCODE_MUL, result_dst, op[0], op[1]); |
| break; |
| case ir_binop_div: |
| if (result_dst.type == GLSL_TYPE_FLOAT) |
| assert(!"not reached: should be handled by ir_div_to_mul_rcp"); |
| else |
| emit(ir, TGSI_OPCODE_DIV, result_dst, op[0], op[1]); |
| break; |
| case ir_binop_mod: |
| if (result_dst.type == GLSL_TYPE_FLOAT) |
| assert(!"ir_binop_mod should have been converted to b * fract(a/b)"); |
| else |
| emit(ir, TGSI_OPCODE_MOD, result_dst, op[0], op[1]); |
| break; |
| |
| case ir_binop_less: |
| emit(ir, TGSI_OPCODE_SLT, result_dst, op[0], op[1]); |
| break; |
| case ir_binop_greater: |
| emit(ir, TGSI_OPCODE_SLT, result_dst, op[1], op[0]); |
| break; |
| case ir_binop_lequal: |
| emit(ir, TGSI_OPCODE_SGE, result_dst, op[1], op[0]); |
| break; |
| case ir_binop_gequal: |
| emit(ir, TGSI_OPCODE_SGE, result_dst, op[0], op[1]); |
| break; |
| case ir_binop_equal: |
| emit(ir, TGSI_OPCODE_SEQ, result_dst, op[0], op[1]); |
| break; |
| case ir_binop_nequal: |
| emit(ir, TGSI_OPCODE_SNE, result_dst, op[0], op[1]); |
| break; |
| case ir_binop_all_equal: |
| /* "==" operator producing a scalar boolean. */ |
| if (ir->operands[0]->type->is_vector() || |
| ir->operands[1]->type->is_vector()) { |
| st_src_reg temp = get_temp(native_integers ? |
| glsl_type::get_instance(ir->operands[0]->type->base_type, 4, 1) : |
| glsl_type::vec4_type); |
| |
| if (native_integers) { |
| st_dst_reg temp_dst = st_dst_reg(temp); |
| st_src_reg temp1 = st_src_reg(temp), temp2 = st_src_reg(temp); |
| |
| emit(ir, TGSI_OPCODE_SEQ, st_dst_reg(temp), op[0], op[1]); |
| |
| /* Emit 1-3 AND operations to combine the SEQ results. */ |
| switch (ir->operands[0]->type->vector_elements) { |
| case 2: |
| break; |
| case 3: |
| temp_dst.writemask = WRITEMASK_Y; |
| temp1.swizzle = SWIZZLE_YYYY; |
| temp2.swizzle = SWIZZLE_ZZZZ; |
| emit(ir, TGSI_OPCODE_AND, temp_dst, temp1, temp2); |
| break; |
| case 4: |
| temp_dst.writemask = WRITEMASK_X; |
| temp1.swizzle = SWIZZLE_XXXX; |
| temp2.swizzle = SWIZZLE_YYYY; |
| emit(ir, TGSI_OPCODE_AND, temp_dst, temp1, temp2); |
| temp_dst.writemask = WRITEMASK_Y; |
| temp1.swizzle = SWIZZLE_ZZZZ; |
| temp2.swizzle = SWIZZLE_WWWW; |
| emit(ir, TGSI_OPCODE_AND, temp_dst, temp1, temp2); |
| } |
| |
| temp1.swizzle = SWIZZLE_XXXX; |
| temp2.swizzle = SWIZZLE_YYYY; |
| emit(ir, TGSI_OPCODE_AND, result_dst, temp1, temp2); |
| } else { |
| emit(ir, TGSI_OPCODE_SNE, st_dst_reg(temp), op[0], op[1]); |
| |
| /* After the dot-product, the value will be an integer on the |
| * range [0,4]. Zero becomes 1.0, and positive values become zero. |
| */ |
| emit_dp(ir, result_dst, temp, temp, vector_elements); |
| |
| /* Negating the result of the dot-product gives values on the range |
| * [-4, 0]. Zero becomes 1.0, and negative values become zero. |
| * This is achieved using SGE. |
| */ |
| st_src_reg sge_src = result_src; |
| sge_src.negate = ~sge_src.negate; |
| emit(ir, TGSI_OPCODE_SGE, result_dst, sge_src, st_src_reg_for_float(0.0)); |
| } |
| } else { |
| emit(ir, TGSI_OPCODE_SEQ, result_dst, op[0], op[1]); |
| } |
| break; |
| case ir_binop_any_nequal: |
| /* "!=" operator producing a scalar boolean. */ |
| if (ir->operands[0]->type->is_vector() || |
| ir->operands[1]->type->is_vector()) { |
| st_src_reg temp = get_temp(native_integers ? |
| glsl_type::get_instance(ir->operands[0]->type->base_type, 4, 1) : |
| glsl_type::vec4_type); |
| emit(ir, TGSI_OPCODE_SNE, st_dst_reg(temp), op[0], op[1]); |
| |
| if (native_integers) { |
| st_dst_reg temp_dst = st_dst_reg(temp); |
| st_src_reg temp1 = st_src_reg(temp), temp2 = st_src_reg(temp); |
| |
| /* Emit 1-3 OR operations to combine the SNE results. */ |
| switch (ir->operands[0]->type->vector_elements) { |
| case 2: |
| break; |
| case 3: |
| temp_dst.writemask = WRITEMASK_Y; |
| temp1.swizzle = SWIZZLE_YYYY; |
| temp2.swizzle = SWIZZLE_ZZZZ; |
| emit(ir, TGSI_OPCODE_OR, temp_dst, temp1, temp2); |
| break; |
| case 4: |
| temp_dst.writemask = WRITEMASK_X; |
| temp1.swizzle = SWIZZLE_XXXX; |
| temp2.swizzle = SWIZZLE_YYYY; |
| emit(ir, TGSI_OPCODE_OR, temp_dst, temp1, temp2); |
| temp_dst.writemask = WRITEMASK_Y; |
| temp1.swizzle = SWIZZLE_ZZZZ; |
| temp2.swizzle = SWIZZLE_WWWW; |
| emit(ir, TGSI_OPCODE_OR, temp_dst, temp1, temp2); |
| } |
| |
| temp1.swizzle = SWIZZLE_XXXX; |
| temp2.swizzle = SWIZZLE_YYYY; |
| emit(ir, TGSI_OPCODE_OR, result_dst, temp1, temp2); |
| } else { |
| /* After the dot-product, the value will be an integer on the |
| * range [0,4]. Zero stays zero, and positive values become 1.0. |
| */ |
| glsl_to_tgsi_instruction *const dp = |
| emit_dp(ir, result_dst, temp, temp, vector_elements); |
| if (this->prog->Target == GL_FRAGMENT_PROGRAM_ARB) { |
| /* The clamping to [0,1] can be done for free in the fragment |
| * shader with a saturate. |
| */ |
| dp->saturate = true; |
| } else { |
| /* Negating the result of the dot-product gives values on the range |
| * [-4, 0]. Zero stays zero, and negative values become 1.0. This |
| * achieved using SLT. |
| */ |
| st_src_reg slt_src = result_src; |
| slt_src.negate = ~slt_src.negate; |
| emit(ir, TGSI_OPCODE_SLT, result_dst, slt_src, st_src_reg_for_float(0.0)); |
| } |
| } |
| } else { |
| emit(ir, TGSI_OPCODE_SNE, result_dst, op[0], op[1]); |
| } |
| break; |
| |
| case ir_unop_any: { |
| assert(ir->operands[0]->type->is_vector()); |
| |
| /* After the dot-product, the value will be an integer on the |
| * range [0,4]. Zero stays zero, and positive values become 1.0. |
| */ |
| glsl_to_tgsi_instruction *const dp = |
| emit_dp(ir, result_dst, op[0], op[0], |
| ir->operands[0]->type->vector_elements); |
| if (this->prog->Target == GL_FRAGMENT_PROGRAM_ARB && |
| result_dst.type == GLSL_TYPE_FLOAT) { |
| /* The clamping to [0,1] can be done for free in the fragment |
| * shader with a saturate. |
| */ |
| dp->saturate = true; |
| } else if (result_dst.type == GLSL_TYPE_FLOAT) { |
| /* Negating the result of the dot-product gives values on the range |
| * [-4, 0]. Zero stays zero, and negative values become 1.0. This |
| * is achieved using SLT. |
| */ |
| st_src_reg slt_src = result_src; |
| slt_src.negate = ~slt_src.negate; |
| emit(ir, TGSI_OPCODE_SLT, result_dst, slt_src, st_src_reg_for_float(0.0)); |
| } |
| else { |
| /* Use SNE 0 if integers are being used as boolean values. */ |
| emit(ir, TGSI_OPCODE_SNE, result_dst, result_src, st_src_reg_for_int(0)); |
| } |
| break; |
| } |
| |
| case ir_binop_logic_xor: |
| if (native_integers) |
| emit(ir, TGSI_OPCODE_XOR, result_dst, op[0], op[1]); |
| else |
| emit(ir, TGSI_OPCODE_SNE, result_dst, op[0], op[1]); |
| break; |
| |
| case ir_binop_logic_or: { |
| if (native_integers) { |
| /* If integers are used as booleans, we can use an actual "or" |
| * instruction. |
| */ |
| assert(native_integers); |
| emit(ir, TGSI_OPCODE_OR, result_dst, op[0], op[1]); |
| } else { |
| /* After the addition, the value will be an integer on the |
| * range [0,2]. Zero stays zero, and positive values become 1.0. |
| */ |
| glsl_to_tgsi_instruction *add = |
| emit(ir, TGSI_OPCODE_ADD, result_dst, op[0], op[1]); |
| if (this->prog->Target == GL_FRAGMENT_PROGRAM_ARB) { |
| /* The clamping to [0,1] can be done for free in the fragment |
| * shader with a saturate if floats are being used as boolean values. |
| */ |
| add->saturate = true; |
| } else { |
| /* Negating the result of the addition gives values on the range |
| * [-2, 0]. Zero stays zero, and negative values become 1.0. This |
| * is achieved using SLT. |
| */ |
| st_src_reg slt_src = result_src; |
| slt_src.negate = ~slt_src.negate; |
| emit(ir, TGSI_OPCODE_SLT, result_dst, slt_src, st_src_reg_for_float(0.0)); |
| } |
| } |
| break; |
| } |
| |
| case ir_binop_logic_and: |
| /* If native integers are disabled, the bool args are stored as float 0.0 |
| * or 1.0, so "mul" gives us "and". If they're enabled, just use the |
| * actual AND opcode. |
| */ |
| if (native_integers) |
| emit(ir, TGSI_OPCODE_AND, result_dst, op[0], op[1]); |
| else |
| emit(ir, TGSI_OPCODE_MUL, result_dst, op[0], op[1]); |
| break; |
| |
| case ir_binop_dot: |
| assert(ir->operands[0]->type->is_vector()); |
| assert(ir->operands[0]->type == ir->operands[1]->type); |
| emit_dp(ir, result_dst, op[0], op[1], |
| ir->operands[0]->type->vector_elements); |
| break; |
| |
| case ir_unop_sqrt: |
| /* sqrt(x) = x * rsq(x). */ |
| emit_scalar(ir, TGSI_OPCODE_RSQ, result_dst, op[0]); |
| emit(ir, TGSI_OPCODE_MUL, result_dst, result_src, op[0]); |
| /* For incoming channels <= 0, set the result to 0. */ |
| op[0].negate = ~op[0].negate; |
| emit(ir, TGSI_OPCODE_CMP, result_dst, |
| op[0], result_src, st_src_reg_for_float(0.0)); |
| break; |
| case ir_unop_rsq: |
| emit_scalar(ir, TGSI_OPCODE_RSQ, result_dst, op[0]); |
| break; |
| case ir_unop_i2f: |
| if (native_integers) { |
| emit(ir, TGSI_OPCODE_I2F, result_dst, op[0]); |
| break; |
| } |
| /* fallthrough to next case otherwise */ |
| case ir_unop_b2f: |
| if (native_integers) { |
| emit(ir, TGSI_OPCODE_AND, result_dst, op[0], st_src_reg_for_float(1.0)); |
| break; |
| } |
| /* fallthrough to next case otherwise */ |
| case ir_unop_i2u: |
| case ir_unop_u2i: |
| /* Converting between signed and unsigned integers is a no-op. */ |
| result_src = op[0]; |
| break; |
| case ir_unop_b2i: |
| if (native_integers) { |
| /* Booleans are stored as integers using ~0 for true and 0 for false. |
| * GLSL requires that int(bool) return 1 for true and 0 for false. |
| * This conversion is done with AND, but it could be done with NEG. |
| */ |
| emit(ir, TGSI_OPCODE_AND, result_dst, op[0], st_src_reg_for_int(1)); |
| } else { |
| /* Booleans and integers are both stored as floats when native |
| * integers are disabled. |
| */ |
| result_src = op[0]; |
| } |
| break; |
| case ir_unop_f2i: |
| if (native_integers) |
| emit(ir, TGSI_OPCODE_F2I, result_dst, op[0]); |
| else |
| emit(ir, TGSI_OPCODE_TRUNC, result_dst, op[0]); |
| break; |
| case ir_unop_f2u: |
| if (native_integers) |
| emit(ir, TGSI_OPCODE_F2U, result_dst, op[0]); |
| else |
| emit(ir, TGSI_OPCODE_TRUNC, result_dst, op[0]); |
| break; |
| case ir_unop_bitcast_f2i: |
| case ir_unop_bitcast_f2u: |
| case ir_unop_bitcast_i2f: |
| case ir_unop_bitcast_u2f: |
| result_src = op[0]; |
| break; |
| case ir_unop_f2b: |
| emit(ir, TGSI_OPCODE_SNE, result_dst, op[0], st_src_reg_for_float(0.0)); |
| break; |
| case ir_unop_i2b: |
| if (native_integers) |
| emit(ir, TGSI_OPCODE_INEG, result_dst, op[0]); |
| else |
| emit(ir, TGSI_OPCODE_SNE, result_dst, op[0], st_src_reg_for_float(0.0)); |
| break; |
| case ir_unop_trunc: |
| emit(ir, TGSI_OPCODE_TRUNC, result_dst, op[0]); |
| break; |
| case ir_unop_ceil: |
| emit(ir, TGSI_OPCODE_CEIL, result_dst, op[0]); |
| break; |
| case ir_unop_floor: |
| emit(ir, TGSI_OPCODE_FLR, result_dst, op[0]); |
| break; |
| case ir_unop_round_even: |
| emit(ir, TGSI_OPCODE_ROUND, result_dst, op[0]); |
| break; |
| case ir_unop_fract: |
| emit(ir, TGSI_OPCODE_FRC, result_dst, op[0]); |
| break; |
| |
| case ir_binop_min: |
| emit(ir, TGSI_OPCODE_MIN, result_dst, op[0], op[1]); |
| break; |
| case ir_binop_max: |
| emit(ir, TGSI_OPCODE_MAX, result_dst, op[0], op[1]); |
| break; |
| case ir_binop_pow: |
| emit_scalar(ir, TGSI_OPCODE_POW, result_dst, op[0], op[1]); |
| break; |
| |
| case ir_unop_bit_not: |
| if (native_integers) { |
| emit(ir, TGSI_OPCODE_NOT, result_dst, op[0]); |
| break; |
| } |
| case ir_unop_u2f: |
| if (native_integers) { |
| emit(ir, TGSI_OPCODE_U2F, result_dst, op[0]); |
| break; |
| } |
| case ir_binop_lshift: |
| if (native_integers) { |
| emit(ir, TGSI_OPCODE_SHL, result_dst, op[0], op[1]); |
| break; |
| } |
| case ir_binop_rshift: |
| if (native_integers) { |
| emit(ir, TGSI_OPCODE_ISHR, result_dst, op[0], op[1]); |
| break; |
| } |
| case ir_binop_bit_and: |
| if (native_integers) { |
| emit(ir, TGSI_OPCODE_AND, result_dst, op[0], op[1]); |
| break; |
| } |
| case ir_binop_bit_xor: |
| if (native_integers) { |
| emit(ir, TGSI_OPCODE_XOR, result_dst, op[0], op[1]); |
| break; |
| } |
| case ir_binop_bit_or: |
| if (native_integers) { |
| emit(ir, TGSI_OPCODE_OR, result_dst, op[0], op[1]); |
| break; |
| } |
| |
| assert(!"GLSL 1.30 features unsupported"); |
| break; |
| |
| case ir_binop_ubo_load: |
| assert(!"not yet supported"); |
| break; |
| |
| case ir_quadop_vector: |
| /* This operation should have already been handled. |
| */ |
| assert(!"Should not get here."); |
| break; |
| } |
| |
| this->result = result_src; |
| } |
| |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_swizzle *ir) |
| { |
| st_src_reg src; |
| int i; |
| int swizzle[4]; |
| |
| /* Note that this is only swizzles in expressions, not those on the left |
| * hand side of an assignment, which do write masking. See ir_assignment |
| * for that. |
| */ |
| |
| ir->val->accept(this); |
| src = this->result; |
| assert(src.file != PROGRAM_UNDEFINED); |
| |
| for (i = 0; i < 4; i++) { |
| if (i < ir->type->vector_elements) { |
| switch (i) { |
| case 0: |
| swizzle[i] = GET_SWZ(src.swizzle, ir->mask.x); |
| break; |
| case 1: |
| swizzle[i] = GET_SWZ(src.swizzle, ir->mask.y); |
| break; |
| case 2: |
| swizzle[i] = GET_SWZ(src.swizzle, ir->mask.z); |
| break; |
| case 3: |
| swizzle[i] = GET_SWZ(src.swizzle, ir->mask.w); |
| break; |
| } |
| } else { |
| /* If the type is smaller than a vec4, replicate the last |
| * channel out. |
| */ |
| swizzle[i] = swizzle[ir->type->vector_elements - 1]; |
| } |
| } |
| |
| src.swizzle = MAKE_SWIZZLE4(swizzle[0], swizzle[1], swizzle[2], swizzle[3]); |
| |
| this->result = src; |
| } |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_dereference_variable *ir) |
| { |
| variable_storage *entry = find_variable_storage(ir->var); |
| ir_variable *var = ir->var; |
| |
| if (!entry) { |
| switch (var->mode) { |
| case ir_var_uniform: |
| entry = new(mem_ctx) variable_storage(var, PROGRAM_UNIFORM, |
| var->location); |
| this->variables.push_tail(entry); |
| break; |
| case ir_var_in: |
| case ir_var_inout: |
| /* The linker assigns locations for varyings and attributes, |
| * including deprecated builtins (like gl_Color), user-assign |
| * generic attributes (glBindVertexLocation), and |
| * user-defined varyings. |
| * |
| * FINISHME: We would hit this path for function arguments. Fix! |
| */ |
| assert(var->location != -1); |
| entry = new(mem_ctx) variable_storage(var, |
| PROGRAM_INPUT, |
| var->location); |
| break; |
| case ir_var_out: |
| assert(var->location != -1); |
| entry = new(mem_ctx) variable_storage(var, |
| PROGRAM_OUTPUT, |
| var->location + var->index); |
| break; |
| case ir_var_system_value: |
| entry = new(mem_ctx) variable_storage(var, |
| PROGRAM_SYSTEM_VALUE, |
| var->location); |
| break; |
| case ir_var_auto: |
| case ir_var_temporary: |
| entry = new(mem_ctx) variable_storage(var, PROGRAM_TEMPORARY, |
| this->next_temp); |
| this->variables.push_tail(entry); |
| |
| next_temp += type_size(var->type); |
| break; |
| } |
| |
| if (!entry) { |
| printf("Failed to make storage for %s\n", var->name); |
| exit(1); |
| } |
| } |
| |
| this->result = st_src_reg(entry->file, entry->index, var->type); |
| if (!native_integers) |
| this->result.type = GLSL_TYPE_FLOAT; |
| } |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_dereference_array *ir) |
| { |
| ir_constant *index; |
| st_src_reg src; |
| int element_size = type_size(ir->type); |
| |
| index = ir->array_index->constant_expression_value(); |
| |
| ir->array->accept(this); |
| src = this->result; |
| |
| if (index) { |
| src.index += index->value.i[0] * element_size; |
| } else { |
| /* Variable index array dereference. It eats the "vec4" of the |
| * base of the array and an index that offsets the TGSI register |
| * index. |
| */ |
| ir->array_index->accept(this); |
| |
| st_src_reg index_reg; |
| |
| if (element_size == 1) { |
| index_reg = this->result; |
| } else { |
| index_reg = get_temp(native_integers ? |
| glsl_type::int_type : glsl_type::float_type); |
| |
| emit(ir, TGSI_OPCODE_MUL, st_dst_reg(index_reg), |
| this->result, st_src_reg_for_type(index_reg.type, element_size)); |
| } |
| |
| /* If there was already a relative address register involved, add the |
| * new and the old together to get the new offset. |
| */ |
| if (src.reladdr != NULL) { |
| st_src_reg accum_reg = get_temp(native_integers ? |
| glsl_type::int_type : glsl_type::float_type); |
| |
| emit(ir, TGSI_OPCODE_ADD, st_dst_reg(accum_reg), |
| index_reg, *src.reladdr); |
| |
| index_reg = accum_reg; |
| } |
| |
| src.reladdr = ralloc(mem_ctx, st_src_reg); |
| memcpy(src.reladdr, &index_reg, sizeof(index_reg)); |
| } |
| |
| /* If the type is smaller than a vec4, replicate the last channel out. */ |
| if (ir->type->is_scalar() || ir->type->is_vector()) |
| src.swizzle = swizzle_for_size(ir->type->vector_elements); |
| else |
| src.swizzle = SWIZZLE_NOOP; |
| |
| /* Change the register type to the element type of the array. */ |
| src.type = ir->type->base_type; |
| |
| this->result = src; |
| } |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_dereference_record *ir) |
| { |
| unsigned int i; |
| const glsl_type *struct_type = ir->record->type; |
| int offset = 0; |
| |
| ir->record->accept(this); |
| |
| for (i = 0; i < struct_type->length; i++) { |
| if (strcmp(struct_type->fields.structure[i].name, ir->field) == 0) |
| break; |
| offset += type_size(struct_type->fields.structure[i].type); |
| } |
| |
| /* If the type is smaller than a vec4, replicate the last channel out. */ |
| if (ir->type->is_scalar() || ir->type->is_vector()) |
| this->result.swizzle = swizzle_for_size(ir->type->vector_elements); |
| else |
| this->result.swizzle = SWIZZLE_NOOP; |
| |
| this->result.index += offset; |
| this->result.type = ir->type->base_type; |
| } |
| |
| /** |
| * We want to be careful in assignment setup to hit the actual storage |
| * instead of potentially using a temporary like we might with the |
| * ir_dereference handler. |
| */ |
| static st_dst_reg |
| get_assignment_lhs(ir_dereference *ir, glsl_to_tgsi_visitor *v) |
| { |
| /* The LHS must be a dereference. If the LHS is a variable indexed array |
| * access of a vector, it must be separated into a series conditional moves |
| * before reaching this point (see ir_vec_index_to_cond_assign). |
| */ |
| assert(ir->as_dereference()); |
| ir_dereference_array *deref_array = ir->as_dereference_array(); |
| if (deref_array) { |
| assert(!deref_array->array->type->is_vector()); |
| } |
| |
| /* Use the rvalue deref handler for the most part. We'll ignore |
| * swizzles in it and write swizzles using writemask, though. |
| */ |
| ir->accept(v); |
| return st_dst_reg(v->result); |
| } |
| |
| /** |
| * Process the condition of a conditional assignment |
| * |
| * Examines the condition of a conditional assignment to generate the optimal |
| * first operand of a \c CMP instruction. If the condition is a relational |
| * operator with 0 (e.g., \c ir_binop_less), the value being compared will be |
| * used as the source for the \c CMP instruction. Otherwise the comparison |
| * is processed to a boolean result, and the boolean result is used as the |
| * operand to the CMP instruction. |
| */ |
| bool |
| glsl_to_tgsi_visitor::process_move_condition(ir_rvalue *ir) |
| { |
| ir_rvalue *src_ir = ir; |
| bool negate = true; |
| bool switch_order = false; |
| |
| ir_expression *const expr = ir->as_expression(); |
| if ((expr != NULL) && (expr->get_num_operands() == 2)) { |
| bool zero_on_left = false; |
| |
| if (expr->operands[0]->is_zero()) { |
| src_ir = expr->operands[1]; |
| zero_on_left = true; |
| } else if (expr->operands[1]->is_zero()) { |
| src_ir = expr->operands[0]; |
| zero_on_left = false; |
| } |
| |
| /* a is - 0 + - 0 + |
| * (a < 0) T F F ( a < 0) T F F |
| * (0 < a) F F T (-a < 0) F F T |
| * (a <= 0) T T F (-a < 0) F F T (swap order of other operands) |
| * (0 <= a) F T T ( a < 0) T F F (swap order of other operands) |
| * (a > 0) F F T (-a < 0) F F T |
| * (0 > a) T F F ( a < 0) T F F |
| * (a >= 0) F T T ( a < 0) T F F (swap order of other operands) |
| * (0 >= a) T T F (-a < 0) F F T (swap order of other operands) |
| * |
| * Note that exchanging the order of 0 and 'a' in the comparison simply |
| * means that the value of 'a' should be negated. |
| */ |
| if (src_ir != ir) { |
| switch (expr->operation) { |
| case ir_binop_less: |
| switch_order = false; |
| negate = zero_on_left; |
| break; |
| |
| case ir_binop_greater: |
| switch_order = false; |
| negate = !zero_on_left; |
| break; |
| |
| case ir_binop_lequal: |
| switch_order = true; |
| negate = !zero_on_left; |
| break; |
| |
| case ir_binop_gequal: |
| switch_order = true; |
| negate = zero_on_left; |
| break; |
| |
| default: |
| /* This isn't the right kind of comparison afterall, so make sure |
| * the whole condition is visited. |
| */ |
| src_ir = ir; |
| break; |
| } |
| } |
| } |
| |
| src_ir->accept(this); |
| |
| /* We use the TGSI_OPCODE_CMP (a < 0 ? b : c) for conditional moves, and the |
| * condition we produced is 0.0 or 1.0. By flipping the sign, we can |
| * choose which value TGSI_OPCODE_CMP produces without an extra instruction |
| * computing the condition. |
| */ |
| if (negate) |
| this->result.negate = ~this->result.negate; |
| |
| return switch_order; |
| } |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_assignment *ir) |
| { |
| st_dst_reg l; |
| st_src_reg r; |
| int i; |
| |
| ir->rhs->accept(this); |
| r = this->result; |
| |
| l = get_assignment_lhs(ir->lhs, this); |
| |
| /* FINISHME: This should really set to the correct maximal writemask for each |
| * FINISHME: component written (in the loops below). This case can only |
| * FINISHME: occur for matrices, arrays, and structures. |
| */ |
| if (ir->write_mask == 0) { |
| assert(!ir->lhs->type->is_scalar() && !ir->lhs->type->is_vector()); |
| l.writemask = WRITEMASK_XYZW; |
| } else if (ir->lhs->type->is_scalar() && |
| ir->lhs->variable_referenced()->mode == ir_var_out) { |
| /* FINISHME: This hack makes writing to gl_FragDepth, which lives in the |
| * FINISHME: W component of fragment shader output zero, work correctly. |
| */ |
| l.writemask = WRITEMASK_XYZW; |
| } else { |
| int swizzles[4]; |
| int first_enabled_chan = 0; |
| int rhs_chan = 0; |
| |
| l.writemask = ir->write_mask; |
| |
| for (int i = 0; i < 4; i++) { |
| if (l.writemask & (1 << i)) { |
| first_enabled_chan = GET_SWZ(r.swizzle, i); |
| break; |
| } |
| } |
| |
| /* Swizzle a small RHS vector into the channels being written. |
| * |
| * glsl ir treats write_mask as dictating how many channels are |
| * present on the RHS while TGSI treats write_mask as just |
| * showing which channels of the vec4 RHS get written. |
| */ |
| for (int i = 0; i < 4; i++) { |
| if (l.writemask & (1 << i)) |
| swizzles[i] = GET_SWZ(r.swizzle, rhs_chan++); |
| else |
| swizzles[i] = first_enabled_chan; |
| } |
| r.swizzle = MAKE_SWIZZLE4(swizzles[0], swizzles[1], |
| swizzles[2], swizzles[3]); |
| } |
| |
| assert(l.file != PROGRAM_UNDEFINED); |
| assert(r.file != PROGRAM_UNDEFINED); |
| |
| if (ir->condition) { |
| const bool switch_order = this->process_move_condition(ir->condition); |
| st_src_reg condition = this->result; |
| |
| for (i = 0; i < type_size(ir->lhs->type); i++) { |
| st_src_reg l_src = st_src_reg(l); |
| st_src_reg condition_temp = condition; |
| l_src.swizzle = swizzle_for_size(ir->lhs->type->vector_elements); |
| |
| if (native_integers) { |
| /* This is necessary because TGSI's CMP instruction expects the |
| * condition to be a float, and we store booleans as integers. |
| * If TGSI had a UCMP instruction or similar, this extra |
| * instruction would not be necessary. |
| */ |
| condition_temp = get_temp(glsl_type::vec4_type); |
| condition.negate = 0; |
| emit(ir, TGSI_OPCODE_I2F, st_dst_reg(condition_temp), condition); |
| condition_temp.swizzle = condition.swizzle; |
| } |
| |
| if (switch_order) { |
| emit(ir, TGSI_OPCODE_CMP, l, condition_temp, l_src, r); |
| } else { |
| emit(ir, TGSI_OPCODE_CMP, l, condition_temp, r, l_src); |
| } |
| |
| l.index++; |
| r.index++; |
| } |
| } else if (ir->rhs->as_expression() && |
| this->instructions.get_tail() && |
| ir->rhs == ((glsl_to_tgsi_instruction *)this->instructions.get_tail())->ir && |
| type_size(ir->lhs->type) == 1 && |
| l.writemask == ((glsl_to_tgsi_instruction *)this->instructions.get_tail())->dst.writemask) { |
| /* To avoid emitting an extra MOV when assigning an expression to a |
| * variable, emit the last instruction of the expression again, but |
| * replace the destination register with the target of the assignment. |
| * Dead code elimination will remove the original instruction. |
| */ |
| glsl_to_tgsi_instruction *inst, *new_inst; |
| inst = (glsl_to_tgsi_instruction *)this->instructions.get_tail(); |
| new_inst = emit(ir, inst->op, l, inst->src[0], inst->src[1], inst->src[2]); |
| new_inst->saturate = inst->saturate; |
| inst->dead_mask = inst->dst.writemask; |
| } else { |
| for (i = 0; i < type_size(ir->lhs->type); i++) { |
| if (ir->rhs->type->is_array()) |
| r.type = ir->rhs->type->element_type()->base_type; |
| else if (ir->rhs->type->is_record()) |
| r.type = ir->rhs->type->fields.structure[i].type->base_type; |
| emit(ir, TGSI_OPCODE_MOV, l, r); |
| l.index++; |
| r.index++; |
| } |
| } |
| } |
| |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_constant *ir) |
| { |
| st_src_reg src; |
| GLfloat stack_vals[4] = { 0 }; |
| gl_constant_value *values = (gl_constant_value *) stack_vals; |
| GLenum gl_type = GL_NONE; |
| unsigned int i; |
| static int in_array = 0; |
| gl_register_file file = in_array ? PROGRAM_CONSTANT : PROGRAM_IMMEDIATE; |
| |
| /* Unfortunately, 4 floats is all we can get into |
| * _mesa_add_typed_unnamed_constant. So, make a temp to store an |
| * aggregate constant and move each constant value into it. If we |
| * get lucky, copy propagation will eliminate the extra moves. |
| */ |
| if (ir->type->base_type == GLSL_TYPE_STRUCT) { |
| st_src_reg temp_base = get_temp(ir->type); |
| st_dst_reg temp = st_dst_reg(temp_base); |
| |
| foreach_iter(exec_list_iterator, iter, ir->components) { |
| ir_constant *field_value = (ir_constant *)iter.get(); |
| int size = type_size(field_value->type); |
| |
| assert(size > 0); |
| |
| field_value->accept(this); |
| src = this->result; |
| |
| for (i = 0; i < (unsigned int)size; i++) { |
| emit(ir, TGSI_OPCODE_MOV, temp, src); |
| |
| src.index++; |
| temp.index++; |
| } |
| } |
| this->result = temp_base; |
| return; |
| } |
| |
| if (ir->type->is_array()) { |
| st_src_reg temp_base = get_temp(ir->type); |
| st_dst_reg temp = st_dst_reg(temp_base); |
| int size = type_size(ir->type->fields.array); |
| |
| assert(size > 0); |
| in_array++; |
| |
| for (i = 0; i < ir->type->length; i++) { |
| ir->array_elements[i]->accept(this); |
| src = this->result; |
| for (int j = 0; j < size; j++) { |
| emit(ir, TGSI_OPCODE_MOV, temp, src); |
| |
| src.index++; |
| temp.index++; |
| } |
| } |
| this->result = temp_base; |
| in_array--; |
| return; |
| } |
| |
| if (ir->type->is_matrix()) { |
| st_src_reg mat = get_temp(ir->type); |
| st_dst_reg mat_column = st_dst_reg(mat); |
| |
| for (i = 0; i < ir->type->matrix_columns; i++) { |
| assert(ir->type->base_type == GLSL_TYPE_FLOAT); |
| values = (gl_constant_value *) &ir->value.f[i * ir->type->vector_elements]; |
| |
| src = st_src_reg(file, -1, ir->type->base_type); |
| src.index = add_constant(file, |
| values, |
| ir->type->vector_elements, |
| GL_FLOAT, |
| &src.swizzle); |
| emit(ir, TGSI_OPCODE_MOV, mat_column, src); |
| |
| mat_column.index++; |
| } |
| |
| this->result = mat; |
| return; |
| } |
| |
| switch (ir->type->base_type) { |
| case GLSL_TYPE_FLOAT: |
| gl_type = GL_FLOAT; |
| for (i = 0; i < ir->type->vector_elements; i++) { |
| values[i].f = ir->value.f[i]; |
| } |
| break; |
| case GLSL_TYPE_UINT: |
| gl_type = native_integers ? GL_UNSIGNED_INT : GL_FLOAT; |
| for (i = 0; i < ir->type->vector_elements; i++) { |
| if (native_integers) |
| values[i].u = ir->value.u[i]; |
| else |
| values[i].f = ir->value.u[i]; |
| } |
| break; |
| case GLSL_TYPE_INT: |
| gl_type = native_integers ? GL_INT : GL_FLOAT; |
| for (i = 0; i < ir->type->vector_elements; i++) { |
| if (native_integers) |
| values[i].i = ir->value.i[i]; |
| else |
| values[i].f = ir->value.i[i]; |
| } |
| break; |
| case GLSL_TYPE_BOOL: |
| gl_type = native_integers ? GL_BOOL : GL_FLOAT; |
| for (i = 0; i < ir->type->vector_elements; i++) { |
| if (native_integers) |
| values[i].u = ir->value.b[i] ? ~0 : 0; |
| else |
| values[i].f = ir->value.b[i]; |
| } |
| break; |
| default: |
| assert(!"Non-float/uint/int/bool constant"); |
| } |
| |
| this->result = st_src_reg(file, -1, ir->type); |
| this->result.index = add_constant(file, |
| values, |
| ir->type->vector_elements, |
| gl_type, |
| &this->result.swizzle); |
| } |
| |
| function_entry * |
| glsl_to_tgsi_visitor::get_function_signature(ir_function_signature *sig) |
| { |
| function_entry *entry; |
| |
| foreach_iter(exec_list_iterator, iter, this->function_signatures) { |
| entry = (function_entry *)iter.get(); |
| |
| if (entry->sig == sig) |
| return entry; |
| } |
| |
| entry = ralloc(mem_ctx, function_entry); |
| entry->sig = sig; |
| entry->sig_id = this->next_signature_id++; |
| entry->bgn_inst = NULL; |
| |
| /* Allocate storage for all the parameters. */ |
| foreach_iter(exec_list_iterator, iter, sig->parameters) { |
| ir_variable *param = (ir_variable *)iter.get(); |
| variable_storage *storage; |
| |
| storage = find_variable_storage(param); |
| assert(!storage); |
| |
| storage = new(mem_ctx) variable_storage(param, PROGRAM_TEMPORARY, |
| this->next_temp); |
| this->variables.push_tail(storage); |
| |
| this->next_temp += type_size(param->type); |
| } |
| |
| if (!sig->return_type->is_void()) { |
| entry->return_reg = get_temp(sig->return_type); |
| } else { |
| entry->return_reg = undef_src; |
| } |
| |
| this->function_signatures.push_tail(entry); |
| return entry; |
| } |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_call *ir) |
| { |
| glsl_to_tgsi_instruction *call_inst; |
| ir_function_signature *sig = ir->callee; |
| function_entry *entry = get_function_signature(sig); |
| int i; |
| |
| /* Process in parameters. */ |
| exec_list_iterator sig_iter = sig->parameters.iterator(); |
| foreach_iter(exec_list_iterator, iter, *ir) { |
| ir_rvalue *param_rval = (ir_rvalue *)iter.get(); |
| ir_variable *param = (ir_variable *)sig_iter.get(); |
| |
| if (param->mode == ir_var_in || |
| param->mode == ir_var_inout) { |
| variable_storage *storage = find_variable_storage(param); |
| assert(storage); |
| |
| param_rval->accept(this); |
| st_src_reg r = this->result; |
| |
| st_dst_reg l; |
| l.file = storage->file; |
| l.index = storage->index; |
| l.reladdr = NULL; |
| l.writemask = WRITEMASK_XYZW; |
| l.cond_mask = COND_TR; |
| |
| for (i = 0; i < type_size(param->type); i++) { |
| emit(ir, TGSI_OPCODE_MOV, l, r); |
| l.index++; |
| r.index++; |
| } |
| } |
| |
| sig_iter.next(); |
| } |
| assert(!sig_iter.has_next()); |
| |
| /* Emit call instruction */ |
| call_inst = emit(ir, TGSI_OPCODE_CAL); |
| call_inst->function = entry; |
| |
| /* Process out parameters. */ |
| sig_iter = sig->parameters.iterator(); |
| foreach_iter(exec_list_iterator, iter, *ir) { |
| ir_rvalue *param_rval = (ir_rvalue *)iter.get(); |
| ir_variable *param = (ir_variable *)sig_iter.get(); |
| |
| if (param->mode == ir_var_out || |
| param->mode == ir_var_inout) { |
| variable_storage *storage = find_variable_storage(param); |
| assert(storage); |
| |
| st_src_reg r; |
| r.file = storage->file; |
| r.index = storage->index; |
| r.reladdr = NULL; |
| r.swizzle = SWIZZLE_NOOP; |
| r.negate = 0; |
| |
| param_rval->accept(this); |
| st_dst_reg l = st_dst_reg(this->result); |
| |
| for (i = 0; i < type_size(param->type); i++) { |
| emit(ir, TGSI_OPCODE_MOV, l, r); |
| l.index++; |
| r.index++; |
| } |
| } |
| |
| sig_iter.next(); |
| } |
| assert(!sig_iter.has_next()); |
| |
| /* Process return value. */ |
| this->result = entry->return_reg; |
| } |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_texture *ir) |
| { |
| st_src_reg result_src, coord, lod_info, projector, dx, dy, offset; |
| st_dst_reg result_dst, coord_dst; |
| glsl_to_tgsi_instruction *inst = NULL; |
| unsigned opcode = TGSI_OPCODE_NOP; |
| |
| if (ir->coordinate) { |
| ir->coordinate->accept(this); |
| |
| /* Put our coords in a temp. We'll need to modify them for shadow, |
| * projection, or LOD, so the only case we'd use it as is is if |
| * we're doing plain old texturing. The optimization passes on |
| * glsl_to_tgsi_visitor should handle cleaning up our mess in that case. |
| */ |
| coord = get_temp(glsl_type::vec4_type); |
| coord_dst = st_dst_reg(coord); |
| emit(ir, TGSI_OPCODE_MOV, coord_dst, this->result); |
| } |
| |
| if (ir->projector) { |
| ir->projector->accept(this); |
| projector = this->result; |
| } |
| |
| /* Storage for our result. Ideally for an assignment we'd be using |
| * the actual storage for the result here, instead. |
| */ |
| result_src = get_temp(ir->type); |
| result_dst = st_dst_reg(result_src); |
| |
| switch (ir->op) { |
| case ir_tex: |
| opcode = TGSI_OPCODE_TEX; |
| break; |
| case ir_txb: |
| opcode = TGSI_OPCODE_TXB; |
| ir->lod_info.bias->accept(this); |
| lod_info = this->result; |
| break; |
| case ir_txl: |
| opcode = TGSI_OPCODE_TXL; |
| ir->lod_info.lod->accept(this); |
| lod_info = this->result; |
| break; |
| case ir_txd: |
| opcode = TGSI_OPCODE_TXD; |
| ir->lod_info.grad.dPdx->accept(this); |
| dx = this->result; |
| ir->lod_info.grad.dPdy->accept(this); |
| dy = this->result; |
| break; |
| case ir_txs: |
| opcode = TGSI_OPCODE_TXQ; |
| ir->lod_info.lod->accept(this); |
| lod_info = this->result; |
| break; |
| case ir_txf: |
| opcode = TGSI_OPCODE_TXF; |
| ir->lod_info.lod->accept(this); |
| lod_info = this->result; |
| if (ir->offset) { |
| ir->offset->accept(this); |
| offset = this->result; |
| } |
| break; |
| } |
| |
| const glsl_type *sampler_type = ir->sampler->type; |
| |
| if (ir->projector) { |
| if (opcode == TGSI_OPCODE_TEX) { |
| /* Slot the projector in as the last component of the coord. */ |
| coord_dst.writemask = WRITEMASK_W; |
| emit(ir, TGSI_OPCODE_MOV, coord_dst, projector); |
| coord_dst.writemask = WRITEMASK_XYZW; |
| opcode = TGSI_OPCODE_TXP; |
| } else { |
| st_src_reg coord_w = coord; |
| coord_w.swizzle = SWIZZLE_WWWW; |
| |
| /* For the other TEX opcodes there's no projective version |
| * since the last slot is taken up by LOD info. Do the |
| * projective divide now. |
| */ |
| coord_dst.writemask = WRITEMASK_W; |
| emit(ir, TGSI_OPCODE_RCP, coord_dst, projector); |
| |
| /* In the case where we have to project the coordinates "by hand," |
| * the shadow comparator value must also be projected. |
| */ |
| st_src_reg tmp_src = coord; |
| if (ir->shadow_comparitor) { |
| /* Slot the shadow value in as the second to last component of the |
| * coord. |
| */ |
| ir->shadow_comparitor->accept(this); |
| |
| tmp_src = get_temp(glsl_type::vec4_type); |
| st_dst_reg tmp_dst = st_dst_reg(tmp_src); |
| |
| /* Projective division not allowed for array samplers. */ |
| assert(!sampler_type->sampler_array); |
| |
| tmp_dst.writemask = WRITEMASK_Z; |
| emit(ir, TGSI_OPCODE_MOV, tmp_dst, this->result); |
| |
| tmp_dst.writemask = WRITEMASK_XY; |
| emit(ir, TGSI_OPCODE_MOV, tmp_dst, coord); |
| } |
| |
| coord_dst.writemask = WRITEMASK_XYZ; |
| emit(ir, TGSI_OPCODE_MUL, coord_dst, tmp_src, coord_w); |
| |
| coord_dst.writemask = WRITEMASK_XYZW; |
| coord.swizzle = SWIZZLE_XYZW; |
| } |
| } |
| |
| /* If projection is done and the opcode is not TGSI_OPCODE_TXP, then the shadow |
| * comparator was put in the correct place (and projected) by the code, |
| * above, that handles by-hand projection. |
| */ |
| if (ir->shadow_comparitor && (!ir->projector || opcode == TGSI_OPCODE_TXP)) { |
| /* Slot the shadow value in as the second to last component of the |
| * coord. |
| */ |
| ir->shadow_comparitor->accept(this); |
| |
| /* XXX This will need to be updated for cubemap array samplers. */ |
| if ((sampler_type->sampler_dimensionality == GLSL_SAMPLER_DIM_2D && |
| sampler_type->sampler_array) || |
| sampler_type->sampler_dimensionality == GLSL_SAMPLER_DIM_CUBE) { |
| coord_dst.writemask = WRITEMASK_W; |
| } else { |
| coord_dst.writemask = WRITEMASK_Z; |
| } |
| |
| emit(ir, TGSI_OPCODE_MOV, coord_dst, this->result); |
| coord_dst.writemask = WRITEMASK_XYZW; |
| } |
| |
| if (opcode == TGSI_OPCODE_TXL || opcode == TGSI_OPCODE_TXB || |
| opcode == TGSI_OPCODE_TXF) { |
| /* TGSI stores LOD or LOD bias in the last channel of the coords. */ |
| coord_dst.writemask = WRITEMASK_W; |
| emit(ir, TGSI_OPCODE_MOV, coord_dst, lod_info); |
| coord_dst.writemask = WRITEMASK_XYZW; |
| } |
| |
| if (opcode == TGSI_OPCODE_TXD) |
| inst = emit(ir, opcode, result_dst, coord, dx, dy); |
| else if (opcode == TGSI_OPCODE_TXQ) |
| inst = emit(ir, opcode, result_dst, lod_info); |
| else if (opcode == TGSI_OPCODE_TXF) { |
| inst = emit(ir, opcode, result_dst, coord); |
| } else |
| inst = emit(ir, opcode, result_dst, coord); |
| |
| if (ir->shadow_comparitor) |
| inst->tex_shadow = GL_TRUE; |
| |
| inst->sampler = _mesa_get_sampler_uniform_value(ir->sampler, |
| this->shader_program, |
| this->prog); |
| |
| if (ir->offset) { |
| inst->tex_offset_num_offset = 1; |
| inst->tex_offsets[0].Index = offset.index; |
| inst->tex_offsets[0].File = offset.file; |
| inst->tex_offsets[0].SwizzleX = GET_SWZ(offset.swizzle, 0); |
| inst->tex_offsets[0].SwizzleY = GET_SWZ(offset.swizzle, 1); |
| inst->tex_offsets[0].SwizzleZ = GET_SWZ(offset.swizzle, 2); |
| } |
| |
| switch (sampler_type->sampler_dimensionality) { |
| case GLSL_SAMPLER_DIM_1D: |
| inst->tex_target = (sampler_type->sampler_array) |
| ? TEXTURE_1D_ARRAY_INDEX : TEXTURE_1D_INDEX; |
| break; |
| case GLSL_SAMPLER_DIM_2D: |
| inst->tex_target = (sampler_type->sampler_array) |
| ? TEXTURE_2D_ARRAY_INDEX : TEXTURE_2D_INDEX; |
| break; |
| case GLSL_SAMPLER_DIM_3D: |
| inst->tex_target = TEXTURE_3D_INDEX; |
| break; |
| case GLSL_SAMPLER_DIM_CUBE: |
| inst->tex_target = TEXTURE_CUBE_INDEX; |
| break; |
| case GLSL_SAMPLER_DIM_RECT: |
| inst->tex_target = TEXTURE_RECT_INDEX; |
| break; |
| case GLSL_SAMPLER_DIM_BUF: |
| assert(!"FINISHME: Implement ARB_texture_buffer_object"); |
| break; |
| case GLSL_SAMPLER_DIM_EXTERNAL: |
| inst->tex_target = TEXTURE_EXTERNAL_INDEX; |
| break; |
| default: |
| assert(!"Should not get here."); |
| } |
| |
| this->result = result_src; |
| } |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_return *ir) |
| { |
| if (ir->get_value()) { |
| st_dst_reg l; |
| int i; |
| |
| assert(current_function); |
| |
| ir->get_value()->accept(this); |
| st_src_reg r = this->result; |
| |
| l = st_dst_reg(current_function->return_reg); |
| |
| for (i = 0; i < type_size(current_function->sig->return_type); i++) { |
| emit(ir, TGSI_OPCODE_MOV, l, r); |
| l.index++; |
| r.index++; |
| } |
| } |
| |
| emit(ir, TGSI_OPCODE_RET); |
| } |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_discard *ir) |
| { |
| if (ir->condition) { |
| ir->condition->accept(this); |
| this->result.negate = ~this->result.negate; |
| emit(ir, TGSI_OPCODE_KIL, undef_dst, this->result); |
| } else { |
| emit(ir, TGSI_OPCODE_KILP); |
| } |
| } |
| |
| void |
| glsl_to_tgsi_visitor::visit(ir_if *ir) |
| { |
| glsl_to_tgsi_instruction *cond_inst, *if_inst; |
| glsl_to_tgsi_instruction *prev_inst; |
| |
| prev_inst = (glsl_to_tgsi_instruction *)this->instructions.get_tail(); |
| |
| ir->condition->accept(this); |
| assert(this->result.file != PROGRAM_UNDEFINED); |
| |
| if (this->options->EmitCondCodes) { |
| cond_inst = (glsl_to_tgsi_instruction *)this->instructions.get_tail(); |
| |
| /* See if we actually generated any instruction for generating |
| * the condition. If not, then cook up a move to a temp so we |
| * have something to set cond_update on. |
| */ |
| if (cond_inst == prev_inst) { |
| st_src_reg temp = get_temp(glsl_type::bool_type); |
| cond_inst = emit(ir->condition, TGSI_OPCODE_MOV, st_dst_reg(temp), result); |
| } |
| cond_inst->cond_update = GL_TRUE; |
| |
| if_inst = emit(ir->condition, TGSI_OPCODE_IF); |
| if_inst->dst.cond_mask = COND_NE; |
| } else { |
| if_inst = emit(ir->condition, TGSI_OPCODE_IF, undef_dst, this->result); |
| } |
| |
| this->instructions.push_tail(if_inst); |
| |
| visit_exec_list(&ir->then_instructions, this); |
| |
| if (!ir->else_instructions.is_empty()) { |
| emit(ir->condition, TGSI_OPCODE_ELSE); |
| visit_exec_list(&ir->else_instructions, this); |
| } |
| |
| if_inst = emit(ir->condition, TGSI_OPCODE_ENDIF); |
| } |
| |
| glsl_to_tgsi_visitor::glsl_to_tgsi_visitor() |
| { |
| result.file = PROGRAM_UNDEFINED; |
| next_temp = 1; |
| next_signature_id = 1; |
| num_immediates = 0; |
| current_function = NULL; |
| num_address_regs = 0; |
| samplers_used = 0; |
| indirect_addr_temps = false; |
| indirect_addr_consts = false; |
| glsl_version = 0; |
| native_integers = false; |
| mem_ctx = ralloc_context(NULL); |
| ctx = NULL; |
| prog = NULL; |
| shader_program = NULL; |
| options = NULL; |
| } |
| |
| glsl_to_tgsi_visitor::~glsl_to_tgsi_visitor() |
| { |
| ralloc_free(mem_ctx); |
| } |
| |
| extern "C" void free_glsl_to_tgsi_visitor(glsl_to_tgsi_visitor *v) |
| { |
| delete v; |
| } |
| |
| |
| /** |
| * Count resources used by the given gpu program (number of texture |
| * samplers, etc). |
| */ |
| static void |
| count_resources(glsl_to_tgsi_visitor *v, gl_program *prog) |
| { |
| v->samplers_used = 0; |
| |
| foreach_iter(exec_list_iterator, iter, v->instructions) { |
| glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get(); |
| |
| if (is_tex_instruction(inst->op)) { |
| v->samplers_used |= 1 << inst->sampler; |
| |
| if (inst->tex_shadow) { |
| prog->ShadowSamplers |= 1 << inst->sampler; |
| } |
| } |
| } |
| |
| prog->SamplersUsed = v->samplers_used; |
| |
| if (v->shader_program != NULL) |
| _mesa_update_shader_textures_used(v->shader_program, prog); |
| } |
| |
| static void |
| set_uniform_initializer(struct gl_context *ctx, void *mem_ctx, |
| struct gl_shader_program *shader_program, |
| const char *name, const glsl_type *type, |
| ir_constant *val) |
| { |
| if (type->is_record()) { |
| ir_constant *field_constant; |
| |
| field_constant = (ir_constant *)val->components.get_head(); |
| |
| for (unsigned int i = 0; i < type->length; i++) { |
| const glsl_type *field_type = type->fields.structure[i].type; |
| const char *field_name = ralloc_asprintf(mem_ctx, "%s.%s", name, |
| type->fields.structure[i].name); |
| set_uniform_initializer(ctx, mem_ctx, shader_program, field_name, |
| field_type, field_constant); |
| field_constant = (ir_constant *)field_constant->next; |
| } |
| return; |
| } |
| |
| unsigned offset; |
| unsigned index = _mesa_get_uniform_location(ctx, shader_program, name, |
| &offset); |
| if (offset == GL_INVALID_INDEX) { |
| fail_link(shader_program, |
| "Couldn't find uniform for initializer %s\n", name); |
| return; |
| } |
| int loc = _mesa_uniform_merge_location_offset(index, offset); |
| |
| for (unsigned int i = 0; i < (type->is_array() ? type->length : 1); i++) { |
| ir_constant *element; |
| const glsl_type *element_type; |
| if (type->is_array()) { |
| element = val->array_elements[i]; |
| element_type = type->fields.array; |
| } else { |
| element = val; |
| element_type = type; |
| } |
| |
| void *values; |
| |
| if (element_type->base_type == GLSL_TYPE_BOOL) { |
| int *conv = ralloc_array(mem_ctx, int, element_type->components()); |
| for (unsigned int j = 0; j < element_type->components(); j++) { |
| conv[j] = element->value.b[j]; |
| } |
| values = (void *)conv; |
| element_type = glsl_type::get_instance(GLSL_TYPE_INT, |
| element_type->vector_elements, |
| 1); |
| } else { |
| values = &element->value; |
| } |
| |
| if (element_type->is_matrix()) { |
| _mesa_uniform_matrix(ctx, shader_program, |
| element_type->matrix_columns, |
| element_type->vector_elements, |
| loc, 1, GL_FALSE, (GLfloat *)values); |
| } else { |
| _mesa_uniform(ctx, shader_program, loc, element_type->matrix_columns, |
| values, element_type->gl_type); |
| } |
| |
| loc++; |
| } |
| } |
| |
| /** |
| * Returns the mask of channels (bitmask of WRITEMASK_X,Y,Z,W) which |
| * are read from the given src in this instruction |
| */ |
| static int |
| get_src_arg_mask(st_dst_reg dst, st_src_reg src) |
| { |
| int read_mask = 0, comp; |
| |
| /* Now, given the src swizzle and the written channels, find which |
| * components are actually read |
| */ |
| for (comp = 0; comp < 4; ++comp) { |
| const unsigned coord = GET_SWZ(src.swizzle, comp); |
| ASSERT(coord < 4); |
| if (dst.writemask & (1 << comp) && coord <= SWIZZLE_W) |
| read_mask |= 1 << coord; |
| } |
| |
| return read_mask; |
| } |
| |
| /** |
| * This pass replaces CMP T0, T1 T2 T0 with MOV T0, T2 when the CMP |
| * instruction is the first instruction to write to register T0. There are |
| * several lowering passes done in GLSL IR (e.g. branches and |
| * relative addressing) that create a large number of conditional assignments |
| * that ir_to_mesa converts to CMP instructions like the one mentioned above. |
| * |
| * Here is why this conversion is safe: |
| * CMP T0, T1 T2 T0 can be expanded to: |
| * if (T1 < 0.0) |
| * MOV T0, T2; |
| * else |
| * MOV T0, T0; |
| * |
| * If (T1 < 0.0) evaluates to true then our replacement MOV T0, T2 is the same |
| * as the original program. If (T1 < 0.0) evaluates to false, executing |
| * MOV T0, T0 will store a garbage value in T0 since T0 is uninitialized. |
| * Therefore, it doesn't matter that we are replacing MOV T0, T0 with MOV T0, T2 |
| * because any instruction that was going to read from T0 after this was going |
| * to read a garbage value anyway. |
| */ |
| void |
| glsl_to_tgsi_visitor::simplify_cmp(void) |
| { |
| unsigned *tempWrites; |
| unsigned outputWrites[MAX_PROGRAM_OUTPUTS]; |
| |
| tempWrites = new unsigned[MAX_TEMPS]; |
| if (!tempWrites) { |
| return; |
| } |
| memset(tempWrites, 0, sizeof(unsigned) * MAX_TEMPS); |
| memset(outputWrites, 0, sizeof(outputWrites)); |
| |
| foreach_iter(exec_list_iterator, iter, this->instructions) { |
| glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get(); |
| unsigned prevWriteMask = 0; |
| |
| /* Give up if we encounter relative addressing or flow control. */ |
| if (inst->dst.reladdr || |
| tgsi_get_opcode_info(inst->op)->is_branch || |
| inst->op == TGSI_OPCODE_BGNSUB || |
| inst->op == TGSI_OPCODE_CONT || |
| inst->op == TGSI_OPCODE_END || |
| inst->op == TGSI_OPCODE_ENDSUB || |
| inst->op == TGSI_OPCODE_RET) { |
| break; |
| } |
| |
| if (inst->dst.file == PROGRAM_OUTPUT) { |
| assert(inst->dst.index < MAX_PROGRAM_OUTPUTS); |
| prevWriteMask = outputWrites[inst->dst.index]; |
| outputWrites[inst->dst.index] |= inst->dst.writemask; |
| } else if (inst->dst.file == PROGRAM_TEMPORARY) { |
| assert(inst->dst.index < MAX_TEMPS); |
| prevWriteMask = tempWrites[inst->dst.index]; |
| tempWrites[inst->dst.index] |= inst->dst.writemask; |
| } |
| |
| /* For a CMP to be considered a conditional write, the destination |
| * register and source register two must be the same. */ |
| if (inst->op == TGSI_OPCODE_CMP |
| && !(inst->dst.writemask & prevWriteMask) |
| && inst->src[2].file == inst->dst.file |
| && inst->src[2].index == inst->dst.index |
| && inst->dst.writemask == get_src_arg_mask(inst->dst, inst->src[2])) { |
| |
| inst->op = TGSI_OPCODE_MOV; |
| inst->src[0] = inst->src[1]; |
| } |
| } |
| |
| delete [] tempWrites; |
| } |
| |
| /* Replaces all references to a temporary register index with another index. */ |
| void |
| glsl_to_tgsi_visitor::rename_temp_register(int index, int new_index) |
| { |
| foreach_iter(exec_list_iterator, iter, this->instructions) { |
| glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get(); |
| unsigned j; |
| |
| for (j=0; j < num_inst_src_regs(inst->op); j++) { |
| if (inst->src[j].file == PROGRAM_TEMPORARY && |
| inst->src[j].index == index) { |
| inst->src[j].index = new_index; |
| } |
| } |
| |
| if (inst->dst.file == PROGRAM_TEMPORARY && inst->dst.index == index) { |
| inst->dst.index = new_index; |
| } |
| } |
| } |
| |
| int |
| glsl_to_tgsi_visitor::get_first_temp_read(int index) |
| { |
| int depth = 0; /* loop depth */ |
| int loop_start = -1; /* index of the first active BGNLOOP (if any) */ |
| unsigned i = 0, j; |
| |
| foreach_iter(exec_list_iterator, iter, this->instructions) { |
| glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get(); |
| |
| for (j=0; j < num_inst_src_regs(inst->op); j++) { |
| if (inst->src[j].file == PROGRAM_TEMPORARY && |
| inst->src[j].index == index) { |
| return (depth == 0) ? i : loop_start; |
| } |
| } |
| |
| if (inst->op == TGSI_OPCODE_BGNLOOP) { |
| if(depth++ == 0) |
| loop_start = i; |
| } else if (inst->op == TGSI_OPCODE_ENDLOOP) { |
| if (--depth == 0) |
| loop_start = -1; |
| } |
| assert(depth >= 0); |
| |
| i++; |
| } |
| |
| return -1; |
| } |
| |
| int |
| glsl_to_tgsi_visitor::get_first_temp_write(int index) |
| { |
| int depth = 0; /* loop depth */ |
| int loop_start = -1; /* index of the first active BGNLOOP (if any) */ |
| int i = 0; |
| |
| foreach_iter(exec_list_iterator, iter, this->instructions) { |
| glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get(); |
| |
| if (inst->dst.file == PROGRAM_TEMPORARY && inst->dst.index == index) { |
| return (depth == 0) ? i : loop_start; |
| } |
| |
| if (inst->op == TGSI_OPCODE_BGNLOOP) { |
| if(depth++ == 0) |
| loop_start = i; |
| } else if (inst->op == TGSI_OPCODE_ENDLOOP) { |
| if (--depth == 0) |
| loop_start = -1; |
| } |
| assert(depth >= 0); |
| |
| i++; |
| } |
| |
| return -1; |
| } |
| |
| int |
| glsl_to_tgsi_visitor::get_last_temp_read(int index) |
| { |
| int depth = 0; /* loop depth */ |
| int last = -1; /* index of last instruction that reads the temporary */ |
| unsigned i = 0, j; |
| |
| foreach_iter(exec_list_iterator, iter, this->instructions) { |
| glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get(); |
| |
| for (j=0; j < num_inst_src_regs(inst->op); j++) { |
| if (inst->src[j].file == PROGRAM_TEMPORARY && |
| inst->src[j].index == index) { |
| last = (depth == 0) ? i : -2; |
| } |
| } |
| |
| if (inst->op == TGSI_OPCODE_BGNLOOP) |
| depth++; |
| else if (inst->op == TGSI_OPCODE_ENDLOOP) |
| if (--depth == 0 && last == -2) |
| last = i; |
| assert(depth >= 0); |
| |
| i++; |
| } |
| |
| assert(last >= -1); |
| return last; |
| } |
| |
| int |
| glsl_to_tgsi_visitor::get_last_temp_write(int index) |
| { |
| int depth = 0; /* loop depth */ |
| int last = -1; /* index of last instruction that writes to the temporary */ |
| int i = 0; |
| |
| foreach_iter(exec_list_iterator, iter, this->instructions) { |
| glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get(); |
| |
| if (inst->dst.file == PROGRAM_TEMPORARY && inst->dst.index == index) |
| last = (depth == 0) ? i : -2; |
| |
| if (inst->op == TGSI_OPCODE_BGNLOOP) |
| depth++; |
| else if (inst->op == TGSI_OPCODE_ENDLOOP) |
| if (--depth == 0 && last == -2) |
| last = i; |
| assert(depth >= 0); |
| |
| i++; |
| } |
| |
| assert(last >= -1); |
| return last; |
| } |
| |
| /* |
| * On a basic block basis, tracks available PROGRAM_TEMPORARY register |
| * channels for copy propagation and updates following instructions to |
| * use the original versions. |
| * |
| * The glsl_to_tgsi_visitor lazily produces code assuming that this pass |
| * will occur. As an example, a TXP production before this pass: |
| * |
| * 0: MOV TEMP[1], INPUT[4].xyyy; |
| * 1: MOV TEMP[1].w, INPUT[4].wwww; |
| * 2: TXP TEMP[2], TEMP[1], texture[0], 2D; |
| * |
| * and after: |
| * |
| * 0: MOV TEMP[1], INPUT[4].xyyy; |
| * 1: MOV TEMP[1].w, INPUT[4].wwww; |
| * 2: TXP TEMP[2], INPUT[4].xyyw, texture[0], 2D; |
| * |
| * which allows for dead code elimination on TEMP[1]'s writes. |
| */ |
| void |
| glsl_to_tgsi_visitor::copy_propagate(void) |
| { |
| glsl_to_tgsi_instruction **acp = rzalloc_array(mem_ctx, |
| glsl_to_tgsi_instruction *, |
| this->next_temp * 4); |
| int *acp_level = rzalloc_array(mem_ctx, int, this->next_temp * 4); |
| int level = 0; |
| |
| foreach_iter(exec_list_iterator, iter, this->instructions) { |
| glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get(); |
| |
| assert(inst->dst.file != PROGRAM_TEMPORARY |
| || inst->dst.index < this->next_temp); |
| |
| /* First, do any copy propagation possible into the src regs. */ |
| for (int r = 0; r < 3; r++) { |
| glsl_to_tgsi_instruction *first = NULL; |
| bool good = true; |
| int acp_base = inst->src[r].index * 4; |
| |
| if (inst->src[r].file != PROGRAM_TEMPORARY || |
| inst->src[r].reladdr) |
| continue; |
| |
| /* See if we can find entries in the ACP consisting of MOVs |
| * from the same src register for all the swizzled channels |
| * of this src register reference. |
| */ |
| for (int i = 0; i < 4; i++) { |
| int src_chan = GET_SWZ(inst->src[r].swizzle, i); |
| glsl_to_tgsi_instruction *copy_chan = acp[acp_base + src_chan]; |
| |
| if (!copy_chan) { |
| good = false; |
| break; |
| } |
| |
| assert(acp_level[acp_base + src_chan] <= level); |
| |
| if (!first) { |
| first = copy_chan; |
| } else { |
| if (first->src[0].file != copy_chan->src[0].file || |
| first->src[0].index != copy_chan->src[0].index) { |
| good = false; |
| break; |
| } |
| } |
| } |
| |
| if (good) { |
| /* We've now validated that we can copy-propagate to |
| * replace this src register reference. Do it. |
| */ |
| inst->src[r].file = first->src[0].file; |
| inst->src[r].index = first->src[0].index; |
| |
| int swizzle = 0; |
| for (int i = 0; i < 4; i++) { |
| int src_chan = GET_SWZ(inst->src[r].swizzle, i); |
| glsl_to_tgsi_instruction *copy_inst = acp[acp_base + src_chan]; |
| swizzle |= (GET_SWZ(copy_inst->src[0].swizzle, src_chan) << |
| (3 * i)); |
| } |
| inst->src[r].swizzle = swizzle; |
| } |
| } |
| |
| switch (inst->op) { |
| case TGSI_OPCODE_BGNLOOP: |
| case TGSI_OPCODE_ENDLOOP: |
| /* End of a basic block, clear the ACP entirely. */ |
| memset(acp, 0, sizeof(*acp) * this->next_temp * 4); |
| break; |
| |
| case TGSI_OPCODE_IF: |
| ++level; |
| break; |
| |
| case TGSI_OPCODE_ENDIF: |
| case TGSI_OPCODE_ELSE: |
| /* Clear all channels written inside the block from the ACP, but |
| * leaving those that were not touched. |
| */ |
| for (int r = 0; r < this->next_temp; r++) { |
| for (int c = 0; c < 4; c++) { |
| if (!acp[4 * r + c]) |
| continue; |
| |
| if (acp_level[4 * r + c] >= level) |
| acp[4 * r + c] = NULL; |
| } |
| } |
| if (inst->op == TGSI_OPCODE_ENDIF) |
| --level; |
| break; |
| |
| default: |
| /* Continuing the block, clear any written channels from |
| * the ACP. |
| */ |
| if (inst->dst.file == PROGRAM_TEMPORARY && inst->dst.reladdr) { |
| /* Any temporary might be written, so no copy propagation |
| * across this instruction. |
| */ |
| memset(acp, 0, sizeof(*acp) * this->next_temp * 4); |
| } else if (inst->dst.file == PROGRAM_OUTPUT && |
| inst->dst.reladdr) { |
| /* Any output might be written, so no copy propagation |
| * from outputs across this instruction. |
| */ |
| for (int r = 0; r < this->next_temp; r++) { |
| for (int c = 0; c < 4; c++) { |
| if (!acp[4 * r + c]) |
| continue; |
| |
| if (acp[4 * r + c]->src[0].file == PROGRAM_OUTPUT) |
| acp[4 * r + c] = NULL; |
| } |
| } |
| } else if (inst->dst.file == PROGRAM_TEMPORARY || |
| inst->dst.file == PROGRAM_OUTPUT) { |
| /* Clear where it's used as dst. */ |
| if (inst->dst.file == PROGRAM_TEMPORARY) { |
| for (int c = 0; c < 4; c++) { |
| if (inst->dst.writemask & (1 << c)) { |
| acp[4 * inst->dst.index + c] = NULL; |
| } |
| } |
| } |
| |
| /* Clear where it's used as src. */ |
| for (int r = 0; r < this->next_temp; r++) { |
| for (int c = 0; c < 4; c++) { |
| if (!acp[4 * r + c]) |
| continue; |
| |
| int src_chan = GET_SWZ(acp[4 * r + c]->src[0].swizzle, c); |
| |
| if (acp[4 * r + c]->src[0].file == inst->dst.file && |
| acp[4 * r + c]->src[0].index == inst->dst.index && |
| inst->dst.writemask & (1 << src_chan)) |
| { |
| acp[4 * r + c] = NULL; |
| } |
| } |
| } |
| } |
| break; |
| } |
| |
| /* If this is a copy, add it to the ACP. */ |
| if (inst->op == TGSI_OPCODE_MOV && |
| inst->dst.file == PROGRAM_TEMPORARY && |
| !inst->dst.reladdr && |
| !inst->saturate && |
| !inst->src[0].reladdr && |
| !inst->src[0].negate) { |
| for (int i = 0; i < 4; i++) { |
| if (inst->dst.writemask & (1 << i)) { |
| acp[4 * inst->dst.index + i] = inst; |
| acp_level[4 * inst->dst.index + i] = level; |
| } |
| } |
| } |
| } |
| |
| ralloc_free(acp_level); |
| ralloc_free(acp); |
| } |
| |
| /* |
| * Tracks available PROGRAM_TEMPORARY registers for dead code elimination. |
| * |
| * The glsl_to_tgsi_visitor lazily produces code assuming that this pass |
| * will occur. As an example, a TXP production after copy propagation but |
| * before this pass: |
| * |
| * 0: MOV TEMP[1], INPUT[4].xyyy; |
| * 1: MOV TEMP[1].w, INPUT[4].wwww; |
| * 2: TXP TEMP[2], INPUT[4].xyyw, texture[0], 2D; |
| * |
| * and after this pass: |
| * |
| * 0: TXP TEMP[2], INPUT[4].xyyw, texture[0], 2D; |
| * |
| * FIXME: assumes that all functions are inlined (no support for BGNSUB/ENDSUB) |
| * FIXME: doesn't eliminate all dead code inside of loops; it steps around them |
| */ |
| void |
| glsl_to_tgsi_visitor::eliminate_dead_code(void) |
| { |
| int i; |
| |
| for (i=0; i < this->next_temp; i++) { |
| int last_read = get_last_temp_read(i); |
| int j = 0; |
| |
| foreach_iter(exec_list_iterator, iter, this->instructions) { |
| glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get(); |
| |
| if (inst->dst.file == PROGRAM_TEMPORARY && inst->dst.index == i && |
| j > last_read) |
| { |
| iter.remove(); |
| delete inst; |
| } |
| |
| j++; |
| } |
| } |
| } |
| |
| /* |
| * On a basic block basis, tracks available PROGRAM_TEMPORARY registers for dead |
| * code elimination. This is less primitive than eliminate_dead_code(), as it |
| * is per-channel and can detect consecutive writes without a read between them |
| * as dead code. However, there is some dead code that can be eliminated by |
| * eliminate_dead_code() but not this function - for example, this function |
| * cannot eliminate an instruction writing to a register that is never read and |
| * is the only instruction writing to that register. |
| * |
| * The glsl_to_tgsi_visitor lazily produces code assuming that this pass |
| * will occur. |
| */ |
| int |
| glsl_to_tgsi_visitor::eliminate_dead_code_advanced(void) |
| { |
| glsl_to_tgsi_instruction **writes = rzalloc_array(mem_ctx, |
| glsl_to_tgsi_instruction *, |
| this->next_temp * 4); |
| int *write_level = rzalloc_array(mem_ctx, int, this->next_temp * 4); |
| int level = 0; |
| int removed = 0; |
| |
| foreach_iter(exec_list_iterator, iter, this->instructions) { |
| glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get(); |
| |
| assert(inst->dst.file != PROGRAM_TEMPORARY |
| || inst->dst.index < this->next_temp); |
| |
| switch (inst->op) { |
| case TGSI_OPCODE_BGNLOOP: |
| case TGSI_OPCODE_ENDLOOP: |
| case TGSI_OPCODE_CONT: |
| case TGSI_OPCODE_BRK: |
| /* End of a basic block, clear the write array entirely. |
| * |
| * This keeps us from killing dead code when the writes are |
| * on either side of a loop, even when the register isn't touched |
| * inside the loop. However, glsl_to_tgsi_visitor doesn't seem to emit |
| * dead code of this type, so it shouldn't make a difference as long as |
| * the dead code elimination pass in the GLSL compiler does its job. |
| */ |
| memset(writes, 0, sizeof(*writes) * this->next_temp * 4); |
| break; |
| |
| case TGSI_OPCODE_ENDIF: |
| case TGSI_OPCODE_ELSE: |
| /* Promote the recorded level of all channels written inside the |
| * preceding if or else block to the level above the if/else block. |
| */ |
| for (int r = 0; r < this->next_temp; r++) { |
| for (int c = 0; c < 4; c++) { |
| if (!writes[4 * r + c]) |
| continue; |
| |
| if (write_level[4 * r + c] == level) |
| write_level[4 * r + c] = level-1; |
| } |
| } |
| |
| if(inst->op == TGSI_OPCODE_ENDIF) |
| --level; |
| |
| break; |
| |
| case TGSI_OPCODE_IF: |
| ++level; |
| /* fallthrough to default case to mark the condition as read */ |
| |
| default: |
| /* Continuing the block, clear any channels from the write array that |
| * are read by this instruction. |
| */ |
| for (unsigned i = 0; i < Elements(inst->src); i++) { |
| if (inst->src[i].file == PROGRAM_TEMPORARY && inst->src[i].reladdr){ |
| /* Any temporary might be read, so no dead code elimination |
| * across this instruction. |
| */ |
| memset(writes, 0, sizeof(*writes) * this->next_temp * 4); |
| } else if (inst->src[i].file == PROGRAM_TEMPORARY) { |
| /* Clear where it's used as src. */ |
| int src_chans = 1 << GET_SWZ(inst->src[i].swizzle, 0); |
| src_chans |= 1 << GET_SWZ(inst->src[i].swizzle, 1); |
| src_chans |= 1 << GET_SWZ(inst->src[i].swizzle, 2); |
| src_chans |= 1 << GET_SWZ(inst->src[i].swizzle, 3); |
| |
| for (int c = 0; c < 4; c++) { |
| if (src_chans & (1 << c)) { |
| writes[4 * inst->src[i].index + c] = NULL; |
| } |
| } |
| } |
| } |
| break; |
| } |
| |
| /* If this instruction writes to a temporary, add it to the write array. |
| * If there is already an instruction in the write array for one or more |
| * of the channels, flag that channel write as dead. |
| */ |
| if (inst->dst.file == PROGRAM_TEMPORARY && |
| !inst->dst.reladdr && |
| !inst->saturate) { |
| for (int c = 0; c < 4; c++) { |
| if (inst->dst.writemask & (1 << c)) { |
| if (writes[4 * inst->dst.index + c]) { |
| if (write_level[4 * inst->dst.index + c] < level) |
| continue; |
| else |
| writes[4 * inst->dst.index + c]->dead_mask |= (1 << c); |
| } |
| writes[4 * inst->dst.index + c] = inst; |
| write_level[4 * inst->dst.index + c] = level; |
| } |
| } |
| } |
| } |
| |
| /* Anything still in the write array at this point is dead code. */ |
| for (int r = 0; r < this->next_temp; r++) { |
| for (int c = 0; c < 4; c++) { |
| glsl_to_tgsi_instruction *inst = writes[4 * r + c]; |
| if (inst) |
| inst->dead_mask |= (1 << c); |
| } |
| } |
| |
| /* Now actually remove the instructions that are completely dead and update |
| * the writemask of other instructions with dead channels. |
| */ |
| foreach_iter(exec_list_iterator, iter, this->instructions) { |
| glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get(); |
| |
| if (!inst->dead_mask || !inst->dst.writemask) |
| continue; |
| else if ((inst->dst.writemask & ~inst->dead_mask) == 0) { |
| iter.remove(); |
| delete inst; |
| removed++; |
| } else |
| inst->dst.writemask &= ~(inst->dead_mask); |
| } |
| |
| ralloc_free(write_level); |
| ralloc_free(writes); |
| |
| return removed; |
| } |
| |
| /* Merges temporary registers together where possible to reduce the number of |
| * registers needed to run a program. |
| * |
| * Produces optimal code only after copy propagation and dead code elimination |
| * have been run. */ |
| void |
| glsl_to_tgsi_visitor::merge_registers(void) |
| { |
| int *last_reads = rzalloc_array(mem_ctx, int, this->next_temp); |
| int *first_writes = rzalloc_array(mem_ctx, int, this->next_temp); |
| int i, j; |
| |
| /* Read the indices of the last read and first write to each temp register |
| * into an array so that we don't have to traverse the instruction list as |
| * much. */ |
| for (i=0; i < this->next_temp; i++) { |
| last_reads[i] = get_last_temp_read(i); |
| first_writes[i] = get_first_temp_write(i); |
| } |
| |
| /* Start looking for registers with non-overlapping usages that can be |
| * merged together. */ |
| for (i=0; i < this->next_temp; i++) { |
| /* Don't touch unused registers. */ |
| if (last_reads[i] < 0 || first_writes[i] < 0) continue; |
| |
| for (j=0; j < this->next_temp; j++) { |
| /* Don't touch unused registers. */ |
| if (last_reads[j] < 0 || first_writes[j] < 0) continue; |
| |
| /* We can merge the two registers if the first write to j is after or |
| * in the same instruction as the last read from i. Note that the |
| * register at index i will always be used earlier or at the same time |
| * as the register at index j. */ |
| if (first_writes[i] <= first_writes[j] && |
| last_reads[i] <= first_writes[j]) |
| { |
| rename_temp_register(j, i); /* Replace all references to j with i.*/ |
| |
| /* Update the first_writes and last_reads arrays with the new |
| * values for the merged register index, and mark the newly unused |
| * register index as such. */ |
| last_reads[i] = last_reads[j]; |
| first_writes[j] = -1; |
| last_reads[j] = -1; |
| } |
| } |
| } |
| |
| ralloc_free(last_reads); |
| ralloc_free(first_writes); |
| } |
| |
| /* Reassign indices to temporary registers by reusing unused indices created |
| * by optimization passes. */ |
| void |
| glsl_to_tgsi_visitor::renumber_registers(void) |
| { |
| int i = 0; |
| int new_index = 0; |
| |
| for (i=0; i < this->next_temp; i++) { |
| if (get_first_temp_read(i) < 0) continue; |
| if (i != new_index) |
| rename_temp_register(i, new_index); |
| new_index++; |
| } |
| |
| this->next_temp = new_index; |
| } |
| |
| /** |
| * Returns a fragment program which implements the current pixel transfer ops. |
| * Based on get_pixel_transfer_program in st_atom_pixeltransfer.c. |
| */ |
| extern "C" void |
| get_pixel_transfer_visitor(struct st_fragment_program *fp, |
| glsl_to_tgsi_visitor *original, |
| int scale_and_bias, int pixel_maps) |
| { |
| glsl_to_tgsi_visitor *v = new glsl_to_tgsi_visitor(); |
| struct st_context *st = st_context(original->ctx); |
| struct gl_program *prog = &fp->Base.Base; |
| struct gl_program_parameter_list *params = _mesa_new_parameter_list(); |
| st_src_reg coord, src0; |
| st_dst_reg dst0; |
| glsl_to_tgsi_instruction *inst; |
| |
| /* Copy attributes of the glsl_to_tgsi_visitor in the original shader. */ |
| v->ctx = original->ctx; |
| v->prog = prog; |
| v->shader_program = NULL; |
| v->glsl_version = original->glsl_version; |
| v->native_integers = original->native_integers; |
| v->options = original->options; |
| v->next_temp = original->next_temp; |
| v->num_address_regs = original->num_address_regs; |
| v->samplers_used = prog->SamplersUsed = original->samplers_used; |
| v->indirect_addr_temps = original->indirect_addr_temps; |
| v->indirect_addr_consts = original->indirect_addr_consts; |
| memcpy(&v->immediates, &original->immediates, sizeof(v->immediates)); |
| v->num_immediates = original->num_immediates; |
| |
| /* |
| * Get initial pixel color from the texture. |
| * TEX colorTemp, fragment.texcoord[0], texture[0], 2D; |
| */ |
| coord = st_src_reg(PROGRAM_INPUT, FRAG_ATTRIB_TEX0, glsl_type::vec2_type); |
| src0 = v->get_temp(glsl_type::vec4_type); |
| dst0 = st_dst_reg(src0); |
| inst = v->emit(NULL, TGSI_OPCODE_TEX, dst0, coord); |
| inst->sampler = 0; |
| inst->tex_target = TEXTURE_2D_INDEX; |
| |
| prog->InputsRead |= FRAG_BIT_TEX0; |
| prog->SamplersUsed |= (1 << 0); /* mark sampler 0 as used */ |
| v->samplers_used |= (1 << 0); |
| |
| if (scale_and_bias) { |
| static const gl_state_index scale_state[STATE_LENGTH] = |
| { STATE_INTERNAL, STATE_PT_SCALE, |
| (gl_state_index) 0, (gl_state_index) 0, (gl_state_index) 0 }; |
| static const gl_state_index bias_state[STATE_LENGTH] = |
| { STATE_INTERNAL, STATE_PT_BIAS, |
| (gl_state_index) 0, (gl_state_index) 0, (gl_state_index) 0 }; |
| GLint scale_p, bias_p; |
| st_src_reg scale, bias; |
| |
| scale_p = _mesa_add_state_reference(params, scale_state); |
| bias_p = _mesa_add_state_reference(params, bias_state); |
| |
| /* MAD colorTemp, colorTemp, scale, bias; */ |
| scale = st_src_reg(PROGRAM_STATE_VAR, scale_p, GLSL_TYPE_FLOAT); |
| bias = st_src_reg(PROGRAM_STATE_VAR, bias_p, GLSL_TYPE_FLOAT); |
| inst = v->emit(NULL, TGSI_OPCODE_MAD, dst0, src0, scale, bias); |
| } |
| |
| if (pixel_maps) { |
| st_src_reg temp = v->get_temp(glsl_type::vec4_type); |
| st_dst_reg temp_dst = st_dst_reg(temp); |
| |
| assert(st->pixel_xfer.pixelmap_texture); |
| |
| /* With a little effort, we can do four pixel map look-ups with |
| * two TEX instructions: |
| */ |
| |
| /* TEX temp.rg, colorTemp.rgba, texture[1], 2D; */ |
| temp_dst.writemask = WRITEMASK_XY; /* write R,G */ |
| inst = v->emit(NULL, TGSI_OPCODE_TEX, temp_dst, src0); |
| inst->sampler = 1; |
| inst->tex_target = TEXTURE_2D_INDEX; |
| |
| /* TEX temp.ba, colorTemp.baba, texture[1], 2D; */ |
| src0.swizzle = MAKE_SWIZZLE4(SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W); |
| temp_dst.writemask = WRITEMASK_ZW; /* write B,A */ |
| inst = v->emit(NULL, TGSI_OPCODE_TEX, temp_dst, src0); |
| inst->sampler = 1; |
| inst->tex_target = TEXTURE_2D_INDEX; |
| |
| prog->SamplersUsed |= (1 << 1); /* mark sampler 1 as used */ |
| v->samplers_used |= (1 << 1); |
| |
| /* MOV colorTemp, temp; */ |
| inst = v->emit(NULL, TGSI_OPCODE_MOV, dst0, temp); |
| } |
| |
| /* Now copy the instructions from the original glsl_to_tgsi_visitor into the |
| * new visitor. */ |
| foreach_iter(exec_list_iterator, iter, original->instructions) { |
| glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get(); |
| glsl_to_tgsi_instruction *newinst; |
| st_src_reg src_regs[3]; |
| |
| if (inst->dst.file == PROGRAM_OUTPUT) |
| prog->OutputsWritten |= BITFIELD64_BIT(inst->dst.index); |
| |
| for (int i=0; i<3; i++) { |
| src_regs[i] = inst->src[i]; |
| if (src_regs[i].file == PROGRAM_INPUT && |
| src_regs[i].index == FRAG_ATTRIB_COL0) |
| { |
| src_regs[i].file = PROGRAM_TEMPORARY; |
| src_regs[i].index = src0.index; |
| } |
| else if (src_regs[i].file == PROGRAM_INPUT) |
| prog->InputsRead |= BITFIELD64_BIT(src_regs[i].index); |
| } |
| |
| newinst = v->emit(NULL, inst->op, inst->dst, src_regs[0], src_regs[1], src_regs[2]); |
| newinst->tex_target = inst->tex_target; |
| } |
| |
| /* Make modifications to fragment program info. */ |
| prog->Parameters = _mesa_combine_parameter_lists(params, |
| original->prog->Parameters); |
| _mesa_free_parameter_list(params); |
| count_resources(v, prog); |
| fp->glsl_to_tgsi = v; |
| } |
| |
| /** |
| * Make fragment program for glBitmap: |
| * Sample the texture and kill the fragment if the bit is 0. |
| * This program will be combined with the user's fragment program. |
| * |
| * Based on make_bitmap_fragment_program in st_cb_bitmap.c. |
| */ |
| extern "C" void |
| get_bitmap_visitor(struct st_fragment_program *fp, |
| glsl_to_tgsi_visitor *original, int samplerIndex) |
| { |
| glsl_to_tgsi_visitor *v = new glsl_to_tgsi_visitor(); |
| struct st_context *st = st_context(original->ctx); |
| struct gl_program *prog = &fp->Base.Base; |
| st_src_reg coord, src0; |
| st_dst_reg dst0; |
| glsl_to_tgsi_instruction *inst; |
| |
| /* Copy attributes of the glsl_to_tgsi_visitor in the original shader. */ |
| v->ctx = original->ctx; |
| v->prog = prog; |
| v->shader_program = NULL; |
| v->glsl_version = original->glsl_version; |
| v->native_integers = original->native_integers; |
| v->options = original->options; |
| v->next_temp = original->next_temp; |
| v->num_address_regs = original->num_address_regs; |
| v->samplers_used = prog->SamplersUsed = original->samplers_used; |
| v->indirect_addr_temps = original->indirect_addr_temps; |
| v->indirect_addr_consts = original->indirect_addr_consts; |
| memcpy(&v->immediates, &original->immediates, sizeof(v->immediates)); |
| v->num_immediates = original->num_immediates; |
| |
| /* TEX tmp0, fragment.texcoord[0], texture[0], 2D; */ |
| coord = st_src_reg(PROGRAM_INPUT, FRAG_ATTRIB_TEX0, glsl_type::vec2_type); |
| src0 = v->get_temp(glsl_type::vec4_type); |
| dst0 = st_dst_reg(src0); |
| inst = v->emit(NULL, TGSI_OPCODE_TEX, dst0, coord); |
| inst->sampler = samplerIndex; |
| inst->tex_target = TEXTURE_2D_INDEX; |
| |
| prog->InputsRead |= FRAG_BIT_TEX0; |
| prog->SamplersUsed |= (1 << samplerIndex); /* mark sampler as used */ |
| v->samplers_used |= (1 << samplerIndex); |
| |
| /* KIL if -tmp0 < 0 # texel=0 -> keep / texel=0 -> discard */ |
| src0.negate = NEGATE_XYZW; |
| if (st->bitmap.tex_format == PIPE_FORMAT_L8_UNORM) |
| src0.swizzle = SWIZZLE_XXXX; |
| inst = v->emit(NULL, TGSI_OPCODE_KIL, undef_dst, src0); |
| |
| /* Now copy the instructions from the original glsl_to_tgsi_visitor into the |
| * new visitor. */ |
| foreach_iter(exec_list_iterator, iter, original->instructions) { |
| glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get(); |
| glsl_to_tgsi_instruction *newinst; |
| st_src_reg src_regs[3]; |
| |
| if (inst->dst.file == PROGRAM_OUTPUT) |
| prog->OutputsWritten |= BITFIELD64_BIT(inst->dst.index); |
| |
| for (int i=0; i<3; i++) { |
| src_regs[i] = inst->src[i]; |
| if (src_regs[i].file == PROGRAM_INPUT) |
| prog->InputsRead |= BITFIELD64_BIT(src_regs[i].index); |
| } |
| |
| newinst = v->emit(NULL, inst->op, inst->dst, src_regs[0], src_regs[1], src_regs[2]); |
| newinst->tex_target = inst->tex_target; |
| } |
| |
| /* Make modifications to fragment program info. */ |
| prog->Parameters = _mesa_clone_parameter_list(original->prog->Parameters); |
| count_resources(v, prog); |
| fp->glsl_to_tgsi = v; |
| } |
| |
| /* ------------------------- TGSI conversion stuff -------------------------- */ |
| struct label { |
| unsigned branch_target; |
| unsigned token; |
| }; |
| |
| /** |
| * Intermediate state used during shader translation. |
| */ |
| struct st_translate { |
| struct ureg_program *ureg; |
| |
| struct ureg_dst temps[MAX_TEMPS]; |
| struct ureg_src *constants; |
| struct ureg_src *immediates; |
| struct ureg_dst outputs[PIPE_MAX_SHADER_OUTPUTS]; |
| struct ureg_src inputs[PIPE_MAX_SHADER_INPUTS]; |
| struct ureg_dst address[1]; |
| struct ureg_src samplers[PIPE_MAX_SAMPLERS]; |
| struct ureg_src systemValues[SYSTEM_VALUE_MAX]; |
| |
| const GLuint *inputMapping; |
| const GLuint *outputMapping; |
| |
| /* For every instruction that contains a label (eg CALL), keep |
| * details so that we can go back afterwards and emit the correct |
| * tgsi instruction number for each label. |
| */ |
| struct label *labels; |
| unsigned labels_size; |
| unsigned labels_count; |
| |
| /* Keep a record of the tgsi instruction number that each mesa |
| * instruction starts at, will be used to fix up labels after |
| * translation. |
| */ |
| unsigned *insn; |
| unsigned insn_size; |
| unsigned insn_count; |
| |
| unsigned procType; /**< TGSI_PROCESSOR_VERTEX/FRAGMENT */ |
| |
| boolean error; |
| }; |
| |
| /** Map Mesa's SYSTEM_VALUE_x to TGSI_SEMANTIC_x */ |
| static unsigned mesa_sysval_to_semantic[SYSTEM_VALUE_MAX] = { |
| TGSI_SEMANTIC_FACE, |
| TGSI_SEMANTIC_VERTEXID, |
| TGSI_SEMANTIC_INSTANCEID |
| }; |
| |
| /** |
| * Make note of a branch to a label in the TGSI code. |
| * After we've emitted all instructions, we'll go over the list |
| * of labels built here and patch the TGSI code with the actual |
| * location of each label. |
| */ |
| static unsigned *get_label(struct st_translate *t, unsigned branch_target) |
| { |
| unsigned i; |
| |
| if (t->labels_count + 1 >= t->labels_size) { |
| t->labels_size = 1 << (util_logbase2(t->labels_size) + 1); |
| t->labels = (struct label *)realloc(t->labels, |
| t->labels_size * sizeof(struct label)); |
| if (t->labels == NULL) { |
| static unsigned dummy; |
| t->error = TRUE; |
| return &dummy; |
| } |
| } |
| |
| i = t->labels_count++; |
| t->labels[i].branch_target = branch_target; |
| return &t->labels[i].token; |
| } |
| |
| /** |
| * Called prior to emitting the TGSI code for each instruction. |
| * Allocate additional space for instructions if needed. |
| * Update the insn[] array so the next glsl_to_tgsi_instruction points to |
| * the next TGSI instruction. |
| */ |
| static void set_insn_start(struct st_translate *t, unsigned start) |
| { |
| if (t->insn_count + 1 >= t->insn_size) { |
| t->insn_size = 1 << (util_logbase2(t->insn_size) + 1); |
| t->insn = (unsigned *)realloc(t->insn, t->insn_size * sizeof(t->insn[0])); |
| if (t->insn == NULL) { |
| t->error = TRUE; |
| return; |
| } |
| } |
| |
| t->insn[t->insn_count++] = start; |
| } |
| |
| /** |
| * Map a glsl_to_tgsi constant/immediate to a TGSI immediate. |
| */ |
| static struct ureg_src |
| emit_immediate(struct st_translate *t, |
| gl_constant_value values[4], |
| int type, int size) |
| { |
| struct ureg_program *ureg = t->ureg; |
| |
| switch(type) |
| { |
| case GL_FLOAT: |
| return ureg_DECL_immediate(ureg, &values[0].f, size); |
| case GL_INT: |
| return ureg_DECL_immediate_int(ureg, &values[0].i, size); |
| case GL_UNSIGNED_INT: |
| case GL_BOOL: |
| return ureg_DECL_immediate_uint(ureg, &values[0].u, size); |
| default: |
| assert(!"should not get here - type must be float, int, uint, or bool"); |
| return ureg_src_undef(); |
| } |
| } |
| |
| /** |
| * Map a glsl_to_tgsi dst register to a TGSI ureg_dst register. |
| */ |
| static struct ureg_dst |
| dst_register(struct st_translate *t, |
| gl_register_file file, |
| GLuint index) |
| { |
| switch(file) { |
| case PROGRAM_UNDEFINED: |
| return ureg_dst_undef(); |
| |
| case PROGRAM_TEMPORARY: |
| if (ureg_dst_is_undef(t->temps[index])) |
| t->temps[index] = ureg_DECL_local_temporary(t->ureg); |
| |
| return t->temps[index]; |
| |
| case PROGRAM_OUTPUT: |
| if (t->procType == TGSI_PROCESSOR_VERTEX) |
| assert(index < VERT_RESULT_MAX); |
| else if (t->procType == TGSI_PROCESSOR_FRAGMENT) |
| assert(index < FRAG_RESULT_MAX); |
| else |
| assert(index < GEOM_RESULT_MAX); |
| |
| assert(t->outputMapping[index] < Elements(t->outputs)); |
| |
| return t->outputs[t->outputMapping[index]]; |
| |
| case PROGRAM_ADDRESS: |
| return t->address[index]; |
| |
| default: |
| assert(!"unknown dst register file"); |
| return ureg_dst_undef(); |
| } |
| } |
| |
| /** |
| * Map a glsl_to_tgsi src register to a TGSI ureg_src register. |
| */ |
| static struct ureg_src |
| src_register(struct st_translate *t, |
| gl_register_file file, |
| GLint index) |
| { |
| switch(file) { |
| case PROGRAM_UNDEFINED: |
| return ureg_src_undef(); |
| |
| case PROGRAM_TEMPORARY: |
| assert(index >= 0); |
| assert(index < (int) Elements(t->temps)); |
| if (ureg_dst_is_undef(t->temps[index])) |
| t->temps[index] = ureg_DECL_local_temporary(t->ureg); |
| return ureg_src(t->temps[index]); |
| |
| case PROGRAM_NAMED_PARAM: |
| case PROGRAM_ENV_PARAM: |
| case PROGRAM_LOCAL_PARAM: |
| case PROGRAM_UNIFORM: |
| assert(index >= 0); |
| return t->constants[index]; |
| case PROGRAM_STATE_VAR: |
| case PROGRAM_CONSTANT: /* ie, immediate */ |
| if (index < 0) |
| return ureg_DECL_constant(t->ureg, 0); |
| else |
| return t->constants[index]; |
| |
| case PROGRAM_IMMEDIATE: |
| return t->immediates[index]; |
| |
| case PROGRAM_INPUT: |
| assert(t->inputMapping[index] < Elements(t->inputs)); |
| return t->inputs[t->inputMapping[index]]; |
| |
| case PROGRAM_OUTPUT: |
| assert(t->outputMapping[index] < Elements(t->outputs)); |
| return ureg_src(t->outputs[t->outputMapping[index]]); /* not needed? */ |
| |
| case PROGRAM_ADDRESS: |
| return ureg_src(t->address[index]); |
| |
| case PROGRAM_SYSTEM_VALUE: |
| assert(index < (int) Elements(t->systemValues)); |
| return t->systemValues[index]; |
| |
| default: |
| assert(!"unknown src register file"); |
| return ureg_src_undef(); |
| } |
| } |
| |
| /** |
| * Create a TGSI ureg_dst register from an st_dst_reg. |
| */ |
| static struct ureg_dst |
| translate_dst(struct st_translate *t, |
| const st_dst_reg *dst_reg, |
| bool saturate, bool clamp_color) |
| { |
| struct ureg_dst dst = dst_register(t, |
| dst_reg->file, |
| dst_reg->index); |
| |
| dst = ureg_writemask(dst, dst_reg->writemask); |
| |
| if (saturate) |
| dst = ureg_saturate(dst); |
| else if (clamp_color && dst_reg->file == PROGRAM_OUTPUT) { |
| /* Clamp colors for ARB_color_buffer_float. */ |
| switch (t->procType) { |
| case TGSI_PROCESSOR_VERTEX: |
| /* XXX if the geometry shader is present, this must be done there |
| * instead of here. */ |
| if (dst_reg->index == VERT_RESULT_COL0 || |
| dst_reg->index == VERT_RESULT_COL1 || |
| dst_reg->index == VERT_RESULT_BFC0 || |
| dst_reg->index == VERT_RESULT_BFC1) { |
| dst = ureg_saturate(dst); |
| } |
| break; |
| |
| case TGSI_PROCESSOR_FRAGMENT: |
| if (dst_reg->index >= FRAG_RESULT_COLOR) { |
| dst = ureg_saturate(dst); |
| } |
| break; |
| } |
| } |
| |
| if (dst_reg->reladdr != NULL) |
| dst = ureg_dst_indirect(dst, ureg_src(t->address[0])); |
| |
| return dst; |
| } |
| |
| /** |
| * Create a TGSI ureg_src register from an st_src_reg. |
| */ |
| static struct ureg_src |
| translate_src(struct st_translate *t, const st_src_reg *src_reg) |
| { |
| struct ureg_src src = src_register(t, src_reg->file, src_reg->index); |
| |
| src = ureg_swizzle(src, |
| GET_SWZ(src_reg->swizzle, 0) & 0x3, |
| GET_SWZ(src_reg->swizzle, 1) & 0x3, |
| GET_SWZ(src_reg->swizzle, 2) & 0x3, |
| GET_SWZ(src_reg->swizzle, 3) & 0x3); |
| |
| if ((src_reg->negate & 0xf) == NEGATE_XYZW) |
| src = ureg_negate(src); |
| |
| if (src_reg->reladdr != NULL) { |
| /* Normally ureg_src_indirect() would be used here, but a stupid compiler |
| * bug in g++ makes ureg_src_indirect (an inline C function) erroneously |
| * set the bit for src.Negate. So we have to do the operation manually |
| * here to work around the compiler's problems. */ |
| /*src = ureg_src_indirect(src, ureg_src(t->address[0]));*/ |
| struct ureg_src addr = ureg_src(t->address[0]); |
| src.Indirect = 1; |
| src.IndirectFile = addr.File; |
| src.IndirectIndex = addr.Index; |
| src.IndirectSwizzle = addr.SwizzleX; |
| |
| if (src_reg->file != PROGRAM_INPUT && |
| src_reg->file != PROGRAM_OUTPUT) { |
| /* If src_reg->index was negative, it was set to zero in |
| * src_register(). Reassign it now. But don't do this |
| * for input/output regs since they get remapped while |
| * const buffers don't. |
| */ |
| src.Index = src_reg->index; |
| } |
| } |
| |
| return src; |
| } |
| |
| static struct tgsi_texture_offset |
| translate_tex_offset(struct st_translate *t, |
| const struct tgsi_texture_offset *in_offset) |
| { |
| struct tgsi_texture_offset offset; |
| |
| assert(in_offset->File == PROGRAM_IMMEDIATE); |
| |
| offset.File = TGSI_FILE_IMMEDIATE; |
| offset.Index = in_offset->Index; |
| offset.SwizzleX = in_offset->SwizzleX; |
| offset.SwizzleY = in_offset->SwizzleY; |
| offset.SwizzleZ = in_offset->SwizzleZ; |
| offset.Padding = 0; |
| |
| return offset; |
| } |
| |
| static void |
| compile_tgsi_instruction(struct st_translate *t, |
| const glsl_to_tgsi_instruction *inst, |
| bool clamp_dst_color_output) |
| { |
| struct ureg_program *ureg = t->ureg; |
| GLuint i; |
| struct ureg_dst dst[1]; |
| struct ureg_src src[4]; |
| struct tgsi_texture_offset texoffsets[MAX_GLSL_TEXTURE_OFFSET]; |
| |
| unsigned num_dst; |
| unsigned num_src; |
| |
| num_dst = num_inst_dst_regs(inst->op); |
| num_src = num_inst_src_regs(inst->op); |
| |
| if (num_dst) |
| dst[0] = translate_dst(t, |
| &inst->dst, |
| inst->saturate, |
| clamp_dst_color_output); |
| |
| for (i = 0; i < num_src; i++) |
| src[i] = translate_src(t, &inst->src[i]); |
| |
| switch(inst->op) { |
| case TGSI_OPCODE_BGNLOOP: |
| case TGSI_OPCODE_CAL: |
| case TGSI_OPCODE_ELSE: |
| case TGSI_OPCODE_ENDLOOP: |
| case TGSI_OPCODE_IF: |
| assert(num_dst == 0); |
| ureg_label_insn(ureg, |
| inst->op, |
| src, num_src, |
| get_label(t, |
| inst->op == TGSI_OPCODE_CAL ? inst->function->sig_id : 0)); |
| return; |
| |
| case TGSI_OPCODE_TEX: |
| case TGSI_OPCODE_TXB: |
| case TGSI_OPCODE_TXD: |
| case TGSI_OPCODE_TXL: |
| case TGSI_OPCODE_TXP: |
| case TGSI_OPCODE_TXQ: |
| case TGSI_OPCODE_TXF: |
| src[num_src++] = t->samplers[inst->sampler]; |
| for (i = 0; i < inst->tex_offset_num_offset; i++) { |
| texoffsets[i] = translate_tex_offset(t, &inst->tex_offsets[i]); |
| } |
| ureg_tex_insn(ureg, |
| inst->op, |
| dst, num_dst, |
| st_translate_texture_target(inst->tex_target, inst->tex_shadow), |
| texoffsets, inst->tex_offset_num_offset, |
| src, num_src); |
| return; |
| |
| case TGSI_OPCODE_SCS: |
| dst[0] = ureg_writemask(dst[0], TGSI_WRITEMASK_XY); |
| ureg_insn(ureg, inst->op, dst, num_dst, src, num_src); |
| break; |
| |
| default: |
| ureg_insn(ureg, |
| inst->op, |
| dst, num_dst, |
| src, num_src); |
| break; |
| } |
| } |
| |
| /** |
| * Emit the TGSI instructions for inverting and adjusting WPOS. |
| * This code is unavoidable because it also depends on whether |
| * a FBO is bound (STATE_FB_WPOS_Y_TRANSFORM). |
| */ |
| static void |
| emit_wpos_adjustment( struct st_translate *t, |
| const struct gl_program *program, |
| boolean invert, |
| GLfloat adjX, GLfloat adjY[2]) |
| { |
| struct ureg_program *ureg = t->ureg; |
| |
| /* Fragment program uses fragment position input. |
| * Need to replace instances of INPUT[WPOS] with temp T |
| * where T = INPUT[WPOS] by y is inverted. |
| */ |
| static const gl_state_index wposTransformState[STATE_LENGTH] |
| = { STATE_INTERNAL, STATE_FB_WPOS_Y_TRANSFORM, |
| (gl_state_index)0, (gl_state_index)0, (gl_state_index)0 }; |
| |
| /* XXX: note we are modifying the incoming shader here! Need to |
| * do this before emitting the constant decls below, or this |
| * will be missed: |
| */ |
| unsigned wposTransConst = _mesa_add_state_reference(program->Parameters, |
| wposTransformState); |
| |
| struct ureg_src wpostrans = ureg_DECL_constant( ureg, wposTransConst ); |
| struct ureg_dst wpos_temp = ureg_DECL_temporary( ureg ); |
| struct ureg_src wpos_input = t->inputs[t->inputMapping[FRAG_ATTRIB_WPOS]]; |
| |
| /* First, apply the coordinate shift: */ |
| if (adjX || adjY[0] || adjY[1]) { |
| if (adjY[0] != adjY[1]) { |
| /* Adjust the y coordinate by adjY[1] or adjY[0] respectively |
| * depending on whether inversion is actually going to be applied |
| * or not, which is determined by testing against the inversion |
| * state variable used below, which will be either +1 or -1. |
| */ |
| struct ureg_dst adj_temp = ureg_DECL_local_temporary(ureg); |
| |
| ureg_CMP(ureg, adj_temp, |
| ureg_scalar(wpostrans, invert ? 2 : 0), |
| ureg_imm4f(ureg, adjX, adjY[0], 0.0f, 0.0f), |
| ureg_imm4f(ureg, adjX, adjY[1], 0.0f, 0.0f)); |
| ureg_ADD(ureg, wpos_temp, wpos_input, ureg_src(adj_temp)); |
| } else { |
| ureg_ADD(ureg, wpos_temp, wpos_input, |
| ureg_imm4f(ureg, adjX, adjY[0], 0.0f, 0.0f)); |
| } |
| wpos_input = ureg_src(wpos_temp); |
| } else { |
| /* MOV wpos_temp, input[wpos] |
| */ |
| ureg_MOV( ureg, wpos_temp, wpos_input ); |
| } |
| |
| /* Now the conditional y flip: STATE_FB_WPOS_Y_TRANSFORM.xy/zw will be |
| * inversion/identity, or the other way around if we're drawing to an FBO. |
| */ |
| if (invert) { |
| /* MAD wpos_temp.y, wpos_input, wpostrans.xxxx, wpostrans.yyyy |
| */ |
| ureg_MAD( ureg, |
| ureg_writemask(wpos_temp, TGSI_WRITEMASK_Y ), |
| wpos_input, |
| ureg_scalar(wpostrans, 0), |
| ureg_scalar(wpostrans, 1)); |
| } else { |
| /* MAD wpos_temp.y, wpos_input, wpostrans.zzzz, wpostrans.wwww |
| */ |
| ureg_MAD( ureg, |
| ureg_writemask(wpos_temp, TGSI_WRITEMASK_Y ), |
| wpos_input, |
| ureg_scalar(wpostrans, 2), |
| ureg_scalar(wpostrans, 3)); |
| } |
| |
| /* Use wpos_temp as position input from here on: |
| */ |
| t->inputs[t->inputMapping[FRAG_ATTRIB_WPOS]] = ureg_src(wpos_temp); |
| } |
| |
| |
| /** |
| * Emit fragment position/ooordinate code. |
| */ |
| static void |
| emit_wpos(struct st_context *st, |
| struct st_translate *t, |
| const struct gl_program *program, |
| struct ureg_program *ureg) |
| { |
| const struct gl_fragment_program *fp = |
| (const struct gl_fragment_program *) program; |
| struct pipe_screen *pscreen = st->pipe->screen; |
| GLfloat adjX = 0.0f; |
| GLfloat adjY[2] = { 0.0f, 0.0f }; |
| boolean invert = FALSE; |
| |
| /* Query the pixel center conventions supported by the pipe driver and set |
| * adjX, adjY to help out if it cannot handle the requested one internally. |
| * |
| * The bias of the y-coordinate depends on whether y-inversion takes place |
| * (adjY[1]) or not (adjY[0]), which is in turn dependent on whether we are |
| * drawing to an FBO (causes additional inversion), and whether the the pipe |
| * driver origin and the requested origin differ (the latter condition is |
| * stored in the 'invert' variable). |
| * |
| * For height = 100 (i = integer, h = half-integer, l = lower, u = upper): |
| * |
| * center shift only: |
| * i -> h: +0.5 |
| * h -> i: -0.5 |
| * |
| * inversion only: |
| * l,i -> u,i: ( 0.0 + 1.0) * -1 + 100 = 99 |
| * l,h -> u,h: ( 0.5 + 0.0) * -1 + 100 = 99.5 |
| * u,i -> l,i: (99.0 + 1.0) * -1 + 100 = 0 |
| * u,h -> l,h: (99.5 + 0.0) * -1 + 100 = 0.5 |
| * |
| * inversion and center shift: |
| * l,i -> u,h: ( 0.0 + 0.5) * -1 + 100 = 99.5 |
| * l,h -> u,i: ( 0.5 + 0.5) * -1 + 100 = 99 |
| * u,i -> l,h: (99.0 + 0.5) * -1 + 100 = 0.5 |
| * u,h -> l,i: (99.5 + 0.5) * -1 + 100 = 0 |
| */ |
| if (fp->OriginUpperLeft) { |
| /* Fragment shader wants origin in upper-left */ |
| if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT)) { |
| /* the driver supports upper-left origin */ |
| } |
| else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT)) { |
| /* the driver supports lower-left origin, need to invert Y */ |
| ureg_property_fs_coord_origin(ureg, TGSI_FS_COORD_ORIGIN_LOWER_LEFT); |
| invert = TRUE; |
| } |
| else |
| assert(0); |
| } |
| else { |
| /* Fragment shader wants origin in lower-left */ |
| if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT)) |
| /* the driver supports lower-left origin */ |
| ureg_property_fs_coord_origin(ureg, TGSI_FS_COORD_ORIGIN_LOWER_LEFT); |
| else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT)) |
| /* the driver supports upper-left origin, need to invert Y */ |
| invert = TRUE; |
| else |
| assert(0); |
| } |
| |
| if (fp->PixelCenterInteger) { |
| /* Fragment shader wants pixel center integer */ |
| if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER)) { |
| /* the driver supports pixel center integer */ |
| adjY[1] = 1.0f; |
| ureg_property_fs_coord_pixel_center(ureg, TGSI_FS_COORD_PIXEL_CENTER_INTEGER); |
| } |
| else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER)) { |
| /* the driver supports pixel center half integer, need to bias X,Y */ |
| adjX = -0.5f; |
| adjY[0] = -0.5f; |
| adjY[1] = 0.5f; |
| } |
| else |
| assert(0); |
| } |
| else { |
| /* Fragment shader wants pixel center half integer */ |
| if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER)) { |
| /* the driver supports pixel center half integer */ |
| } |
| else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER)) { |
| /* the driver supports pixel center integer, need to bias X,Y */ |
| adjX = adjY[0] = adjY[1] = 0.5f; |
| ureg_property_fs_coord_pixel_center(ureg, TGSI_FS_COORD_PIXEL_CENTER_INTEGER); |
| } |
| else |
| assert(0); |
| } |
| |
| /* we invert after adjustment so that we avoid the MOV to temporary, |
| * and reuse the adjustment ADD instead */ |
| emit_wpos_adjustment(t, program, invert, adjX, adjY); |
| } |
| |
| /** |
| * OpenGL's fragment gl_FrontFace input is 1 for front-facing, 0 for back. |
| * TGSI uses +1 for front, -1 for back. |
| * This function converts the TGSI value to the GL value. Simply clamping/ |
| * saturating the value to [0,1] does the job. |
| */ |
| static void |
| emit_face_var(struct st_translate *t) |
| { |
| struct ureg_program *ureg = t->ureg; |
| struct ureg_dst face_temp = ureg_DECL_temporary(ureg); |
| struct ureg_src face_input = t->inputs[t->inputMapping[FRAG_ATTRIB_FACE]]; |
| |
| /* MOV_SAT face_temp, input[face] */ |
| face_temp = ureg_saturate(face_temp); |
| ureg_MOV(ureg, face_temp, face_input); |
| |
| /* Use face_temp as face input from here on: */ |
| t->inputs[t->inputMapping[FRAG_ATTRIB_FACE]] = ureg_src(face_temp); |
| } |
| |
| static void |
| emit_edgeflags(struct st_translate *t) |
| { |
| struct ureg_program *ureg = t->ureg; |
| struct ureg_dst edge_dst = t->outputs[t->outputMapping[VERT_RESULT_EDGE]]; |
| struct ureg_src edge_src = t->inputs[t->inputMapping[VERT_ATTRIB_EDGEFLAG]]; |
| |
| ureg_MOV(ureg, edge_dst, edge_src); |
| } |
| |
| /** |
| * Translate intermediate IR (glsl_to_tgsi_instruction) to TGSI format. |
| * \param program the program to translate |
| * \param numInputs number of input registers used |
| * \param inputMapping maps Mesa fragment program inputs to TGSI generic |
| * input indexes |
| * \param inputSemanticName the TGSI_SEMANTIC flag for each input |
| * \param inputSemanticIndex the semantic index (ex: which texcoord) for |
| * each input |
| * \param interpMode the TGSI_INTERPOLATE_LINEAR/PERSP mode for each input |
| * \param numOutputs number of output registers used |
| * \param outputMapping maps Mesa fragment program outputs to TGSI |
| * generic outputs |
| * \param outputSemanticName the TGSI_SEMANTIC flag for each output |
| * \param outputSemanticIndex the semantic index (ex: which texcoord) for |
| * each output |
| * |
| * \return PIPE_OK or PIPE_ERROR_OUT_OF_MEMORY |
| */ |
| extern "C" enum pipe_error |
| st_translate_program( |
| struct gl_context *ctx, |
| uint procType, |
| struct ureg_program *ureg, |
| glsl_to_tgsi_visitor *program, |
| const struct gl_program *proginfo, |
| GLuint numInputs, |
| const GLuint inputMapping[], |
| const ubyte inputSemanticName[], |
| const ubyte inputSemanticIndex[], |
| const GLuint interpMode[], |
| const GLboolean is_centroid[], |
| GLuint numOutputs, |
| const GLuint outputMapping[], |
| const ubyte outputSemanticName[], |
| const ubyte outputSemanticIndex[], |
| boolean passthrough_edgeflags, |
| boolean clamp_color) |
| { |
| struct st_translate *t; |
| unsigned i; |
| enum pipe_error ret = PIPE_OK; |
| |
| assert(numInputs <= Elements(t->inputs)); |
| assert(numOutputs <= Elements(t->outputs)); |
| |
| t = CALLOC_STRUCT(st_translate); |
| if (!t) { |
| ret = PIPE_ERROR_OUT_OF_MEMORY; |
| goto out; |
| } |
| |
| memset(t, 0, sizeof *t); |
| |
| t->procType = procType; |
| t->inputMapping = inputMapping; |
| t->outputMapping = outputMapping; |
| t->ureg = ureg; |
| |
| if (program->shader_program) { |
| for (i = 0; i < program->shader_program->NumUserUniformStorage; i++) { |
| struct gl_uniform_storage *const storage = |
| &program->shader_program->UniformStorage[i]; |
| |
| _mesa_uniform_detach_all_driver_storage(storage); |
| } |
| } |
| |
| /* |
| * Declare input attributes. |
| */ |
| if (procType == TGSI_PROCESSOR_FRAGMENT) { |
| for (i = 0; i < numInputs; i++) { |
| t->inputs[i] = ureg_DECL_fs_input_cyl_centroid(ureg, |
| inputSemanticName[i], |
| inputSemanticIndex[i], |
| interpMode[i], 0, |
| is_centroid[i]); |
| } |
| |
| if (proginfo->InputsRead & FRAG_BIT_WPOS) { |
| /* Must do this after setting up t->inputs, and before |
| * emitting constant references, below: |
| */ |
| emit_wpos(st_context(ctx), t, proginfo, ureg); |
| } |
| |
| if (proginfo->InputsRead & FRAG_BIT_FACE) |
| emit_face_var(t); |
| |
| /* |
| * Declare output attributes. |
| */ |
| for (i = 0; i < numOutputs; i++) { |
| switch (outputSemanticName[i]) { |
| case TGSI_SEMANTIC_POSITION: |
| t->outputs[i] = ureg_DECL_output(ureg, |
| TGSI_SEMANTIC_POSITION, /* Z/Depth */ |
| outputSemanticIndex[i]); |
| t->outputs[i] = ureg_writemask(t->outputs[i], TGSI_WRITEMASK_Z); |
| break; |
| case TGSI_SEMANTIC_STENCIL: |
| t->outputs[i] = ureg_DECL_output(ureg, |
| TGSI_SEMANTIC_STENCIL, /* Stencil */ |
| outputSemanticIndex[i]); |
| t->outputs[i] = ureg_writemask(t->outputs[i], TGSI_WRITEMASK_Y); |
| break; |
| case TGSI_SEMANTIC_COLOR: |
| t->outputs[i] = ureg_DECL_output(ureg, |
| TGSI_SEMANTIC_COLOR, |
| outputSemanticIndex[i]); |
| break; |
| default: |
| assert(!"fragment shader outputs must be POSITION/STENCIL/COLOR"); |
| ret = PIPE_ERROR_BAD_INPUT; |
| goto out; |
| } |
| } |
| } |
| else if (procType == TGSI_PROCESSOR_GEOMETRY) { |
| for (i = 0; i < numInputs; i++) { |
| t->inputs[i] = ureg_DECL_gs_input(ureg, |
| i, |
| inputSemanticName[i], |
| inputSemanticIndex[i]); |
| } |
| |
| for (i = 0; i < numOutputs; i++) { |
| t->outputs[i] = ureg_DECL_output(ureg, |
| outputSemanticName[i], |
| outputSemanticIndex[i]); |
| } |
| } |
| else { |
| assert(procType == TGSI_PROCESSOR_VERTEX); |
| |
| for (i = 0; i < numInputs; i++) { |
| t->inputs[i] = ureg_DECL_vs_input(ureg, i); |
| } |
| |
| for (i = 0; i < numOutputs; i++) { |
| t->outputs[i] = ureg_DECL_output(ureg, |
| outputSemanticName[i], |
| outputSemanticIndex[i]); |
| } |
| if (passthrough_edgeflags) |
| emit_edgeflags(t); |
| } |
| |
| /* Declare address register. |
| */ |
| if (program->num_address_regs > 0) { |
| assert(program->num_address_regs == 1); |
| t->address[0] = ureg_DECL_address(ureg); |
| } |
| |
| /* Declare misc input registers |
| */ |
| { |
| GLbitfield sysInputs = proginfo->SystemValuesRead; |
| unsigned numSys = 0; |
| for (i = 0; sysInputs; i++) { |
| if (sysInputs & (1 << i)) { |
| unsigned semName = mesa_sysval_to_semantic[i]; |
| t->systemValues[i] = ureg_DECL_system_value(ureg, numSys, semName, 0); |
| if (semName == TGSI_SEMANTIC_INSTANCEID || |
| semName == TGSI_SEMANTIC_VERTEXID) { |
| /* From Gallium perspective, these system values are always |
| * integer, and require native integer support. However, if |
| * native integer is supported on the vertex stage but not the |
| * pixel stage (e.g, i915g + draw), Mesa will generate IR that |
| * assumes these system values are floats. To resolve the |
| * inconsistency, we insert a U2F. |
| */ |
| struct st_context *st = st_context(ctx); |
| struct pipe_screen *pscreen = st->pipe->screen; |
| assert(procType == TGSI_PROCESSOR_VERTEX); |
| assert(pscreen->get_shader_param(pscreen, PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_INTEGERS)); |
| if (!ctx->Const.NativeIntegers) { |
| struct ureg_dst temp = ureg_DECL_local_temporary(t->ureg); |
| ureg_U2F( t->ureg, ureg_writemask(temp, TGSI_WRITEMASK_X), t->systemValues[i]); |
| t->systemValues[i] = ureg_scalar(ureg_src(temp), 0); |
| } |
| } |
| numSys++; |
| sysInputs &= ~(1 << i); |
| } |
| } |
| } |
| |
| if (program->indirect_addr_temps) { |
| /* If temps are accessed with indirect addressing, declare temporaries |
| * in sequential order. Else, we declare them on demand elsewhere. |
| * (Note: the number of temporaries is equal to program->next_temp) |
| */ |
| for (i = 0; i < (unsigned)program->next_temp; i++) { |
| /* XXX use TGSI_FILE_TEMPORARY_ARRAY when it's supported by ureg */ |
| t->temps[i] = ureg_DECL_local_temporary(t->ureg); |
| } |
| } |
| |
| /* Emit constants and uniforms. TGSI uses a single index space for these, |
| * so we put all the translated regs in t->constants. |
| */ |
| if (proginfo->Parameters) { |
| t->constants = (struct ureg_src *)CALLOC(proginfo->Parameters->NumParameters * sizeof(t->constants[0])); |
| if (t->constants == NULL) { |
| ret = PIPE_ERROR_OUT_OF_MEMORY; |
| goto out; |
| } |
| |
| for (i = 0; i < proginfo->Parameters->NumParameters; i++) { |
| switch (proginfo->Parameters->Parameters[i].Type) { |
| case PROGRAM_ENV_PARAM: |
| case PROGRAM_LOCAL_PARAM: |
| case PROGRAM_STATE_VAR: |
| case PROGRAM_NAMED_PARAM: |
| case PROGRAM_UNIFORM: |
| t->constants[i] = ureg_DECL_constant(ureg, i); |
| break; |
| |
| /* Emit immediates for PROGRAM_CONSTANT only when there's no indirect |
| * addressing of the const buffer. |
| * FIXME: Be smarter and recognize param arrays: |
| * indirect addressing is only valid within the referenced |
| * array. |
| */ |
| case PROGRAM_CONSTANT: |
| if (program->indirect_addr_consts) |
| t->constants[i] = ureg_DECL_constant(ureg, i); |
| else |
| t->constants[i] = emit_immediate(t, |
| proginfo->Parameters->ParameterValues[i], |
| proginfo->Parameters->Parameters[i].DataType, |
| 4); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| |
| /* Emit immediate values. |
| */ |
| t->immediates = (struct ureg_src *)CALLOC(program->num_immediates * sizeof(struct ureg_src)); |
| if (t->immediates == NULL) { |
| ret = PIPE_ERROR_OUT_OF_MEMORY; |
| goto out; |
| } |
| i = 0; |
| foreach_iter(exec_list_iterator, iter, program->immediates) { |
| immediate_storage *imm = (immediate_storage *)iter.get(); |
| assert(i < program->num_immediates); |
| t->immediates[i++] = emit_immediate(t, imm->values, imm->type, imm->size); |
| } |
| assert(i == program->num_immediates); |
| |
| /* texture samplers */ |
| for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { |
| if (program->samplers_used & (1 << i)) { |
| t->samplers[i] = ureg_DECL_sampler(ureg, i); |
| } |
| } |
| |
| /* Emit each instruction in turn: |
| */ |
| foreach_iter(exec_list_iterator, iter, program->instructions) { |
| set_insn_start(t, ureg_get_instruction_number(ureg)); |
| compile_tgsi_instruction(t, (glsl_to_tgsi_instruction *)iter.get(), |
| clamp_color); |
| } |
| |
| /* Fix up all emitted labels: |
| */ |
| for (i = 0; i < t->labels_count; i++) { |
| ureg_fixup_label(ureg, t->labels[i].token, |
| t->insn[t->labels[i].branch_target]); |
| } |
| |
| if (program->shader_program) { |
| /* This has to be done last. Any operation the can cause |
| * prog->ParameterValues to get reallocated (e.g., anything that adds a |
| * program constant) has to happen before creating this linkage. |
| */ |
| for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) { |
| if (program->shader_program->_LinkedShaders[i] == NULL) |
| continue; |
| |
| _mesa_associate_uniform_storage(ctx, program->shader_program, |
| program->shader_program->_LinkedShaders[i]->Program->Parameters); |
| } |
| } |
| |
| out: |
| if (t) { |
| FREE(t->insn); |
| FREE(t->labels); |
| FREE(t->constants); |
| FREE(t->immediates); |
| |
| if (t->error) { |
| debug_printf("%s: translate error flag set\n", __FUNCTION__); |
| } |
| |
| FREE(t); |
| } |
| |
| return ret; |
| } |
| /* ----------------------------- End TGSI code ------------------------------ */ |
| |
| /** |
| * Convert a shader's GLSL IR into a Mesa gl_program, although without |
| * generating Mesa IR. |
| */ |
| static struct gl_program * |
| get_mesa_program(struct gl_context *ctx, |
| struct gl_shader_program *shader_program, |
| struct gl_shader *shader) |
| { |
| glsl_to_tgsi_visitor* v; |
| struct gl_program *prog; |
| GLenum target; |
| const char *target_string; |
| bool progress; |
| struct gl_shader_compiler_options *options = |
| &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(shader->Type)]; |
| |
| switch (shader->Type) { |
| case GL_VERTEX_SHADER: |
| target = GL_VERTEX_PROGRAM_ARB; |
| target_string = "vertex"; |
| break; |
| case GL_FRAGMENT_SHADER: |
| target = GL_FRAGMENT_PROGRAM_ARB; |
| target_string = "fragment"; |
| break; |
| case GL_GEOMETRY_SHADER: |
| target = GL_GEOMETRY_PROGRAM_NV; |
| target_string = "geometry"; |
| break; |
| default: |
| assert(!"should not be reached"); |
| return NULL; |
| } |
| |
| validate_ir_tree(shader->ir); |
| |
| prog = ctx->Driver.NewProgram(ctx, target, shader_program->Name); |
| if (!prog) |
| return NULL; |
| prog->Parameters = _mesa_new_parameter_list(); |
| v = new glsl_to_tgsi_visitor(); |
| v->ctx = ctx; |
| v->prog = prog; |
| v->shader_program = shader_program; |
| v->options = options; |
| v->glsl_version = ctx->Const.GLSLVersion; |
| v->native_integers = ctx->Const.NativeIntegers; |
| |
| _mesa_generate_parameters_list_for_uniforms(shader_program, shader, |
| prog->Parameters); |
| |
| /* Remove reads from output registers. */ |
| lower_output_reads(shader->ir); |
| |
| /* Emit intermediate IR for main(). */ |
| visit_exec_list(shader->ir, v); |
| |
| /* Now emit bodies for any functions that were used. */ |
| do { |
| progress = GL_FALSE; |
| |
| foreach_iter(exec_list_iterator, iter, v->function_signatures) { |
| function_entry *entry = (function_entry *)iter.get(); |
| |
| if (!entry->bgn_inst) { |
| v->current_function = entry; |
| |
| entry->bgn_inst = v->emit(NULL, TGSI_OPCODE_BGNSUB); |
| entry->bgn_inst->function = entry; |
| |
| visit_exec_list(&entry->sig->body, v); |
| |
| glsl_to_tgsi_instruction *last; |
| last = (glsl_to_tgsi_instruction *)v->instructions.get_tail(); |
| if (last->op != TGSI_OPCODE_RET) |
| v->emit(NULL, TGSI_OPCODE_RET); |
| |
| glsl_to_tgsi_instruction *end; |
| end = v->emit(NULL, TGSI_OPCODE_ENDSUB); |
| end->function = entry; |
| |
| progress = GL_TRUE; |
| } |
| } |
| } while (progress); |
| |
| #if 0 |
| /* Print out some information (for debugging purposes) used by the |
| * optimization passes. */ |
| for (i=0; i < v->next_temp; i++) { |
| int fr = v->get_first_temp_read(i); |
| int fw = v->get_first_temp_write(i); |
| int lr = v->get_last_temp_read(i); |
| int lw = v->get_last_temp_write(i); |
| |
| printf("Temp %d: FR=%3d FW=%3d LR=%3d LW=%3d\n", i, fr, fw, lr, lw); |
| assert(fw <= fr); |
| } |
| #endif |
| |
| /* Perform optimizations on the instructions in the glsl_to_tgsi_visitor. */ |
| v->simplify_cmp(); |
| v->copy_propagate(); |
| while (v->eliminate_dead_code_advanced()); |
| |
| /* FIXME: These passes to optimize temporary registers don't work when there |
| * is indirect addressing of the temporary register space. We need proper |
| * array support so that we don't have to give up these passes in every |
| * shader that uses arrays. |
| */ |
| if (!v->indirect_addr_temps) { |
| v->eliminate_dead_code(); |
| v->merge_registers(); |
| v->renumber_registers(); |
| } |
| |
| /* Write the END instruction. */ |
| v->emit(NULL, TGSI_OPCODE_END); |
| |
| if (ctx->Shader.Flags & GLSL_DUMP) { |
| printf("\n"); |
| printf("GLSL IR for linked %s program %d:\n", target_string, |
| shader_program->Name); |
| _mesa_print_ir(shader->ir, NULL); |
| printf("\n"); |
| printf("\n"); |
| fflush(stdout); |
| } |
| |
| prog->Instructions = NULL; |
| prog->NumInstructions = 0; |
| |
| do_set_program_inouts(shader->ir, prog, shader->Type == GL_FRAGMENT_SHADER); |
| count_resources(v, prog); |
| |
| _mesa_reference_program(ctx, &shader->Program, prog); |
| |
| /* This has to be done last. Any operation the can cause |
| * prog->ParameterValues to get reallocated (e.g., anything that adds a |
| * program constant) has to happen before creating this linkage. |
| */ |
| _mesa_associate_uniform_storage(ctx, shader_program, prog->Parameters); |
| if (!shader_program->LinkStatus) { |
| return NULL; |
| } |
| |
| struct st_vertex_program *stvp; |
| struct st_fragment_program *stfp; |
| struct st_geometry_program *stgp; |
| |
| switch (shader->Type) { |
| case GL_VERTEX_SHADER: |
| stvp = (struct st_vertex_program *)prog; |
| stvp->glsl_to_tgsi = v; |
| break; |
| case GL_FRAGMENT_SHADER: |
| stfp = (struct st_fragment_program *)prog; |
| stfp->glsl_to_tgsi = v; |
| break; |
| case GL_GEOMETRY_SHADER: |
| stgp = (struct st_geometry_program *)prog; |
| stgp->glsl_to_tgsi = v; |
| break; |
| default: |
| assert(!"should not be reached"); |
| return NULL; |
| } |
| |
| return prog; |
| } |
| |
| extern "C" { |
| |
| struct gl_shader * |
| st_new_shader(struct gl_context *ctx, GLuint name, GLuint type) |
| { |
| struct gl_shader *shader; |
| assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER || |
| type == GL_GEOMETRY_SHADER_ARB); |
| shader = rzalloc(NULL, struct gl_shader); |
| if (shader) { |
| shader->Type = type; |
| shader->Name = name; |
| _mesa_init_shader(ctx, shader); |
| } |
| return shader; |
| } |
| |
| struct gl_shader_program * |
| st_new_shader_program(struct gl_context *ctx, GLuint name) |
| { |
| struct gl_shader_program *shProg; |
| shProg = rzalloc(NULL, struct gl_shader_program); |
| if (shProg) { |
| shProg->Name = name; |
| _mesa_init_shader_program(ctx, shProg); |
| } |
| return shProg; |
| } |
| |
| /** |
| * Link a shader. |
| * Called via ctx->Driver.LinkShader() |
| * This actually involves converting GLSL IR into an intermediate TGSI-like IR |
| * with code lowering and other optimizations. |
| */ |
| GLboolean |
| st_link_shader(struct gl_context *ctx, struct gl_shader_program *prog) |
| { |
| assert(prog->LinkStatus); |
| |
| for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) { |
| if (prog->_LinkedShaders[i] == NULL) |
| continue; |
| |
| bool progress; |
| exec_list *ir = prog->_LinkedShaders[i]->ir; |
| const struct gl_shader_compiler_options *options = |
| &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(prog->_LinkedShaders[i]->Type)]; |
| |
| do { |
| unsigned what_to_lower = MOD_TO_FRACT | DIV_TO_MUL_RCP | |
| EXP_TO_EXP2 | LOG_TO_LOG2; |
| if (options->EmitNoPow) |
| what_to_lower |= POW_TO_EXP2; |
| if (!ctx->Const.NativeIntegers) |
| what_to_lower |= INT_DIV_TO_MUL_RCP; |
| |
| progress = false; |
| |
| /* Lowering */ |
| do_mat_op_to_vec(ir); |
| lower_instructions(ir, what_to_lower); |
| |
| progress = do_lower_jumps(ir, true, true, options->EmitNoMainReturn, options->EmitNoCont, options->EmitNoLoops) || progress; |
| |
| progress = do_common_optimization(ir, true, true, |
| options->MaxUnrollIterations) |
| || progress; |
| |
| progress = lower_quadop_vector(ir, false) || progress; |
| |
| if (options->MaxIfDepth == 0) |
| progress = lower_discard(ir) || progress; |
| |
| progress = lower_if_to_cond_assign(ir, options->MaxIfDepth) || progress; |
| |
| if (options->EmitNoNoise) |
| progress = lower_noise(ir) || progress; |
| |
| /* If there are forms of indirect addressing that the driver |
| * cannot handle, perform the lowering pass. |
| */ |
| if (options->EmitNoIndirectInput || options->EmitNoIndirectOutput |
| || options->EmitNoIndirectTemp || options->EmitNoIndirectUniform) |
| progress = |
| lower_variable_index_to_cond_assign(ir, |
| options->EmitNoIndirectInput, |
| options->EmitNoIndirectOutput, |
| options->EmitNoIndirectTemp, |
| options->EmitNoIndirectUniform) |
| || progress; |
| |
| progress = do_vec_index_to_cond_assign(ir) || progress; |
| } while (progress); |
| |
| validate_ir_tree(ir); |
| } |
| |
| for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) { |
| struct gl_program *linked_prog; |
| |
| if (prog->_LinkedShaders[i] == NULL) |
| continue; |
| |
| linked_prog = get_mesa_program(ctx, prog, prog->_LinkedShaders[i]); |
| |
| if (linked_prog) { |
| static const GLenum targets[] = { |
| GL_VERTEX_PROGRAM_ARB, |
| GL_FRAGMENT_PROGRAM_ARB, |
| GL_GEOMETRY_PROGRAM_NV |
| }; |
| |
| _mesa_reference_program(ctx, &prog->_LinkedShaders[i]->Program, |
| linked_prog); |
| if (!ctx->Driver.ProgramStringNotify(ctx, targets[i], linked_prog)) { |
| _mesa_reference_program(ctx, &prog->_LinkedShaders[i]->Program, |
| NULL); |
| _mesa_reference_program(ctx, &linked_prog, NULL); |
| return GL_FALSE; |
| } |
| } |
| |
| _mesa_reference_program(ctx, &linked_prog, NULL); |
| } |
| |
| return GL_TRUE; |
| } |
| |
| void |
| st_translate_stream_output_info(glsl_to_tgsi_visitor *glsl_to_tgsi, |
| const GLuint outputMapping[], |
| struct pipe_stream_output_info *so) |
| { |
| unsigned i; |
| struct gl_transform_feedback_info *info = |
| &glsl_to_tgsi->shader_program->LinkedTransformFeedback; |
| |
| for (i = 0; i < info->NumOutputs; i++) { |
| so->output[i].register_index = |
| outputMapping[info->Outputs[i].OutputRegister]; |
| so->output[i].start_component = info->Outputs[i].ComponentOffset; |
| so->output[i].num_components = info->Outputs[i].NumComponents; |
| so->output[i].output_buffer = info->Outputs[i].OutputBuffer; |
| so->output[i].dst_offset = info->Outputs[i].DstOffset; |
| } |
| |
| for (i = 0; i < PIPE_MAX_SO_BUFFERS; i++) { |
| so->stride[i] = info->BufferStride[i]; |
| } |
| so->num_outputs = info->NumOutputs; |
| } |
| |
| } /* extern "C" */ |