1 /* 2 * Copyright © 2011 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 21 * IN THE SOFTWARE. 22 */ 23 24 #ifndef BRW_VEC4_H 25 #define BRW_VEC4_H 26 27 #include "brw_shader.h" 28 29 #ifdef __cplusplus 30 #include "brw_ir_vec4.h" 31 #include "brw_vec4_builder.h" 32 #endif 33 34 #include "compiler/glsl/ir.h" 35 #include "compiler/nir/nir.h" 36 37 38 #ifdef __cplusplus 39 extern "C" { 40 #endif 41 42 const unsigned * 43 brw_vec4_generate_assembly(const struct brw_compiler *compiler, 44 void *log_data, 45 void *mem_ctx, 46 const nir_shader *nir, 47 struct brw_vue_prog_data *prog_data, 48 const struct cfg_t *cfg, 49 unsigned *out_assembly_size); 50 51 #ifdef __cplusplus 52 } /* extern "C" */ 53 54 namespace brw { 55 56 class vec4_live_variables; 57 58 /** 59 * The vertex shader front-end. 60 * 61 * Translates either GLSL IR or Mesa IR (for ARB_vertex_program and 62 * fixed-function) into VS IR. 63 */ 64 class vec4_visitor : public backend_shader 65 { 66 public: 67 vec4_visitor(const struct brw_compiler *compiler, 68 void *log_data, 69 const struct brw_sampler_prog_key_data *key, 70 struct brw_vue_prog_data *prog_data, 71 const nir_shader *shader, 72 void *mem_ctx, 73 bool no_spills, 74 int shader_time_index); 75 dst_null_f()76 dst_reg dst_null_f() 77 { 78 return dst_reg(brw_null_reg()); 79 } 80 dst_null_df()81 dst_reg dst_null_df() 82 { 83 return dst_reg(retype(brw_null_reg(), BRW_REGISTER_TYPE_DF)); 84 } 85 dst_null_d()86 dst_reg dst_null_d() 87 { 88 return dst_reg(retype(brw_null_reg(), BRW_REGISTER_TYPE_D)); 89 } 90 dst_null_ud()91 dst_reg dst_null_ud() 92 { 93 return dst_reg(retype(brw_null_reg(), BRW_REGISTER_TYPE_UD)); 94 } 95 96 const struct brw_sampler_prog_key_data * const key_tex; 97 struct brw_vue_prog_data * const prog_data; 98 char *fail_msg; 99 bool failed; 100 101 /** 102 * GLSL IR currently being processed, which is associated with our 103 * driver IR instructions for debugging purposes. 104 */ 105 const void *base_ir; 106 const char *current_annotation; 107 108 int first_non_payload_grf; 109 unsigned int max_grf; 110 int *virtual_grf_start; 111 int *virtual_grf_end; 112 brw::vec4_live_variables *live_intervals; 113 dst_reg userplane[MAX_CLIP_PLANES]; 114 115 bool need_all_constants_in_pull_buffer; 116 117 /* Regs for vertex results. Generated at ir_variable visiting time 118 * for the ir->location's used. 119 */ 120 dst_reg output_reg[VARYING_SLOT_TESS_MAX][4]; 121 unsigned output_num_components[VARYING_SLOT_TESS_MAX][4]; 122 const char *output_reg_annotation[VARYING_SLOT_TESS_MAX]; 123 int uniforms; 124 125 src_reg shader_start_time; 126 127 bool run(); 128 void fail(const char *msg, ...); 129 130 int setup_uniforms(int payload_reg); 131 132 bool reg_allocate_trivial(); 133 bool reg_allocate(); 134 void evaluate_spill_costs(float *spill_costs, bool *no_spill); 135 int choose_spill_reg(struct ra_graph *g); 136 void spill_reg(int spill_reg); 137 void move_grf_array_access_to_scratch(); 138 void move_uniform_array_access_to_pull_constants(); 139 void move_push_constants_to_pull_constants(); 140 void split_uniform_registers(); 141 void pack_uniform_registers(); 142 void calculate_live_intervals(); 143 void invalidate_live_intervals(); 144 void split_virtual_grfs(); 145 bool opt_vector_float(); 146 bool opt_reduce_swizzle(); 147 bool dead_code_eliminate(); 148 int var_range_start(unsigned v, unsigned n) const; 149 int var_range_end(unsigned v, unsigned n) const; 150 bool virtual_grf_interferes(int a, int b); 151 bool opt_cmod_propagation(); 152 bool opt_copy_propagation(bool do_constant_prop = true); 153 bool opt_cse_local(bblock_t *block); 154 bool opt_cse(); 155 bool opt_algebraic(); 156 bool opt_register_coalesce(); 157 bool eliminate_find_live_channel(); 158 bool is_dep_ctrl_unsafe(const vec4_instruction *inst); 159 void opt_set_dependency_control(); 160 void opt_schedule_instructions(); 161 void convert_to_hw_regs(); 162 void fixup_3src_null_dest(); 163 164 bool is_supported_64bit_region(vec4_instruction *inst, unsigned arg); 165 bool lower_simd_width(); 166 bool scalarize_df(); 167 bool lower_64bit_mad_to_mul_add(); 168 void apply_logical_swizzle(struct brw_reg *hw_reg, 169 vec4_instruction *inst, int arg); 170 171 vec4_instruction *emit(vec4_instruction *inst); 172 173 vec4_instruction *emit(enum opcode opcode); 174 vec4_instruction *emit(enum opcode opcode, const dst_reg &dst); 175 vec4_instruction *emit(enum opcode opcode, const dst_reg &dst, 176 const src_reg &src0); 177 vec4_instruction *emit(enum opcode opcode, const dst_reg &dst, 178 const src_reg &src0, const src_reg &src1); 179 vec4_instruction *emit(enum opcode opcode, const dst_reg &dst, 180 const src_reg &src0, const src_reg &src1, 181 const src_reg &src2); 182 183 vec4_instruction *emit_before(bblock_t *block, 184 vec4_instruction *inst, 185 vec4_instruction *new_inst); 186 187 #define EMIT1(op) vec4_instruction *op(const dst_reg &, const src_reg &); 188 #define EMIT2(op) vec4_instruction *op(const dst_reg &, const src_reg &, const src_reg &); 189 #define EMIT3(op) vec4_instruction *op(const dst_reg &, const src_reg &, const src_reg &, const src_reg &); 190 EMIT1(MOV) 191 EMIT1(NOT) 192 EMIT1(RNDD) 193 EMIT1(RNDE) 194 EMIT1(RNDZ) 195 EMIT1(FRC) 196 EMIT1(F32TO16) 197 EMIT1(F16TO32) 198 EMIT2(ADD) 199 EMIT2(MUL) 200 EMIT2(MACH) 201 EMIT2(MAC) 202 EMIT2(AND) 203 EMIT2(OR) 204 EMIT2(XOR) 205 EMIT2(DP3) 206 EMIT2(DP4) 207 EMIT2(DPH) 208 EMIT2(SHL) 209 EMIT2(SHR) 210 EMIT2(ASR) 211 vec4_instruction *CMP(dst_reg dst, src_reg src0, src_reg src1, 212 enum brw_conditional_mod condition); 213 vec4_instruction *IF(src_reg src0, src_reg src1, 214 enum brw_conditional_mod condition); 215 vec4_instruction *IF(enum brw_predicate predicate); 216 EMIT1(SCRATCH_READ) 217 EMIT2(SCRATCH_WRITE) 218 EMIT3(LRP) 219 EMIT1(BFREV) 220 EMIT3(BFE) 221 EMIT2(BFI1) 222 EMIT3(BFI2) 223 EMIT1(FBH) 224 EMIT1(FBL) 225 EMIT1(CBIT) 226 EMIT3(MAD) 227 EMIT2(ADDC) 228 EMIT2(SUBB) 229 EMIT1(DIM) 230 231 #undef EMIT1 232 #undef EMIT2 233 #undef EMIT3 234 235 int implied_mrf_writes(vec4_instruction *inst); 236 237 vec4_instruction *emit_minmax(enum brw_conditional_mod conditionalmod, dst_reg dst, 238 src_reg src0, src_reg src1); 239 240 vec4_instruction *emit_lrp(const dst_reg &dst, const src_reg &x, 241 const src_reg &y, const src_reg &a); 242 243 /** 244 * Copy any live channel from \p src to the first channel of the 245 * result. 246 */ 247 src_reg emit_uniformize(const src_reg &src); 248 249 src_reg fix_3src_operand(const src_reg &src); 250 src_reg resolve_source_modifiers(const src_reg &src); 251 252 vec4_instruction *emit_math(enum opcode opcode, const dst_reg &dst, const src_reg &src0, 253 const src_reg &src1 = src_reg()); 254 255 src_reg fix_math_operand(const src_reg &src); 256 257 void emit_pack_half_2x16(dst_reg dst, src_reg src0); 258 void emit_unpack_half_2x16(dst_reg dst, src_reg src0); 259 void emit_unpack_unorm_4x8(const dst_reg &dst, src_reg src0); 260 void emit_unpack_snorm_4x8(const dst_reg &dst, src_reg src0); 261 void emit_pack_unorm_4x8(const dst_reg &dst, const src_reg &src0); 262 void emit_pack_snorm_4x8(const dst_reg &dst, const src_reg &src0); 263 264 void emit_texture(ir_texture_opcode op, 265 dst_reg dest, 266 const glsl_type *dest_type, 267 src_reg coordinate, 268 int coord_components, 269 src_reg shadow_comparator, 270 src_reg lod, src_reg lod2, 271 src_reg sample_index, 272 uint32_t constant_offset, 273 src_reg offset_value, 274 src_reg mcs, 275 uint32_t surface, src_reg surface_reg, 276 src_reg sampler_reg); 277 278 src_reg emit_mcs_fetch(const glsl_type *coordinate_type, src_reg coordinate, 279 src_reg surface); 280 void emit_gen6_gather_wa(uint8_t wa, dst_reg dst); 281 282 void emit_ndc_computation(); 283 void emit_psiz_and_flags(dst_reg reg); 284 vec4_instruction *emit_generic_urb_slot(dst_reg reg, int varying, int comp); 285 virtual void emit_urb_slot(dst_reg reg, int varying); 286 287 void emit_shader_time_begin(); 288 void emit_shader_time_end(); 289 void emit_shader_time_write(int shader_time_subindex, src_reg value); 290 291 src_reg get_scratch_offset(bblock_t *block, vec4_instruction *inst, 292 src_reg *reladdr, int reg_offset); 293 void emit_scratch_read(bblock_t *block, vec4_instruction *inst, 294 dst_reg dst, 295 src_reg orig_src, 296 int base_offset); 297 void emit_scratch_write(bblock_t *block, vec4_instruction *inst, 298 int base_offset); 299 void emit_pull_constant_load(bblock_t *block, vec4_instruction *inst, 300 dst_reg dst, 301 src_reg orig_src, 302 int base_offset, 303 src_reg indirect); 304 void emit_pull_constant_load_reg(dst_reg dst, 305 src_reg surf_index, 306 src_reg offset, 307 bblock_t *before_block, 308 vec4_instruction *before_inst); 309 src_reg emit_resolve_reladdr(int scratch_loc[], bblock_t *block, 310 vec4_instruction *inst, src_reg src); 311 312 void resolve_ud_negate(src_reg *reg); 313 314 bool lower_minmax(); 315 316 src_reg get_timestamp(); 317 318 void dump_instruction(backend_instruction *inst); 319 void dump_instruction(backend_instruction *inst, FILE *file); 320 321 bool is_high_sampler(src_reg sampler); 322 323 bool optimize_predicate(nir_alu_instr *instr, enum brw_predicate *predicate); 324 325 void emit_conversion_from_double(dst_reg dst, src_reg src, bool saturate); 326 void emit_conversion_to_double(dst_reg dst, src_reg src, bool saturate); 327 328 vec4_instruction *shuffle_64bit_data(dst_reg dst, src_reg src, 329 bool for_write, 330 bblock_t *block = NULL, 331 vec4_instruction *ref = NULL); 332 333 virtual void emit_nir_code(); 334 virtual void nir_setup_uniforms(); 335 virtual void nir_emit_impl(nir_function_impl *impl); 336 virtual void nir_emit_cf_list(exec_list *list); 337 virtual void nir_emit_if(nir_if *if_stmt); 338 virtual void nir_emit_loop(nir_loop *loop); 339 virtual void nir_emit_block(nir_block *block); 340 virtual void nir_emit_instr(nir_instr *instr); 341 virtual void nir_emit_load_const(nir_load_const_instr *instr); 342 virtual void nir_emit_intrinsic(nir_intrinsic_instr *instr); 343 virtual void nir_emit_alu(nir_alu_instr *instr); 344 virtual void nir_emit_jump(nir_jump_instr *instr); 345 virtual void nir_emit_texture(nir_tex_instr *instr); 346 virtual void nir_emit_undef(nir_ssa_undef_instr *instr); 347 virtual void nir_emit_ssbo_atomic(int op, nir_intrinsic_instr *instr); 348 349 dst_reg get_nir_dest(const nir_dest &dest, enum brw_reg_type type); 350 dst_reg get_nir_dest(const nir_dest &dest, nir_alu_type type); 351 dst_reg get_nir_dest(const nir_dest &dest); 352 src_reg get_nir_src(const nir_src &src, enum brw_reg_type type, 353 unsigned num_components = 4); 354 src_reg get_nir_src(const nir_src &src, nir_alu_type type, 355 unsigned num_components = 4); 356 src_reg get_nir_src(const nir_src &src, 357 unsigned num_components = 4); 358 src_reg get_indirect_offset(nir_intrinsic_instr *instr); 359 360 dst_reg *nir_locals; 361 dst_reg *nir_ssa_values; 362 363 protected: 364 void emit_vertex(); 365 void setup_payload_interference(struct ra_graph *g, int first_payload_node, 366 int reg_node_count); 367 virtual void setup_payload() = 0; 368 virtual void emit_prolog() = 0; 369 virtual void emit_thread_end() = 0; 370 virtual void emit_urb_write_header(int mrf) = 0; 371 virtual vec4_instruction *emit_urb_write_opcode(bool complete) = 0; 372 virtual void gs_emit_vertex(int stream_id); 373 virtual void gs_end_primitive(); 374 375 private: 376 /** 377 * If true, then register allocation should fail instead of spilling. 378 */ 379 const bool no_spills; 380 381 int shader_time_index; 382 383 unsigned last_scratch; /**< measured in 32-byte (register size) units */ 384 }; 385 386 } /* namespace brw */ 387 #endif /* __cplusplus */ 388 389 #endif /* BRW_VEC4_H */ 390