1 /*
2 * Copyright (C) 2020 Collabora, Ltd.
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 #ifndef __PAN_IR_H
25 #define __PAN_IR_H
26
27 #include <stdint.h>
28 #include "compiler/nir/nir.h"
29 #include "util/u_dynarray.h"
30 #include "util/hash_table.h"
31
32 /* Define the general compiler entry point */
33
34 #define MAX_SYSVAL_COUNT 32
35
36 /* Allow 2D of sysval IDs, while allowing nonparametric sysvals to equal
37 * their class for equal comparison */
38
39 #define PAN_SYSVAL(type, no) (((no) << 16) | PAN_SYSVAL_##type)
40 #define PAN_SYSVAL_TYPE(sysval) ((sysval) & 0xffff)
41 #define PAN_SYSVAL_ID(sysval) ((sysval) >> 16)
42
43 /* Define some common types. We start at one for easy indexing of hash
44 * tables internal to the compiler */
45
46 enum {
47 PAN_SYSVAL_VIEWPORT_SCALE = 1,
48 PAN_SYSVAL_VIEWPORT_OFFSET = 2,
49 PAN_SYSVAL_TEXTURE_SIZE = 3,
50 PAN_SYSVAL_SSBO = 4,
51 PAN_SYSVAL_NUM_WORK_GROUPS = 5,
52 PAN_SYSVAL_SAMPLER = 7,
53 };
54
55 #define PAN_TXS_SYSVAL_ID(texidx, dim, is_array) \
56 ((texidx) | ((dim) << 7) | ((is_array) ? (1 << 9) : 0))
57
58 #define PAN_SYSVAL_ID_TO_TXS_TEX_IDX(id) ((id) & 0x7f)
59 #define PAN_SYSVAL_ID_TO_TXS_DIM(id) (((id) >> 7) & 0x3)
60 #define PAN_SYSVAL_ID_TO_TXS_IS_ARRAY(id) !!((id) & (1 << 9))
61
62 /* Special attribute slots for vertex builtins. Sort of arbitrary but let's be
63 * consistent with the blob so we can compare traces easier. */
64
65 enum {
66 PAN_VERTEX_ID = 16,
67 PAN_INSTANCE_ID = 17,
68 PAN_MAX_ATTRIBUTE
69 };
70
71 struct panfrost_sysvals {
72 /* The mapping of sysvals to uniforms, the count, and the off-by-one inverse */
73 unsigned sysvals[MAX_SYSVAL_COUNT];
74 unsigned sysval_count;
75 struct hash_table_u64 *sysval_to_id;
76 };
77
78 void
79 panfrost_nir_assign_sysvals(struct panfrost_sysvals *ctx, void *memctx, nir_shader *shader);
80
81 int
82 panfrost_sysval_for_instr(nir_instr *instr, nir_dest *dest);
83
84 bool
85 nir_undef_to_zero(nir_shader *shader);
86
87 typedef struct {
88 int work_register_count;
89 int uniform_cutoff;
90
91 /* For Bifrost - output type for each RT */
92 nir_alu_type blend_types[8];
93
94 /* For Bifrost - return address for blend instructions */
95 uint32_t blend_ret_offsets[8];
96
97 /* Prepended before uniforms, mapping to SYSVAL_ names for the
98 * sysval */
99
100 unsigned sysval_count;
101 unsigned sysvals[MAX_SYSVAL_COUNT];
102
103 int first_tag;
104
105 struct util_dynarray compiled;
106
107 /* The number of bytes to allocate per-thread for Thread Local Storage
108 * (register spilling), or zero if no spilling is used */
109 unsigned tls_size;
110
111 } panfrost_program;
112
113 struct panfrost_compile_inputs {
114 unsigned gpu_id;
115 bool is_blend;
116 struct {
117 unsigned rt;
118 float constants[4];
119 uint64_t bifrost_blend_desc;
120 } blend;
121 bool shaderdb;
122
123 enum pipe_format rt_formats[8];
124 };
125
126 typedef struct pan_block {
127 /* Link to next block. Must be first for mir_get_block */
128 struct list_head link;
129
130 /* List of instructions emitted for the current block */
131 struct list_head instructions;
132
133 /* Index of the block in source order */
134 unsigned name;
135
136 /* Control flow graph */
137 struct pan_block *successors[2];
138 struct set *predecessors;
139 bool unconditional_jumps;
140
141 /* In liveness analysis, these are live masks (per-component) for
142 * indices for the block. Scalar compilers have the luxury of using
143 * simple bit fields, but for us, liveness is a vector idea. */
144 uint16_t *live_in;
145 uint16_t *live_out;
146 } pan_block;
147
148 struct pan_instruction {
149 struct list_head link;
150 };
151
152 #define pan_foreach_instr_in_block_rev(block, v) \
153 list_for_each_entry_rev(struct pan_instruction, v, &block->instructions, link)
154
155 #define pan_foreach_successor(blk, v) \
156 pan_block *v; \
157 pan_block **_v; \
158 for (_v = (pan_block **) &blk->successors[0], \
159 v = *_v; \
160 v != NULL && _v < (pan_block **) &blk->successors[2]; \
161 _v++, v = *_v) \
162
163 #define pan_foreach_predecessor(blk, v) \
164 struct set_entry *_entry_##v; \
165 struct pan_block *v; \
166 for (_entry_##v = _mesa_set_next_entry(blk->predecessors, NULL), \
167 v = (struct pan_block *) (_entry_##v ? _entry_##v->key : NULL); \
168 _entry_##v != NULL; \
169 _entry_##v = _mesa_set_next_entry(blk->predecessors, _entry_##v), \
170 v = (struct pan_block *) (_entry_##v ? _entry_##v->key : NULL))
171
172 static inline pan_block *
pan_exit_block(struct list_head * blocks)173 pan_exit_block(struct list_head *blocks)
174 {
175 pan_block *last = list_last_entry(blocks, pan_block, link);
176 assert(!last->successors[0] && !last->successors[1]);
177 return last;
178 }
179
180 typedef void (*pan_liveness_update)(uint16_t *, void *, unsigned max);
181
182 void pan_liveness_gen(uint16_t *live, unsigned node, unsigned max, uint16_t mask);
183 void pan_liveness_kill(uint16_t *live, unsigned node, unsigned max, uint16_t mask);
184 bool pan_liveness_get(uint16_t *live, unsigned node, uint16_t max);
185
186 void pan_compute_liveness(struct list_head *blocks,
187 unsigned temp_count,
188 pan_liveness_update callback);
189
190 void pan_free_liveness(struct list_head *blocks);
191
192 uint16_t
193 pan_to_bytemask(unsigned bytes, unsigned mask);
194
195 void pan_block_add_successor(pan_block *block, pan_block *successor);
196
197 /* IR indexing */
198 #define PAN_IS_REG (1)
199
200 static inline unsigned
pan_ssa_index(nir_ssa_def * ssa)201 pan_ssa_index(nir_ssa_def *ssa)
202 {
203 /* Off-by-one ensures BIR_NO_ARG is skipped */
204 return ((ssa->index + 1) << 1) | 0;
205 }
206
207 static inline unsigned
pan_src_index(nir_src * src)208 pan_src_index(nir_src *src)
209 {
210 if (src->is_ssa)
211 return pan_ssa_index(src->ssa);
212 else {
213 assert(!src->reg.indirect);
214 return (src->reg.reg->index << 1) | PAN_IS_REG;
215 }
216 }
217
218 static inline unsigned
pan_dest_index(nir_dest * dst)219 pan_dest_index(nir_dest *dst)
220 {
221 if (dst->is_ssa)
222 return pan_ssa_index(&dst->ssa);
223 else {
224 assert(!dst->reg.indirect);
225 return (dst->reg.reg->index << 1) | PAN_IS_REG;
226 }
227 }
228
229 /* IR printing helpers */
230 void pan_print_alu_type(nir_alu_type t, FILE *fp);
231
232 /* Until it can be upstreamed.. */
233 bool pan_has_source_mod(nir_alu_src *src, nir_op op);
234 bool pan_has_dest_mod(nir_dest **dest, nir_op op);
235
236 /* NIR passes to do some backend-specific lowering */
237
238 #define PAN_WRITEOUT_C 1
239 #define PAN_WRITEOUT_Z 2
240 #define PAN_WRITEOUT_S 4
241
242 bool pan_nir_reorder_writeout(nir_shader *nir);
243 bool pan_nir_lower_zs_store(nir_shader *nir);
244
245 #endif
246