X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fdrivers%2Fdri%2Fi965%2Fbrw_fs_generator.cpp;h=2f4ba7b55929c4a0e8f1fec1d4d75e26d0544fc9;hb=2fc9c7e3d9b2bcd65c9e192bc11d3c87835f85dc;hp=d979518c9225c8368c3bf10d585d5bf723233039;hpb=d8a3294ac21741c3a78eef72b832902e15fbd948;p=mesa.git diff --git a/src/mesa/drivers/dri/i965/brw_fs_generator.cpp b/src/mesa/drivers/dri/i965/brw_fs_generator.cpp index d979518c922..2f4ba7b5592 100644 --- a/src/mesa/drivers/dri/i965/brw_fs_generator.cpp +++ b/src/mesa/drivers/dri/i965/brw_fs_generator.cpp @@ -54,9 +54,9 @@ brw_file_from_reg(fs_reg *reg) } static struct brw_reg -brw_reg_from_fs_reg(const struct brw_codegen *p, - fs_inst *inst, fs_reg *reg, unsigned gen) +brw_reg_from_fs_reg(fs_inst *inst, fs_reg *reg, unsigned gen, bool compressed) { + assert(reg->reg_offset == 0); struct brw_reg brw_reg; switch (reg->file) { @@ -66,27 +66,34 @@ brw_reg_from_fs_reg(const struct brw_codegen *p, case VGRF: if (reg->stride == 0) { brw_reg = brw_vec1_reg(brw_file_from_reg(reg), reg->nr, 0); - } else if (!p->compressed && - inst->exec_size * reg->stride * type_sz(reg->type) <= 32) { - brw_reg = brw_vecn_reg(inst->exec_size, brw_file_from_reg(reg), - reg->nr, 0); - brw_reg = stride(brw_reg, inst->exec_size * reg->stride, - inst->exec_size, reg->stride); } else { /* From the Haswell PRM: * - * VertStride must be used to cross GRF register boundaries. This - * rule implies that elements within a 'Width' cannot cross GRF - * boundaries. + * "VertStride must be used to cross GRF register boundaries. This + * rule implies that elements within a 'Width' cannot cross GRF + * boundaries." * - * So, for registers that are large enough, we have to split the exec - * size in two and trust the compression state to sort it out. + * The maximum width value that could satisfy this restriction is: */ - assert(inst->exec_size / 2 * reg->stride * type_sz(reg->type) <= 32); - brw_reg = brw_vecn_reg(inst->exec_size / 2, brw_file_from_reg(reg), - reg->nr, 0); - brw_reg = stride(brw_reg, inst->exec_size / 2 * reg->stride, - inst->exec_size / 2, reg->stride); + const unsigned reg_width = REG_SIZE / (reg->stride * type_sz(reg->type)); + + /* Because the hardware can only split source regions at a whole + * multiple of width during decompression (i.e. vertically), clamp + * the value obtained above to the physical execution size of a + * single decompressed chunk of the instruction: + */ + const unsigned phys_width = compressed ? inst->exec_size / 2 : + inst->exec_size; + + /* XXX - The equation above is strictly speaking not correct on + * hardware that supports unbalanced GRF writes -- On Gen9+ + * each decompressed chunk of the instruction may have a + * different execution size when the number of components + * written to each destination GRF is not the same. + */ + const unsigned width = MIN2(reg_width, phys_width); + brw_reg = brw_vecn_reg(width, brw_file_from_reg(reg), reg->nr, 0); + brw_reg = stride(brw_reg, width * reg->stride, width, reg->stride); } brw_reg = retype(brw_reg, reg->type); @@ -97,6 +104,7 @@ brw_reg_from_fs_reg(const struct brw_codegen *p, case ARF: case FIXED_GRF: case IMM: + assert(reg->subreg_offset == 0); brw_reg = reg->as_brw_reg(); break; case BAD_FILE: @@ -206,7 +214,7 @@ fs_generator::fire_fb_write(fs_inst *inst, if (inst->opcode == FS_OPCODE_REP_FB_WRITE) msg_control = BRW_DATAPORT_RENDER_TARGET_WRITE_SIMD16_SINGLE_SOURCE_REPLICATED; else if (prog_data->dual_src_blend) { - if (!inst->force_sechalf) + if (!inst->group) msg_control = BRW_DATAPORT_RENDER_TARGET_WRITE_SIMD8_DUAL_SOURCE_SUBSPAN01; else msg_control = BRW_DATAPORT_RENDER_TARGET_WRITE_SIMD8_DUAL_SOURCE_SUBSPAN23; @@ -223,7 +231,6 @@ fs_generator::fire_fb_write(fs_inst *inst, brw_fb_WRITE(p, - dispatch_width, payload, implied_header, msg_control, @@ -346,6 +353,22 @@ fs_generator::generate_fb_write(fs_inst *inst, struct brw_reg payload) } } +void +fs_generator::generate_fb_read(fs_inst *inst, struct brw_reg dst, + struct brw_reg payload) +{ + brw_wm_prog_data *prog_data = + reinterpret_cast(this->prog_data); + const unsigned surf_index = + prog_data->binding_table.render_target_start + inst->target; + + gen9_fb_READ(p, dst, payload, surf_index, + inst->header_size, inst->regs_written, + prog_data->persample_dispatch); + + brw_mark_surface_used(&prog_data->base, surf_index); +} + void fs_generator::generate_mov_indirect(fs_inst *inst, struct brw_reg dst, @@ -433,7 +456,7 @@ fs_generator::generate_urb_read(fs_inst *inst, assert(header.type == BRW_REGISTER_TYPE_UD); brw_inst *send = brw_next_insn(p, BRW_OPCODE_SEND); - brw_set_dest(p, send, dst); + brw_set_dest(p, send, retype(dst, BRW_REGISTER_TYPE_UD)); brw_set_src0(p, send, header); brw_set_src1(p, send, brw_imm_ud(0u)); @@ -509,47 +532,6 @@ fs_generator::generate_cs_terminate(fs_inst *inst, struct brw_reg payload) brw_inst_set_mask_control(devinfo, insn, BRW_MASK_DISABLE); } -void -fs_generator::generate_stencil_ref_packing(fs_inst *inst, - struct brw_reg dst, - struct brw_reg src) -{ - assert(dispatch_width == 8); - assert(devinfo->gen >= 9); - - /* Stencil value updates are provided in 8 slots of 1 byte per slot. - * Presumably, in order to save memory bandwidth, the stencil reference - * values written from the FS need to be packed into 2 dwords (this makes - * sense because the stencil values are limited to 1 byte each and a SIMD8 - * send, so stencil slots 0-3 in dw0, and 4-7 in dw1.) - * - * The spec is confusing here because in the payload definition of MDP_RTW_S8 - * (Message Data Payload for Render Target Writes with Stencil 8b) the - * stencil value seems to be dw4.0-dw4.7. However, if you look at the type of - * dw4 it is type MDPR_STENCIL (Message Data Payload Register) which is the - * packed values specified above and diagrammed below: - * - * 31 0 - * -------------------------------- - * DW | | - * 2-7 | IGNORED | - * | | - * -------------------------------- - * DW1 | STC | STC | STC | STC | - * | slot7 | slot6 | slot5 | slot4| - * -------------------------------- - * DW0 | STC | STC | STC | STC | - * | slot3 | slot2 | slot1 | slot0| - * -------------------------------- - */ - - src.vstride = BRW_VERTICAL_STRIDE_4; - src.width = BRW_WIDTH_1; - src.hstride = BRW_HORIZONTAL_STRIDE_0; - assert(src.type == BRW_REGISTER_TYPE_UB); - brw_MOV(p, retype(dst, BRW_REGISTER_TYPE_UB), src); -} - void fs_generator::generate_barrier(fs_inst *inst, struct brw_reg src) { @@ -582,7 +564,7 @@ fs_generator::generate_linterp(fs_inst *inst, * See also: emit_interpolation_setup_gen4(). */ struct brw_reg delta_x = src[0]; - struct brw_reg delta_y = offset(src[0], dispatch_width / 8); + struct brw_reg delta_y = offset(src[0], inst->exec_size / 8); struct brw_reg interp = src[1]; if (devinfo->has_pln && @@ -594,82 +576,6 @@ fs_generator::generate_linterp(fs_inst *inst, } } -void -fs_generator::generate_math_gen6(fs_inst *inst, - struct brw_reg dst, - struct brw_reg src0, - struct brw_reg src1) -{ - int op = brw_math_function(inst->opcode); - bool binop = src1.file != BRW_ARCHITECTURE_REGISTER_FILE; - - if (dispatch_width == 8) { - gen6_math(p, dst, op, src0, src1); - } else if (dispatch_width == 16) { - brw_push_insn_state(p); - brw_set_default_exec_size(p, BRW_EXECUTE_8); - brw_set_default_compression_control(p, BRW_COMPRESSION_NONE); - gen6_math(p, firsthalf(dst), op, firsthalf(src0), firsthalf(src1)); - brw_set_default_compression_control(p, BRW_COMPRESSION_2NDHALF); - gen6_math(p, sechalf(dst), op, sechalf(src0), - binop ? sechalf(src1) : brw_null_reg()); - brw_pop_insn_state(p); - } -} - -void -fs_generator::generate_math_gen4(fs_inst *inst, - struct brw_reg dst, - struct brw_reg src) -{ - int op = brw_math_function(inst->opcode); - - assert(inst->mlen >= 1); - - if (dispatch_width == 8) { - gen4_math(p, dst, - op, - inst->base_mrf, src, - BRW_MATH_PRECISION_FULL); - } else if (dispatch_width == 16) { - brw_set_default_exec_size(p, BRW_EXECUTE_8); - brw_set_default_compression_control(p, BRW_COMPRESSION_NONE); - gen4_math(p, firsthalf(dst), - op, - inst->base_mrf, firsthalf(src), - BRW_MATH_PRECISION_FULL); - brw_set_default_compression_control(p, BRW_COMPRESSION_2NDHALF); - gen4_math(p, sechalf(dst), - op, - inst->base_mrf + 1, sechalf(src), - BRW_MATH_PRECISION_FULL); - - brw_set_default_compression_control(p, BRW_COMPRESSION_COMPRESSED); - } -} - -void -fs_generator::generate_math_g45(fs_inst *inst, - struct brw_reg dst, - struct brw_reg src) -{ - if (inst->opcode == SHADER_OPCODE_POW || - inst->opcode == SHADER_OPCODE_INT_QUOTIENT || - inst->opcode == SHADER_OPCODE_INT_REMAINDER) { - generate_math_gen4(inst, dst, src); - return; - } - - int op = brw_math_function(inst->opcode); - - assert(inst->mlen >= 1); - - gen4_math(p, dst, - op, - inst->base_mrf, src, - BRW_MATH_PRECISION_FULL); -} - void fs_generator::generate_get_buffer_size(fs_inst *inst, struct brw_reg dst, @@ -1114,34 +1020,6 @@ fs_generator::generate_ddy(enum opcode opcode, struct brw_reg dst, struct brw_reg src) { if (opcode == FS_OPCODE_DDY_FINE) { - /* From the Ivy Bridge PRM, volume 4 part 3, section 3.3.9 (Register - * Region Restrictions): - * - * In Align16 access mode, SIMD16 is not allowed for DW operations - * and SIMD8 is not allowed for DF operations. - * - * In this context, "DW operations" means "operations acting on 32-bit - * values", so it includes operations on floats. - * - * Gen4 has a similar restriction. From the i965 PRM, section 11.5.3 - * (Instruction Compression -> Rules and Restrictions): - * - * A compressed instruction must be in Align1 access mode. Align16 - * mode instructions cannot be compressed. - * - * Similar text exists in the g45 PRM. - * - * Empirically, compressed align16 instructions using odd register - * numbers don't appear to work on Sandybridge either. - * - * On these platforms, if we're building a SIMD16 shader, we need to - * manually unroll to a pair of SIMD8 instructions. - */ - bool unroll_to_simd8 = - (dispatch_width == 16 && - (devinfo->gen == 4 || devinfo->gen == 6 || - (devinfo->gen == 7 && !devinfo->is_haswell))); - /* produce accurate derivatives */ struct brw_reg src0 = brw_reg(src.file, src.nr, 0, src.negate, src.abs, @@ -1159,15 +1037,7 @@ fs_generator::generate_ddy(enum opcode opcode, BRW_SWIZZLE_ZWZW, WRITEMASK_XYZW); brw_push_insn_state(p); brw_set_default_access_mode(p, BRW_ALIGN_16); - if (unroll_to_simd8) { - brw_set_default_exec_size(p, BRW_EXECUTE_8); - brw_set_default_compression_control(p, BRW_COMPRESSION_NONE); - brw_ADD(p, firsthalf(dst), negate(firsthalf(src0)), firsthalf(src1)); - brw_set_default_compression_control(p, BRW_COMPRESSION_2NDHALF); - brw_ADD(p, sechalf(dst), negate(sechalf(src0)), sechalf(src1)); - } else { - brw_ADD(p, dst, negate(src0), src1); - } + brw_ADD(p, dst, negate(src0), src1); brw_pop_insn_state(p); } else { /* replicate the derivative at the top-left pixel to other pixels */ @@ -1199,28 +1069,44 @@ fs_generator::generate_discard_jump(fs_inst *inst) * current block (or the program). */ this->discard_halt_patches.push_tail(new(mem_ctx) ip_record(p->nr_insn)); - - brw_push_insn_state(p); - brw_set_default_mask_control(p, BRW_MASK_DISABLE); gen6_HALT(p); - brw_pop_insn_state(p); } void fs_generator::generate_scratch_write(fs_inst *inst, struct brw_reg src) { + /* The 32-wide messages only respect the first 16-wide half of the channel + * enable signals which are replicated identically for the second group of + * 16 channels, so we cannot use them unless the write is marked + * force_writemask_all. + */ + const unsigned lower_size = inst->force_writemask_all ? inst->exec_size : + MIN2(16, inst->exec_size); + const unsigned block_size = 4 * lower_size / REG_SIZE; assert(inst->mlen != 0); - brw_MOV(p, - brw_uvec_mrf(inst->exec_size, (inst->base_mrf + 1), 0), - retype(src, BRW_REGISTER_TYPE_UD)); - brw_oword_block_write_scratch(p, brw_message_reg(inst->base_mrf), - inst->exec_size / 8, inst->offset); + brw_push_insn_state(p); + brw_set_default_exec_size(p, cvt(lower_size) - 1); + brw_set_default_compression(p, lower_size > 8); + + for (unsigned i = 0; i < inst->exec_size / lower_size; i++) { + brw_set_default_group(p, inst->group + lower_size * i); + + brw_MOV(p, brw_uvec_mrf(lower_size, inst->base_mrf + 1, 0), + retype(offset(src, block_size * i), BRW_REGISTER_TYPE_UD)); + + brw_oword_block_write_scratch(p, brw_message_reg(inst->base_mrf), + block_size, + inst->offset + block_size * REG_SIZE * i); + } + + brw_pop_insn_state(p); } void fs_generator::generate_scratch_read(fs_inst *inst, struct brw_reg dst) { + assert(inst->exec_size <= 16 || inst->force_writemask_all); assert(inst->mlen != 0); brw_oword_block_read_scratch(p, dst, brw_message_reg(inst->base_mrf), @@ -1230,6 +1116,8 @@ fs_generator::generate_scratch_read(fs_inst *inst, struct brw_reg dst) void fs_generator::generate_scratch_read_gen7(fs_inst *inst, struct brw_reg dst) { + assert(inst->exec_size <= 16 || inst->force_writemask_all); + gen7_block_read_scratch(p, dst, inst->exec_size / 8, inst->offset); } @@ -1301,7 +1189,7 @@ fs_generator::generate_uniform_pull_constant_load_gen7(fs_inst *inst, brw_inst_set_exec_size(devinfo, send, BRW_EXECUTE_4); brw_pop_insn_state(p); - brw_set_dest(p, send, dst); + brw_set_dest(p, send, retype(dst, BRW_REGISTER_TYPE_UD)); brw_set_src0(p, send, src); brw_set_sampler_message(p, send, surf_index, @@ -1345,9 +1233,9 @@ fs_generator::generate_uniform_pull_constant_load_gen7(fs_inst *inst, } void -fs_generator::generate_varying_pull_constant_load(fs_inst *inst, - struct brw_reg dst, - struct brw_reg index) +fs_generator::generate_varying_pull_constant_load_gen4(fs_inst *inst, + struct brw_reg dst, + struct brw_reg index) { assert(devinfo->gen < 7); /* Should use the gen7 variant. */ assert(inst->header_size != 0); @@ -1358,10 +1246,11 @@ fs_generator::generate_varying_pull_constant_load(fs_inst *inst, uint32_t surf_index = index.ud; uint32_t simd_mode, rlen, msg_type; - if (dispatch_width == 16) { + if (inst->exec_size == 16) { simd_mode = BRW_SAMPLER_SIMD_MODE_SIMD16; rlen = 8; } else { + assert(inst->exec_size == 8); simd_mode = BRW_SAMPLER_SIMD_MODE_SIMD8; rlen = 4; } @@ -1383,7 +1272,7 @@ fs_generator::generate_varying_pull_constant_load(fs_inst *inst, gen6_resolve_implied_move(p, &header, inst->base_mrf); brw_inst *send = brw_next_insn(p, BRW_OPCODE_SEND); - brw_inst_set_qtr_control(p->devinfo, send, BRW_COMPRESSION_NONE); + brw_inst_set_compression(devinfo, send, false); brw_set_dest(p, send, retype(dst, BRW_REGISTER_TYPE_UW)); brw_set_src0(p, send, header); if (devinfo->gen < 6) @@ -1419,11 +1308,12 @@ fs_generator::generate_varying_pull_constant_load_gen7(fs_inst *inst, assert(index.type == BRW_REGISTER_TYPE_UD); uint32_t simd_mode, rlen, mlen; - if (dispatch_width == 16) { + if (inst->exec_size == 16) { mlen = 2; rlen = 8; simd_mode = BRW_SAMPLER_SIMD_MODE_SIMD16; } else { + assert(inst->exec_size == 8); mlen = 1; rlen = 4; simd_mode = BRW_SAMPLER_SIMD_MODE_SIMD8; @@ -1559,9 +1449,9 @@ fs_generator::generate_set_sample_id(fs_inst *inst, src0.type == BRW_REGISTER_TYPE_UD); struct brw_reg reg = stride(src1, 1, 4, 0); - if (devinfo->gen >= 8 || dispatch_width == 8) { + if (devinfo->gen >= 8 || inst->exec_size == 8) { brw_ADD(p, dst, src0, reg); - } else if (dispatch_width == 16) { + } else if (inst->exec_size == 16) { brw_push_insn_state(p); brw_set_default_exec_size(p, BRW_EXECUTE_8); brw_set_default_compression_control(p, BRW_COMPRESSION_NONE); @@ -1694,8 +1584,6 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) brw_NOP(p); this->dispatch_width = dispatch_width; - if (dispatch_width == 16) - brw_set_default_compression_control(p, BRW_COMPRESSION_COMPRESSED); int start_offset = p->next_insn_offset; int spill_count = 0, fill_count = 0; @@ -1730,36 +1618,27 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) if (unlikely(debug_flag)) annotate(p->devinfo, &annotation, cfg, inst, p->next_insn_offset); - switch (inst->exec_size) { - case 1: - case 2: - case 4: - assert(inst->force_writemask_all); - brw_set_default_compression_control(p, BRW_COMPRESSION_NONE); - break; - case 8: - if (inst->force_sechalf) { - brw_set_default_compression_control(p, BRW_COMPRESSION_2NDHALF); - } else { - brw_set_default_compression_control(p, BRW_COMPRESSION_NONE); - } - break; - case 16: - case 32: - /* If the instruction writes to more than one register, it needs to - * be a "compressed" instruction on Gen <= 5. - */ - if (inst->dst.component_size(inst->exec_size) > REG_SIZE) - brw_set_default_compression_control(p, BRW_COMPRESSION_COMPRESSED); - else - brw_set_default_compression_control(p, BRW_COMPRESSION_NONE); - break; - default: - unreachable("Invalid instruction width"); - } + /* If the instruction writes to more than one register, it needs to be + * explicitly marked as compressed on Gen <= 5. On Gen >= 6 the + * hardware figures out by itself what the right compression mode is, + * but we still need to know whether the instruction is compressed to + * set up the source register regions appropriately. + * + * XXX - This is wrong for instructions that write a single register but + * read more than one which should strictly speaking be treated as + * compressed. For instructions that don't write any registers it + * relies on the destination being a null register of the correct + * type and regioning so the instruction is considered compressed + * or not accordingly. + */ + const bool compressed = + inst->dst.component_size(inst->exec_size) > REG_SIZE; + brw_set_default_compression(p, compressed); + brw_set_default_group(p, inst->group); for (unsigned int i = 0; i < inst->sources; i++) { - src[i] = brw_reg_from_fs_reg(p, inst, &inst->src[i], devinfo->gen); + src[i] = brw_reg_from_fs_reg(inst, &inst->src[i], devinfo->gen, + compressed); /* The accumulator result appears to get used for the * conditional modifier generation. When negating a UD @@ -1771,8 +1650,9 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) inst->src[i].type != BRW_REGISTER_TYPE_UD || !inst->src[i].negate); } - dst = brw_reg_from_fs_reg(p, inst, &inst->dst, devinfo->gen); + dst = brw_reg_from_fs_reg(inst, &inst->dst, devinfo->gen, compressed); + brw_set_default_access_mode(p, BRW_ALIGN_1); brw_set_default_predicate_control(p, inst->predicate); brw_set_default_predicate_inverse(p, inst->predicate_inverse); brw_set_default_flag_reg(p, 0, inst->flag_subreg); @@ -1781,6 +1661,8 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) brw_set_default_acc_write_control(p, inst->writes_accumulator); brw_set_default_exec_size(p, cvt(inst->exec_size) - 1); + assert(inst->force_writemask_all || inst->exec_size >= 4); + assert(inst->force_writemask_all || inst->group % inst->exec_size == 0); assert(inst->base_mrf + inst->mlen <= BRW_MAX_MRF(devinfo->gen)); assert(inst->mlen <= BRW_MAX_MSG_LENGTH); @@ -1808,45 +1690,13 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) case BRW_OPCODE_MAD: assert(devinfo->gen >= 6); brw_set_default_access_mode(p, BRW_ALIGN_16); - if (dispatch_width == 16 && !devinfo->supports_simd16_3src) { - brw_set_default_exec_size(p, BRW_EXECUTE_8); - brw_set_default_compression_control(p, BRW_COMPRESSION_NONE); - brw_inst *f = brw_MAD(p, firsthalf(dst), firsthalf(src[0]), firsthalf(src[1]), firsthalf(src[2])); - brw_set_default_compression_control(p, BRW_COMPRESSION_2NDHALF); - brw_inst *s = brw_MAD(p, sechalf(dst), sechalf(src[0]), sechalf(src[1]), sechalf(src[2])); - brw_set_default_compression_control(p, BRW_COMPRESSION_COMPRESSED); - - if (inst->conditional_mod) { - brw_inst_set_cond_modifier(p->devinfo, f, inst->conditional_mod); - brw_inst_set_cond_modifier(p->devinfo, s, inst->conditional_mod); - multiple_instructions_emitted = true; - } - } else { - brw_MAD(p, dst, src[0], src[1], src[2]); - } - brw_set_default_access_mode(p, BRW_ALIGN_1); + brw_MAD(p, dst, src[0], src[1], src[2]); break; case BRW_OPCODE_LRP: assert(devinfo->gen >= 6); brw_set_default_access_mode(p, BRW_ALIGN_16); - if (dispatch_width == 16 && !devinfo->supports_simd16_3src) { - brw_set_default_exec_size(p, BRW_EXECUTE_8); - brw_set_default_compression_control(p, BRW_COMPRESSION_NONE); - brw_inst *f = brw_LRP(p, firsthalf(dst), firsthalf(src[0]), firsthalf(src[1]), firsthalf(src[2])); - brw_set_default_compression_control(p, BRW_COMPRESSION_2NDHALF); - brw_inst *s = brw_LRP(p, sechalf(dst), sechalf(src[0]), sechalf(src[1]), sechalf(src[2])); - brw_set_default_compression_control(p, BRW_COMPRESSION_COMPRESSED); - - if (inst->conditional_mod) { - brw_inst_set_cond_modifier(p->devinfo, f, inst->conditional_mod); - brw_inst_set_cond_modifier(p->devinfo, s, inst->conditional_mod); - multiple_instructions_emitted = true; - } - } else { - brw_LRP(p, dst, src[0], src[1], src[2]); - } - brw_set_default_access_mode(p, BRW_ALIGN_1); + brw_LRP(p, dst, src[0], src[1], src[2]); break; case BRW_OPCODE_FRC: @@ -1892,43 +1742,17 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) brw_F16TO32(p, dst, src[0]); break; case BRW_OPCODE_CMP: - /* The Ivybridge/BayTrail WaCMPInstFlagDepClearedEarly workaround says - * that when the destination is a GRF that the dependency-clear bit on - * the flag register is cleared early. - * - * Suggested workarounds are to disable coissuing CMP instructions - * or to split CMP(16) instructions into two CMP(8) instructions. - * - * We choose to split into CMP(8) instructions since disabling - * coissuing would affect CMP instructions not otherwise affected by - * the errata. - */ - if (dispatch_width == 16 && devinfo->gen == 7 && !devinfo->is_haswell) { - if (dst.file == BRW_GENERAL_REGISTER_FILE) { - brw_set_default_exec_size(p, BRW_EXECUTE_8); - brw_set_default_compression_control(p, BRW_COMPRESSION_NONE); - brw_CMP(p, firsthalf(dst), inst->conditional_mod, - firsthalf(src[0]), firsthalf(src[1])); - brw_set_default_compression_control(p, BRW_COMPRESSION_2NDHALF); - brw_CMP(p, sechalf(dst), inst->conditional_mod, - sechalf(src[0]), sechalf(src[1])); - brw_set_default_compression_control(p, BRW_COMPRESSION_COMPRESSED); - - multiple_instructions_emitted = true; - } else if (dst.file == BRW_ARCHITECTURE_REGISTER_FILE) { - /* For unknown reasons, the aforementioned workaround is not - * sufficient. Overriding the type when the destination is the - * null register is necessary but not sufficient by itself. - */ - assert(dst.nr == BRW_ARF_NULL); - dst.type = BRW_REGISTER_TYPE_D; - brw_CMP(p, dst, inst->conditional_mod, src[0], src[1]); - } else { - unreachable("not reached"); - } - } else { - brw_CMP(p, dst, inst->conditional_mod, src[0], src[1]); + if (inst->exec_size >= 16 && devinfo->gen == 7 && !devinfo->is_haswell && + dst.file == BRW_ARCHITECTURE_REGISTER_FILE) { + /* For unknown reasons the WaCMPInstFlagDepClearedEarly workaround + * implemented in the compiler is not sufficient. Overriding the + * type when the destination is the null register is necessary but + * not sufficient by itself. + */ + assert(dst.nr == BRW_ARF_NULL); + dst.type = BRW_REGISTER_TYPE_D; } + brw_CMP(p, dst, inst->conditional_mod, src[0], src[1]); break; case BRW_OPCODE_SEL: brw_SEL(p, dst, src[0], src[1]); @@ -1949,6 +1773,9 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) /* FBL only supports UD type for dst. */ brw_FBL(p, retype(dst, BRW_REGISTER_TYPE_UD), src[0]); break; + case BRW_OPCODE_LZD: + brw_LZD(p, dst, src[0]); + break; case BRW_OPCODE_CBIT: assert(devinfo->gen >= 7); /* CBIT only supports UD type for dst. */ @@ -1969,60 +1796,17 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) case BRW_OPCODE_BFE: assert(devinfo->gen >= 7); brw_set_default_access_mode(p, BRW_ALIGN_16); - if (dispatch_width == 16 && !devinfo->supports_simd16_3src) { - brw_set_default_exec_size(p, BRW_EXECUTE_8); - brw_set_default_compression_control(p, BRW_COMPRESSION_NONE); - brw_BFE(p, firsthalf(dst), firsthalf(src[0]), firsthalf(src[1]), firsthalf(src[2])); - brw_set_default_compression_control(p, BRW_COMPRESSION_2NDHALF); - brw_BFE(p, sechalf(dst), sechalf(src[0]), sechalf(src[1]), sechalf(src[2])); - brw_set_default_compression_control(p, BRW_COMPRESSION_COMPRESSED); - } else { - brw_BFE(p, dst, src[0], src[1], src[2]); - } - brw_set_default_access_mode(p, BRW_ALIGN_1); + brw_BFE(p, dst, src[0], src[1], src[2]); break; case BRW_OPCODE_BFI1: assert(devinfo->gen >= 7); - /* The Haswell WaForceSIMD8ForBFIInstruction workaround says that we - * should - * - * "Force BFI instructions to be executed always in SIMD8." - */ - if (dispatch_width == 16 && devinfo->is_haswell) { - brw_set_default_exec_size(p, BRW_EXECUTE_8); - brw_set_default_compression_control(p, BRW_COMPRESSION_NONE); - brw_BFI1(p, firsthalf(dst), firsthalf(src[0]), firsthalf(src[1])); - brw_set_default_compression_control(p, BRW_COMPRESSION_2NDHALF); - brw_BFI1(p, sechalf(dst), sechalf(src[0]), sechalf(src[1])); - brw_set_default_compression_control(p, BRW_COMPRESSION_COMPRESSED); - } else { - brw_BFI1(p, dst, src[0], src[1]); - } + brw_BFI1(p, dst, src[0], src[1]); break; case BRW_OPCODE_BFI2: assert(devinfo->gen >= 7); brw_set_default_access_mode(p, BRW_ALIGN_16); - /* The Haswell WaForceSIMD8ForBFIInstruction workaround says that we - * should - * - * "Force BFI instructions to be executed always in SIMD8." - * - * Otherwise we would be able to emit compressed instructions like we - * do for the other three-source instructions. - */ - if (dispatch_width == 16 && - (devinfo->is_haswell || !devinfo->supports_simd16_3src)) { - brw_set_default_exec_size(p, BRW_EXECUTE_8); - brw_set_default_compression_control(p, BRW_COMPRESSION_NONE); - brw_BFI2(p, firsthalf(dst), firsthalf(src[0]), firsthalf(src[1]), firsthalf(src[2])); - brw_set_default_compression_control(p, BRW_COMPRESSION_2NDHALF); - brw_BFI2(p, sechalf(dst), sechalf(src[0]), sechalf(src[1]), sechalf(src[2])); - brw_set_default_compression_control(p, BRW_COMPRESSION_COMPRESSED); - } else { - brw_BFI2(p, dst, src[0], src[1], src[2]); - } - brw_set_default_access_mode(p, BRW_ALIGN_1); + brw_BFI2(p, dst, src[0], src[1], src[2]); break; case BRW_OPCODE_IF: @@ -2031,7 +1815,7 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) assert(devinfo->gen == 6); gen6_IF(p, inst->conditional_mod, src[0], src[1]); } else { - brw_IF(p, dispatch_width == 16 ? BRW_EXECUTE_16 : BRW_EXECUTE_8); + brw_IF(p, brw_inst_exec_size(devinfo, p->current)); } break; @@ -2043,16 +1827,14 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) break; case BRW_OPCODE_DO: - brw_DO(p, dispatch_width == 16 ? BRW_EXECUTE_16 : BRW_EXECUTE_8); + brw_DO(p, brw_inst_exec_size(devinfo, p->current)); break; case BRW_OPCODE_BREAK: brw_BREAK(p); - brw_set_default_predicate_control(p, BRW_PREDICATE_NONE); break; case BRW_OPCODE_CONTINUE: brw_CONT(p); - brw_set_default_predicate_control(p, BRW_PREDICATE_NONE); break; case BRW_OPCODE_WHILE: @@ -2067,30 +1849,36 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) case SHADER_OPCODE_LOG2: case SHADER_OPCODE_SIN: case SHADER_OPCODE_COS: - assert(devinfo->gen < 6 || inst->mlen == 0); assert(inst->conditional_mod == BRW_CONDITIONAL_NONE); - if (devinfo->gen >= 7) { - gen6_math(p, dst, brw_math_function(inst->opcode), src[0], - brw_null_reg()); - } else if (devinfo->gen == 6) { - generate_math_gen6(inst, dst, src[0], brw_null_reg()); - } else if (devinfo->gen == 5 || devinfo->is_g4x) { - generate_math_g45(inst, dst, src[0]); + if (devinfo->gen >= 6) { + assert(inst->mlen == 0); + assert(devinfo->gen >= 7 || inst->exec_size == 8); + gen6_math(p, dst, brw_math_function(inst->opcode), + src[0], brw_null_reg()); } else { - generate_math_gen4(inst, dst, src[0]); + assert(inst->mlen >= 1); + assert(devinfo->gen == 5 || devinfo->is_g4x || inst->exec_size == 8); + gen4_math(p, dst, + brw_math_function(inst->opcode), + inst->base_mrf, src[0], + BRW_MATH_PRECISION_FULL); } break; case SHADER_OPCODE_INT_QUOTIENT: case SHADER_OPCODE_INT_REMAINDER: case SHADER_OPCODE_POW: - assert(devinfo->gen < 6 || inst->mlen == 0); assert(inst->conditional_mod == BRW_CONDITIONAL_NONE); - if (devinfo->gen >= 7 && inst->opcode == SHADER_OPCODE_POW) { + if (devinfo->gen >= 6) { + assert(inst->mlen == 0); + assert((devinfo->gen >= 7 && inst->opcode == SHADER_OPCODE_POW) || + inst->exec_size == 8); gen6_math(p, dst, brw_math_function(inst->opcode), src[0], src[1]); - } else if (devinfo->gen >= 6) { - generate_math_gen6(inst, dst, src[0], src[1]); - } else { - generate_math_gen4(inst, dst, src[0]); + } else { + assert(inst->mlen >= 1); + assert(inst->exec_size == 8); + gen4_math(p, dst, brw_math_function(inst->opcode), + inst->base_mrf, src[0], + BRW_MATH_PRECISION_FULL); } break; case FS_OPCODE_CINTERP: @@ -2180,8 +1968,8 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) generate_uniform_pull_constant_load_gen7(inst, dst, src[0], src[1]); break; - case FS_OPCODE_VARYING_PULL_CONSTANT_LOAD: - generate_varying_pull_constant_load(inst, dst, src[0]); + case FS_OPCODE_VARYING_PULL_CONSTANT_LOAD_GEN4: + generate_varying_pull_constant_load_gen4(inst, dst, src[0]); break; case FS_OPCODE_VARYING_PULL_CONSTANT_LOAD_GEN7: @@ -2193,6 +1981,10 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) generate_fb_write(inst, src[0]); break; + case FS_OPCODE_FB_READ: + generate_fb_read(inst, dst, src[0]); + break; + case FS_OPCODE_MOV_DISPATCH_TO_FLAGS: generate_mov_dispatch_to_flags(inst); break; @@ -2253,31 +2045,10 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) break; case SHADER_OPCODE_BROADCAST: + assert(inst->force_writemask_all); brw_broadcast(p, dst, src[0], src[1]); break; - case SHADER_OPCODE_EXTRACT_BYTE: { - assert(src[0].type == BRW_REGISTER_TYPE_D || - src[0].type == BRW_REGISTER_TYPE_UD); - - enum brw_reg_type type = - src[0].type == BRW_REGISTER_TYPE_D ? BRW_REGISTER_TYPE_B - : BRW_REGISTER_TYPE_UB; - brw_MOV(p, dst, spread(suboffset(retype(src[0], type), src[1].ud), 4)); - break; - } - - case SHADER_OPCODE_EXTRACT_WORD: { - assert(src[0].type == BRW_REGISTER_TYPE_D || - src[0].type == BRW_REGISTER_TYPE_UD); - - enum brw_reg_type type = - src[0].type == BRW_REGISTER_TYPE_D ? BRW_REGISTER_TYPE_W - : BRW_REGISTER_TYPE_UW; - brw_MOV(p, dst, spread(suboffset(retype(src[0], type), src[1].ud), 2)); - break; - } - case FS_OPCODE_SET_SAMPLE_ID: generate_set_sample_id(inst, dst, src[0], src[1]); break; @@ -2302,11 +2073,6 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) } break; - case FS_OPCODE_INTERPOLATE_AT_CENTROID: - generate_pixel_interpolator_query(inst, dst, src[0], src[1], - GEN7_PIXEL_INTERPOLATOR_LOC_CENTROID); - break; - case FS_OPCODE_INTERPOLATE_AT_SAMPLE: generate_pixel_interpolator_query(inst, dst, src[0], src[1], GEN7_PIXEL_INTERPOLATOR_LOC_SAMPLE); @@ -2330,8 +2096,11 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) generate_barrier(inst, src[0]); break; - case FS_OPCODE_PACK_STENCIL_REF: - generate_stencil_ref_packing(inst, dst, src[0]); + case BRW_OPCODE_DIM: + assert(devinfo->is_haswell); + assert(src[0].type == BRW_REGISTER_TYPE_DF); + assert(dst.type == BRW_REGISTER_TYPE_DF); + brw_DIM(p, dst, retype(src[0], BRW_REGISTER_TYPE_F)); break; default: @@ -2358,7 +2127,7 @@ fs_generator::generate_code(const cfg_t *cfg, int dispatch_width) } } - brw_set_uip_jip(p); + brw_set_uip_jip(p, start_offset); annotation_finalize(&annotation, p->next_insn_offset); #ifndef NDEBUG