1 /* -*- mesa-c++ -*- 2 * 3 * Copyright (c) 2019 Collabora LTD 4 * 5 * Author: Gert Wollny <gert.wollny@collabora.com> 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * on the rights to use, copy, modify, merge, publish, distribute, sub 11 * license, and/or sell copies of the Software, and to permit persons to whom 12 * the Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the next 15 * paragraph) shall be included in all copies or substantial portions of the 16 * Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 21 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, 22 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 23 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 24 * USE OR OTHER DEALINGS IN THE SOFTWARE. 25 */ 26 27 #ifndef sfn_shader_from_nir_h 28 #define sfn_shader_from_nir_h 29 30 31 #include "gallium/drivers/r600/r600_shader.h" 32 33 #include "compiler/nir/nir.h" 34 #include "compiler/nir_types.h" 35 36 #include "sfn_instruction_block.h" 37 #include "sfn_instruction_export.h" 38 #include "sfn_alu_defines.h" 39 #include "sfn_valuepool.h" 40 #include "sfn_debug.h" 41 #include "sfn_instruction_cf.h" 42 #include "sfn_emittexinstruction.h" 43 #include "sfn_emitaluinstruction.h" 44 #include "sfn_emitssboinstruction.h" 45 46 #include <vector> 47 #include <set> 48 #include <stack> 49 #include <unordered_map> 50 51 struct nir_instr; 52 53 namespace r600 { 54 55 extern SfnLog sfn_log; 56 57 class ShaderFromNirProcessor : public ValuePool { 58 public: 59 ShaderFromNirProcessor(pipe_shader_type ptype, r600_pipe_shader_selector& sel, 60 r600_shader& sh_info, int scratch_size, enum chip_class _chip_class, 61 int atomic_base); 62 virtual ~ShaderFromNirProcessor(); 63 64 void emit_instruction(Instruction *ir); 65 66 PValue from_nir_with_fetch_constant(const nir_src& src, unsigned component, int channel = -1); 67 GPRVector vec_from_nir_with_fetch_constant(const nir_src& src, unsigned mask, 68 const GPRVector::Swizzle& swizzle, bool match = false); 69 70 bool emit_instruction(EAluOp opcode, PValue dest, 71 std::vector<PValue> src0, 72 const std::set<AluModifiers>& m_flags); 73 void emit_export_instruction(WriteoutInstruction *ir); 74 void emit_instruction(AluInstruction *ir); 75 76 void split_constants(nir_alu_instr* instr); 77 void remap_registers(); 78 79 const nir_variable *get_deref_location(const nir_src& src) const; 80 sh_info()81 r600_shader& sh_info() {return m_sh_info;} 82 void add_param_output_reg(int loc, const GPRVector *gpr); 83 void set_output(unsigned pos, int sel); 84 const GPRVector *output_register(unsigned location) const; 85 void evaluate_spi_sid(r600_shader_io &io); 86 87 enum chip_class get_chip_class() const; 88 remap_atomic_base(int base)89 int remap_atomic_base(int base) { 90 return m_atomic_base_map[base]; 91 } 92 93 protected: 94 95 void set_var_address(nir_deref_instr *instr); 96 void set_input(unsigned pos, PValue var); 97 98 bool scan_instruction(nir_instr *instr); 99 100 virtual bool scan_sysvalue_access(nir_instr *instr) = 0; 101 102 bool emit_if_start(int if_id, nir_if *if_stmt); 103 bool emit_else_start(int if_id); 104 bool emit_ifelse_end(int if_id); 105 106 bool emit_loop_start(int loop_id); 107 bool emit_loop_end(int loop_id); 108 bool emit_jump_instruction(nir_jump_instr *instr); 109 110 bool emit_load_tcs_param_base(nir_intrinsic_instr* instr, int offset); 111 bool emit_load_local_shared(nir_intrinsic_instr* instr); 112 bool emit_store_local_shared(nir_intrinsic_instr* instr); 113 bool emit_atomic_local_shared(nir_intrinsic_instr* instr); 114 115 bool emit_barrier(nir_intrinsic_instr* instr); 116 117 bool load_preloaded_value(const nir_dest& dest, int chan, PValue value, 118 bool as_last = true); 119 120 void inc_atomic_file_count(); 121 122 enum ESlots { 123 es_face, 124 es_instanceid, 125 es_invocation_id, 126 es_patch_id, 127 es_pos, 128 es_rel_patch_id, 129 es_sample_mask_in, 130 es_sample_id, 131 es_sample_pos, 132 es_tess_factor_base, 133 es_vertexid, 134 es_tess_coord, 135 es_primitive_id, 136 es_helper_invocation, 137 es_last 138 }; 139 140 std::bitset<es_last> m_sv_values; 141 142 bool allocate_reserved_registers(); 143 144 145 private: 146 virtual bool do_allocate_reserved_registers() = 0; 147 148 149 void emit_instruction_internal(Instruction *ir); 150 151 bool emit_alu_instruction(nir_instr *instr); 152 bool emit_deref_instruction(nir_deref_instr* instr); 153 bool emit_intrinsic_instruction(nir_intrinsic_instr* instr); 154 virtual bool emit_intrinsic_instruction_override(nir_intrinsic_instr* instr); 155 bool emit_tex_instruction(nir_instr* instr); 156 bool emit_discard_if(nir_intrinsic_instr* instr); 157 bool emit_load_ubo_vec4(nir_intrinsic_instr* instr); 158 bool emit_ssbo_atomic_add(nir_intrinsic_instr* instr); 159 bool load_uniform_indirect(nir_intrinsic_instr* instr, PValue addr, int offest, int bufid); 160 161 /* Code creating functions */ 162 bool emit_load_input_deref(const nir_variable *var, nir_intrinsic_instr* instr); 163 bool emit_load_function_temp(const nir_variable *var, nir_intrinsic_instr *instr); 164 AluInstruction *emit_load_literal(const nir_load_const_instr *literal, const nir_src& src, unsigned writemask); 165 166 bool emit_store_deref(nir_intrinsic_instr* instr); 167 168 bool load_uniform(nir_intrinsic_instr* instr); 169 bool process_uniforms(nir_variable *uniform); 170 bool process_inputs(nir_variable *input); 171 bool process_outputs(nir_variable *output); 172 173 void add_array_deref(nir_deref_instr* instr); 174 175 void append_block(int nesting_change); 176 177 virtual void emit_shader_start(); 178 virtual bool emit_deref_instruction_override(nir_deref_instr* instr); 179 virtual bool do_process_inputs(nir_variable *input) = 0; 180 virtual bool do_process_outputs(nir_variable *output) = 0; 181 virtual bool do_emit_load_deref(const nir_variable *in_var, nir_intrinsic_instr* instr) = 0; 182 virtual bool do_emit_store_deref(const nir_variable *out_var, nir_intrinsic_instr* instr) = 0; 183 184 185 bool emit_store_scratch(nir_intrinsic_instr* instr); 186 bool emit_load_scratch(nir_intrinsic_instr* instr); 187 virtual void do_finalize() = 0; 188 189 void finalize(); 190 friend class ShaderFromNir; 191 192 std::set<nir_variable*> m_arrays; 193 194 std::map<unsigned, PValue> m_inputs; 195 std::map<unsigned, int> m_outputs; 196 197 std::map<unsigned, nir_variable*> m_var_derefs; 198 std::map<const nir_variable *, nir_variable_mode> m_var_mode; 199 200 std::map<unsigned, const glsl_type*> m_uniform_type_map; 201 std::map<int, IfElseInstruction *> m_if_block_start_map; 202 std::map<int, LoopBeginInstruction *> m_loop_begin_block_map; 203 204 pipe_shader_type m_processor_type; 205 206 std::vector<InstructionBlock> m_output; 207 unsigned m_nesting_depth; 208 unsigned m_block_number; 209 InstructionBlock m_export_output; 210 r600_shader& m_sh_info; 211 enum chip_class m_chip_class; 212 EmitTexInstruction m_tex_instr; 213 EmitAluInstruction m_alu_instr; 214 EmitSSBOInstruction m_ssbo_instr; 215 OutputRegisterMap m_output_register_map; 216 217 IfElseInstruction *m_pending_else; 218 int m_scratch_size; 219 int m_next_hwatomic_loc; 220 221 r600_pipe_shader_selector& m_sel; 222 int m_atomic_base ; 223 int m_image_count; 224 225 std::unordered_map<int, int> m_atomic_base_map; 226 AluInstruction *last_emitted_alu; 227 }; 228 229 } 230 231 #endif 232