Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 1 | /* |
| 2 | * © Copyright 2018 Alyssa Rosenzweig |
| 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 FROM, |
| 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| 21 | * SOFTWARE. |
| 22 | * |
| 23 | */ |
| 24 | |
| 25 | #include <stdio.h> |
| 26 | #include <stdlib.h> |
| 27 | #include <string.h> |
Boris Brezillon | 154cb72 | 2019-09-14 09:58:55 +0200 | [diff] [blame] | 28 | #include "pan_bo.h" |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 29 | #include "pan_context.h" |
Alyssa Rosenzweig | 35418f6 | 2019-12-16 18:05:21 -0500 | [diff] [blame] | 30 | #include "pan_util.h" |
Alyssa Rosenzweig | 8016906 | 2020-04-06 16:44:17 -0400 | [diff] [blame] | 31 | #include "panfrost-quirks.h" |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 32 | |
| 33 | #include "compiler/nir/nir.h" |
| 34 | #include "nir/tgsi_to_nir.h" |
| 35 | #include "midgard/midgard_compile.h" |
Alyssa Rosenzweig | 8016906 | 2020-04-06 16:44:17 -0400 | [diff] [blame] | 36 | #include "bifrost/bifrost_compile.h" |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 37 | #include "util/u_dynarray.h" |
Alyssa Rosenzweig | 1e4c49e | 2020-08-21 14:16:18 -0400 | [diff] [blame] | 38 | #include "util/u_upload_mgr.h" |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 39 | |
| 40 | #include "tgsi/tgsi_dump.h" |
| 41 | |
Alyssa Rosenzweig | a29fb64 | 2020-08-21 12:34:24 -0400 | [diff] [blame] | 42 | static void |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 43 | pan_prepare_midgard_props(struct panfrost_shader_state *state, |
| 44 | gl_shader_stage stage) |
Alyssa Rosenzweig | a29fb64 | 2020-08-21 12:34:24 -0400 | [diff] [blame] | 45 | { |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 46 | pan_prepare(&state->properties, RENDERER_PROPERTIES); |
| 47 | state->properties.uniform_buffer_count = state->ubo_count; |
Boris Brezillon | 519643b | 2020-10-13 18:32:14 +0200 | [diff] [blame] | 48 | state->properties.midgard.uniform_count = state->uniform_count; |
| 49 | state->properties.midgard.shader_has_side_effects = state->writes_global; |
| 50 | |
| 51 | /* TODO: Select the appropriate mode. Suppresing inf/nan works around |
| 52 | * some bugs in gles2 apps (eg glmark2's terrain scene) but isn't |
| 53 | * conformant on gles3 */ |
| 54 | state->properties.midgard.fp_mode = MALI_FP_MODE_GL_INF_NAN_SUPPRESSED; |
Alyssa Rosenzweig | 55d9c25 | 2020-08-21 13:14:09 -0400 | [diff] [blame] | 55 | |
Alyssa Rosenzweig | cd66aa7 | 2020-11-04 11:17:43 -0500 | [diff] [blame^] | 56 | /* For fragment shaders, work register count, early-z, reads at draw-time */ |
| 57 | |
| 58 | if (stage != MESA_SHADER_FRAGMENT) |
Boris Brezillon | 519643b | 2020-10-13 18:32:14 +0200 | [diff] [blame] | 59 | state->properties.midgard.work_register_count = state->work_reg_count; |
Alyssa Rosenzweig | a29fb64 | 2020-08-21 12:34:24 -0400 | [diff] [blame] | 60 | } |
| 61 | |
| 62 | static void |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 63 | pan_prepare_bifrost_props(struct panfrost_shader_state *state, |
| 64 | gl_shader_stage stage) |
Alyssa Rosenzweig | a29fb64 | 2020-08-21 12:34:24 -0400 | [diff] [blame] | 65 | { |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 66 | |
Alyssa Rosenzweig | a29fb64 | 2020-08-21 12:34:24 -0400 | [diff] [blame] | 67 | switch (stage) { |
| 68 | case MESA_SHADER_VERTEX: |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 69 | pan_prepare(&state->properties, RENDERER_PROPERTIES); |
Boris Brezillon | 519643b | 2020-10-13 18:32:14 +0200 | [diff] [blame] | 70 | state->properties.bifrost.zs_update_operation = MALI_PIXEL_KILL_STRONG_EARLY; |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 71 | state->properties.uniform_buffer_count = state->ubo_count; |
Alyssa Rosenzweig | a29fb64 | 2020-08-21 12:34:24 -0400 | [diff] [blame] | 72 | |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 73 | pan_prepare(&state->preload, PRELOAD); |
| 74 | state->preload.uniform_count = state->uniform_count; |
Boris Brezillon | 7486b5d | 2020-10-17 11:02:12 +0200 | [diff] [blame] | 75 | state->preload.vertex.vertex_id = true; |
| 76 | state->preload.vertex.instance_id = true; |
Alyssa Rosenzweig | a29fb64 | 2020-08-21 12:34:24 -0400 | [diff] [blame] | 77 | break; |
| 78 | case MESA_SHADER_FRAGMENT: |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 79 | pan_prepare(&state->properties, RENDERER_PROPERTIES); |
| 80 | /* Early-Z set at draw-time */ |
Boris Brezillon | 519643b | 2020-10-13 18:32:14 +0200 | [diff] [blame] | 81 | state->properties.bifrost.zs_update_operation = MALI_PIXEL_KILL_STRONG_EARLY; |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 82 | state->properties.uniform_buffer_count = state->ubo_count; |
Boris Brezillon | 519643b | 2020-10-13 18:32:14 +0200 | [diff] [blame] | 83 | state->properties.bifrost.shader_modifies_coverage = state->can_discard; |
Alyssa Rosenzweig | 55d9c25 | 2020-08-21 13:14:09 -0400 | [diff] [blame] | 84 | |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 85 | pan_prepare(&state->preload, PRELOAD); |
| 86 | state->preload.uniform_count = state->uniform_count; |
Boris Brezillon | 7486b5d | 2020-10-17 11:02:12 +0200 | [diff] [blame] | 87 | state->preload.fragment.fragment_position = state->reads_frag_coord; |
| 88 | state->preload.fragment.coverage = true; |
Boris Brezillon | 0a582b5 | 2020-10-18 18:08:48 +0200 | [diff] [blame] | 89 | state->preload.fragment.primitive_flags = state->reads_face; |
Alyssa Rosenzweig | a29fb64 | 2020-08-21 12:34:24 -0400 | [diff] [blame] | 90 | break; |
| 91 | default: |
| 92 | unreachable("TODO"); |
| 93 | } |
| 94 | } |
| 95 | |
Alyssa Rosenzweig | 1e4c49e | 2020-08-21 14:16:18 -0400 | [diff] [blame] | 96 | static void |
| 97 | pan_upload_shader_descriptor(struct panfrost_context *ctx, |
| 98 | struct panfrost_shader_state *state) |
| 99 | { |
| 100 | const struct panfrost_device *dev = pan_device(ctx->base.screen); |
Alyssa Rosenzweig | c86b51a | 2020-08-21 18:06:24 -0400 | [diff] [blame] | 101 | struct mali_state_packed *out; |
Alyssa Rosenzweig | 1e4c49e | 2020-08-21 14:16:18 -0400 | [diff] [blame] | 102 | |
Boris Brezillon | f734e67 | 2020-09-29 15:47:04 +0200 | [diff] [blame] | 103 | u_upload_alloc(ctx->state_uploader, 0, MALI_RENDERER_STATE_LENGTH, MALI_RENDERER_STATE_LENGTH, |
Alyssa Rosenzweig | c86b51a | 2020-08-21 18:06:24 -0400 | [diff] [blame] | 104 | &state->upload.offset, &state->upload.rsrc, (void **) &out); |
Alyssa Rosenzweig | 1e4c49e | 2020-08-21 14:16:18 -0400 | [diff] [blame] | 105 | |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 106 | pan_pack(out, RENDERER_STATE, cfg) { |
Alyssa Rosenzweig | c86b51a | 2020-08-21 18:06:24 -0400 | [diff] [blame] | 107 | cfg.shader = state->shader; |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 108 | cfg.properties = state->properties; |
Alyssa Rosenzweig | 1e4c49e | 2020-08-21 14:16:18 -0400 | [diff] [blame] | 109 | |
Alyssa Rosenzweig | c86b51a | 2020-08-21 18:06:24 -0400 | [diff] [blame] | 110 | if (dev->quirks & IS_BIFROST) |
| 111 | cfg.preload = state->preload; |
| 112 | } |
| 113 | |
| 114 | u_upload_unmap(ctx->state_uploader); |
Alyssa Rosenzweig | 1e4c49e | 2020-08-21 14:16:18 -0400 | [diff] [blame] | 115 | } |
| 116 | |
Alyssa Rosenzweig | d104239 | 2020-04-08 13:54:17 -0400 | [diff] [blame] | 117 | static unsigned |
| 118 | pan_format_from_nir_base(nir_alu_type base) |
| 119 | { |
| 120 | switch (base) { |
| 121 | case nir_type_int: |
| 122 | return MALI_FORMAT_SINT; |
| 123 | case nir_type_uint: |
| 124 | case nir_type_bool: |
| 125 | return MALI_FORMAT_UINT; |
| 126 | case nir_type_float: |
| 127 | return MALI_CHANNEL_FLOAT; |
| 128 | default: |
| 129 | unreachable("Invalid base"); |
| 130 | } |
| 131 | } |
| 132 | |
| 133 | static unsigned |
| 134 | pan_format_from_nir_size(nir_alu_type base, unsigned size) |
| 135 | { |
| 136 | if (base == nir_type_float) { |
| 137 | switch (size) { |
| 138 | case 16: return MALI_FORMAT_SINT; |
| 139 | case 32: return MALI_FORMAT_UNORM; |
| 140 | default: |
| 141 | unreachable("Invalid float size for format"); |
| 142 | } |
| 143 | } else { |
| 144 | switch (size) { |
| 145 | case 1: |
| 146 | case 8: return MALI_CHANNEL_8; |
| 147 | case 16: return MALI_CHANNEL_16; |
| 148 | case 32: return MALI_CHANNEL_32; |
| 149 | default: |
| 150 | unreachable("Invalid int size for format"); |
| 151 | } |
| 152 | } |
| 153 | } |
| 154 | |
| 155 | static enum mali_format |
Alyssa Rosenzweig | 1c1782c | 2020-06-09 18:15:20 -0400 | [diff] [blame] | 156 | pan_format_from_glsl(const struct glsl_type *type, unsigned precision, unsigned frac) |
Alyssa Rosenzweig | d104239 | 2020-04-08 13:54:17 -0400 | [diff] [blame] | 157 | { |
Alyssa Rosenzweig | 8462ca0 | 2020-06-10 15:47:45 -0400 | [diff] [blame] | 158 | const struct glsl_type *column = glsl_without_array_or_matrix(type); |
| 159 | enum glsl_base_type glsl_base = glsl_get_base_type(column); |
Alyssa Rosenzweig | d104239 | 2020-04-08 13:54:17 -0400 | [diff] [blame] | 160 | nir_alu_type t = nir_get_nir_type_for_glsl_base_type(glsl_base); |
Alyssa Rosenzweig | 8462ca0 | 2020-06-10 15:47:45 -0400 | [diff] [blame] | 161 | unsigned chan = glsl_get_components(column); |
| 162 | |
| 163 | /* If we have a fractional location added, we need to increase the size |
| 164 | * so it will fit, i.e. a vec3 in YZW requires us to allocate a vec4. |
| 165 | * We could do better but this is an edge case as it is, normally |
| 166 | * packed varyings will be aligned. */ |
| 167 | chan += frac; |
| 168 | |
| 169 | assert(chan >= 1 && chan <= 4); |
Alyssa Rosenzweig | d104239 | 2020-04-08 13:54:17 -0400 | [diff] [blame] | 170 | |
| 171 | unsigned base = nir_alu_type_get_base_type(t); |
| 172 | unsigned size = nir_alu_type_get_type_size(t); |
| 173 | |
Alyssa Rosenzweig | 1c1782c | 2020-06-09 18:15:20 -0400 | [diff] [blame] | 174 | /* Demote to fp16 where possible. int16 varyings are TODO as the hw |
| 175 | * will saturate instead of wrap which is not conformant, so we need to |
| 176 | * insert i2i16/u2u16 instructions before the st_vary_32i/32u to get |
| 177 | * the intended behaviour */ |
| 178 | |
| 179 | bool is_16 = (precision == GLSL_PRECISION_MEDIUM) |
| 180 | || (precision == GLSL_PRECISION_LOW); |
| 181 | |
| 182 | if (is_16 && base == nir_type_float) |
| 183 | size = 16; |
| 184 | else |
| 185 | size = 32; |
| 186 | |
Alyssa Rosenzweig | d104239 | 2020-04-08 13:54:17 -0400 | [diff] [blame] | 187 | return pan_format_from_nir_base(base) | |
| 188 | pan_format_from_nir_size(base, size) | |
Alyssa Rosenzweig | 8462ca0 | 2020-06-10 15:47:45 -0400 | [diff] [blame] | 189 | MALI_NR_CHANNELS(chan); |
Alyssa Rosenzweig | d104239 | 2020-04-08 13:54:17 -0400 | [diff] [blame] | 190 | } |
| 191 | |
Boris Brezillon | 8389976 | 2020-09-16 13:31:37 +0200 | [diff] [blame] | 192 | static enum mali_bifrost_register_file_format |
Tomeu Vizoso | 3c98c45 | 2020-04-24 08:40:51 +0200 | [diff] [blame] | 193 | bifrost_blend_type_from_nir(nir_alu_type nir_type) |
| 194 | { |
| 195 | switch(nir_type) { |
| 196 | case 0: /* Render target not in use */ |
| 197 | return 0; |
| 198 | case nir_type_float16: |
Boris Brezillon | 8389976 | 2020-09-16 13:31:37 +0200 | [diff] [blame] | 199 | return MALI_BIFROST_REGISTER_FILE_FORMAT_F16; |
Tomeu Vizoso | 3c98c45 | 2020-04-24 08:40:51 +0200 | [diff] [blame] | 200 | case nir_type_float32: |
Boris Brezillon | 8389976 | 2020-09-16 13:31:37 +0200 | [diff] [blame] | 201 | return MALI_BIFROST_REGISTER_FILE_FORMAT_F32; |
Tomeu Vizoso | 3c98c45 | 2020-04-24 08:40:51 +0200 | [diff] [blame] | 202 | case nir_type_int32: |
Boris Brezillon | 8389976 | 2020-09-16 13:31:37 +0200 | [diff] [blame] | 203 | return MALI_BIFROST_REGISTER_FILE_FORMAT_I32; |
Tomeu Vizoso | 3c98c45 | 2020-04-24 08:40:51 +0200 | [diff] [blame] | 204 | case nir_type_uint32: |
Boris Brezillon | 8389976 | 2020-09-16 13:31:37 +0200 | [diff] [blame] | 205 | return MALI_BIFROST_REGISTER_FILE_FORMAT_U32; |
Tomeu Vizoso | 3c98c45 | 2020-04-24 08:40:51 +0200 | [diff] [blame] | 206 | case nir_type_int16: |
Boris Brezillon | 8389976 | 2020-09-16 13:31:37 +0200 | [diff] [blame] | 207 | return MALI_BIFROST_REGISTER_FILE_FORMAT_I16; |
Tomeu Vizoso | 3c98c45 | 2020-04-24 08:40:51 +0200 | [diff] [blame] | 208 | case nir_type_uint16: |
Boris Brezillon | 8389976 | 2020-09-16 13:31:37 +0200 | [diff] [blame] | 209 | return MALI_BIFROST_REGISTER_FILE_FORMAT_U16; |
Tomeu Vizoso | 3c98c45 | 2020-04-24 08:40:51 +0200 | [diff] [blame] | 210 | default: |
Alyssa Rosenzweig | ed1910d | 2020-07-07 16:15:45 -0400 | [diff] [blame] | 211 | unreachable("Unsupported blend shader type for NIR alu type"); |
Tomeu Vizoso | 3c98c45 | 2020-04-24 08:40:51 +0200 | [diff] [blame] | 212 | return 0; |
| 213 | } |
| 214 | } |
| 215 | |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 216 | void |
Boris Brezillon | b02f97c | 2020-03-05 16:20:18 +0100 | [diff] [blame] | 217 | panfrost_shader_compile(struct panfrost_context *ctx, |
| 218 | enum pipe_shader_ir ir_type, |
| 219 | const void *ir, |
| 220 | gl_shader_stage stage, |
| 221 | struct panfrost_shader_state *state, |
| 222 | uint64_t *outputs_written) |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 223 | { |
Alyssa Rosenzweig | ca8c625 | 2020-03-23 18:44:21 -0400 | [diff] [blame] | 224 | struct panfrost_device *dev = pan_device(ctx->base.screen); |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 225 | |
| 226 | nir_shader *s; |
| 227 | |
Alyssa Rosenzweig | c228046 | 2019-07-31 15:19:09 -0700 | [diff] [blame] | 228 | if (ir_type == PIPE_SHADER_IR_NIR) { |
| 229 | s = nir_shader_clone(NULL, ir); |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 230 | } else { |
Alyssa Rosenzweig | c228046 | 2019-07-31 15:19:09 -0700 | [diff] [blame] | 231 | assert (ir_type == PIPE_SHADER_IR_TGSI); |
Axel Davy | 522bd41 | 2020-05-12 21:52:40 +0200 | [diff] [blame] | 232 | s = tgsi_to_nir(ir, ctx->base.screen, false); |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 233 | } |
| 234 | |
Alyssa Rosenzweig | 4647999 | 2019-07-31 15:49:13 -0700 | [diff] [blame] | 235 | s->info.stage = stage; |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 236 | |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 237 | /* Call out to Midgard compiler given the above NIR */ |
Boris Brezillon | 0a74a04 | 2020-10-08 10:09:56 +0200 | [diff] [blame] | 238 | struct panfrost_compile_inputs inputs = { |
| 239 | .gpu_id = dev->gpu_id, |
| 240 | .shaderdb = !!(dev->debug & PAN_DBG_PRECOMPILE), |
| 241 | }; |
Icecream95 | 75018f6 | 2020-07-06 19:40:05 +1200 | [diff] [blame] | 242 | |
Boris Brezillon | 0a74a04 | 2020-10-08 10:09:56 +0200 | [diff] [blame] | 243 | memcpy(inputs.rt_formats, state->rt_formats, sizeof(inputs.rt_formats)); |
| 244 | |
Boris Brezillon | 69c864b | 2020-10-17 12:08:17 +0200 | [diff] [blame] | 245 | panfrost_program *program; |
| 246 | |
Boris Brezillon | 0a74a04 | 2020-10-08 10:09:56 +0200 | [diff] [blame] | 247 | if (dev->quirks & IS_BIFROST) |
Boris Brezillon | 69c864b | 2020-10-17 12:08:17 +0200 | [diff] [blame] | 248 | program = bifrost_compile_shader_nir(NULL, s, &inputs); |
Boris Brezillon | 0a74a04 | 2020-10-08 10:09:56 +0200 | [diff] [blame] | 249 | else |
Boris Brezillon | 69c864b | 2020-10-17 12:08:17 +0200 | [diff] [blame] | 250 | program = midgard_compile_shader_nir(NULL, s, &inputs); |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 251 | |
| 252 | /* Prepare the compiled binary for upload */ |
Alyssa Rosenzweig | 661b469 | 2020-08-21 10:34:06 -0400 | [diff] [blame] | 253 | mali_ptr shader = 0; |
| 254 | unsigned attribute_count = 0, varying_count = 0; |
Boris Brezillon | 69c864b | 2020-10-17 12:08:17 +0200 | [diff] [blame] | 255 | int size = program->compiled.size; |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 256 | |
Alyssa Rosenzweig | bf5d8cf | 2019-12-16 16:45:28 -0500 | [diff] [blame] | 257 | if (size) { |
Alyssa Rosenzweig | 1d88f07 | 2020-07-07 16:19:39 -0400 | [diff] [blame] | 258 | state->bo = panfrost_bo_create(dev, size, PAN_BO_EXECUTE); |
Boris Brezillon | 1b3b289 | 2020-10-18 10:13:18 +0200 | [diff] [blame] | 259 | memcpy(state->bo->ptr.cpu, program->compiled.data, size); |
| 260 | shader = state->bo->ptr.gpu; |
Alyssa Rosenzweig | 8016906 | 2020-04-06 16:44:17 -0400 | [diff] [blame] | 261 | } |
| 262 | |
Alyssa Rosenzweig | 9f83217 | 2020-08-19 10:13:59 -0400 | [diff] [blame] | 263 | /* Midgard needs the first tag on the bottom nibble */ |
| 264 | |
Alyssa Rosenzweig | 8016906 | 2020-04-06 16:44:17 -0400 | [diff] [blame] | 265 | if (!(dev->quirks & IS_BIFROST)) { |
Alyssa Rosenzweig | 9f83217 | 2020-08-19 10:13:59 -0400 | [diff] [blame] | 266 | /* If size = 0, we tag as "end-of-shader" */ |
| 267 | |
| 268 | if (size) |
Boris Brezillon | 69c864b | 2020-10-17 12:08:17 +0200 | [diff] [blame] | 269 | shader |= program->first_tag; |
Alyssa Rosenzweig | 9f83217 | 2020-08-19 10:13:59 -0400 | [diff] [blame] | 270 | else |
Alyssa Rosenzweig | 661b469 | 2020-08-21 10:34:06 -0400 | [diff] [blame] | 271 | shader = 0x1; |
Alyssa Rosenzweig | bf5d8cf | 2019-12-16 16:45:28 -0500 | [diff] [blame] | 272 | } |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 273 | |
Boris Brezillon | 69c864b | 2020-10-17 12:08:17 +0200 | [diff] [blame] | 274 | state->sysval_count = program->sysval_count; |
| 275 | memcpy(state->sysval, program->sysvals, sizeof(state->sysval[0]) * state->sysval_count); |
Alyssa Rosenzweig | 7e8de5a | 2019-04-03 01:48:09 +0000 | [diff] [blame] | 276 | |
Alyssa Rosenzweig | 8781378 | 2019-12-19 13:39:14 -0500 | [diff] [blame] | 277 | bool vertex_id = s->info.system_values_read & (1 << SYSTEM_VALUE_VERTEX_ID); |
| 278 | bool instance_id = s->info.system_values_read & (1 << SYSTEM_VALUE_INSTANCE_ID); |
| 279 | |
Alyssa Rosenzweig | 1d194f8 | 2020-05-29 16:06:10 -0400 | [diff] [blame] | 280 | /* On Bifrost it's a sysval, on Midgard it's a varying */ |
| 281 | state->reads_frag_coord = s->info.system_values_read & (1 << SYSTEM_VALUE_FRAG_COORD); |
| 282 | |
Alyssa Rosenzweig | dce7722 | 2020-06-02 14:12:29 -0400 | [diff] [blame] | 283 | state->writes_global = s->info.writes_memory; |
| 284 | |
Alyssa Rosenzweig | 4647999 | 2019-07-31 15:49:13 -0700 | [diff] [blame] | 285 | switch (stage) { |
Alyssa Rosenzweig | 5534fdb | 2019-07-23 17:02:38 -0700 | [diff] [blame] | 286 | case MESA_SHADER_VERTEX: |
Alyssa Rosenzweig | 661b469 | 2020-08-21 10:34:06 -0400 | [diff] [blame] | 287 | attribute_count = util_bitcount64(s->info.inputs_read); |
| 288 | varying_count = util_bitcount64(s->info.outputs_written); |
Alyssa Rosenzweig | 8781378 | 2019-12-19 13:39:14 -0500 | [diff] [blame] | 289 | |
| 290 | if (vertex_id) |
Alyssa Rosenzweig | 661b469 | 2020-08-21 10:34:06 -0400 | [diff] [blame] | 291 | attribute_count = MAX2(attribute_count, PAN_VERTEX_ID + 1); |
Alyssa Rosenzweig | 8781378 | 2019-12-19 13:39:14 -0500 | [diff] [blame] | 292 | |
| 293 | if (instance_id) |
Alyssa Rosenzweig | 661b469 | 2020-08-21 10:34:06 -0400 | [diff] [blame] | 294 | attribute_count = MAX2(attribute_count, PAN_INSTANCE_ID + 1); |
Alyssa Rosenzweig | 8781378 | 2019-12-19 13:39:14 -0500 | [diff] [blame] | 295 | |
Alyssa Rosenzweig | 5534fdb | 2019-07-23 17:02:38 -0700 | [diff] [blame] | 296 | break; |
| 297 | case MESA_SHADER_FRAGMENT: |
Boris Brezillon | 91d9c55 | 2020-10-12 15:18:35 +0200 | [diff] [blame] | 298 | for (unsigned i = 0; i < ARRAY_SIZE(state->blend_ret_addrs); i++) { |
Boris Brezillon | 69c864b | 2020-10-17 12:08:17 +0200 | [diff] [blame] | 299 | if (!program->blend_ret_offsets[i]) |
Boris Brezillon | 91d9c55 | 2020-10-12 15:18:35 +0200 | [diff] [blame] | 300 | continue; |
| 301 | |
Boris Brezillon | 1b3b289 | 2020-10-18 10:13:18 +0200 | [diff] [blame] | 302 | state->blend_ret_addrs[i] = (state->bo->ptr.gpu & UINT32_MAX) + |
Boris Brezillon | 69c864b | 2020-10-17 12:08:17 +0200 | [diff] [blame] | 303 | program->blend_ret_offsets[i]; |
Boris Brezillon | 91d9c55 | 2020-10-12 15:18:35 +0200 | [diff] [blame] | 304 | assert(!(state->blend_ret_addrs[i] & 0x7)); |
| 305 | } |
Alyssa Rosenzweig | 661b469 | 2020-08-21 10:34:06 -0400 | [diff] [blame] | 306 | varying_count = util_bitcount64(s->info.inputs_read); |
Boris Brezillon | 38c2069 | 2020-01-31 10:55:49 +0100 | [diff] [blame] | 307 | if (s->info.outputs_written & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) |
| 308 | state->writes_depth = true; |
| 309 | if (s->info.outputs_written & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) |
| 310 | state->writes_stencil = true; |
Alyssa Rosenzweig | 1085f74 | 2020-05-21 15:49:30 -0400 | [diff] [blame] | 311 | |
Icecream95 | e603248 | 2020-07-06 19:41:28 +1200 | [diff] [blame] | 312 | uint64_t outputs_read = s->info.outputs_read; |
| 313 | if (outputs_read & BITFIELD64_BIT(FRAG_RESULT_COLOR)) |
| 314 | outputs_read |= BITFIELD64_BIT(FRAG_RESULT_DATA0); |
| 315 | |
| 316 | state->outputs_read = outputs_read >> FRAG_RESULT_DATA0; |
| 317 | |
Alyssa Rosenzweig | 1085f74 | 2020-05-21 15:49:30 -0400 | [diff] [blame] | 318 | /* List of reasons we need to execute frag shaders when things |
| 319 | * are masked off */ |
| 320 | |
| 321 | state->fs_sidefx = |
| 322 | s->info.writes_memory || |
| 323 | s->info.fs.uses_discard || |
| 324 | s->info.fs.uses_demote; |
Alyssa Rosenzweig | 5534fdb | 2019-07-23 17:02:38 -0700 | [diff] [blame] | 325 | break; |
Alyssa Rosenzweig | ff345d4 | 2019-07-31 15:52:04 -0700 | [diff] [blame] | 326 | case MESA_SHADER_COMPUTE: |
| 327 | /* TODO: images */ |
Alyssa Rosenzweig | 9603126 | 2020-02-06 14:29:42 -0500 | [diff] [blame] | 328 | state->shared_size = s->info.cs.shared_size; |
Alyssa Rosenzweig | ff345d4 | 2019-07-31 15:52:04 -0700 | [diff] [blame] | 329 | break; |
Alyssa Rosenzweig | 5534fdb | 2019-07-23 17:02:38 -0700 | [diff] [blame] | 330 | default: |
| 331 | unreachable("Unknown shader state"); |
| 332 | } |
| 333 | |
Alyssa Rosenzweig | bab4f6c | 2019-07-23 16:52:40 -0700 | [diff] [blame] | 334 | state->can_discard = s->info.fs.uses_discard; |
Alyssa Rosenzweig | 48991c7 | 2019-07-23 16:49:37 -0700 | [diff] [blame] | 335 | state->helper_invocations = s->info.fs.needs_helper_invocations; |
Boris Brezillon | 69c864b | 2020-10-17 12:08:17 +0200 | [diff] [blame] | 336 | state->stack_size = program->tls_size; |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 337 | |
Alyssa Rosenzweig | f1de952 | 2020-06-08 18:05:21 -0400 | [diff] [blame] | 338 | state->reads_frag_coord = s->info.inputs_read & (1 << VARYING_SLOT_POS); |
| 339 | state->reads_point_coord = s->info.inputs_read & (1 << VARYING_SLOT_PNTC); |
Boris Brezillon | 0a582b5 | 2020-10-18 18:08:48 +0200 | [diff] [blame] | 340 | state->reads_face = (s->info.inputs_read & (1 << VARYING_SLOT_FACE)) || |
| 341 | (s->info.system_values_read & (1 << SYSTEM_VALUE_FRONT_FACE)); |
Alyssa Rosenzweig | f1de952 | 2020-06-08 18:05:21 -0400 | [diff] [blame] | 342 | state->writes_point_size = s->info.outputs_written & (1 << VARYING_SLOT_PSIZ); |
| 343 | |
Alyssa Rosenzweig | 5b0a1a4 | 2019-08-07 10:26:12 -0700 | [diff] [blame] | 344 | if (outputs_written) |
| 345 | *outputs_written = s->info.outputs_written; |
| 346 | |
Alyssa Rosenzweig | e30091b | 2020-04-08 14:44:31 -0400 | [diff] [blame] | 347 | /* Separate as primary uniform count is truncated. Sysvals are prefix |
| 348 | * uniforms */ |
Boris Brezillon | 69c864b | 2020-10-17 12:08:17 +0200 | [diff] [blame] | 349 | state->uniform_count = MIN2(s->num_uniforms + program->sysval_count, program->uniform_cutoff); |
| 350 | state->work_reg_count = program->work_register_count; |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 351 | |
Tomeu Vizoso | 3c98c45 | 2020-04-24 08:40:51 +0200 | [diff] [blame] | 352 | if (dev->quirks & IS_BIFROST) |
Boris Brezillon | 8389976 | 2020-09-16 13:31:37 +0200 | [diff] [blame] | 353 | for (unsigned i = 0; i < ARRAY_SIZE(state->blend_types); i++) |
Boris Brezillon | 69c864b | 2020-10-17 12:08:17 +0200 | [diff] [blame] | 354 | state->blend_types[i] = bifrost_blend_type_from_nir(program->blend_types[i]); |
Tomeu Vizoso | 3c98c45 | 2020-04-24 08:40:51 +0200 | [diff] [blame] | 355 | |
Alyssa Rosenzweig | d104239 | 2020-04-08 13:54:17 -0400 | [diff] [blame] | 356 | /* Record the varying mapping for the command stream's bookkeeping */ |
| 357 | |
Jason Ekstrand | a61be31 | 2020-07-21 18:13:34 -0500 | [diff] [blame] | 358 | nir_variable_mode varying_mode = |
| 359 | stage == MESA_SHADER_VERTEX ? nir_var_shader_out : nir_var_shader_in; |
Alyssa Rosenzweig | d104239 | 2020-04-08 13:54:17 -0400 | [diff] [blame] | 360 | |
Jason Ekstrand | a61be31 | 2020-07-21 18:13:34 -0500 | [diff] [blame] | 361 | nir_foreach_variable_with_modes(var, s, varying_mode) { |
Alyssa Rosenzweig | d104239 | 2020-04-08 13:54:17 -0400 | [diff] [blame] | 362 | unsigned loc = var->data.driver_location; |
| 363 | unsigned sz = glsl_count_attribute_slots(var->type, FALSE); |
| 364 | |
| 365 | for (int c = 0; c < sz; ++c) { |
Alyssa Rosenzweig | 3cc425e | 2020-06-10 15:48:33 -0400 | [diff] [blame] | 366 | state->varyings_loc[loc + c] = var->data.location + c; |
Alyssa Rosenzweig | 1c1782c | 2020-06-09 18:15:20 -0400 | [diff] [blame] | 367 | state->varyings[loc + c] = pan_format_from_glsl(var->type, |
| 368 | var->data.precision, var->data.location_frac); |
Alyssa Rosenzweig | d104239 | 2020-04-08 13:54:17 -0400 | [diff] [blame] | 369 | } |
| 370 | } |
Alyssa Rosenzweig | 9146f59 | 2020-08-18 08:07:15 -0400 | [diff] [blame] | 371 | |
Alyssa Rosenzweig | a29fb64 | 2020-08-21 12:34:24 -0400 | [diff] [blame] | 372 | /* Needed for linkage */ |
| 373 | state->attribute_count = attribute_count; |
| 374 | state->varying_count = varying_count; |
| 375 | state->ubo_count = s->info.num_ubos + 1; /* off-by-one for uniforms */ |
| 376 | |
Alyssa Rosenzweig | 661b469 | 2020-08-21 10:34:06 -0400 | [diff] [blame] | 377 | /* Prepare the descriptors at compile-time */ |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 378 | state->shader.shader = shader; |
| 379 | state->shader.attribute_count = attribute_count; |
| 380 | state->shader.varying_count = varying_count; |
| 381 | state->shader.texture_count = s->info.num_textures; |
| 382 | state->shader.sampler_count = s->info.num_textures; |
Alyssa Rosenzweig | 661b469 | 2020-08-21 10:34:06 -0400 | [diff] [blame] | 383 | |
Alyssa Rosenzweig | a29fb64 | 2020-08-21 12:34:24 -0400 | [diff] [blame] | 384 | if (dev->quirks & IS_BIFROST) |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 385 | pan_prepare_bifrost_props(state, stage); |
Alyssa Rosenzweig | a29fb64 | 2020-08-21 12:34:24 -0400 | [diff] [blame] | 386 | else |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 387 | pan_prepare_midgard_props(state, stage); |
Alyssa Rosenzweig | 661b469 | 2020-08-21 10:34:06 -0400 | [diff] [blame] | 388 | |
Alyssa Rosenzweig | cd66aa7 | 2020-11-04 11:17:43 -0500 | [diff] [blame^] | 389 | state->properties.stencil_from_shader = state->writes_stencil; |
| 390 | state->properties.shader_contains_barrier = state->helper_invocations; |
| 391 | state->properties.depth_source = state->writes_depth ? |
| 392 | MALI_DEPTH_SOURCE_SHADER : |
| 393 | MALI_DEPTH_SOURCE_FIXED_FUNCTION; |
| 394 | |
Alyssa Rosenzweig | 1e4c49e | 2020-08-21 14:16:18 -0400 | [diff] [blame] | 395 | if (stage != MESA_SHADER_FRAGMENT) |
| 396 | pan_upload_shader_descriptor(ctx, state); |
| 397 | |
Boris Brezillon | 69c864b | 2020-10-17 12:08:17 +0200 | [diff] [blame] | 398 | ralloc_free(program); |
| 399 | |
Alyssa Rosenzweig | 9146f59 | 2020-08-18 08:07:15 -0400 | [diff] [blame] | 400 | /* In both clone and tgsi_to_nir paths, the shader is ralloc'd against |
| 401 | * a NULL context */ |
| 402 | ralloc_free(s); |
Alyssa Rosenzweig | 7da251f | 2019-02-05 04:32:27 +0000 | [diff] [blame] | 403 | } |