projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
nir/print: Use nir_src_as_int for array indices
[mesa.git] / src / compiler / nir / nir_print.c
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 "compiler/shader_enums.h"
30 #include "util/half_float.h"
31 #include "vulkan/vulkan_core.h"
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <inttypes.h> /* for PRIx64 macro */
35
36 static void
37 print_tabs(unsigned num_tabs, FILE *fp)
38 {
39 for (unsigned i = 0; i < num_tabs; i++)
40 fprintf(fp, "\t");
41 }
42
43 typedef struct {
44 FILE *fp;
45 nir_shader *shader;
46 /** map from nir_variable -> printable name */
47 struct hash_table *ht;
48
49 /** set of names used so far for nir_variables */
50 struct set *syms;
51
52 /* an index used to make new non-conflicting names */
53 unsigned index;
54
55 /**
56 * Optional table of annotations mapping nir object
57 * (such as instr or var) to message to print.
58 */
59 struct hash_table *annotations;
60 } print_state;
61
62 static void
63 print_annotation(print_state *state, void *obj)
64 {
65 if (!state->annotations)
66 return;
67
68 struct hash_entry *entry = _mesa_hash_table_search(state->annotations, obj);
69 if (!entry)
70 return;
71
72 const char *note = entry->data;
73 _mesa_hash_table_remove(state->annotations, entry);
74
75 fprintf(stderr, "%s\n\n", note);
76 }
77
78 static void
79 print_register(nir_register *reg, print_state *state)
80 {
81 FILE *fp = state->fp;
82 if (reg->name != NULL)
83 fprintf(fp, "/* %s */ ", reg->name);
84 fprintf(fp, "r%u", reg->index);
85 }
86
87 static const char *sizes[] = { "error", "vec1", "vec2", "vec3", "vec4",
88 "error", "error", "error", "vec8",
89 "error", "error", "error", "error",
90 "error", "error", "error", "vec16"};
91
92 static void
93 print_register_decl(nir_register *reg, print_state *state)
94 {
95 FILE *fp = state->fp;
96 fprintf(fp, "decl_reg %s %u ", sizes[reg->num_components], reg->bit_size);
97 print_register(reg, state);
98 if (reg->num_array_elems != 0)
99 fprintf(fp, "[%u]", reg->num_array_elems);
100 fprintf(fp, "\n");
101 }
102
103 static void
104 print_ssa_def(nir_ssa_def *def, print_state *state)
105 {
106 FILE *fp = state->fp;
107 if (def->name != NULL)
108 fprintf(fp, "/* %s */ ", def->name);
109 fprintf(fp, "%s %u ssa_%u", sizes[def->num_components], def->bit_size,
110 def->index);
111 }
112
113 static void
114 print_ssa_use(nir_ssa_def *def, print_state *state)
115 {
116 FILE *fp = state->fp;
117 if (def->name != NULL)
118 fprintf(fp, "/* %s */ ", def->name);
119 fprintf(fp, "ssa_%u", def->index);
120 }
121
122 static void print_src(const nir_src *src, print_state *state);
123
124 static void
125 print_reg_src(const nir_reg_src *src, print_state *state)
126 {
127 FILE *fp = state->fp;
128 print_register(src->reg, state);
129 if (src->reg->num_array_elems != 0) {
130 fprintf(fp, "[%u", src->base_offset);
131 if (src->indirect != NULL) {
132 fprintf(fp, " + ");
133 print_src(src->indirect, state);
134 }
135 fprintf(fp, "]");
136 }
137 }
138
139 static void
140 print_reg_dest(nir_reg_dest *dest, print_state *state)
141 {
142 FILE *fp = state->fp;
143 print_register(dest->reg, state);
144 if (dest->reg->num_array_elems != 0) {
145 fprintf(fp, "[%u", dest->base_offset);
146 if (dest->indirect != NULL) {
147 fprintf(fp, " + ");
148 print_src(dest->indirect, state);
149 }
150 fprintf(fp, "]");
151 }
152 }
153
154 static void
155 print_src(const nir_src *src, print_state *state)
156 {
157 if (src->is_ssa)
158 print_ssa_use(src->ssa, state);
159 else
160 print_reg_src(&src->reg, state);
161 }
162
163 static void
164 print_dest(nir_dest *dest, print_state *state)
165 {
166 if (dest->is_ssa)
167 print_ssa_def(&dest->ssa, state);
168 else
169 print_reg_dest(&dest->reg, state);
170 }
171
172 static void
173 print_alu_src(nir_alu_instr *instr, unsigned src, print_state *state)
174 {
175 FILE *fp = state->fp;
176
177 if (instr->src[src].negate)
178 fprintf(fp, "-");
179 if (instr->src[src].abs)
180 fprintf(fp, "abs(");
181
182 print_src(&instr->src[src].src, state);
183
184 bool print_swizzle = false;
185 nir_component_mask_t used_channels = 0;
186
187 for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++) {
188 if (!nir_alu_instr_channel_used(instr, src, i))
189 continue;
190
191 used_channels++;
192
193 if (instr->src[src].swizzle[i] != i) {
194 print_swizzle = true;
195 break;
196 }
197 }
198
199 unsigned live_channels = nir_src_num_components(instr->src[src].src);
200
201 if (print_swizzle || used_channels != live_channels) {
202 fprintf(fp, ".");
203 for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++) {
204 if (!nir_alu_instr_channel_used(instr, src, i))
205 continue;
206
207 fprintf(fp, "%c", "xyzw"[instr->src[src].swizzle[i]]);
208 }
209 }
210
211 if (instr->src[src].abs)
212 fprintf(fp, ")");
213 }
214
215 static void
216 print_alu_dest(nir_alu_dest *dest, print_state *state)
217 {
218 FILE *fp = state->fp;
219 /* we're going to print the saturate modifier later, after the opcode */
220
221 print_dest(&dest->dest, state);
222
223 if (!dest->dest.is_ssa &&
224 dest->write_mask != (1 << dest->dest.reg.reg->num_components) - 1) {
225 fprintf(fp, ".");
226 for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++)
227 if ((dest->write_mask >> i) & 1)
228 fprintf(fp, "%c", "xyzw"[i]);
229 }
230 }
231
232 static void
233 print_alu_instr(nir_alu_instr *instr, print_state *state)
234 {
235 FILE *fp = state->fp;
236
237 print_alu_dest(&instr->dest, state);
238
239 fprintf(fp, " = %s", nir_op_infos[instr->op].name);
240 if (instr->exact)
241 fprintf(fp, "!");
242 if (instr->dest.saturate)
243 fprintf(fp, ".sat");
244 fprintf(fp, " ");
245
246 for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) {
247 if (i != 0)
248 fprintf(fp, ", ");
249
250 print_alu_src(instr, i, state);
251 }
252 }
253
254 static const char *
255 get_var_name(nir_variable *var, print_state *state)
256 {
257 if (state->ht == NULL)
258 return var->name ? var->name : "unnamed";
259
260 assert(state->syms);
261
262 struct hash_entry *entry = _mesa_hash_table_search(state->ht, var);
263 if (entry)
264 return entry->data;
265
266 char *name;
267 if (var->name == NULL) {
268 name = ralloc_asprintf(state->syms, "@%u", state->index++);
269 } else {
270 struct set_entry *set_entry = _mesa_set_search(state->syms, var->name);
271 if (set_entry != NULL) {
272 /* we have a collision with another name, append an @ + a unique
273 * index */
274 name = ralloc_asprintf(state->syms, "%s@%u", var->name,
275 state->index++);
276 } else {
277 /* Mark this one as seen */
278 _mesa_set_add(state->syms, var->name);
279 name = var->name;
280 }
281 }
282
283 _mesa_hash_table_insert(state->ht, var, name);
284
285 return name;
286 }
287
288 static void
289 print_constant(nir_constant *c, const struct glsl_type *type, print_state *state)
290 {
291 FILE *fp = state->fp;
292 const unsigned rows = glsl_get_vector_elements(type);
293 const unsigned cols = glsl_get_matrix_columns(type);
294 unsigned i, j;
295
296 switch (glsl_get_base_type(type)) {
297 case GLSL_TYPE_BOOL:
298 /* Only float base types can be matrices. */
299 assert(cols == 1);
300
301 for (i = 0; i < rows; i++) {
302 if (i > 0) fprintf(fp, ", ");
303 fprintf(fp, "%s", c->values[0].b[i] ? "true" : "false");
304 }
305 break;
306
307 case GLSL_TYPE_UINT8:
308 case GLSL_TYPE_INT8:
309 /* Only float base types can be matrices. */
310 assert(cols == 1);
311
312 for (i = 0; i < rows; i++) {
313 if (i > 0) fprintf(fp, ", ");
314 fprintf(fp, "0x%02x", c->values[0].u8[i]);
315 }
316 break;
317
318 case GLSL_TYPE_UINT16:
319 case GLSL_TYPE_INT16:
320 /* Only float base types can be matrices. */
321 assert(cols == 1);
322
323 for (i = 0; i < rows; i++) {
324 if (i > 0) fprintf(fp, ", ");
325 fprintf(fp, "0x%04x", c->values[0].u16[i]);
326 }
327 break;
328
329 case GLSL_TYPE_UINT:
330 case GLSL_TYPE_INT:
331 /* Only float base types can be matrices. */
332 assert(cols == 1);
333
334 for (i = 0; i < rows; i++) {
335 if (i > 0) fprintf(fp, ", ");
336 fprintf(fp, "0x%08x", c->values[0].u32[i]);
337 }
338 break;
339
340 case GLSL_TYPE_FLOAT16:
341 for (i = 0; i < cols; i++) {
342 for (j = 0; j < rows; j++) {
343 if (i + j > 0) fprintf(fp, ", ");
344 fprintf(fp, "%f", _mesa_half_to_float(c->values[i].u16[j]));
345 }
346 }
347 break;
348
349 case GLSL_TYPE_FLOAT:
350 for (i = 0; i < cols; i++) {
351 for (j = 0; j < rows; j++) {
352 if (i + j > 0) fprintf(fp, ", ");
353 fprintf(fp, "%f", c->values[i].f32[j]);
354 }
355 }
356 break;
357
358 case GLSL_TYPE_DOUBLE:
359 for (i = 0; i < cols; i++) {
360 for (j = 0; j < rows; j++) {
361 if (i + j > 0) fprintf(fp, ", ");
362 fprintf(fp, "%f", c->values[i].f64[j]);
363 }
364 }
365 break;
366
367 case GLSL_TYPE_UINT64:
368 case GLSL_TYPE_INT64:
369 /* Only float base types can be matrices. */
370 assert(cols == 1);
371
372 for (i = 0; i < cols; i++) {
373 if (i > 0) fprintf(fp, ", ");
374 fprintf(fp, "0x%08" PRIx64, c->values[0].u64[i]);
375 }
376 break;
377
378 case GLSL_TYPE_STRUCT:
379 for (i = 0; i < c->num_elements; i++) {
380 if (i > 0) fprintf(fp, ", ");
381 fprintf(fp, "{ ");
382 print_constant(c->elements[i], glsl_get_struct_field(type, i), state);
383 fprintf(fp, " }");
384 }
385 break;
386
387 case GLSL_TYPE_ARRAY:
388 for (i = 0; i < c->num_elements; i++) {
389 if (i > 0) fprintf(fp, ", ");
390 fprintf(fp, "{ ");
391 print_constant(c->elements[i], glsl_get_array_element(type), state);
392 fprintf(fp, " }");
393 }
394 break;
395
396 default:
397 unreachable("not reached");
398 }
399 }
400
401 static const char *
402 get_variable_mode_str(nir_variable_mode mode, bool want_local_global_mode)
403 {
404 switch (mode) {
405 case nir_var_shader_in:
406 return "shader_in";
407 case nir_var_shader_out:
408 return "shader_out";
409 case nir_var_uniform:
410 return "uniform";
411 case nir_var_mem_ubo:
412 return "ubo";
413 case nir_var_system_value:
414 return "system";
415 case nir_var_mem_ssbo:
416 return "ssbo";
417 case nir_var_mem_shared:
418 return "shared";
419 case nir_var_mem_global:
420 return "global";
421 case nir_var_shader_temp:
422 return want_local_global_mode ? "shader_temp" : "";
423 case nir_var_function_temp:
424 return want_local_global_mode ? "function_temp" : "";
425 default:
426 return "";
427 }
428 }
429
430 static void
431 print_var_decl(nir_variable *var, print_state *state)
432 {
433 FILE *fp = state->fp;
434
435 fprintf(fp, "decl_var ");
436
437 const char *const cent = (var->data.centroid) ? "centroid " : "";
438 const char *const samp = (var->data.sample) ? "sample " : "";
439 const char *const patch = (var->data.patch) ? "patch " : "";
440 const char *const inv = (var->data.invariant) ? "invariant " : "";
441 fprintf(fp, "%s%s%s%s%s %s ",
442 cent, samp, patch, inv, get_variable_mode_str(var->data.mode, false),
443 glsl_interp_mode_name(var->data.interpolation));
444
445 enum gl_access_qualifier access = var->data.image.access;
446 const char *const coher = (access & ACCESS_COHERENT) ? "coherent " : "";
447 const char *const volat = (access & ACCESS_VOLATILE) ? "volatile " : "";
448 const char *const restr = (access & ACCESS_RESTRICT) ? "restrict " : "";
449 const char *const ronly = (access & ACCESS_NON_WRITEABLE) ? "readonly " : "";
450 const char *const wonly = (access & ACCESS_NON_READABLE) ? "writeonly " : "";
451 fprintf(fp, "%s%s%s%s%s", coher, volat, restr, ronly, wonly);
452
453 #define FORMAT_CASE(x) case x: fprintf(stderr, #x " "); break
454 switch (var->data.image.format) {
455 FORMAT_CASE(GL_RGBA32F);
456 FORMAT_CASE(GL_RGBA32UI);
457 FORMAT_CASE(GL_RGBA32I);
458 FORMAT_CASE(GL_R32F);
459 FORMAT_CASE(GL_R32UI);
460 FORMAT_CASE(GL_R32I);
461 FORMAT_CASE(GL_RG32F);
462 FORMAT_CASE(GL_RG32UI);
463 FORMAT_CASE(GL_RG32I);
464 FORMAT_CASE(GL_R8);
465 FORMAT_CASE(GL_RG8);
466 FORMAT_CASE(GL_RGBA8);
467 FORMAT_CASE(GL_R8_SNORM);
468 FORMAT_CASE(GL_RG8_SNORM);
469 FORMAT_CASE(GL_RGBA8_SNORM);
470 FORMAT_CASE(GL_R16);
471 FORMAT_CASE(GL_RG16);
472 FORMAT_CASE(GL_RGBA16);
473 FORMAT_CASE(GL_R16_SNORM);
474 FORMAT_CASE(GL_RG16_SNORM);
475 FORMAT_CASE(GL_RGBA16_SNORM);
476 FORMAT_CASE(GL_R16F);
477 FORMAT_CASE(GL_RG16F);
478 FORMAT_CASE(GL_RGBA16F);
479 FORMAT_CASE(GL_R8UI);
480 FORMAT_CASE(GL_R8I);
481 FORMAT_CASE(GL_RG8UI);
482 FORMAT_CASE(GL_RG8I);
483 FORMAT_CASE(GL_RGBA8UI);
484 FORMAT_CASE(GL_RGBA8I);
485 FORMAT_CASE(GL_R16UI);
486 FORMAT_CASE(GL_R16I);
487 FORMAT_CASE(GL_RG16UI);
488 FORMAT_CASE(GL_RG16I);
489 FORMAT_CASE(GL_RGBA16UI);
490 FORMAT_CASE(GL_RGBA16I);
491 FORMAT_CASE(GL_R11F_G11F_B10F);
492 FORMAT_CASE(GL_RGB9_E5);
493 FORMAT_CASE(GL_RGB10_A2);
494 FORMAT_CASE(GL_RGB10_A2UI);
495 default: /* Including the normal GL_NONE */
496 break;
497 }
498 #undef FORMAT_CASE
499
500 fprintf(fp, "%s %s", glsl_get_type_name(var->type),
501 get_var_name(var, state));
502
503 if (var->data.mode == nir_var_shader_in ||
504 var->data.mode == nir_var_shader_out ||
505 var->data.mode == nir_var_uniform ||
506 var->data.mode == nir_var_mem_ubo ||
507 var->data.mode == nir_var_mem_ssbo) {
508 const char *loc = NULL;
509 char buf[4];
510
511 switch (state->shader->info.stage) {
512 case MESA_SHADER_VERTEX:
513 if (var->data.mode == nir_var_shader_in)
514 loc = gl_vert_attrib_name(var->data.location);
515 else if (var->data.mode == nir_var_shader_out)
516 loc = gl_varying_slot_name(var->data.location);
517 break;
518 case MESA_SHADER_GEOMETRY:
519 if ((var->data.mode == nir_var_shader_in) ||
520 (var->data.mode == nir_var_shader_out))
521 loc = gl_varying_slot_name(var->data.location);
522 break;
523 case MESA_SHADER_FRAGMENT:
524 if (var->data.mode == nir_var_shader_in)
525 loc = gl_varying_slot_name(var->data.location);
526 else if (var->data.mode == nir_var_shader_out)
527 loc = gl_frag_result_name(var->data.location);
528 break;
529 case MESA_SHADER_TESS_CTRL:
530 case MESA_SHADER_TESS_EVAL:
531 case MESA_SHADER_COMPUTE:
532 case MESA_SHADER_KERNEL:
533 default:
534 /* TODO */
535 break;
536 }
537
538 if (!loc) {
539 snprintf(buf, sizeof(buf), "%u", var->data.location);
540 loc = buf;
541 }
542
543 /* For shader I/O vars that have been split to components or packed,
544 * print the fractional location within the input/output.
545 */
546 unsigned int num_components =
547 glsl_get_components(glsl_without_array(var->type));
548 const char *components = NULL;
549 char components_local[6] = {'.' /* the rest is 0-filled */};
550 switch (var->data.mode) {
551 case nir_var_shader_in:
552 case nir_var_shader_out:
553 if (num_components < 4 && num_components != 0) {
554 const char *xyzw = "xyzw";
555 for (int i = 0; i < num_components; i++)
556 components_local[i + 1] = xyzw[i + var->data.location_frac];
557
558 components = components_local;
559 }
560 break;
561 default:
562 break;
563 }
564
565 fprintf(fp, " (%s%s, %u, %u)%s", loc,
566 components ? components : "",
567 var->data.driver_location, var->data.binding,
568 var->data.compact ? " compact" : "");
569 }
570
571 if (var->constant_initializer) {
572 fprintf(fp, " = { ");
573 print_constant(var->constant_initializer, var->type, state);
574 fprintf(fp, " }");
575 }
576
577 fprintf(fp, "\n");
578 print_annotation(state, var);
579 }
580
581 static void
582 print_deref_link(const nir_deref_instr *instr, bool whole_chain, print_state *state)
583 {
584 FILE *fp = state->fp;
585
586 if (instr->deref_type == nir_deref_type_var) {
587 fprintf(fp, "%s", get_var_name(instr->var, state));
588 return;
589 } else if (instr->deref_type == nir_deref_type_cast) {
590 fprintf(fp, "(%s *)", glsl_get_type_name(instr->type));
591 print_src(&instr->parent, state);
592 return;
593 }
594
595 assert(instr->parent.is_ssa);
596 nir_deref_instr *parent =
597 nir_instr_as_deref(instr->parent.ssa->parent_instr);
598
599 /* Is the parent we're going to print a bare cast? */
600 const bool is_parent_cast =
601 whole_chain && parent->deref_type == nir_deref_type_cast;
602
603 /* If we're not printing the whole chain, the parent we print will be a SSA
604 * value that represents a pointer. The only deref type that naturally
605 * gives a pointer is a cast.
606 */
607 const bool is_parent_pointer =
608 !whole_chain || parent->deref_type == nir_deref_type_cast;
609
610 /* Struct derefs have a nice syntax that works on pointers, arrays derefs
611 * do not.
612 */
613 const bool need_deref =
614 is_parent_pointer && instr->deref_type != nir_deref_type_struct;
615
616 /* Cast need extra parens and so * dereferences */
617 if (is_parent_cast || need_deref)
618 fprintf(fp, "(");
619
620 if (need_deref)
621 fprintf(fp, "*");
622
623 if (whole_chain) {
624 print_deref_link(parent, whole_chain, state);
625 } else {
626 print_src(&instr->parent, state);
627 }
628
629 if (is_parent_cast || need_deref)
630 fprintf(fp, ")");
631
632 switch (instr->deref_type) {
633 case nir_deref_type_struct:
634 fprintf(fp, "%s%s", is_parent_pointer ? "->" : ".",
635 glsl_get_struct_elem_name(parent->type, instr->strct.index));
636 break;
637
638 case nir_deref_type_array:
639 case nir_deref_type_ptr_as_array: {
640 if (nir_src_is_const(instr->arr.index)) {
641 fprintf(fp, "[%"PRIx64"]", nir_src_as_int(instr->arr.index));
642 } else {
643 fprintf(fp, "[");
644 print_src(&instr->arr.index, state);
645 fprintf(fp, "]");
646 }
647 break;
648 }
649
650 case nir_deref_type_array_wildcard:
651 fprintf(fp, "[*]");
652 break;
653
654 default:
655 unreachable("Invalid deref instruction type");
656 }
657 }
658
659 static void
660 print_deref_instr(nir_deref_instr *instr, print_state *state)
661 {
662 FILE *fp = state->fp;
663
664 print_dest(&instr->dest, state);
665
666 switch (instr->deref_type) {
667 case nir_deref_type_var:
668 fprintf(fp, " = deref_var ");
669 break;
670 case nir_deref_type_array:
671 case nir_deref_type_array_wildcard:
672 fprintf(fp, " = deref_array ");
673 break;
674 case nir_deref_type_struct:
675 fprintf(fp, " = deref_struct ");
676 break;
677 case nir_deref_type_cast:
678 fprintf(fp, " = deref_cast ");
679 break;
680 case nir_deref_type_ptr_as_array:
681 fprintf(fp, " = deref_ptr_as_array ");
682 break;
683 default:
684 unreachable("Invalid deref instruction type");
685 }
686
687 /* Only casts naturally return a pointer type */
688 if (instr->deref_type != nir_deref_type_cast)
689 fprintf(fp, "&");
690
691 print_deref_link(instr, false, state);
692
693 fprintf(fp, " (%s %s) ",
694 get_variable_mode_str(instr->mode, true),
695 glsl_get_type_name(instr->type));
696
697 if (instr->deref_type != nir_deref_type_var &&
698 instr->deref_type != nir_deref_type_cast) {
699 /* Print the entire chain as a comment */
700 fprintf(fp, "/* &");
701 print_deref_link(instr, true, state);
702 fprintf(fp, " */");
703 }
704 }
705
706 static const char *
707 vulkan_descriptor_type_name(VkDescriptorType type)
708 {
709 switch (type) {
710 case VK_DESCRIPTOR_TYPE_SAMPLER: return "sampler";
711 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: return "texture+sampler";
712 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: return "texture";
713 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: return "image";
714 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: return "texture-buffer";
715 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: return "image-buffer";
716 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: return "UBO";
717 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: return "SSBO";
718 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: return "UBO";
719 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: return "SSBO";
720 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: return "input-att";
721 case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT: return "inline-UBO";
722 default: return "unknown";
723 }
724 }
725
726 static void
727 print_intrinsic_instr(nir_intrinsic_instr *instr, print_state *state)
728 {
729 const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic];
730 unsigned num_srcs = info->num_srcs;
731 FILE *fp = state->fp;
732
733 if (info->has_dest) {
734 print_dest(&instr->dest, state);
735 fprintf(fp, " = ");
736 }
737
738 fprintf(fp, "intrinsic %s (", info->name);
739
740 for (unsigned i = 0; i < num_srcs; i++) {
741 if (i != 0)
742 fprintf(fp, ", ");
743
744 print_src(&instr->src[i], state);
745 }
746
747 fprintf(fp, ") (");
748
749 for (unsigned i = 0; i < info->num_indices; i++) {
750 if (i != 0)
751 fprintf(fp, ", ");
752
753 fprintf(fp, "%d", instr->const_index[i]);
754 }
755
756 fprintf(fp, ")");
757
758 static const char *index_name[NIR_INTRINSIC_NUM_INDEX_FLAGS] = {
759 [NIR_INTRINSIC_BASE] = "base",
760 [NIR_INTRINSIC_WRMASK] = "wrmask",
761 [NIR_INTRINSIC_STREAM_ID] = "stream-id",
762 [NIR_INTRINSIC_UCP_ID] = "ucp-id",
763 [NIR_INTRINSIC_RANGE] = "range",
764 [NIR_INTRINSIC_DESC_SET] = "desc-set",
765 [NIR_INTRINSIC_BINDING] = "binding",
766 [NIR_INTRINSIC_COMPONENT] = "component",
767 [NIR_INTRINSIC_INTERP_MODE] = "interp_mode",
768 [NIR_INTRINSIC_REDUCTION_OP] = "reduction_op",
769 [NIR_INTRINSIC_CLUSTER_SIZE] = "cluster_size",
770 [NIR_INTRINSIC_PARAM_IDX] = "param_idx",
771 [NIR_INTRINSIC_IMAGE_DIM] = "image_dim",
772 [NIR_INTRINSIC_IMAGE_ARRAY] = "image_array",
773 [NIR_INTRINSIC_ACCESS] = "access",
774 [NIR_INTRINSIC_FORMAT] = "format",
775 [NIR_INTRINSIC_ALIGN_MUL] = "align_mul",
776 [NIR_INTRINSIC_ALIGN_OFFSET] = "align_offset",
777 [NIR_INTRINSIC_DESC_TYPE] = "desc_type",
778 };
779 for (unsigned idx = 1; idx < NIR_INTRINSIC_NUM_INDEX_FLAGS; idx++) {
780 if (!info->index_map[idx])
781 continue;
782 fprintf(fp, " /*");
783 if (idx == NIR_INTRINSIC_WRMASK) {
784 /* special case wrmask to show it as a writemask.. */
785 unsigned wrmask = nir_intrinsic_write_mask(instr);
786 fprintf(fp, " wrmask=");
787 for (unsigned i = 0; i < 4; i++)
788 if ((wrmask >> i) & 1)
789 fprintf(fp, "%c", "xyzw"[i]);
790 } else if (idx == NIR_INTRINSIC_REDUCTION_OP) {
791 nir_op reduction_op = nir_intrinsic_reduction_op(instr);
792 fprintf(fp, " reduction_op=%s", nir_op_infos[reduction_op].name);
793 } else if (idx == NIR_INTRINSIC_IMAGE_DIM) {
794 static const char *dim_name[] = {
795 [GLSL_SAMPLER_DIM_1D] = "1D",
796 [GLSL_SAMPLER_DIM_2D] = "2D",
797 [GLSL_SAMPLER_DIM_3D] = "3D",
798 [GLSL_SAMPLER_DIM_CUBE] = "Cube",
799 [GLSL_SAMPLER_DIM_RECT] = "Rect",
800 [GLSL_SAMPLER_DIM_BUF] = "Buf",
801 [GLSL_SAMPLER_DIM_MS] = "2D-MSAA",
802 [GLSL_SAMPLER_DIM_SUBPASS] = "Subpass",
803 [GLSL_SAMPLER_DIM_SUBPASS_MS] = "Subpass-MSAA",
804 };
805 enum glsl_sampler_dim dim = nir_intrinsic_image_dim(instr);
806 assert(dim < ARRAY_SIZE(dim_name) && dim_name[dim]);
807 fprintf(fp, " image_dim=%s", dim_name[dim]);
808 } else if (idx == NIR_INTRINSIC_IMAGE_ARRAY) {
809 bool array = nir_intrinsic_image_array(instr);
810 fprintf(fp, " image_array=%s", array ? "true" : "false");
811 } else if (idx == NIR_INTRINSIC_DESC_TYPE) {
812 VkDescriptorType desc_type = nir_intrinsic_desc_type(instr);
813 fprintf(fp, " desc_type=%s", vulkan_descriptor_type_name(desc_type));
814 } else {
815 unsigned off = info->index_map[idx] - 1;
816 assert(index_name[idx]); /* forgot to update index_name table? */
817 fprintf(fp, " %s=%d", index_name[idx], instr->const_index[off]);
818 }
819 fprintf(fp, " */");
820 }
821
822 if (!state->shader)
823 return;
824
825 struct exec_list *var_list = NULL;
826
827 switch (instr->intrinsic) {
828 case nir_intrinsic_load_uniform:
829 var_list = &state->shader->uniforms;
830 break;
831 case nir_intrinsic_load_input:
832 case nir_intrinsic_load_interpolated_input:
833 case nir_intrinsic_load_per_vertex_input:
834 var_list = &state->shader->inputs;
835 break;
836 case nir_intrinsic_load_output:
837 case nir_intrinsic_store_output:
838 case nir_intrinsic_store_per_vertex_output:
839 var_list = &state->shader->outputs;
840 break;
841 default:
842 return;
843 }
844
845 nir_foreach_variable(var, var_list) {
846 if ((var->data.driver_location == nir_intrinsic_base(instr)) &&
847 (instr->intrinsic == nir_intrinsic_load_uniform ||
848 (nir_intrinsic_component(instr) >= var->data.location_frac &&
849 nir_intrinsic_component(instr) <
850 (var->data.location_frac + glsl_get_components(var->type)))) &&
851 var->name) {
852 fprintf(fp, "\t/* %s */", var->name);
853 break;
854 }
855 }
856 }
857
858 static void
859 print_tex_instr(nir_tex_instr *instr, print_state *state)
860 {
861 FILE *fp = state->fp;
862
863 print_dest(&instr->dest, state);
864
865 fprintf(fp, " = ");
866
867 switch (instr->op) {
868 case nir_texop_tex:
869 fprintf(fp, "tex ");
870 break;
871 case nir_texop_txb:
872 fprintf(fp, "txb ");
873 break;
874 case nir_texop_txl:
875 fprintf(fp, "txl ");
876 break;
877 case nir_texop_txd:
878 fprintf(fp, "txd ");
879 break;
880 case nir_texop_txf:
881 fprintf(fp, "txf ");
882 break;
883 case nir_texop_txf_ms:
884 fprintf(fp, "txf_ms ");
885 break;
886 case nir_texop_txf_ms_mcs:
887 fprintf(fp, "txf_ms_mcs ");
888 break;
889 case nir_texop_txs:
890 fprintf(fp, "txs ");
891 break;
892 case nir_texop_lod:
893 fprintf(fp, "lod ");
894 break;
895 case nir_texop_tg4:
896 fprintf(fp, "tg4 ");
897 break;
898 case nir_texop_query_levels:
899 fprintf(fp, "query_levels ");
900 break;
901 case nir_texop_texture_samples:
902 fprintf(fp, "texture_samples ");
903 break;
904 case nir_texop_samples_identical:
905 fprintf(fp, "samples_identical ");
906 break;
907 default:
908 unreachable("Invalid texture operation");
909 break;
910 }
911
912 bool has_texture_deref = false, has_sampler_deref = false;
913 for (unsigned i = 0; i < instr->num_srcs; i++) {
914 print_src(&instr->src[i].src, state);
915
916 fprintf(fp, " ");
917
918 switch(instr->src[i].src_type) {
919 case nir_tex_src_coord:
920 fprintf(fp, "(coord)");
921 break;
922 case nir_tex_src_projector:
923 fprintf(fp, "(projector)");
924 break;
925 case nir_tex_src_comparator:
926 fprintf(fp, "(comparator)");
927 break;
928 case nir_tex_src_offset:
929 fprintf(fp, "(offset)");
930 break;
931 case nir_tex_src_bias:
932 fprintf(fp, "(bias)");
933 break;
934 case nir_tex_src_lod:
935 fprintf(fp, "(lod)");
936 break;
937 case nir_tex_src_min_lod:
938 fprintf(fp, "(min_lod)");
939 break;
940 case nir_tex_src_ms_index:
941 fprintf(fp, "(ms_index)");
942 break;
943 case nir_tex_src_ms_mcs:
944 fprintf(fp, "(ms_mcs)");
945 break;
946 case nir_tex_src_ddx:
947 fprintf(fp, "(ddx)");
948 break;
949 case nir_tex_src_ddy:
950 fprintf(fp, "(ddy)");
951 break;
952 case nir_tex_src_texture_deref:
953 has_texture_deref = true;
954 fprintf(fp, "(texture_deref)");
955 break;
956 case nir_tex_src_sampler_deref:
957 has_sampler_deref = true;
958 fprintf(fp, "(sampler_deref)");
959 break;
960 case nir_tex_src_texture_offset:
961 fprintf(fp, "(texture_offset)");
962 break;
963 case nir_tex_src_sampler_offset:
964 fprintf(fp, "(sampler_offset)");
965 break;
966 case nir_tex_src_texture_handle:
967 fprintf(fp, "(texture_handle)");
968 break;
969 case nir_tex_src_sampler_handle:
970 fprintf(fp, "(sampler_handle)");
971 break;
972 case nir_tex_src_plane:
973 fprintf(fp, "(plane)");
974 break;
975
976 default:
977 unreachable("Invalid texture source type");
978 break;
979 }
980
981 fprintf(fp, ", ");
982 }
983
984 if (instr->op == nir_texop_tg4) {
985 fprintf(fp, "%u (gather_component), ", instr->component);
986 }
987
988 if (nir_tex_instr_has_explicit_tg4_offsets(instr)) {
989 fprintf(fp, "{ (%i, %i)", instr->tg4_offsets[0][0], instr->tg4_offsets[0][1]);
990 for (unsigned i = 1; i < 4; ++i)
991 fprintf(fp, ", (%i, %i)", instr->tg4_offsets[i][0],
992 instr->tg4_offsets[i][1]);
993 fprintf(fp, " } (offsets), ");
994 }
995
996 if (!has_texture_deref) {
997 fprintf(fp, "%u (texture), ", instr->texture_index);
998 }
999
1000 if (!has_sampler_deref) {
1001 fprintf(fp, "%u (sampler), ", instr->sampler_index);
1002 }
1003 }
1004
1005 static void
1006 print_call_instr(nir_call_instr *instr, print_state *state)
1007 {
1008 FILE *fp = state->fp;
1009
1010 fprintf(fp, "call %s ", instr->callee->name);
1011
1012 for (unsigned i = 0; i < instr->num_params; i++) {
1013 if (i != 0)
1014 fprintf(fp, ", ");
1015
1016 print_src(&instr->params[i], state);
1017 }
1018 }
1019
1020 static void
1021 print_load_const_instr(nir_load_const_instr *instr, print_state *state)
1022 {
1023 FILE *fp = state->fp;
1024
1025 print_ssa_def(&instr->def, state);
1026
1027 fprintf(fp, " = load_const (");
1028
1029 for (unsigned i = 0; i < instr->def.num_components; i++) {
1030 if (i != 0)
1031 fprintf(fp, ", ");
1032
1033 /*
1034 * we don't really know the type of the constant (if it will be used as a
1035 * float or an int), so just print the raw constant in hex for fidelity
1036 * and then print the float in a comment for readability.
1037 */
1038
1039 switch (instr->def.bit_size) {
1040 case 64:
1041 fprintf(fp, "0x%16" PRIx64 " /* %f */", instr->value.u64[i],
1042 instr->value.f64[i]);
1043 break;
1044 case 32:
1045 fprintf(fp, "0x%08x /* %f */", instr->value.u32[i], instr->value.f32[i]);
1046 break;
1047 case 16:
1048 fprintf(fp, "0x%04x /* %f */", instr->value.u16[i],
1049 _mesa_half_to_float(instr->value.u16[i]));
1050 break;
1051 case 8:
1052 fprintf(fp, "0x%02x", instr->value.u8[i]);
1053 break;
1054 case 1:
1055 fprintf(fp, "%s", instr->value.b[i] ? "true" : "false");
1056 break;
1057 }
1058 }
1059
1060 fprintf(fp, ")");
1061 }
1062
1063 static void
1064 print_jump_instr(nir_jump_instr *instr, print_state *state)
1065 {
1066 FILE *fp = state->fp;
1067
1068 switch (instr->type) {
1069 case nir_jump_break:
1070 fprintf(fp, "break");
1071 break;
1072
1073 case nir_jump_continue:
1074 fprintf(fp, "continue");
1075 break;
1076
1077 case nir_jump_return:
1078 fprintf(fp, "return");
1079 break;
1080 }
1081 }
1082
1083 static void
1084 print_ssa_undef_instr(nir_ssa_undef_instr* instr, print_state *state)
1085 {
1086 FILE *fp = state->fp;
1087 print_ssa_def(&instr->def, state);
1088 fprintf(fp, " = undefined");
1089 }
1090
1091 static void
1092 print_phi_instr(nir_phi_instr *instr, print_state *state)
1093 {
1094 FILE *fp = state->fp;
1095 print_dest(&instr->dest, state);
1096 fprintf(fp, " = phi ");
1097 nir_foreach_phi_src(src, instr) {
1098 if (&src->node != exec_list_get_head(&instr->srcs))
1099 fprintf(fp, ", ");
1100
1101 fprintf(fp, "block_%u: ", src->pred->index);
1102 print_src(&src->src, state);
1103 }
1104 }
1105
1106 static void
1107 print_parallel_copy_instr(nir_parallel_copy_instr *instr, print_state *state)
1108 {
1109 FILE *fp = state->fp;
1110 nir_foreach_parallel_copy_entry(entry, instr) {
1111 if (&entry->node != exec_list_get_head(&instr->entries))
1112 fprintf(fp, "; ");
1113
1114 print_dest(&entry->dest, state);
1115 fprintf(fp, " = ");
1116 print_src(&entry->src, state);
1117 }
1118 }
1119
1120 static void
1121 print_instr(const nir_instr *instr, print_state *state, unsigned tabs)
1122 {
1123 FILE *fp = state->fp;
1124 print_tabs(tabs, fp);
1125
1126 switch (instr->type) {
1127 case nir_instr_type_alu:
1128 print_alu_instr(nir_instr_as_alu(instr), state);
1129 break;
1130
1131 case nir_instr_type_deref:
1132 print_deref_instr(nir_instr_as_deref(instr), state);
1133 break;
1134
1135 case nir_instr_type_call:
1136 print_call_instr(nir_instr_as_call(instr), state);
1137 break;
1138
1139 case nir_instr_type_intrinsic:
1140 print_intrinsic_instr(nir_instr_as_intrinsic(instr), state);
1141 break;
1142
1143 case nir_instr_type_tex:
1144 print_tex_instr(nir_instr_as_tex(instr), state);
1145 break;
1146
1147 case nir_instr_type_load_const:
1148 print_load_const_instr(nir_instr_as_load_const(instr), state);
1149 break;
1150
1151 case nir_instr_type_jump:
1152 print_jump_instr(nir_instr_as_jump(instr), state);
1153 break;
1154
1155 case nir_instr_type_ssa_undef:
1156 print_ssa_undef_instr(nir_instr_as_ssa_undef(instr), state);
1157 break;
1158
1159 case nir_instr_type_phi:
1160 print_phi_instr(nir_instr_as_phi(instr), state);
1161 break;
1162
1163 case nir_instr_type_parallel_copy:
1164 print_parallel_copy_instr(nir_instr_as_parallel_copy(instr), state);
1165 break;
1166
1167 default:
1168 unreachable("Invalid instruction type");
1169 break;
1170 }
1171 }
1172
1173 static int
1174 compare_block_index(const void *p1, const void *p2)
1175 {
1176 const nir_block *block1 = *((const nir_block **) p1);
1177 const nir_block *block2 = *((const nir_block **) p2);
1178
1179 return (int) block1->index - (int) block2->index;
1180 }
1181
1182 static void print_cf_node(nir_cf_node *node, print_state *state,
1183 unsigned tabs);
1184
1185 static void
1186 print_block(nir_block *block, print_state *state, unsigned tabs)
1187 {
1188 FILE *fp = state->fp;
1189
1190 print_tabs(tabs, fp);
1191 fprintf(fp, "block block_%u:\n", block->index);
1192
1193 /* sort the predecessors by index so we consistently print the same thing */
1194
1195 nir_block **preds =
1196 malloc(block->predecessors->entries * sizeof(nir_block *));
1197
1198 unsigned i = 0;
1199 set_foreach(block->predecessors, entry) {
1200 preds[i++] = (nir_block *) entry->key;
1201 }
1202
1203 qsort(preds, block->predecessors->entries, sizeof(nir_block *),
1204 compare_block_index);
1205
1206 print_tabs(tabs, fp);
1207 fprintf(fp, "/* preds: ");
1208 for (unsigned i = 0; i < block->predecessors->entries; i++) {
1209 fprintf(fp, "block_%u ", preds[i]->index);
1210 }
1211 fprintf(fp, "*/\n");
1212
1213 free(preds);
1214
1215 nir_foreach_instr(instr, block) {
1216 print_instr(instr, state, tabs);
1217 fprintf(fp, "\n");
1218 print_annotation(state, instr);
1219 }
1220
1221 print_tabs(tabs, fp);
1222 fprintf(fp, "/* succs: ");
1223 for (unsigned i = 0; i < 2; i++)
1224 if (block->successors[i]) {
1225 fprintf(fp, "block_%u ", block->successors[i]->index);
1226 }
1227 fprintf(fp, "*/\n");
1228 }
1229
1230 static void
1231 print_if(nir_if *if_stmt, print_state *state, unsigned tabs)
1232 {
1233 FILE *fp = state->fp;
1234
1235 print_tabs(tabs, fp);
1236 fprintf(fp, "if ");
1237 print_src(&if_stmt->condition, state);
1238 fprintf(fp, " {\n");
1239 foreach_list_typed(nir_cf_node, node, node, &if_stmt->then_list) {
1240 print_cf_node(node, state, tabs + 1);
1241 }
1242 print_tabs(tabs, fp);
1243 fprintf(fp, "} else {\n");
1244 foreach_list_typed(nir_cf_node, node, node, &if_stmt->else_list) {
1245 print_cf_node(node, state, tabs + 1);
1246 }
1247 print_tabs(tabs, fp);
1248 fprintf(fp, "}\n");
1249 }
1250
1251 static void
1252 print_loop(nir_loop *loop, print_state *state, unsigned tabs)
1253 {
1254 FILE *fp = state->fp;
1255
1256 print_tabs(tabs, fp);
1257 fprintf(fp, "loop {\n");
1258 foreach_list_typed(nir_cf_node, node, node, &loop->body) {
1259 print_cf_node(node, state, tabs + 1);
1260 }
1261 print_tabs(tabs, fp);
1262 fprintf(fp, "}\n");
1263 }
1264
1265 static void
1266 print_cf_node(nir_cf_node *node, print_state *state, unsigned int tabs)
1267 {
1268 switch (node->type) {
1269 case nir_cf_node_block:
1270 print_block(nir_cf_node_as_block(node), state, tabs);
1271 break;
1272
1273 case nir_cf_node_if:
1274 print_if(nir_cf_node_as_if(node), state, tabs);
1275 break;
1276
1277 case nir_cf_node_loop:
1278 print_loop(nir_cf_node_as_loop(node), state, tabs);
1279 break;
1280
1281 default:
1282 unreachable("Invalid CFG node type");
1283 }
1284 }
1285
1286 static void
1287 print_function_impl(nir_function_impl *impl, print_state *state)
1288 {
1289 FILE *fp = state->fp;
1290
1291 fprintf(fp, "\nimpl %s ", impl->function->name);
1292
1293 fprintf(fp, "{\n");
1294
1295 nir_foreach_variable(var, &impl->locals) {
1296 fprintf(fp, "\t");
1297 print_var_decl(var, state);
1298 }
1299
1300 foreach_list_typed(nir_register, reg, node, &impl->registers) {
1301 fprintf(fp, "\t");
1302 print_register_decl(reg, state);
1303 }
1304
1305 nir_index_blocks(impl);
1306
1307 foreach_list_typed(nir_cf_node, node, node, &impl->body) {
1308 print_cf_node(node, state, 1);
1309 }
1310
1311 fprintf(fp, "\tblock block_%u:\n}\n\n", impl->end_block->index);
1312 }
1313
1314 static void
1315 print_function(nir_function *function, print_state *state)
1316 {
1317 FILE *fp = state->fp;
1318
1319 fprintf(fp, "decl_function %s (%d params)", function->name,
1320 function->num_params);
1321
1322 fprintf(fp, "\n");
1323
1324 if (function->impl != NULL) {
1325 print_function_impl(function->impl, state);
1326 return;
1327 }
1328 }
1329
1330 static void
1331 init_print_state(print_state *state, nir_shader *shader, FILE *fp)
1332 {
1333 state->fp = fp;
1334 state->shader = shader;
1335 state->ht = _mesa_pointer_hash_table_create(NULL);
1336 state->syms = _mesa_set_create(NULL, _mesa_key_hash_string,
1337 _mesa_key_string_equal);
1338 state->index = 0;
1339 }
1340
1341 static void
1342 destroy_print_state(print_state *state)
1343 {
1344 _mesa_hash_table_destroy(state->ht, NULL);
1345 _mesa_set_destroy(state->syms, NULL);
1346 }
1347
1348 void
1349 nir_print_shader_annotated(nir_shader *shader, FILE *fp,
1350 struct hash_table *annotations)
1351 {
1352 print_state state;
1353 init_print_state(&state, shader, fp);
1354
1355 state.annotations = annotations;
1356
1357 fprintf(fp, "shader: %s\n", gl_shader_stage_name(shader->info.stage));
1358
1359 if (shader->info.name)
1360 fprintf(fp, "name: %s\n", shader->info.name);
1361
1362 if (shader->info.label)
1363 fprintf(fp, "label: %s\n", shader->info.label);
1364
1365 if (gl_shader_stage_is_compute(shader->info.stage)) {
1366 fprintf(fp, "local-size: %u, %u, %u%s\n",
1367 shader->info.cs.local_size[0],
1368 shader->info.cs.local_size[1],
1369 shader->info.cs.local_size[2],
1370 shader->info.cs.local_size_variable ? " (variable)" : "");
1371 fprintf(fp, "shared-size: %u\n", shader->info.cs.shared_size);
1372 }
1373
1374 fprintf(fp, "inputs: %u\n", shader->num_inputs);
1375 fprintf(fp, "outputs: %u\n", shader->num_outputs);
1376 fprintf(fp, "uniforms: %u\n", shader->num_uniforms);
1377 fprintf(fp, "shared: %u\n", shader->num_shared);
1378 if (shader->scratch_size)
1379 fprintf(fp, "scratch: %u\n", shader->scratch_size);
1380
1381 nir_foreach_variable(var, &shader->uniforms) {
1382 print_var_decl(var, &state);
1383 }
1384
1385 nir_foreach_variable(var, &shader->inputs) {
1386 print_var_decl(var, &state);
1387 }
1388
1389 nir_foreach_variable(var, &shader->outputs) {
1390 print_var_decl(var, &state);
1391 }
1392
1393 nir_foreach_variable(var, &shader->shared) {
1394 print_var_decl(var, &state);
1395 }
1396
1397 nir_foreach_variable(var, &shader->globals) {
1398 print_var_decl(var, &state);
1399 }
1400
1401 nir_foreach_variable(var, &shader->system_values) {
1402 print_var_decl(var, &state);
1403 }
1404
1405 foreach_list_typed(nir_function, func, node, &shader->functions) {
1406 print_function(func, &state);
1407 }
1408
1409 destroy_print_state(&state);
1410 }
1411
1412 void
1413 nir_print_shader(nir_shader *shader, FILE *fp)
1414 {
1415 nir_print_shader_annotated(shader, fp, NULL);
1416 fflush(fp);
1417 }
1418
1419 void
1420 nir_print_instr(const nir_instr *instr, FILE *fp)
1421 {
1422 print_state state = {
1423 .fp = fp,
1424 };
1425 print_instr(instr, &state, 0);
1426
1427 }
1428
1429 void
1430 nir_print_deref(const nir_deref_instr *deref, FILE *fp)
1431 {
1432 print_state state = {
1433 .fp = fp,
1434 };
1435 print_deref_link(deref, true, &state);
1436 }