e56912d8e218d7f3300ecee47ce0f79e5107066c
[mesa.git] / src / gallium / drivers / lima / lima_program.c
1 /*
2 * Copyright (c) 2017-2019 Lima Project
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, sub license,
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
12 * next paragraph) shall be included in all copies or substantial portions
13 * of the 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 NON-INFRINGEMENT. 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
21 * DEALINGS IN THE SOFTWARE.
22 *
23 */
24
25 #include "util/u_memory.h"
26 #include "util/ralloc.h"
27 #include "util/u_debug.h"
28
29 #include "tgsi/tgsi_dump.h"
30 #include "compiler/nir/nir.h"
31 #include "nir/tgsi_to_nir.h"
32
33 #include "pipe/p_state.h"
34
35 #include "lima_screen.h"
36 #include "lima_context.h"
37 #include "lima_program.h"
38 #include "lima_bo.h"
39 #include "ir/lima_ir.h"
40
41 static const nir_shader_compiler_options vs_nir_options = {
42 .lower_ffma = true,
43 .lower_fpow = true,
44 .lower_ffract = true,
45 .lower_fdiv = true,
46 .lower_fsqrt = true,
47 .lower_sub = true,
48 .lower_flrp32 = true,
49 .lower_flrp64 = true,
50 .lower_ftrunc = true,
51 /* could be implemented by clamp */
52 .lower_fsat = true,
53 };
54
55 static const nir_shader_compiler_options fs_nir_options = {
56 .lower_fpow = true,
57 .lower_fdiv = true,
58 .lower_sub = true,
59 .lower_flrp32 = true,
60 .lower_flrp64 = true,
61 .lower_fsign = true,
62 };
63
64 const void *
65 lima_program_get_compiler_options(enum pipe_shader_type shader)
66 {
67 switch (shader) {
68 case PIPE_SHADER_VERTEX:
69 return &vs_nir_options;
70 case PIPE_SHADER_FRAGMENT:
71 return &fs_nir_options;
72 default:
73 return NULL;
74 }
75 }
76
77 static int
78 type_size(const struct glsl_type *type, bool bindless)
79 {
80 return glsl_count_attribute_slots(type, false);
81 }
82
83 static void
84 lima_program_optimize_vs_nir(struct nir_shader *s)
85 {
86 bool progress;
87
88 NIR_PASS_V(s, nir_lower_io, nir_var_all, type_size, 0);
89 NIR_PASS_V(s, nir_lower_regs_to_ssa);
90 NIR_PASS_V(s, nir_lower_load_const_to_scalar);
91 NIR_PASS_V(s, lima_nir_lower_uniform_to_scalar);
92 NIR_PASS_V(s, nir_lower_io_to_scalar,
93 nir_var_shader_in|nir_var_shader_out);
94 NIR_PASS_V(s, nir_lower_sincos);
95
96 do {
97 progress = false;
98
99 NIR_PASS_V(s, nir_lower_vars_to_ssa);
100 NIR_PASS(progress, s, nir_lower_alu_to_scalar);
101 NIR_PASS(progress, s, nir_lower_phis_to_scalar);
102 NIR_PASS(progress, s, nir_copy_prop);
103 NIR_PASS(progress, s, nir_opt_remove_phis);
104 NIR_PASS(progress, s, nir_opt_dce);
105 NIR_PASS(progress, s, nir_opt_dead_cf);
106 NIR_PASS(progress, s, nir_opt_cse);
107 NIR_PASS(progress, s, nir_opt_peephole_select, 8, true, true);
108 NIR_PASS(progress, s, nir_opt_algebraic);
109 NIR_PASS(progress, s, nir_opt_constant_folding);
110 NIR_PASS(progress, s, nir_opt_undef);
111 NIR_PASS(progress, s, nir_opt_loop_unroll,
112 nir_var_shader_in |
113 nir_var_shader_out |
114 nir_var_function_temp);
115 } while (progress);
116
117 NIR_PASS_V(s, nir_lower_int_to_float);
118 NIR_PASS_V(s, nir_copy_prop);
119 NIR_PASS_V(s, nir_lower_locals_to_regs);
120 NIR_PASS_V(s, nir_convert_from_ssa, true);
121 NIR_PASS_V(s, nir_remove_dead_variables, nir_var_function_temp);
122 nir_sweep(s);
123 }
124
125 static void
126 lima_program_optimize_fs_nir(struct nir_shader *s)
127 {
128 bool progress;
129
130 NIR_PASS_V(s, nir_lower_fragcoord_wtrans);
131 NIR_PASS_V(s, nir_lower_io, nir_var_all, type_size, 0);
132 NIR_PASS_V(s, nir_lower_regs_to_ssa);
133
134 do {
135 progress = false;
136
137 NIR_PASS_V(s, nir_lower_vars_to_ssa);
138 //NIR_PASS(progress, s, nir_lower_alu_to_scalar);
139 NIR_PASS(progress, s, nir_lower_phis_to_scalar);
140 NIR_PASS(progress, s, nir_copy_prop);
141 NIR_PASS(progress, s, nir_opt_remove_phis);
142 NIR_PASS(progress, s, nir_opt_dce);
143 NIR_PASS(progress, s, nir_opt_dead_cf);
144 NIR_PASS(progress, s, nir_opt_cse);
145 NIR_PASS(progress, s, nir_opt_peephole_select, 8, true, true);
146 NIR_PASS(progress, s, nir_opt_algebraic);
147 NIR_PASS(progress, s, nir_opt_constant_folding);
148 NIR_PASS(progress, s, nir_opt_undef);
149 NIR_PASS(progress, s, nir_opt_loop_unroll,
150 nir_var_shader_in |
151 nir_var_shader_out |
152 nir_var_function_temp);
153 } while (progress);
154
155 NIR_PASS_V(s, nir_lower_int_to_float);
156
157 /* Lower modifiers */
158 NIR_PASS_V(s, nir_lower_to_source_mods, nir_lower_all_source_mods);
159 NIR_PASS_V(s, nir_copy_prop);
160 NIR_PASS_V(s, nir_opt_dce);
161
162 NIR_PASS_V(s, nir_lower_locals_to_regs);
163 NIR_PASS_V(s, nir_convert_from_ssa, true);
164 NIR_PASS_V(s, nir_remove_dead_variables, nir_var_function_temp);
165
166 NIR_PASS_V(s, nir_move_vec_src_uses_to_dest);
167 NIR_PASS_V(s, nir_lower_vec_to_movs);
168
169 nir_sweep(s);
170 }
171
172 static void *
173 lima_create_fs_state(struct pipe_context *pctx,
174 const struct pipe_shader_state *cso)
175 {
176 struct lima_screen *screen = lima_screen(pctx->screen);
177 struct lima_fs_shader_state *so = rzalloc(NULL, struct lima_fs_shader_state);
178
179 if (!so)
180 return NULL;
181
182 nir_shader *nir;
183 if (cso->type == PIPE_SHADER_IR_NIR)
184 nir = cso->ir.nir;
185 else {
186 assert(cso->type == PIPE_SHADER_IR_TGSI);
187
188 nir = tgsi_to_nir(cso->tokens, pctx->screen);
189 }
190
191 lima_program_optimize_fs_nir(nir);
192
193 if (lima_debug & LIMA_DEBUG_PP)
194 nir_print_shader(nir, stdout);
195
196 if (!ppir_compile_nir(so, nir, screen->pp_ra)) {
197 ralloc_free(so);
198 return NULL;
199 }
200
201 return so;
202 }
203
204 static void
205 lima_bind_fs_state(struct pipe_context *pctx, void *hwcso)
206 {
207 struct lima_context *ctx = lima_context(pctx);
208
209 ctx->fs = hwcso;
210 ctx->dirty |= LIMA_CONTEXT_DIRTY_SHADER_FRAG;
211 }
212
213 static void
214 lima_delete_fs_state(struct pipe_context *pctx, void *hwcso)
215 {
216 struct lima_fs_shader_state *so = hwcso;
217
218 if (so->bo)
219 lima_bo_free(so->bo);
220
221 ralloc_free(so);
222 }
223
224 bool
225 lima_update_vs_state(struct lima_context *ctx)
226 {
227 struct lima_vs_shader_state *vs = ctx->vs;
228 if (!vs->bo) {
229 struct lima_screen *screen = lima_screen(ctx->base.screen);
230 vs->bo = lima_bo_create(screen, vs->shader_size, 0);
231 if (!vs->bo) {
232 fprintf(stderr, "lima: create vs shader bo fail\n");
233 return false;
234 }
235
236 memcpy(lima_bo_map(vs->bo), vs->shader, vs->shader_size);
237 ralloc_free(vs->shader);
238 vs->shader = NULL;
239 }
240
241 return true;
242 }
243
244 bool
245 lima_update_fs_state(struct lima_context *ctx)
246 {
247 struct lima_fs_shader_state *fs = ctx->fs;
248 if (!fs->bo) {
249 struct lima_screen *screen = lima_screen(ctx->base.screen);
250 fs->bo = lima_bo_create(screen, fs->shader_size, 0);
251 if (!fs->bo) {
252 fprintf(stderr, "lima: create fs shader bo fail\n");
253 return false;
254 }
255
256 memcpy(lima_bo_map(fs->bo), fs->shader, fs->shader_size);
257 ralloc_free(fs->shader);
258 fs->shader = NULL;
259 }
260
261 return true;
262 }
263
264 static void *
265 lima_create_vs_state(struct pipe_context *pctx,
266 const struct pipe_shader_state *cso)
267 {
268 struct lima_vs_shader_state *so = rzalloc(NULL, struct lima_vs_shader_state);
269
270 if (!so)
271 return NULL;
272
273 nir_shader *nir;
274 if (cso->type == PIPE_SHADER_IR_NIR)
275 nir = cso->ir.nir;
276 else {
277 assert(cso->type == PIPE_SHADER_IR_TGSI);
278
279 nir = tgsi_to_nir(cso->tokens, pctx->screen);
280 }
281
282 lima_program_optimize_vs_nir(nir);
283
284 if (lima_debug & LIMA_DEBUG_GP)
285 nir_print_shader(nir, stdout);
286
287 if (!gpir_compile_nir(so, nir)) {
288 ralloc_free(so);
289 return NULL;
290 }
291
292 return so;
293 }
294
295 static void
296 lima_bind_vs_state(struct pipe_context *pctx, void *hwcso)
297 {
298 struct lima_context *ctx = lima_context(pctx);
299
300 ctx->vs = hwcso;
301 ctx->dirty |= LIMA_CONTEXT_DIRTY_SHADER_VERT;
302 }
303
304 static void
305 lima_delete_vs_state(struct pipe_context *pctx, void *hwcso)
306 {
307 struct lima_vs_shader_state *so = hwcso;
308
309 if (so->bo)
310 lima_bo_free(so->bo);
311
312 ralloc_free(so);
313 }
314
315 void
316 lima_program_init(struct lima_context *ctx)
317 {
318 ctx->base.create_fs_state = lima_create_fs_state;
319 ctx->base.bind_fs_state = lima_bind_fs_state;
320 ctx->base.delete_fs_state = lima_delete_fs_state;
321
322 ctx->base.create_vs_state = lima_create_vs_state;
323 ctx->base.bind_vs_state = lima_bind_vs_state;
324 ctx->base.delete_vs_state = lima_delete_vs_state;
325 }