3 * Copyright (c) 2018 Collabora LTD
5 * Author: Gert Wollny <gert.wollny@collabora.com>
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:
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
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.
27 #include "tgsi/tgsi_from_mesa.h"
28 #include "sfn_shader_geometry.h"
29 #include "sfn_instruction_misc.h"
30 #include "sfn_instruction_fetch.h"
34 GeometryShaderFromNir::GeometryShaderFromNir(r600_pipe_shader
*sh
,
35 r600_pipe_shader_selector
&sel
,
36 const r600_shader_key
&key
):
37 VertexStage(PIPE_SHADER_GEOMETRY
, sel
, sh
->shader
,
38 sh
->scratch_space_needed
),
41 m_first_vertex_emitted(false),
43 m_next_input_ring_offset(0),
47 m_gs_tri_strip_adj_fix(false)
49 sh_info().atomic_base
= key
.gs
.first_atomic_counter
;
52 bool GeometryShaderFromNir::do_emit_load_deref(UNUSED
const nir_variable
*in_var
, UNUSED nir_intrinsic_instr
* instr
)
57 bool GeometryShaderFromNir::do_emit_store_deref(const nir_variable
*out_var
, nir_intrinsic_instr
* instr
)
59 uint32_t write_mask
= (1 << instr
->num_components
) - 1;
60 GPRVector::Swizzle swz
= swizzle_from_mask(instr
->num_components
);
61 std::unique_ptr
<GPRVector
> vec(vec_from_nir_with_fetch_constant(instr
->src
[1], write_mask
, swz
));
63 GPRVector out_value
= *vec
;
65 sh_info().output
[out_var
->data
.driver_location
].write_mask
=
66 (1 << instr
->num_components
) - 1;
68 auto ir
= new MemRingOutIntruction(cf_mem_ring
, mem_write_ind
, out_value
,
69 4 * out_var
->data
.driver_location
,
76 bool GeometryShaderFromNir::scan_sysvalue_access(UNUSED nir_instr
*instr
)
81 bool GeometryShaderFromNir::do_process_inputs(nir_variable
*input
)
84 if (input
->data
.location
== VARYING_SLOT_POS
||
85 input
->data
.location
== VARYING_SLOT_PSIZ
||
86 input
->data
.location
== VARYING_SLOT_CLIP_VERTEX
||
87 input
->data
.location
== VARYING_SLOT_CLIP_DIST0
||
88 input
->data
.location
== VARYING_SLOT_CLIP_DIST1
||
89 input
->data
.location
== VARYING_SLOT_COL0
||
90 input
->data
.location
== VARYING_SLOT_COL1
||
91 (input
->data
.location
>= VARYING_SLOT_VAR0
&&
92 input
->data
.location
<= VARYING_SLOT_VAR31
) ||
93 (input
->data
.location
>= VARYING_SLOT_TEX0
&&
94 input
->data
.location
<= VARYING_SLOT_TEX7
)) {
96 r600_shader_io
& io
= sh_info().input
[input
->data
.driver_location
];
97 tgsi_get_gl_varying_semantic(static_cast<gl_varying_slot
>( input
->data
.location
),
98 true, &io
.name
, &io
.sid
);
99 io
.ring_offset
= 16 * input
->data
.driver_location
;
101 m_next_input_ring_offset
+= 16;
108 bool GeometryShaderFromNir::do_process_outputs(nir_variable
*output
)
110 if (output
->data
.location
== VARYING_SLOT_COL0
||
111 output
->data
.location
== VARYING_SLOT_COL1
||
112 (output
->data
.location
>= VARYING_SLOT_VAR0
&&
113 output
->data
.location
<= VARYING_SLOT_VAR31
) ||
114 (output
->data
.location
>= VARYING_SLOT_TEX0
&&
115 output
->data
.location
<= VARYING_SLOT_TEX7
) ||
116 output
->data
.location
== VARYING_SLOT_BFC0
||
117 output
->data
.location
== VARYING_SLOT_BFC1
||
118 output
->data
.location
== VARYING_SLOT_CLIP_VERTEX
||
119 output
->data
.location
== VARYING_SLOT_CLIP_DIST0
||
120 output
->data
.location
== VARYING_SLOT_CLIP_DIST1
||
121 output
->data
.location
== VARYING_SLOT_PRIMITIVE_ID
||
122 output
->data
.location
== VARYING_SLOT_POS
||
123 output
->data
.location
== VARYING_SLOT_PSIZ
||
124 output
->data
.location
== VARYING_SLOT_LAYER
||
125 output
->data
.location
== VARYING_SLOT_VIEWPORT
||
126 output
->data
.location
== VARYING_SLOT_FOGC
) {
127 r600_shader_io
& io
= sh_info().output
[output
->data
.driver_location
];
129 tgsi_get_gl_varying_semantic(static_cast<gl_varying_slot
>( output
->data
.location
),
130 true, &io
.name
, &io
.sid
);
131 evaluate_spi_sid(io
);
134 if (output
->data
.location
== VARYING_SLOT_CLIP_DIST0
||
135 output
->data
.location
== VARYING_SLOT_CLIP_DIST1
) {
136 m_num_clip_dist
+= 4;
144 bool GeometryShaderFromNir::allocate_reserved_registers()
146 const int sel
[6] = {0, 0 ,0, 1, 1, 1};
147 const int chan
[6] = {0, 1 ,3, 0, 1, 2};
149 increment_reserved_registers();
150 increment_reserved_registers();
152 /* Reserve registers used by the shaders (should check how many
153 * components are actually used */
154 for (int i
= 0; i
< 6; ++i
) {
155 auto reg
= new GPRValue(sel
[i
], chan
[i
]);
157 m_per_vertex_offsets
[i
].reset(reg
);
158 inject_register(sel
[i
], chan
[i
], m_per_vertex_offsets
[i
], false);
160 auto reg
= new GPRValue(0, 2);
162 m_primitive_id
.reset(reg
);
163 inject_register(0, 2, m_primitive_id
, false);
165 reg
= new GPRValue(1, 3);
167 m_invocation_id
.reset(reg
);
168 inject_register(1, 3, m_invocation_id
, false);
170 m_export_base
= get_temp_register();
171 emit_instruction(new AluInstruction(op1_mov
, m_export_base
, Value::zero
, {alu_write
, alu_last_instr
}));
173 sh_info().ring_item_sizes
[0] = m_next_input_ring_offset
;
175 if (m_key
.gs
.tri_strip_adj_fix
)
181 void GeometryShaderFromNir::emit_adj_fix()
183 PValue
adjhelp0(new GPRValue(m_export_base
->sel(), 1));
184 emit_instruction(op2_and_int
, adjhelp0
, {m_primitive_id
, Value::one_i
}, {alu_write
, alu_last_instr
});
186 int help2
= allocate_temp_register();
188 int reg_chanels
[6] = {0, 1, 2, 3, 2, 3};
190 int rotate_indices
[6] = {4, 5, 0, 1, 2, 3};
192 reg_indices
[0] = reg_indices
[1] = reg_indices
[2] = reg_indices
[3] = help2
;
193 reg_indices
[4] = reg_indices
[5] = m_export_base
->sel();
195 std::array
<PValue
, 6> adjhelp
;
197 AluInstruction
*ir
= nullptr;
198 for (int i
= 0; i
< 6; i
++) {
199 adjhelp
[i
].reset(new GPRValue(reg_indices
[i
], reg_chanels
[i
]));
200 ir
= new AluInstruction(op3_cnde_int
, adjhelp
[i
],
201 {adjhelp0
, m_per_vertex_offsets
[i
],
202 m_per_vertex_offsets
[rotate_indices
[i
]]},
205 ir
->set_flag(alu_last_instr
);
206 emit_instruction(ir
);
208 ir
->set_flag(alu_last_instr
);
210 for (int i
= 0; i
< 6; i
++)
211 m_per_vertex_offsets
[i
] = adjhelp
[i
];
214 bool GeometryShaderFromNir::emit_deref_instruction_override(nir_deref_instr
* instr
)
216 if (instr
->deref_type
== nir_deref_type_array
) {
217 auto var
= get_deref_location(instr
->parent
);
218 ArrayDeref ad
= {var
, &instr
->arr
.index
};
219 assert(instr
->dest
.is_ssa
);
220 m_in_array_deref
[instr
->dest
.ssa
.index
] = ad
;
222 /* Problem: nir_intrinsice_load_deref tries to lookup the
223 * variable, and will not find it, need to override that too */
229 bool GeometryShaderFromNir::emit_intrinsic_instruction_override(nir_intrinsic_instr
* instr
)
231 switch (instr
->intrinsic
) {
232 case nir_intrinsic_load_deref
: {
233 auto& src
= instr
->src
[0];
235 auto array
= m_in_array_deref
.find(src
.ssa
->index
);
236 if (array
!= m_in_array_deref
.end())
237 return emit_load_from_array(instr
, array
->second
);
239 case nir_intrinsic_emit_vertex
:
240 return emit_vertex(instr
, false);
241 case nir_intrinsic_end_primitive
:
242 return emit_vertex(instr
, true);
243 case nir_intrinsic_load_primitive_id
:
244 return load_preloaded_value(instr
->dest
, 0, m_primitive_id
);
245 case nir_intrinsic_load_invocation_id
:
246 return load_preloaded_value(instr
->dest
, 0, m_invocation_id
);
253 bool GeometryShaderFromNir::emit_vertex(nir_intrinsic_instr
* instr
, bool cut
)
255 int stream
= nir_intrinsic_stream_id(instr
);
258 emit_instruction(new EmitVertex(stream
, cut
));
261 emit_instruction(new AluInstruction(op2_add_int
, m_export_base
, m_export_base
,
262 PValue(new LiteralValue(sh_info().noutput
)),
263 {alu_write
, alu_last_instr
}));
268 bool GeometryShaderFromNir::emit_load_from_array(nir_intrinsic_instr
* instr
,
269 const ArrayDeref
& array_deref
)
271 auto dest
= vec_from_nir(instr
->dest
, instr
->num_components
);
273 const nir_load_const_instr
* literal_index
= nullptr;
275 if (array_deref
.index
->is_ssa
)
276 literal_index
= get_literal_constant(array_deref
.index
->ssa
->index
);
278 if (!literal_index
) {
279 sfn_log
<< SfnLog::err
<< "GS: Indirect input addressing not (yet) supported\n";
282 assert(literal_index
->value
[0].u32
< 6);
283 PValue addr
= m_per_vertex_offsets
[literal_index
->value
[0].u32
];
285 auto fetch
= new FetchInstruction(vc_fetch
, no_index_offset
, dest
, addr
,
286 16 * array_deref
.var
->data
.driver_location
,
287 R600_GS_RING_CONST_BUFFER
, PValue(), bim_none
, true);
288 emit_instruction(fetch
);
292 void GeometryShaderFromNir::do_finalize()
294 if (m_num_clip_dist
) {
295 sh_info().cc_dist_mask
= (1 << m_num_clip_dist
) - 1;
296 sh_info().clip_dist_write
= (1 << m_num_clip_dist
) - 1;