Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5564 | serge | 1 | /* |
2 | * Copyright © 2014 Intel Corporation |
||
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 |
||
20 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
||
21 | * IN THE SOFTWARE. |
||
22 | * |
||
23 | * Authors: |
||
24 | * Connor Abbott (cwabbott0@gmail.com) |
||
25 | * |
||
26 | */ |
||
27 | |||
28 | #include "nir.h" |
||
29 | #include |
||
30 | |||
31 | /* |
||
32 | * This file checks for invalid IR indicating a bug somewhere in the compiler. |
||
33 | */ |
||
34 | |||
35 | /* Since this file is just a pile of asserts, don't bother compiling it if |
||
36 | * we're not building a debug build. |
||
37 | */ |
||
38 | #ifdef DEBUG |
||
39 | |||
40 | /* |
||
41 | * Per-register validation state. |
||
42 | */ |
||
43 | |||
44 | typedef struct { |
||
45 | /* |
||
46 | * equivalent to the uses and defs in nir_register, but built up by the |
||
47 | * validator. At the end, we verify that the sets have the same entries. |
||
48 | */ |
||
49 | struct set *uses, *if_uses, *defs; |
||
50 | nir_function_impl *where_defined; /* NULL for global registers */ |
||
51 | } reg_validate_state; |
||
52 | |||
53 | typedef struct { |
||
54 | /* |
||
55 | * equivalent to the uses in nir_ssa_def, but built up by the validator. |
||
56 | * At the end, we verify that the sets have the same entries. |
||
57 | */ |
||
58 | struct set *uses, *if_uses; |
||
59 | nir_function_impl *where_defined; |
||
60 | } ssa_def_validate_state; |
||
61 | |||
62 | typedef struct { |
||
63 | /* map of register -> validation state (struct above) */ |
||
64 | struct hash_table *regs; |
||
65 | |||
66 | /* the current shader being validated */ |
||
67 | nir_shader *shader; |
||
68 | |||
69 | /* the current instruction being validated */ |
||
70 | nir_instr *instr; |
||
71 | |||
72 | /* the current basic block being validated */ |
||
73 | nir_block *block; |
||
74 | |||
75 | /* the current if statement being validated */ |
||
76 | nir_if *if_stmt; |
||
77 | |||
78 | /* the parent of the current cf node being visited */ |
||
79 | nir_cf_node *parent_node; |
||
80 | |||
81 | /* the current function implementation being validated */ |
||
82 | nir_function_impl *impl; |
||
83 | |||
84 | /* map of SSA value -> function implementation where it is defined */ |
||
85 | struct hash_table *ssa_defs; |
||
86 | |||
87 | /* bitset of ssa definitions we have found; used to check uniqueness */ |
||
88 | BITSET_WORD *ssa_defs_found; |
||
89 | |||
90 | /* bitset of registers we have currently found; used to check uniqueness */ |
||
91 | BITSET_WORD *regs_found; |
||
92 | |||
93 | /* map of local variable -> function implementation where it is defined */ |
||
94 | struct hash_table *var_defs; |
||
95 | } validate_state; |
||
96 | |||
97 | static void validate_src(nir_src *src, validate_state *state); |
||
98 | |||
99 | static void |
||
100 | validate_reg_src(nir_src *src, validate_state *state) |
||
101 | { |
||
102 | assert(src->reg.reg != NULL); |
||
103 | |||
104 | struct hash_entry *entry; |
||
105 | entry = _mesa_hash_table_search(state->regs, src->reg.reg); |
||
106 | assert(entry); |
||
107 | |||
108 | reg_validate_state *reg_state = (reg_validate_state *) entry->data; |
||
109 | |||
110 | if (state->instr) { |
||
111 | _mesa_set_add(reg_state->uses, src); |
||
112 | } else { |
||
113 | assert(state->if_stmt); |
||
114 | _mesa_set_add(reg_state->if_uses, src); |
||
115 | } |
||
116 | |||
117 | if (!src->reg.reg->is_global) { |
||
118 | assert(reg_state->where_defined == state->impl && |
||
119 | "using a register declared in a different function"); |
||
120 | } |
||
121 | |||
122 | assert((src->reg.reg->num_array_elems == 0 || |
||
123 | src->reg.base_offset < src->reg.reg->num_array_elems) && |
||
124 | "definitely out-of-bounds array access"); |
||
125 | |||
126 | if (src->reg.indirect) { |
||
127 | assert(src->reg.reg->num_array_elems != 0); |
||
128 | assert((src->reg.indirect->is_ssa || |
||
129 | src->reg.indirect->reg.indirect == NULL) && |
||
130 | "only one level of indirection allowed"); |
||
131 | validate_src(src->reg.indirect, state); |
||
132 | } |
||
133 | } |
||
134 | |||
135 | static void |
||
136 | validate_ssa_src(nir_src *src, validate_state *state) |
||
137 | { |
||
138 | assert(src->ssa != NULL); |
||
139 | |||
140 | struct hash_entry *entry = _mesa_hash_table_search(state->ssa_defs, src->ssa); |
||
141 | |||
142 | assert(entry); |
||
143 | |||
144 | ssa_def_validate_state *def_state = (ssa_def_validate_state *)entry->data; |
||
145 | |||
146 | assert(def_state->where_defined == state->impl && |
||
147 | "using an SSA value defined in a different function"); |
||
148 | |||
149 | if (state->instr) { |
||
150 | _mesa_set_add(def_state->uses, src); |
||
151 | } else { |
||
152 | assert(state->if_stmt); |
||
153 | _mesa_set_add(def_state->if_uses, src); |
||
154 | } |
||
155 | |||
156 | /* TODO validate that the use is dominated by the definition */ |
||
157 | } |
||
158 | |||
159 | static void |
||
160 | validate_src(nir_src *src, validate_state *state) |
||
161 | { |
||
162 | if (state->instr) |
||
163 | assert(src->parent_instr == state->instr); |
||
164 | else |
||
165 | assert(src->parent_if == state->if_stmt); |
||
166 | |||
167 | if (src->is_ssa) |
||
168 | validate_ssa_src(src, state); |
||
169 | else |
||
170 | validate_reg_src(src, state); |
||
171 | } |
||
172 | |||
173 | static void |
||
174 | validate_alu_src(nir_alu_instr *instr, unsigned index, validate_state *state) |
||
175 | { |
||
176 | nir_alu_src *src = &instr->src[index]; |
||
177 | |||
178 | unsigned num_components; |
||
179 | if (src->src.is_ssa) |
||
180 | num_components = src->src.ssa->num_components; |
||
181 | else { |
||
182 | if (src->src.reg.reg->is_packed) |
||
183 | num_components = 4; /* can't check anything */ |
||
184 | else |
||
185 | num_components = src->src.reg.reg->num_components; |
||
186 | } |
||
187 | for (unsigned i = 0; i < 4; i++) { |
||
188 | assert(src->swizzle[i] < 4); |
||
189 | |||
190 | if (nir_alu_instr_channel_used(instr, index, i)) |
||
191 | assert(src->swizzle[i] < num_components); |
||
192 | } |
||
193 | |||
194 | validate_src(&src->src, state); |
||
195 | } |
||
196 | |||
197 | static void |
||
198 | validate_reg_dest(nir_reg_dest *dest, validate_state *state) |
||
199 | { |
||
200 | assert(dest->reg != NULL); |
||
201 | |||
202 | assert(dest->parent_instr == state->instr); |
||
203 | |||
204 | struct hash_entry *entry2; |
||
205 | entry2 = _mesa_hash_table_search(state->regs, dest->reg); |
||
206 | |||
207 | assert(entry2); |
||
208 | |||
209 | reg_validate_state *reg_state = (reg_validate_state *) entry2->data; |
||
210 | _mesa_set_add(reg_state->defs, dest); |
||
211 | |||
212 | if (!dest->reg->is_global) { |
||
213 | assert(reg_state->where_defined == state->impl && |
||
214 | "writing to a register declared in a different function"); |
||
215 | } |
||
216 | |||
217 | assert((dest->reg->num_array_elems == 0 || |
||
218 | dest->base_offset < dest->reg->num_array_elems) && |
||
219 | "definitely out-of-bounds array access"); |
||
220 | |||
221 | if (dest->indirect) { |
||
222 | assert(dest->reg->num_array_elems != 0); |
||
223 | assert((dest->indirect->is_ssa || dest->indirect->reg.indirect == NULL) && |
||
224 | "only one level of indirection allowed"); |
||
225 | validate_src(dest->indirect, state); |
||
226 | } |
||
227 | } |
||
228 | |||
229 | static void |
||
230 | validate_ssa_def(nir_ssa_def *def, validate_state *state) |
||
231 | { |
||
232 | assert(def->index < state->impl->ssa_alloc); |
||
233 | assert(!BITSET_TEST(state->ssa_defs_found, def->index)); |
||
234 | BITSET_SET(state->ssa_defs_found, def->index); |
||
235 | |||
236 | assert(def->parent_instr == state->instr); |
||
237 | |||
238 | assert(def->num_components <= 4); |
||
239 | |||
240 | list_validate(&def->uses); |
||
241 | list_validate(&def->if_uses); |
||
242 | |||
243 | ssa_def_validate_state *def_state = ralloc(state->ssa_defs, |
||
244 | ssa_def_validate_state); |
||
245 | def_state->where_defined = state->impl; |
||
246 | def_state->uses = _mesa_set_create(def_state, _mesa_hash_pointer, |
||
247 | _mesa_key_pointer_equal); |
||
248 | def_state->if_uses = _mesa_set_create(def_state, _mesa_hash_pointer, |
||
249 | _mesa_key_pointer_equal); |
||
250 | _mesa_hash_table_insert(state->ssa_defs, def, def_state); |
||
251 | } |
||
252 | |||
253 | static void |
||
254 | validate_dest(nir_dest *dest, validate_state *state) |
||
255 | { |
||
256 | if (dest->is_ssa) |
||
257 | validate_ssa_def(&dest->ssa, state); |
||
258 | else |
||
259 | validate_reg_dest(&dest->reg, state); |
||
260 | } |
||
261 | |||
262 | static void |
||
263 | validate_alu_dest(nir_alu_dest *dest, validate_state *state) |
||
264 | { |
||
265 | unsigned dest_size = |
||
266 | dest->dest.is_ssa ? dest->dest.ssa.num_components |
||
267 | : dest->dest.reg.reg->num_components; |
||
268 | bool is_packed = !dest->dest.is_ssa && dest->dest.reg.reg->is_packed; |
||
269 | /* |
||
270 | * validate that the instruction doesn't write to components not in the |
||
271 | * register/SSA value |
||
272 | */ |
||
273 | assert(is_packed || !(dest->write_mask & ~((1 << dest_size) - 1))); |
||
274 | |||
275 | /* validate that saturate is only ever used on instructions with |
||
276 | * destinations of type float |
||
277 | */ |
||
278 | nir_alu_instr *alu = nir_instr_as_alu(state->instr); |
||
279 | assert(nir_op_infos[alu->op].output_type == nir_type_float || |
||
280 | !dest->saturate); |
||
281 | |||
282 | validate_dest(&dest->dest, state); |
||
283 | } |
||
284 | |||
285 | static void |
||
286 | validate_alu_instr(nir_alu_instr *instr, validate_state *state) |
||
287 | { |
||
288 | assert(instr->op < nir_num_opcodes); |
||
289 | |||
290 | validate_alu_dest(&instr->dest, state); |
||
291 | |||
292 | for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) { |
||
293 | validate_alu_src(instr, i, state); |
||
294 | } |
||
295 | } |
||
296 | |||
297 | static void |
||
298 | validate_deref_chain(nir_deref *deref, validate_state *state) |
||
299 | { |
||
300 | assert(deref->child == NULL || ralloc_parent(deref->child) == deref); |
||
301 | |||
302 | nir_deref *parent = NULL; |
||
303 | while (deref != NULL) { |
||
304 | switch (deref->deref_type) { |
||
305 | case nir_deref_type_array: |
||
306 | assert(deref->type == glsl_get_array_element(parent->type)); |
||
307 | if (nir_deref_as_array(deref)->deref_array_type == |
||
308 | nir_deref_array_type_indirect) |
||
309 | validate_src(&nir_deref_as_array(deref)->indirect, state); |
||
310 | break; |
||
311 | |||
312 | case nir_deref_type_struct: |
||
313 | assert(deref->type == |
||
314 | glsl_get_struct_field(parent->type, |
||
315 | nir_deref_as_struct(deref)->index)); |
||
316 | break; |
||
317 | |||
318 | case nir_deref_type_var: |
||
319 | break; |
||
320 | |||
321 | default: |
||
322 | assert(!"Invalid deref type"); |
||
323 | break; |
||
324 | } |
||
325 | |||
326 | parent = deref; |
||
327 | deref = deref->child; |
||
328 | } |
||
329 | } |
||
330 | |||
331 | static void |
||
332 | validate_var_use(nir_variable *var, validate_state *state) |
||
333 | { |
||
334 | if (var->data.mode == nir_var_local) { |
||
335 | struct hash_entry *entry = _mesa_hash_table_search(state->var_defs, var); |
||
336 | |||
337 | assert(entry); |
||
338 | assert((nir_function_impl *) entry->data == state->impl); |
||
339 | } |
||
340 | } |
||
341 | |||
342 | static void |
||
343 | validate_deref_var(void *parent_mem_ctx, nir_deref_var *deref, validate_state *state) |
||
344 | { |
||
345 | assert(deref != NULL); |
||
346 | assert(ralloc_parent(deref) == parent_mem_ctx); |
||
347 | assert(deref->deref.type == deref->var->type); |
||
348 | |||
349 | validate_var_use(deref->var, state); |
||
350 | |||
351 | validate_deref_chain(&deref->deref, state); |
||
352 | } |
||
353 | |||
354 | static void |
||
355 | validate_intrinsic_instr(nir_intrinsic_instr *instr, validate_state *state) |
||
356 | { |
||
357 | unsigned num_srcs = nir_intrinsic_infos[instr->intrinsic].num_srcs; |
||
358 | for (unsigned i = 0; i < num_srcs; i++) { |
||
359 | unsigned components_read = |
||
360 | nir_intrinsic_infos[instr->intrinsic].src_components[i]; |
||
361 | if (components_read == 0) |
||
362 | components_read = instr->num_components; |
||
363 | |||
364 | assert(components_read > 0); |
||
365 | |||
366 | if (instr->src[i].is_ssa) { |
||
367 | assert(components_read <= instr->src[i].ssa->num_components); |
||
368 | } else if (!instr->src[i].reg.reg->is_packed) { |
||
369 | assert(components_read <= instr->src[i].reg.reg->num_components); |
||
370 | } |
||
371 | |||
372 | validate_src(&instr->src[i], state); |
||
373 | } |
||
374 | |||
375 | if (nir_intrinsic_infos[instr->intrinsic].has_dest) { |
||
376 | unsigned components_written = |
||
377 | nir_intrinsic_infos[instr->intrinsic].dest_components; |
||
378 | if (components_written == 0) |
||
379 | components_written = instr->num_components; |
||
380 | |||
381 | assert(components_written > 0); |
||
382 | |||
383 | if (instr->dest.is_ssa) { |
||
384 | assert(components_written <= instr->dest.ssa.num_components); |
||
385 | } else if (!instr->dest.reg.reg->is_packed) { |
||
386 | assert(components_written <= instr->dest.reg.reg->num_components); |
||
387 | } |
||
388 | |||
389 | validate_dest(&instr->dest, state); |
||
390 | } |
||
391 | |||
392 | unsigned num_vars = nir_intrinsic_infos[instr->intrinsic].num_variables; |
||
393 | for (unsigned i = 0; i < num_vars; i++) { |
||
394 | validate_deref_var(instr, instr->variables[i], state); |
||
395 | } |
||
396 | |||
397 | switch (instr->intrinsic) { |
||
398 | case nir_intrinsic_load_var: |
||
399 | assert(instr->variables[0]->var->data.mode != nir_var_shader_out); |
||
400 | break; |
||
401 | case nir_intrinsic_store_var: |
||
402 | assert(instr->variables[0]->var->data.mode != nir_var_shader_in && |
||
403 | instr->variables[0]->var->data.mode != nir_var_uniform); |
||
404 | break; |
||
405 | case nir_intrinsic_copy_var: |
||
406 | assert(instr->variables[0]->var->data.mode != nir_var_shader_in && |
||
407 | instr->variables[0]->var->data.mode != nir_var_uniform); |
||
408 | assert(instr->variables[1]->var->data.mode != nir_var_shader_out); |
||
409 | break; |
||
410 | default: |
||
411 | break; |
||
412 | } |
||
413 | } |
||
414 | |||
415 | static void |
||
416 | validate_tex_instr(nir_tex_instr *instr, validate_state *state) |
||
417 | { |
||
418 | validate_dest(&instr->dest, state); |
||
419 | |||
420 | bool src_type_seen[nir_num_tex_src_types]; |
||
421 | for (unsigned i = 0; i < nir_num_tex_src_types; i++) |
||
422 | src_type_seen[i] = false; |
||
423 | |||
424 | for (unsigned i = 0; i < instr->num_srcs; i++) { |
||
425 | assert(!src_type_seen[instr->src[i].src_type]); |
||
426 | src_type_seen[instr->src[i].src_type] = true; |
||
427 | validate_src(&instr->src[i].src, state); |
||
428 | } |
||
429 | |||
430 | if (instr->sampler != NULL) |
||
431 | validate_deref_var(instr, instr->sampler, state); |
||
432 | } |
||
433 | |||
434 | static void |
||
435 | validate_call_instr(nir_call_instr *instr, validate_state *state) |
||
436 | { |
||
437 | if (instr->return_deref == NULL) |
||
438 | assert(glsl_type_is_void(instr->callee->return_type)); |
||
439 | else |
||
440 | assert(instr->return_deref->deref.type == instr->callee->return_type); |
||
441 | |||
442 | assert(instr->num_params == instr->callee->num_params); |
||
443 | |||
444 | for (unsigned i = 0; i < instr->num_params; i++) { |
||
445 | assert(instr->callee->params[i].type == instr->params[i]->deref.type); |
||
446 | validate_deref_var(instr, instr->params[i], state); |
||
447 | } |
||
448 | |||
449 | validate_deref_var(instr, instr->return_deref, state); |
||
450 | } |
||
451 | |||
452 | static void |
||
453 | validate_load_const_instr(nir_load_const_instr *instr, validate_state *state) |
||
454 | { |
||
455 | validate_ssa_def(&instr->def, state); |
||
456 | } |
||
457 | |||
458 | static void |
||
459 | validate_ssa_undef_instr(nir_ssa_undef_instr *instr, validate_state *state) |
||
460 | { |
||
461 | validate_ssa_def(&instr->def, state); |
||
462 | } |
||
463 | |||
464 | static void |
||
465 | validate_phi_instr(nir_phi_instr *instr, validate_state *state) |
||
466 | { |
||
467 | /* |
||
468 | * don't validate the sources until we get to them from their predecessor |
||
469 | * basic blocks, to avoid validating an SSA use before its definition. |
||
470 | */ |
||
471 | |||
472 | validate_dest(&instr->dest, state); |
||
473 | |||
474 | exec_list_validate(&instr->srcs); |
||
475 | assert(exec_list_length(&instr->srcs) == |
||
476 | state->block->predecessors->entries); |
||
477 | } |
||
478 | |||
479 | static void |
||
480 | validate_instr(nir_instr *instr, validate_state *state) |
||
481 | { |
||
482 | assert(instr->block == state->block); |
||
483 | |||
484 | state->instr = instr; |
||
485 | |||
486 | switch (instr->type) { |
||
487 | case nir_instr_type_alu: |
||
488 | validate_alu_instr(nir_instr_as_alu(instr), state); |
||
489 | break; |
||
490 | |||
491 | case nir_instr_type_call: |
||
492 | validate_call_instr(nir_instr_as_call(instr), state); |
||
493 | break; |
||
494 | |||
495 | case nir_instr_type_intrinsic: |
||
496 | validate_intrinsic_instr(nir_instr_as_intrinsic(instr), state); |
||
497 | break; |
||
498 | |||
499 | case nir_instr_type_tex: |
||
500 | validate_tex_instr(nir_instr_as_tex(instr), state); |
||
501 | break; |
||
502 | |||
503 | case nir_instr_type_load_const: |
||
504 | validate_load_const_instr(nir_instr_as_load_const(instr), state); |
||
505 | break; |
||
506 | |||
507 | case nir_instr_type_phi: |
||
508 | validate_phi_instr(nir_instr_as_phi(instr), state); |
||
509 | break; |
||
510 | |||
511 | case nir_instr_type_ssa_undef: |
||
512 | validate_ssa_undef_instr(nir_instr_as_ssa_undef(instr), state); |
||
513 | break; |
||
514 | |||
515 | case nir_instr_type_jump: |
||
516 | break; |
||
517 | |||
518 | default: |
||
519 | assert(!"Invalid ALU instruction type"); |
||
520 | break; |
||
521 | } |
||
522 | |||
523 | state->instr = NULL; |
||
524 | } |
||
525 | |||
526 | static void |
||
527 | validate_phi_src(nir_phi_instr *instr, nir_block *pred, validate_state *state) |
||
528 | { |
||
529 | state->instr = &instr->instr; |
||
530 | |||
531 | assert(instr->dest.is_ssa); |
||
532 | |||
533 | exec_list_validate(&instr->srcs); |
||
534 | nir_foreach_phi_src(instr, src) { |
||
535 | if (src->pred == pred) { |
||
536 | assert(src->src.is_ssa); |
||
537 | assert(src->src.ssa->num_components == |
||
538 | instr->dest.ssa.num_components); |
||
539 | |||
540 | validate_src(&src->src, state); |
||
541 | state->instr = NULL; |
||
542 | return; |
||
543 | } |
||
544 | } |
||
545 | |||
546 | abort(); |
||
547 | } |
||
548 | |||
549 | static void |
||
550 | validate_phi_srcs(nir_block *block, nir_block *succ, validate_state *state) |
||
551 | { |
||
552 | nir_foreach_instr(succ, instr) { |
||
553 | if (instr->type != nir_instr_type_phi) |
||
554 | break; |
||
555 | |||
556 | validate_phi_src(nir_instr_as_phi(instr), block, state); |
||
557 | } |
||
558 | } |
||
559 | |||
560 | static void validate_cf_node(nir_cf_node *node, validate_state *state); |
||
561 | |||
562 | static void |
||
563 | validate_block(nir_block *block, validate_state *state) |
||
564 | { |
||
565 | assert(block->cf_node.parent == state->parent_node); |
||
566 | |||
567 | state->block = block; |
||
568 | |||
569 | exec_list_validate(&block->instr_list); |
||
570 | nir_foreach_instr(block, instr) { |
||
571 | if (instr->type == nir_instr_type_phi) { |
||
572 | assert(instr == nir_block_first_instr(block) || |
||
573 | nir_instr_prev(instr)->type == nir_instr_type_phi); |
||
574 | } |
||
575 | |||
576 | if (instr->type == nir_instr_type_jump) { |
||
577 | assert(instr == nir_block_last_instr(block)); |
||
578 | } |
||
579 | |||
580 | validate_instr(instr, state); |
||
581 | } |
||
582 | |||
583 | assert(block->successors[0] != NULL); |
||
584 | |||
585 | for (unsigned i = 0; i < 2; i++) { |
||
586 | if (block->successors[i] != NULL) { |
||
587 | struct set_entry *entry = |
||
588 | _mesa_set_search(block->successors[i]->predecessors, block); |
||
589 | assert(entry); |
||
590 | |||
591 | validate_phi_srcs(block, block->successors[i], state); |
||
592 | } |
||
593 | } |
||
594 | |||
595 | if (!exec_list_is_empty(&block->instr_list) && |
||
596 | nir_block_last_instr(block)->type == nir_instr_type_jump) |
||
597 | assert(block->successors[1] == NULL); |
||
598 | } |
||
599 | |||
600 | static void |
||
601 | validate_if(nir_if *if_stmt, validate_state *state) |
||
602 | { |
||
603 | state->if_stmt = if_stmt; |
||
604 | |||
605 | assert(!exec_node_is_head_sentinel(if_stmt->cf_node.node.prev)); |
||
606 | nir_cf_node *prev_node = nir_cf_node_prev(&if_stmt->cf_node); |
||
607 | assert(prev_node->type == nir_cf_node_block); |
||
608 | |||
609 | nir_block *prev_block = nir_cf_node_as_block(prev_node); |
||
610 | assert(&prev_block->successors[0]->cf_node == |
||
611 | nir_if_first_then_node(if_stmt)); |
||
612 | assert(&prev_block->successors[1]->cf_node == |
||
613 | nir_if_first_else_node(if_stmt)); |
||
614 | |||
615 | assert(!exec_node_is_tail_sentinel(if_stmt->cf_node.node.next)); |
||
616 | nir_cf_node *next_node = nir_cf_node_next(&if_stmt->cf_node); |
||
617 | assert(next_node->type == nir_cf_node_block); |
||
618 | |||
619 | validate_src(&if_stmt->condition, state); |
||
620 | |||
621 | assert(!exec_list_is_empty(&if_stmt->then_list)); |
||
622 | assert(!exec_list_is_empty(&if_stmt->else_list)); |
||
623 | |||
624 | nir_cf_node *old_parent = state->parent_node; |
||
625 | state->parent_node = &if_stmt->cf_node; |
||
626 | |||
627 | exec_list_validate(&if_stmt->then_list); |
||
628 | foreach_list_typed(nir_cf_node, cf_node, node, &if_stmt->then_list) { |
||
629 | validate_cf_node(cf_node, state); |
||
630 | } |
||
631 | |||
632 | exec_list_validate(&if_stmt->else_list); |
||
633 | foreach_list_typed(nir_cf_node, cf_node, node, &if_stmt->else_list) { |
||
634 | validate_cf_node(cf_node, state); |
||
635 | } |
||
636 | |||
637 | state->parent_node = old_parent; |
||
638 | state->if_stmt = NULL; |
||
639 | } |
||
640 | |||
641 | static void |
||
642 | validate_loop(nir_loop *loop, validate_state *state) |
||
643 | { |
||
644 | assert(!exec_node_is_head_sentinel(loop->cf_node.node.prev)); |
||
645 | nir_cf_node *prev_node = nir_cf_node_prev(&loop->cf_node); |
||
646 | assert(prev_node->type == nir_cf_node_block); |
||
647 | |||
648 | nir_block *prev_block = nir_cf_node_as_block(prev_node); |
||
649 | assert(&prev_block->successors[0]->cf_node == nir_loop_first_cf_node(loop)); |
||
650 | assert(prev_block->successors[1] == NULL); |
||
651 | |||
652 | assert(!exec_node_is_tail_sentinel(loop->cf_node.node.next)); |
||
653 | nir_cf_node *next_node = nir_cf_node_next(&loop->cf_node); |
||
654 | assert(next_node->type == nir_cf_node_block); |
||
655 | |||
656 | assert(!exec_list_is_empty(&loop->body)); |
||
657 | |||
658 | nir_cf_node *old_parent = state->parent_node; |
||
659 | state->parent_node = &loop->cf_node; |
||
660 | |||
661 | exec_list_validate(&loop->body); |
||
662 | foreach_list_typed(nir_cf_node, cf_node, node, &loop->body) { |
||
663 | validate_cf_node(cf_node, state); |
||
664 | } |
||
665 | |||
666 | state->parent_node = old_parent; |
||
667 | } |
||
668 | |||
669 | static void |
||
670 | validate_cf_node(nir_cf_node *node, validate_state *state) |
||
671 | { |
||
672 | assert(node->parent == state->parent_node); |
||
673 | |||
674 | switch (node->type) { |
||
675 | case nir_cf_node_block: |
||
676 | validate_block(nir_cf_node_as_block(node), state); |
||
677 | break; |
||
678 | |||
679 | case nir_cf_node_if: |
||
680 | validate_if(nir_cf_node_as_if(node), state); |
||
681 | break; |
||
682 | |||
683 | case nir_cf_node_loop: |
||
684 | validate_loop(nir_cf_node_as_loop(node), state); |
||
685 | break; |
||
686 | |||
687 | default: |
||
688 | unreachable("Invalid CF node type"); |
||
689 | } |
||
690 | } |
||
691 | |||
692 | static void |
||
693 | prevalidate_reg_decl(nir_register *reg, bool is_global, validate_state *state) |
||
694 | { |
||
695 | assert(reg->is_global == is_global); |
||
696 | |||
697 | if (is_global) |
||
698 | assert(reg->index < state->shader->reg_alloc); |
||
699 | else |
||
700 | assert(reg->index < state->impl->reg_alloc); |
||
701 | assert(!BITSET_TEST(state->regs_found, reg->index)); |
||
702 | BITSET_SET(state->regs_found, reg->index); |
||
703 | |||
704 | list_validate(®->uses); |
||
705 | list_validate(®->defs); |
||
706 | list_validate(®->if_uses); |
||
707 | |||
708 | reg_validate_state *reg_state = ralloc(state->regs, reg_validate_state); |
||
709 | reg_state->uses = _mesa_set_create(reg_state, _mesa_hash_pointer, |
||
710 | _mesa_key_pointer_equal); |
||
711 | reg_state->if_uses = _mesa_set_create(reg_state, _mesa_hash_pointer, |
||
712 | _mesa_key_pointer_equal); |
||
713 | reg_state->defs = _mesa_set_create(reg_state, _mesa_hash_pointer, |
||
714 | _mesa_key_pointer_equal); |
||
715 | |||
716 | reg_state->where_defined = is_global ? NULL : state->impl; |
||
717 | |||
718 | _mesa_hash_table_insert(state->regs, reg, reg_state); |
||
719 | } |
||
720 | |||
721 | static void |
||
722 | postvalidate_reg_decl(nir_register *reg, validate_state *state) |
||
723 | { |
||
724 | struct hash_entry *entry = _mesa_hash_table_search(state->regs, reg); |
||
725 | |||
726 | reg_validate_state *reg_state = (reg_validate_state *) entry->data; |
||
727 | |||
728 | nir_foreach_use(reg, src) { |
||
729 | struct set_entry *entry = _mesa_set_search(reg_state->uses, src); |
||
730 | assert(entry); |
||
731 | _mesa_set_remove(reg_state->uses, entry); |
||
732 | } |
||
733 | |||
734 | if (reg_state->uses->entries != 0) { |
||
735 | printf("extra entries in register uses:\n"); |
||
736 | struct set_entry *entry; |
||
737 | set_foreach(reg_state->uses, entry) |
||
738 | printf("%p\n", entry->key); |
||
739 | |||
740 | abort(); |
||
741 | } |
||
742 | |||
743 | nir_foreach_if_use(reg, src) { |
||
744 | struct set_entry *entry = _mesa_set_search(reg_state->if_uses, src); |
||
745 | assert(entry); |
||
746 | _mesa_set_remove(reg_state->if_uses, entry); |
||
747 | } |
||
748 | |||
749 | if (reg_state->if_uses->entries != 0) { |
||
750 | printf("extra entries in register if_uses:\n"); |
||
751 | struct set_entry *entry; |
||
752 | set_foreach(reg_state->if_uses, entry) |
||
753 | printf("%p\n", entry->key); |
||
754 | |||
755 | abort(); |
||
756 | } |
||
757 | |||
758 | nir_foreach_def(reg, src) { |
||
759 | struct set_entry *entry = _mesa_set_search(reg_state->defs, src); |
||
760 | assert(entry); |
||
761 | _mesa_set_remove(reg_state->defs, entry); |
||
762 | } |
||
763 | |||
764 | if (reg_state->defs->entries != 0) { |
||
765 | printf("extra entries in register defs:\n"); |
||
766 | struct set_entry *entry; |
||
767 | set_foreach(reg_state->defs, entry) |
||
768 | printf("%p\n", entry->key); |
||
769 | |||
770 | abort(); |
||
771 | } |
||
772 | } |
||
773 | |||
774 | static void |
||
775 | validate_var_decl(nir_variable *var, bool is_global, validate_state *state) |
||
776 | { |
||
777 | assert(is_global != (var->data.mode == nir_var_local)); |
||
778 | |||
779 | /* |
||
780 | * TODO validate some things ir_validate.cpp does (requires more GLSL type |
||
781 | * support) |
||
782 | */ |
||
783 | |||
784 | if (!is_global) { |
||
785 | _mesa_hash_table_insert(state->var_defs, var, state->impl); |
||
786 | } |
||
787 | } |
||
788 | |||
789 | static bool |
||
790 | postvalidate_ssa_def(nir_ssa_def *def, void *void_state) |
||
791 | { |
||
792 | validate_state *state = void_state; |
||
793 | |||
794 | struct hash_entry *entry = _mesa_hash_table_search(state->ssa_defs, def); |
||
795 | ssa_def_validate_state *def_state = (ssa_def_validate_state *)entry->data; |
||
796 | |||
797 | nir_foreach_use(def, src) { |
||
798 | struct set_entry *entry = _mesa_set_search(def_state->uses, src); |
||
799 | assert(entry); |
||
800 | _mesa_set_remove(def_state->uses, entry); |
||
801 | } |
||
802 | |||
803 | if (def_state->uses->entries != 0) { |
||
804 | printf("extra entries in register uses:\n"); |
||
805 | struct set_entry *entry; |
||
806 | set_foreach(def_state->uses, entry) |
||
807 | printf("%p\n", entry->key); |
||
808 | |||
809 | abort(); |
||
810 | } |
||
811 | |||
812 | nir_foreach_if_use(def, src) { |
||
813 | struct set_entry *entry = _mesa_set_search(def_state->if_uses, src); |
||
814 | assert(entry); |
||
815 | _mesa_set_remove(def_state->if_uses, entry); |
||
816 | } |
||
817 | |||
818 | if (def_state->if_uses->entries != 0) { |
||
819 | printf("extra entries in register uses:\n"); |
||
820 | struct set_entry *entry; |
||
821 | set_foreach(def_state->if_uses, entry) |
||
822 | printf("%p\n", entry->key); |
||
823 | |||
824 | abort(); |
||
825 | } |
||
826 | |||
827 | return true; |
||
828 | } |
||
829 | |||
830 | static bool |
||
831 | postvalidate_ssa_defs_block(nir_block *block, void *state) |
||
832 | { |
||
833 | nir_foreach_instr(block, instr) |
||
834 | nir_foreach_ssa_def(instr, postvalidate_ssa_def, state); |
||
835 | |||
836 | return true; |
||
837 | } |
||
838 | |||
839 | static void |
||
840 | validate_function_impl(nir_function_impl *impl, validate_state *state) |
||
841 | { |
||
842 | assert(impl->overload->impl == impl); |
||
843 | assert(impl->cf_node.parent == NULL); |
||
844 | |||
845 | assert(impl->num_params == impl->overload->num_params); |
||
846 | for (unsigned i = 0; i < impl->num_params; i++) |
||
847 | assert(impl->params[i]->type == impl->overload->params[i].type); |
||
848 | |||
849 | if (glsl_type_is_void(impl->overload->return_type)) |
||
850 | assert(impl->return_var == NULL); |
||
851 | else |
||
852 | assert(impl->return_var->type == impl->overload->return_type); |
||
853 | |||
854 | assert(exec_list_is_empty(&impl->end_block->instr_list)); |
||
855 | assert(impl->end_block->successors[0] == NULL); |
||
856 | assert(impl->end_block->successors[1] == NULL); |
||
857 | |||
858 | state->impl = impl; |
||
859 | state->parent_node = &impl->cf_node; |
||
860 | |||
861 | exec_list_validate(&impl->locals); |
||
862 | foreach_list_typed(nir_variable, var, node, &impl->locals) { |
||
863 | validate_var_decl(var, false, state); |
||
864 | } |
||
865 | |||
866 | state->regs_found = realloc(state->regs_found, |
||
867 | BITSET_WORDS(impl->reg_alloc) * |
||
868 | sizeof(BITSET_WORD)); |
||
869 | memset(state->regs_found, 0, BITSET_WORDS(impl->reg_alloc) * |
||
870 | sizeof(BITSET_WORD)); |
||
871 | exec_list_validate(&impl->registers); |
||
872 | foreach_list_typed(nir_register, reg, node, &impl->registers) { |
||
873 | prevalidate_reg_decl(reg, false, state); |
||
874 | } |
||
875 | |||
876 | state->ssa_defs_found = realloc(state->ssa_defs_found, |
||
877 | BITSET_WORDS(impl->ssa_alloc) * |
||
878 | sizeof(BITSET_WORD)); |
||
879 | memset(state->ssa_defs_found, 0, BITSET_WORDS(impl->ssa_alloc) * |
||
880 | sizeof(BITSET_WORD)); |
||
881 | exec_list_validate(&impl->body); |
||
882 | foreach_list_typed(nir_cf_node, node, node, &impl->body) { |
||
883 | validate_cf_node(node, state); |
||
884 | } |
||
885 | |||
886 | foreach_list_typed(nir_register, reg, node, &impl->registers) { |
||
887 | postvalidate_reg_decl(reg, state); |
||
888 | } |
||
889 | |||
890 | nir_foreach_block(impl, postvalidate_ssa_defs_block, state); |
||
891 | } |
||
892 | |||
893 | static void |
||
894 | validate_function_overload(nir_function_overload *overload, |
||
895 | validate_state *state) |
||
896 | { |
||
897 | if (overload->impl != NULL) |
||
898 | validate_function_impl(overload->impl, state); |
||
899 | } |
||
900 | |||
901 | static void |
||
902 | validate_function(nir_function *func, validate_state *state) |
||
903 | { |
||
904 | exec_list_validate(&func->overload_list); |
||
905 | foreach_list_typed(nir_function_overload, overload, node, &func->overload_list) { |
||
906 | assert(overload->function == func); |
||
907 | validate_function_overload(overload, state); |
||
908 | } |
||
909 | } |
||
910 | |||
911 | static void |
||
912 | init_validate_state(validate_state *state) |
||
913 | { |
||
914 | state->regs = _mesa_hash_table_create(NULL, _mesa_hash_pointer, |
||
915 | _mesa_key_pointer_equal); |
||
916 | state->ssa_defs = _mesa_hash_table_create(NULL, _mesa_hash_pointer, |
||
917 | _mesa_key_pointer_equal); |
||
918 | state->ssa_defs_found = NULL; |
||
919 | state->regs_found = NULL; |
||
920 | state->var_defs = _mesa_hash_table_create(NULL, _mesa_hash_pointer, |
||
921 | _mesa_key_pointer_equal); |
||
922 | } |
||
923 | |||
924 | static void |
||
925 | destroy_validate_state(validate_state *state) |
||
926 | { |
||
927 | _mesa_hash_table_destroy(state->regs, NULL); |
||
928 | _mesa_hash_table_destroy(state->ssa_defs, NULL); |
||
929 | free(state->ssa_defs_found); |
||
930 | free(state->regs_found); |
||
931 | _mesa_hash_table_destroy(state->var_defs, NULL); |
||
932 | } |
||
933 | |||
934 | void |
||
935 | nir_validate_shader(nir_shader *shader) |
||
936 | { |
||
937 | validate_state state; |
||
938 | init_validate_state(&state); |
||
939 | |||
940 | state.shader = shader; |
||
941 | |||
942 | exec_list_validate(&shader->uniforms); |
||
943 | foreach_list_typed(nir_variable, var, node, &shader->uniforms) { |
||
944 | validate_var_decl(var, true, &state); |
||
945 | } |
||
946 | |||
947 | exec_list_validate(&shader->inputs); |
||
948 | foreach_list_typed(nir_variable, var, node, &shader->inputs) { |
||
949 | validate_var_decl(var, true, &state); |
||
950 | } |
||
951 | |||
952 | exec_list_validate(&shader->outputs); |
||
953 | foreach_list_typed(nir_variable, var, node, &shader->outputs) { |
||
954 | validate_var_decl(var, true, &state); |
||
955 | } |
||
956 | |||
957 | exec_list_validate(&shader->globals); |
||
958 | foreach_list_typed(nir_variable, var, node, &shader->globals) { |
||
959 | validate_var_decl(var, true, &state); |
||
960 | } |
||
961 | |||
962 | exec_list_validate(&shader->system_values); |
||
963 | foreach_list_typed(nir_variable, var, node, &shader->system_values) { |
||
964 | validate_var_decl(var, true, &state); |
||
965 | } |
||
966 | |||
967 | state.regs_found = realloc(state.regs_found, |
||
968 | BITSET_WORDS(shader->reg_alloc) * |
||
969 | sizeof(BITSET_WORD)); |
||
970 | memset(state.regs_found, 0, BITSET_WORDS(shader->reg_alloc) * |
||
971 | sizeof(BITSET_WORD)); |
||
972 | exec_list_validate(&shader->registers); |
||
973 | foreach_list_typed(nir_register, reg, node, &shader->registers) { |
||
974 | prevalidate_reg_decl(reg, true, &state); |
||
975 | } |
||
976 | |||
977 | exec_list_validate(&shader->functions); |
||
978 | foreach_list_typed(nir_function, func, node, &shader->functions) { |
||
979 | validate_function(func, &state); |
||
980 | } |
||
981 | |||
982 | foreach_list_typed(nir_register, reg, node, &shader->registers) { |
||
983 | postvalidate_reg_decl(reg, &state); |
||
984 | } |
||
985 | |||
986 | destroy_validate_state(&state); |
||
987 | } |
||
988 | |||
989 | #endif /* NDEBUG */>>>>>>>>=>=>=>=>>>>><>=>>>>>>> |