/* * Copyright © 2014 Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. * * Authors: * Connor Abbott (cwabbott0@gmail.com) * */ #include /* for PRIx64 macro */ #include #include #include #include "compiler/shader_enums.h" #include "util/half_float.h" #include "util/memstream.h" #include "util/mesa-blake3.h" #include "vulkan/vulkan_core.h" #include "nir.h" #include "nir_builder.h" static void print_indentation(unsigned levels, FILE *fp) { for (unsigned i = 0; i < levels; i++) fprintf(fp, " "); } typedef struct { FILE *fp; nir_shader *shader; const char *def_prefix; /** map from nir_variable -> printable name */ struct hash_table *ht; /** set of names used so far for nir_variables */ struct set *syms; /* an index used to make new non-conflicting names */ unsigned index; /* Used with nir_gather_types() to identify best representation * to print terse inline constant values together with SSA sources. * Updated per nir_function_impl being printed. */ BITSET_WORD *float_types; BITSET_WORD *int_types; /** * Optional table of annotations mapping nir object * (such as instr or var) to message to print. */ struct hash_table *annotations; /* Maximum length for SSA or Reg index in the current impl */ unsigned max_dest_index; /* Padding for instructions without destination to make * them align with the `=` for instructions with destination. */ unsigned padding_for_no_dest; nir_debug_info_instr **debug_info; } print_state; static void print_annotation(print_state *state, void *obj) { FILE *fp = state->fp; if (!state->annotations) return; struct hash_entry *entry = _mesa_hash_table_search(state->annotations, obj); if (!entry) return; const char *note = entry->data; _mesa_hash_table_remove(state->annotations, entry); fprintf(fp, "%s\n\n", note); } /* For 1 element, the size is intentionally omitted. */ static const char *sizes[] = { "x??", " ", "x2 ", "x3 ", "x4 ", "x5 ", "x??", "x??", "x8 ", "x??", "x??", "x??", "x??", "x??", "x??", "x??", "x16" }; static const char * divergence_status(print_state *state, bool divergent) { if (state->shader->info.divergence_analysis_run) return divergent ? "div " : "con "; return ""; } static unsigned count_digits(unsigned n) { return n ? (unsigned)floor(log10(n)) + 1u : 1u; } static void print_def(nir_def *def, print_state *state) { FILE *fp = state->fp; const unsigned ssa_padding = state->max_dest_index ? count_digits(state->max_dest_index) - count_digits(def->index) : 0; const unsigned padding = (def->bit_size == 1) + 1 + ssa_padding; fprintf(fp, "%s%u%s%*s%s%u", divergence_status(state, def->divergent), def->bit_size, sizes[def->num_components], padding, "", state->def_prefix, def->index); } static unsigned calculate_padding_for_no_dest(print_state *state) { const unsigned div = state->shader->info.divergence_analysis_run ? 4 : 0; const unsigned ssa_size = 5; const unsigned percent = 1; const unsigned ssa_index = count_digits(state->max_dest_index); const unsigned equals = 1; return ssa_size + 1 + div + percent + ssa_index + 1 + equals + 1; } static void print_no_dest_padding(print_state *state) { FILE *fp = state->fp; if (state->padding_for_no_dest) fprintf(fp, "%*s", state->padding_for_no_dest, ""); } static void print_hex_padded_const_value(const nir_const_value *value, unsigned bit_size, FILE *fp) { switch (bit_size) { case 64: fprintf(fp, "0x%016" PRIx64, value->u64); break; case 32: fprintf(fp, "0x%08x", value->u32); break; case 16: fprintf(fp, "0x%04x", value->u16); break; case 8: fprintf(fp, "0x%02x", value->u8); break; default: unreachable("unhandled bit size"); } } static void print_hex_terse_const_value(const nir_const_value *value, unsigned bit_size, FILE *fp) { switch (bit_size) { case 64: fprintf(fp, "0x%" PRIx64, value->u64); break; case 32: fprintf(fp, "0x%x", value->u32); break; case 16: fprintf(fp, "0x%x", value->u16); break; case 8: fprintf(fp, "0x%x", value->u8); break; default: unreachable("unhandled bit size"); } } static void print_float_const_value(const nir_const_value *value, unsigned bit_size, FILE *fp) { switch (bit_size) { case 64: fprintf(fp, "%f", value->f64); break; case 32: fprintf(fp, "%f", value->f32); break; case 16: fprintf(fp, "%f", _mesa_half_to_float(value->u16)); break; default: unreachable("unhandled bit size"); } } static void print_int_const_value(const nir_const_value *value, unsigned bit_size, FILE *fp) { switch (bit_size) { case 64: fprintf(fp, "%+" PRIi64, value->i64); break; case 32: fprintf(fp, "%+d", value->i32); break; case 16: fprintf(fp, "%+d", value->i16); break; case 8: fprintf(fp, "%+d", value->i8); break; default: unreachable("unhandled bit size"); } } static void print_uint_const_value(const nir_const_value *value, unsigned bit_size, FILE *fp) { switch (bit_size) { case 64: fprintf(fp, "%" PRIu64, value->u64); break; case 32: fprintf(fp, "%u", value->u32); break; case 16: fprintf(fp, "%u", value->u16); break; case 8: fprintf(fp, "%u", value->u8); break; default: unreachable("unhandled bit size"); } } static void print_const_from_load(nir_load_const_instr *instr, print_state *state, nir_alu_type type) { FILE *fp = state->fp; const unsigned bit_size = instr->def.bit_size; const unsigned num_components = instr->def.num_components; type = nir_alu_type_get_base_type(type); /* There's only one way to print booleans. */ if (bit_size == 1 || type == nir_type_bool) { fprintf(fp, "("); for (unsigned i = 0; i < num_components; i++) { if (i != 0) fprintf(fp, ", "); fprintf(fp, "%s", instr->value[i].b ? "true" : "false"); } fprintf(fp, ")"); return; } fprintf(fp, "("); if (type != nir_type_invalid) { for (unsigned i = 0; i < num_components; i++) { const nir_const_value *v = &instr->value[i]; if (i != 0) fprintf(fp, ", "); switch (type) { case nir_type_float: print_float_const_value(v, bit_size, fp); break; case nir_type_int: case nir_type_uint: print_hex_terse_const_value(v, bit_size, fp); break; default: unreachable("invalid nir alu base type"); } } } else { #define PRINT_VALUES(F) \ do { \ for (unsigned i = 0; i < num_components; i++) { \ if (i != 0) \ fprintf(fp, ", "); \ F(&instr->value[i], bit_size, fp); \ } \ } while (0) #define SEPARATOR() \ if (num_components > 1) \ fprintf(fp, ") = ("); \ else \ fprintf(fp, " = ") bool needs_float = bit_size > 8; bool needs_signed = false; bool needs_decimal = false; for (unsigned i = 0; i < num_components; i++) { const nir_const_value *v = &instr->value[i]; switch (bit_size) { case 64: needs_signed |= v->i64 < 0; needs_decimal |= v->u64 >= 10; break; case 32: needs_signed |= v->i32 < 0; needs_decimal |= v->u32 >= 10; break; case 16: needs_signed |= v->i16 < 0; needs_decimal |= v->u16 >= 10; break; case 8: needs_signed |= v->i8 < 0; needs_decimal |= v->u8 >= 10; break; default: unreachable("invalid bit size"); } } if (state->int_types) { const unsigned index = instr->def.index; const bool inferred_int = BITSET_TEST(state->int_types, index); const bool inferred_float = BITSET_TEST(state->float_types, index); if (inferred_int && !inferred_float) { needs_float = false; } else if (inferred_float && !inferred_int) { needs_signed = false; needs_decimal = false; } } PRINT_VALUES(print_hex_padded_const_value); if (needs_float) { SEPARATOR(); PRINT_VALUES(print_float_const_value); } if (needs_signed) { SEPARATOR(); PRINT_VALUES(print_int_const_value); } if (needs_decimal) { SEPARATOR(); PRINT_VALUES(print_uint_const_value); } } fprintf(fp, ")"); } static void print_load_const_instr(nir_load_const_instr *instr, print_state *state) { FILE *fp = state->fp; print_def(&instr->def, state); fprintf(fp, " = load_const "); /* In the definition, print all interpretations of the value. */ print_const_from_load(instr, state, nir_type_invalid); } static void print_src(const nir_src *src, print_state *state, nir_alu_type src_type) { FILE *fp = state->fp; fprintf(fp, "%s%u", state->def_prefix, src->ssa->index); nir_instr *instr = src->ssa->parent_instr; if (instr->type == nir_instr_type_load_const && !NIR_DEBUG(PRINT_NO_INLINE_CONSTS)) { nir_load_const_instr *load_const = nir_instr_as_load_const(instr); fprintf(fp, " "); nir_alu_type type = nir_alu_type_get_base_type(src_type); if (type == nir_type_invalid && state->int_types) { const unsigned index = load_const->def.index; const bool inferred_int = BITSET_TEST(state->int_types, index); const bool inferred_float = BITSET_TEST(state->float_types, index); if (inferred_float && !inferred_int) type = nir_type_float; } if (type == nir_type_invalid) type = nir_type_uint; /* For a constant in a source, always pick one interpretation. */ assert(type != nir_type_invalid); print_const_from_load(load_const, state, type); } } static const char * comp_mask_string(unsigned num_components) { return (num_components > 4) ? "abcdefghijklmnop" : "xyzw"; } static void print_alu_src(nir_alu_instr *instr, unsigned src, print_state *state) { FILE *fp = state->fp; const nir_op_info *info = &nir_op_infos[instr->op]; print_src(&instr->src[src].src, state, info->input_types[src]); bool print_swizzle = false; nir_component_mask_t used_channels = 0; for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++) { if (!nir_alu_instr_channel_used(instr, src, i)) continue; used_channels++; if (instr->src[src].swizzle[i] != i) { print_swizzle = true; break; } } unsigned live_channels = nir_src_num_components(instr->src[src].src); if (print_swizzle || used_channels != live_channels) { fprintf(fp, "."); for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++) { if (!nir_alu_instr_channel_used(instr, src, i)) continue; fprintf(fp, "%c", comp_mask_string(live_channels)[instr->src[src].swizzle[i]]); } } } static void print_alu_instr(nir_alu_instr *instr, print_state *state) { FILE *fp = state->fp; print_def(&instr->def, state); fprintf(fp, " = %s", nir_op_infos[instr->op].name); if (instr->exact) fprintf(fp, "!"); if (instr->no_signed_wrap) fprintf(fp, ".nsw"); if (instr->no_unsigned_wrap) fprintf(fp, ".nuw"); fprintf(fp, " "); for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) { if (i != 0) fprintf(fp, ", "); print_alu_src(instr, i, state); } } static const char * get_var_name(nir_variable *var, print_state *state) { if (state->ht == NULL) return var->name ? var->name : "unnamed"; assert(state->syms); struct hash_entry *entry = _mesa_hash_table_search(state->ht, var); if (entry) return entry->data; char *name; if (var->name == NULL) { name = ralloc_asprintf(state->syms, "#%u", state->index++); } else { struct set_entry *set_entry = _mesa_set_search(state->syms, var->name); if (set_entry != NULL) { /* we have a collision with another name, append an # + a unique * index */ name = ralloc_asprintf(state->syms, "%s#%u", var->name, state->index++); } else { /* Mark this one as seen */ _mesa_set_add(state->syms, var->name); name = var->name; } } _mesa_hash_table_insert(state->ht, var, name); return name; } static const char * get_constant_sampler_addressing_mode(enum cl_sampler_addressing_mode mode) { switch (mode) { case SAMPLER_ADDRESSING_MODE_NONE: return "none"; case SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE: return "clamp_to_edge"; case SAMPLER_ADDRESSING_MODE_CLAMP: return "clamp"; case SAMPLER_ADDRESSING_MODE_REPEAT: return "repeat"; case SAMPLER_ADDRESSING_MODE_REPEAT_MIRRORED: return "repeat_mirrored"; default: unreachable("Invalid addressing mode"); } } static const char * get_constant_sampler_filter_mode(enum cl_sampler_filter_mode mode) { switch (mode) { case SAMPLER_FILTER_MODE_NEAREST: return "nearest"; case SAMPLER_FILTER_MODE_LINEAR: return "linear"; default: unreachable("Invalid filter mode"); } } static void print_constant(nir_constant *c, const struct glsl_type *type, print_state *state) { FILE *fp = state->fp; const unsigned rows = glsl_get_vector_elements(type); const unsigned cols = glsl_get_matrix_columns(type); unsigned i; switch (glsl_get_base_type(type)) { case GLSL_TYPE_BOOL: /* Only float base types can be matrices. */ assert(cols == 1); for (i = 0; i < rows; i++) { if (i > 0) fprintf(fp, ", "); fprintf(fp, "%s", c->values[i].b ? "true" : "false"); } break; case GLSL_TYPE_UINT8: case GLSL_TYPE_INT8: /* Only float base types can be matrices. */ assert(cols == 1); for (i = 0; i < rows; i++) { if (i > 0) fprintf(fp, ", "); fprintf(fp, "0x%02x", c->values[i].u8); } break; case GLSL_TYPE_UINT16: case GLSL_TYPE_INT16: /* Only float base types can be matrices. */ assert(cols == 1); for (i = 0; i < rows; i++) { if (i > 0) fprintf(fp, ", "); fprintf(fp, "0x%04x", c->values[i].u16); } break; case GLSL_TYPE_UINT: case GLSL_TYPE_INT: /* Only float base types can be matrices. */ assert(cols == 1); for (i = 0; i < rows; i++) { if (i > 0) fprintf(fp, ", "); fprintf(fp, "0x%08x", c->values[i].u32); } break; case GLSL_TYPE_FLOAT16: case GLSL_TYPE_FLOAT: case GLSL_TYPE_DOUBLE: if (cols > 1) { for (i = 0; i < cols; i++) { if (i > 0) fprintf(fp, ", "); print_constant(c->elements[i], glsl_get_column_type(type), state); } } else { switch (glsl_get_base_type(type)) { case GLSL_TYPE_FLOAT16: for (i = 0; i < rows; i++) { if (i > 0) fprintf(fp, ", "); fprintf(fp, "%f", _mesa_half_to_float(c->values[i].u16)); } break; case GLSL_TYPE_FLOAT: for (i = 0; i < rows; i++) { if (i > 0) fprintf(fp, ", "); fprintf(fp, "%f", c->values[i].f32); } break; case GLSL_TYPE_DOUBLE: for (i = 0; i < rows; i++) { if (i > 0) fprintf(fp, ", "); fprintf(fp, "%f", c->values[i].f64); } break; default: unreachable("Cannot get here from the first level switch"); } } break; case GLSL_TYPE_UINT64: case GLSL_TYPE_INT64: /* Only float base types can be matrices. */ assert(cols == 1); for (i = 0; i < cols; i++) { if (i > 0) fprintf(fp, ", "); fprintf(fp, "0x%08" PRIx64, c->values[i].u64); } break; case GLSL_TYPE_STRUCT: case GLSL_TYPE_INTERFACE: for (i = 0; i < c->num_elements; i++) { if (i > 0) fprintf(fp, ", "); fprintf(fp, "{ "); print_constant(c->elements[i], glsl_get_struct_field(type, i), state); fprintf(fp, " }"); } break; case GLSL_TYPE_ARRAY: for (i = 0; i < c->num_elements; i++) { if (i > 0) fprintf(fp, ", "); fprintf(fp, "{ "); print_constant(c->elements[i], glsl_get_array_element(type), state); fprintf(fp, " }"); } break; default: unreachable("not reached"); } } static const char * get_variable_mode_str(nir_variable_mode mode, bool want_local_global_mode) { switch (mode) { case nir_var_shader_in: return "shader_in"; case nir_var_shader_out: return "shader_out"; case nir_var_uniform: return "uniform"; case nir_var_mem_ubo: return "ubo"; case nir_var_system_value: return "system"; case nir_var_mem_ssbo: return "ssbo"; case nir_var_mem_shared: return "shared"; case nir_var_mem_global: return "global"; case nir_var_mem_push_const: return "push_const"; case nir_var_mem_constant: return "constant"; case nir_var_image: return "image"; case nir_var_shader_temp: return want_local_global_mode ? "shader_temp" : ""; case nir_var_function_temp: return want_local_global_mode ? "function_temp" : ""; case nir_var_shader_call_data: return "shader_call_data"; case nir_var_ray_hit_attrib: return "ray_hit_attrib"; case nir_var_mem_task_payload: return "task_payload"; case nir_var_mem_node_payload: return "node_payload"; case nir_var_mem_node_payload_in: return "node_payload_in"; default: if (mode && (mode & nir_var_mem_generic) == mode) return "generic"; return ""; } } static const char * get_location_str(unsigned location, gl_shader_stage stage, nir_variable_mode mode, char *buf) { switch (stage) { case MESA_SHADER_VERTEX: if (mode == nir_var_shader_in) return gl_vert_attrib_name(location); else if (mode == nir_var_shader_out) return gl_varying_slot_name_for_stage(location, stage); break; case MESA_SHADER_TESS_CTRL: case MESA_SHADER_TESS_EVAL: case MESA_SHADER_TASK: case MESA_SHADER_MESH: case MESA_SHADER_GEOMETRY: if (mode == nir_var_shader_in || mode == nir_var_shader_out) return gl_varying_slot_name_for_stage(location, stage); break; case MESA_SHADER_FRAGMENT: if (mode == nir_var_shader_in) return gl_varying_slot_name_for_stage(location, stage); else if (mode == nir_var_shader_out) return gl_frag_result_name(location); break; case MESA_SHADER_COMPUTE: case MESA_SHADER_KERNEL: default: /* TODO */ break; } if (mode == nir_var_system_value) return gl_system_value_name(location); if (location == ~0) { return "~0"; } else { snprintf(buf, 4, "%u", location); return buf; } } static void print_access(enum gl_access_qualifier access, print_state *state, const char *separator) { if (!access) { fputs("none", state->fp); return; } static const struct { enum gl_access_qualifier bit; const char *name; } modes[] = { { ACCESS_COHERENT, "coherent" }, { ACCESS_VOLATILE, "volatile" }, { ACCESS_RESTRICT, "restrict" }, { ACCESS_NON_WRITEABLE, "readonly" }, { ACCESS_NON_READABLE, "writeonly" }, { ACCESS_CAN_REORDER, "reorderable" }, { ACCESS_CAN_SPECULATE, "speculatable" }, { ACCESS_NON_TEMPORAL, "non-temporal" }, { ACCESS_INCLUDE_HELPERS, "include-helpers" }, { ACCESS_CP_GE_COHERENT_AMD, "cp-ge-coherent-amd" }, }; bool first = true; for (unsigned i = 0; i < ARRAY_SIZE(modes); ++i) { if (access & modes[i].bit) { fprintf(state->fp, "%s%s", first ? "" : separator, modes[i].name); first = false; } } } static void print_var_decl(nir_variable *var, print_state *state) { FILE *fp = state->fp; fprintf(fp, "decl_var "); const char *const bindless = (var->data.bindless) ? "bindless " : ""; const char *const cent = (var->data.centroid) ? "centroid " : ""; const char *const samp = (var->data.sample) ? "sample " : ""; const char *const patch = (var->data.patch) ? "patch " : ""; const char *const inv = (var->data.invariant) ? "invariant " : ""; const char *const per_view = (var->data.per_view) ? "per_view " : ""; const char *const per_primitive = (var->data.per_primitive) ? "per_primitive " : ""; const char *const ray_query = (var->data.ray_query) ? "ray_query " : ""; fprintf(fp, "%s%s%s%s%s%s%s%s%s %s ", bindless, cent, samp, patch, inv, per_view, per_primitive, ray_query, get_variable_mode_str(var->data.mode, false), glsl_interp_mode_name(var->data.interpolation)); print_access(var->data.access, state, " "); fprintf(fp, " "); if (glsl_get_base_type(glsl_without_array(var->type)) == GLSL_TYPE_IMAGE) { fprintf(fp, "%s ", util_format_short_name(var->data.image.format)); } if (var->data.precision) { const char *precisions[] = { "", "highp", "mediump", "lowp", }; fprintf(fp, "%s ", precisions[var->data.precision]); } fprintf(fp, "%s %s", glsl_get_type_name(var->type), get_var_name(var, state)); if (var->data.mode & (nir_var_shader_in | nir_var_shader_out | nir_var_uniform | nir_var_system_value | nir_var_mem_ubo | nir_var_mem_ssbo | nir_var_image)) { char buf[4]; const char *loc = get_location_str(var->data.location, state->shader->info.stage, var->data.mode, buf); /* For shader I/O vars that have been split to components or packed, * print the fractional location within the input/output. */ unsigned int num_components = glsl_get_components(glsl_without_array(var->type)); const char *components = ""; char components_local[18] = { '.' /* the rest is 0-filled */ }; switch (var->data.mode) { case nir_var_shader_in: case nir_var_shader_out: if (num_components < 16 && num_components != 0) { const char *xyzw = comp_mask_string(num_components); for (int i = 0; i < num_components; i++) components_local[i + 1] = xyzw[i + var->data.location_frac]; components = components_local; } break; default: break; } if (var->data.mode & nir_var_system_value) { fprintf(fp, " (%s%s)", loc, components); } else { fprintf(fp, " (%s%s, %u, %u)%s", loc, components, var->data.driver_location, var->data.binding, var->data.compact ? " compact" : ""); } } if (var->constant_initializer) { if (var->constant_initializer->is_null_constant) { fprintf(fp, " = null"); } else { fprintf(fp, " = { "); print_constant(var->constant_initializer, var->type, state); fprintf(fp, " }"); } } if (glsl_type_is_sampler(var->type) && var->data.sampler.is_inline_sampler) { fprintf(fp, " = { %s, %s, %s }", get_constant_sampler_addressing_mode(var->data.sampler.addressing_mode), var->data.sampler.normalized_coordinates ? "true" : "false", get_constant_sampler_filter_mode(var->data.sampler.filter_mode)); } if (var->pointer_initializer) fprintf(fp, " = &%s", get_var_name(var->pointer_initializer, state)); fprintf(fp, "\n"); print_annotation(state, var); } static void print_deref_link(const nir_deref_instr *instr, bool whole_chain, print_state *state) { FILE *fp = state->fp; if (instr->deref_type == nir_deref_type_var) { fprintf(fp, "%s", get_var_name(instr->var, state)); return; } else if (instr->deref_type == nir_deref_type_cast) { fprintf(fp, "(%s *)", glsl_get_type_name(instr->type)); print_src(&instr->parent, state, nir_type_invalid); return; } nir_deref_instr *parent = nir_instr_as_deref(instr->parent.ssa->parent_instr); /* Is the parent we're going to print a bare cast? */ const bool is_parent_cast = whole_chain && parent->deref_type == nir_deref_type_cast; /* If we're not printing the whole chain, the parent we print will be a SSA * value that represents a pointer. The only deref type that naturally * gives a pointer is a cast. */ const bool is_parent_pointer = !whole_chain || parent->deref_type == nir_deref_type_cast; /* Struct derefs have a nice syntax that works on pointers, arrays derefs * do not. */ const bool need_deref = is_parent_pointer && instr->deref_type != nir_deref_type_struct; /* Cast need extra parens and so * dereferences */ if (is_parent_cast || need_deref) fprintf(fp, "("); if (need_deref) fprintf(fp, "*"); if (whole_chain) { print_deref_link(parent, whole_chain, state); } else { print_src(&instr->parent, state, nir_type_invalid); } if (is_parent_cast || need_deref) fprintf(fp, ")"); switch (instr->deref_type) { case nir_deref_type_struct: fprintf(fp, "%s%s", is_parent_pointer ? "->" : ".", glsl_get_struct_elem_name(parent->type, instr->strct.index)); break; case nir_deref_type_array: case nir_deref_type_ptr_as_array: { if (nir_src_is_const(instr->arr.index)) { fprintf(fp, "[%" PRId64 "]", nir_src_as_int(instr->arr.index)); } else { fprintf(fp, "["); print_src(&instr->arr.index, state, nir_type_invalid); fprintf(fp, "]"); } break; } case nir_deref_type_array_wildcard: fprintf(fp, "[*]"); break; default: unreachable("Invalid deref instruction type"); } } static void print_deref_instr(nir_deref_instr *instr, print_state *state) { FILE *fp = state->fp; print_def(&instr->def, state); switch (instr->deref_type) { case nir_deref_type_var: fprintf(fp, " = deref_var "); break; case nir_deref_type_array: case nir_deref_type_array_wildcard: fprintf(fp, " = deref_array "); break; case nir_deref_type_struct: fprintf(fp, " = deref_struct "); break; case nir_deref_type_cast: fprintf(fp, " = deref_cast "); break; case nir_deref_type_ptr_as_array: fprintf(fp, " = deref_ptr_as_array "); break; default: unreachable("Invalid deref instruction type"); } /* Only casts naturally return a pointer type */ if (instr->deref_type != nir_deref_type_cast) fprintf(fp, "&"); print_deref_link(instr, false, state); fprintf(fp, " ("); unsigned modes = instr->modes; while (modes) { int m = u_bit_scan(&modes); fprintf(fp, "%s%s", get_variable_mode_str(1 << m, true), modes ? "|" : ""); } fprintf(fp, " %s)", glsl_get_type_name(instr->type)); if (instr->deref_type == nir_deref_type_cast) { fprintf(fp, " (ptr_stride=%u, align_mul=%u, align_offset=%u)", instr->cast.ptr_stride, instr->cast.align_mul, instr->cast.align_offset); } if (instr->deref_type != nir_deref_type_var && instr->deref_type != nir_deref_type_cast) { /* Print the entire chain as a comment */ fprintf(fp, " // &"); print_deref_link(instr, true, state); } } static const char * vulkan_descriptor_type_name(VkDescriptorType type) { switch (type) { case VK_DESCRIPTOR_TYPE_SAMPLER: return "sampler"; case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: return "texture+sampler"; case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: return "texture"; case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: return "image"; case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: return "texture-buffer"; case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: return "image-buffer"; case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: return "UBO"; case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: return "SSBO"; case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: return "UBO"; case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: return "SSBO"; case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: return "input-att"; case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK: return "inline-UBO"; case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: return "accel-struct"; default: return "unknown"; } } static void print_alu_type(nir_alu_type type, print_state *state) { FILE *fp = state->fp; unsigned size = nir_alu_type_get_type_size(type); const char *name; switch (nir_alu_type_get_base_type(type)) { case nir_type_int: name = "int"; break; case nir_type_uint: name = "uint"; break; case nir_type_bool: name = "bool"; break; case nir_type_float: name = "float"; break; default: name = "invalid"; } if (size) fprintf(fp, "%s%u", name, size); else fprintf(fp, "%s", name); } static void print_intrinsic_instr(nir_intrinsic_instr *instr, print_state *state) { const nir_intrinsic_info *info = &nir_intrinsic_infos[instr->intrinsic]; unsigned num_srcs = info->num_srcs; FILE *fp = state->fp; if (info->has_dest) { print_def(&instr->def, state); fprintf(fp, " = "); } else { print_no_dest_padding(state); } fprintf(fp, "@%s", info->name); for (unsigned i = 0; i < num_srcs; i++) { if (i == 0) fprintf(fp, " ("); else fprintf(fp, ", "); print_src(&instr->src[i], state, nir_intrinsic_instr_src_type(instr, i)); } if (num_srcs) fprintf(fp, ")"); for (unsigned i = 0; i < info->num_indices; i++) { unsigned idx = info->indices[i]; if (i == 0) fprintf(fp, " ("); else fprintf(fp, ", "); switch (idx) { case NIR_INTRINSIC_WRITE_MASK: { /* special case wrmask to show it as a writemask.. */ unsigned wrmask = nir_intrinsic_write_mask(instr); fprintf(fp, "wrmask="); for (unsigned i = 0; i < instr->num_components; i++) if ((wrmask >> i) & 1) fprintf(fp, "%c", comp_mask_string(instr->num_components)[i]); break; } case NIR_INTRINSIC_REDUCTION_OP: { nir_op reduction_op = nir_intrinsic_reduction_op(instr); fprintf(fp, "reduction_op=%s", nir_op_infos[reduction_op].name); break; } case NIR_INTRINSIC_ATOMIC_OP: { nir_atomic_op atomic_op = nir_intrinsic_atomic_op(instr); fprintf(fp, "atomic_op="); switch (atomic_op) { case nir_atomic_op_iadd: fprintf(fp, "iadd"); break; case nir_atomic_op_imin: fprintf(fp, "imin"); break; case nir_atomic_op_umin: fprintf(fp, "umin"); break; case nir_atomic_op_imax: fprintf(fp, "imax"); break; case nir_atomic_op_umax: fprintf(fp, "umax"); break; case nir_atomic_op_iand: fprintf(fp, "iand"); break; case nir_atomic_op_ior: fprintf(fp, "ior"); break; case nir_atomic_op_ixor: fprintf(fp, "ixor"); break; case nir_atomic_op_xchg: fprintf(fp, "xchg"); break; case nir_atomic_op_fadd: fprintf(fp, "fadd"); break; case nir_atomic_op_fmin: fprintf(fp, "fmin"); break; case nir_atomic_op_fmax: fprintf(fp, "fmax"); break; case nir_atomic_op_cmpxchg: fprintf(fp, "cmpxchg"); break; case nir_atomic_op_fcmpxchg: fprintf(fp, "fcmpxchg"); break; case nir_atomic_op_inc_wrap: fprintf(fp, "inc_wrap"); break; case nir_atomic_op_dec_wrap: fprintf(fp, "dec_wrap"); break; case nir_atomic_op_ordered_add_gfx12_amd: fprintf(fp, "ordered_add"); break; } break; } case NIR_INTRINSIC_IMAGE_DIM: { static const char *dim_name[] = { [GLSL_SAMPLER_DIM_1D] = "1D", [GLSL_SAMPLER_DIM_2D] = "2D", [GLSL_SAMPLER_DIM_3D] = "3D", [GLSL_SAMPLER_DIM_CUBE] = "Cube", [GLSL_SAMPLER_DIM_RECT] = "Rect", [GLSL_SAMPLER_DIM_BUF] = "Buf", [GLSL_SAMPLER_DIM_MS] = "2D-MSAA", [GLSL_SAMPLER_DIM_SUBPASS] = "Subpass", [GLSL_SAMPLER_DIM_SUBPASS_MS] = "Subpass-MSAA", }; enum glsl_sampler_dim dim = nir_intrinsic_image_dim(instr); assert(dim < ARRAY_SIZE(dim_name) && dim_name[dim]); fprintf(fp, "image_dim=%s", dim_name[dim]); break; } case NIR_INTRINSIC_IMAGE_ARRAY: { bool array = nir_intrinsic_image_array(instr); fprintf(fp, "image_array=%s", array ? "true" : "false"); break; } case NIR_INTRINSIC_FORMAT: { enum pipe_format format = nir_intrinsic_format(instr); fprintf(fp, "format=%s", util_format_short_name(format)); break; } case NIR_INTRINSIC_DESC_TYPE: { VkDescriptorType desc_type = nir_intrinsic_desc_type(instr); fprintf(fp, "desc_type=%s", vulkan_descriptor_type_name(desc_type)); break; } case NIR_INTRINSIC_SRC_TYPE: { fprintf(fp, "src_type="); print_alu_type(nir_intrinsic_src_type(instr), state); break; } case NIR_INTRINSIC_DEST_TYPE: { fprintf(fp, "dest_type="); print_alu_type(nir_intrinsic_dest_type(instr), state); break; } case NIR_INTRINSIC_SWIZZLE_MASK: { fprintf(fp, "swizzle_mask="); unsigned mask = nir_intrinsic_swizzle_mask(instr); if (instr->intrinsic == nir_intrinsic_quad_swizzle_amd) { for (unsigned i = 0; i < 4; i++) fprintf(fp, "%d", (mask >> (i * 2) & 3)); } else if (instr->intrinsic == nir_intrinsic_masked_swizzle_amd) { fprintf(fp, "((id & %d) | %d) ^ %d", mask & 0x1F, (mask >> 5) & 0x1F, (mask >> 10) & 0x1F); } else { fprintf(fp, "%d", mask); } break; } case NIR_INTRINSIC_MEMORY_SEMANTICS: { nir_memory_semantics semantics = nir_intrinsic_memory_semantics(instr); fprintf(fp, "mem_semantics="); switch (semantics & (NIR_MEMORY_ACQUIRE | NIR_MEMORY_RELEASE)) { case 0: fprintf(fp, "NONE"); break; case NIR_MEMORY_ACQUIRE: fprintf(fp, "ACQ"); break; case NIR_MEMORY_RELEASE: fprintf(fp, "REL"); break; default: fprintf(fp, "ACQ|REL"); break; } if (semantics & (NIR_MEMORY_MAKE_AVAILABLE)) fprintf(fp, "|AVAILABLE"); if (semantics & (NIR_MEMORY_MAKE_VISIBLE)) fprintf(fp, "|VISIBLE"); break; } case NIR_INTRINSIC_MEMORY_MODES: { fprintf(fp, "mem_modes="); unsigned int modes = nir_intrinsic_memory_modes(instr); if (modes == 0) fputc('0', fp); while (modes) { nir_variable_mode m = u_bit_scan(&modes); fprintf(fp, "%s%s", get_variable_mode_str(1 << m, true), modes ? "|" : ""); } break; } case NIR_INTRINSIC_EXECUTION_SCOPE: case NIR_INTRINSIC_MEMORY_SCOPE: { mesa_scope scope = idx == NIR_INTRINSIC_MEMORY_SCOPE ? nir_intrinsic_memory_scope(instr) : nir_intrinsic_execution_scope(instr); const char *name = mesa_scope_name(scope); static const char prefix[] = "SCOPE_"; if (strncmp(name, prefix, sizeof(prefix) - 1) == 0) name += sizeof(prefix) - 1; fprintf(fp, "%s=%s", nir_intrinsic_index_names[idx], name); break; } case NIR_INTRINSIC_IO_SEMANTICS: { struct nir_io_semantics io = nir_intrinsic_io_semantics(instr); /* Try to figure out the mode so we can interpret the location */ nir_variable_mode mode = nir_var_mem_generic; switch (instr->intrinsic) { case nir_intrinsic_load_input: case nir_intrinsic_load_per_primitive_input: case nir_intrinsic_load_interpolated_input: case nir_intrinsic_load_per_vertex_input: case nir_intrinsic_load_input_vertex: case nir_intrinsic_load_coefficients_agx: mode = nir_var_shader_in; break; case nir_intrinsic_load_output: case nir_intrinsic_store_output: case nir_intrinsic_store_per_primitive_output: case nir_intrinsic_store_per_vertex_output: mode = nir_var_shader_out; break; default: break; } /* Using that mode, we should be able to name the location */ char buf[4]; const char *loc = get_location_str(io.location, state->shader->info.stage, mode, buf); fprintf(fp, "io location=%s slots=%u", loc, io.num_slots); if (io.interp_explicit_strict) fprintf(fp, " explicit_strict"); if (io.dual_source_blend_index) fprintf(fp, " dualsrc"); if (io.fb_fetch_output) fprintf(fp, " fbfetch"); if (io.per_view) fprintf(fp, " perview"); if (io.medium_precision) fprintf(fp, " mediump"); if (io.high_16bits) fprintf(fp, " high_16bits"); if (io.invariant) fprintf(fp, " invariant"); if (io.high_dvec2) fprintf(fp, " high_dvec2"); if (io.no_varying) fprintf(fp, " no_varying"); if (io.no_sysval_output) fprintf(fp, " no_sysval_output"); if (state->shader && state->shader->info.stage == MESA_SHADER_GEOMETRY && (instr->intrinsic == nir_intrinsic_store_output || instr->intrinsic == nir_intrinsic_store_per_primitive_output || instr->intrinsic == nir_intrinsic_store_per_vertex_output)) { unsigned gs_streams = io.gs_streams; fprintf(fp, " gs_streams("); for (unsigned i = 0; i < 4; i++) { fprintf(fp, "%s%c=%u", i ? " " : "", "xyzw"[i], (gs_streams >> (i * 2)) & 0x3); } fprintf(fp, ")"); } break; } case NIR_INTRINSIC_IO_XFB: case NIR_INTRINSIC_IO_XFB2: { /* This prints both IO_XFB and IO_XFB2. */ fprintf(fp, "xfb%s(", idx == NIR_INTRINSIC_IO_XFB ? "" : "2"); bool first = true; for (unsigned i = 0; i < 2; i++) { unsigned start_comp = (idx == NIR_INTRINSIC_IO_XFB ? 0 : 2) + i; nir_io_xfb xfb = start_comp < 2 ? nir_intrinsic_io_xfb(instr) : nir_intrinsic_io_xfb2(instr); if (!xfb.out[i].num_components) continue; if (!first) fprintf(fp, ", "); first = false; if (xfb.out[i].num_components > 1) { fprintf(fp, "components=%u..%u", start_comp, start_comp + xfb.out[i].num_components - 1); } else { fprintf(fp, "component=%u", start_comp); } fprintf(fp, " buffer=%u offset=%u", xfb.out[i].buffer, (uint32_t)xfb.out[i].offset * 4); } fprintf(fp, ")"); break; } case NIR_INTRINSIC_ROUNDING_MODE: { fprintf(fp, "rounding_mode="); switch (nir_intrinsic_rounding_mode(instr)) { case nir_rounding_mode_undef: fprintf(fp, "undef"); break; case nir_rounding_mode_rtne: fprintf(fp, "rtne"); break; case nir_rounding_mode_ru: fprintf(fp, "ru"); break; case nir_rounding_mode_rd: fprintf(fp, "rd"); break; case nir_rounding_mode_rtz: fprintf(fp, "rtz"); break; default: fprintf(fp, "unknown"); break; } break; } case NIR_INTRINSIC_RAY_QUERY_VALUE: { fprintf(fp, "ray_query_value="); switch (nir_intrinsic_ray_query_value(instr)) { #define VAL(_name) \ case nir_ray_query_value_##_name: \ fprintf(fp, #_name); \ break VAL(intersection_type); VAL(intersection_t); VAL(intersection_instance_custom_index); VAL(intersection_instance_id); VAL(intersection_instance_sbt_index); VAL(intersection_geometry_index); VAL(intersection_primitive_index); VAL(intersection_barycentrics); VAL(intersection_front_face); VAL(intersection_object_ray_direction); VAL(intersection_object_ray_origin); VAL(intersection_object_to_world); VAL(intersection_world_to_object); VAL(intersection_candidate_aabb_opaque); VAL(tmin); VAL(flags); VAL(world_ray_direction); VAL(world_ray_origin); #undef VAL default: fprintf(fp, "unknown"); break; } break; } case NIR_INTRINSIC_RESOURCE_ACCESS_INTEL: { fprintf(fp, "resource_intel="); unsigned int modes = nir_intrinsic_resource_access_intel(instr); if (modes == 0) fputc('0', fp); while (modes) { nir_resource_data_intel i = 1u << u_bit_scan(&modes); switch (i) { case nir_resource_intel_bindless: fprintf(fp, "bindless"); break; case nir_resource_intel_pushable: fprintf(fp, "pushable"); break; case nir_resource_intel_sampler: fprintf(fp, "sampler"); break; case nir_resource_intel_non_uniform: fprintf(fp, "non-uniform"); break; case nir_resource_intel_sampler_embedded: fprintf(fp, "sampler-embedded"); break; default: fprintf(fp, "unknown"); break; } fprintf(fp, "%s", modes ? "|" : ""); } break; } case NIR_INTRINSIC_ACCESS: { fprintf(fp, "access="); print_access(nir_intrinsic_access(instr), state, "|"); break; } case NIR_INTRINSIC_MATRIX_LAYOUT: { fprintf(fp, "matrix_layout="); switch (nir_intrinsic_matrix_layout(instr)) { case GLSL_MATRIX_LAYOUT_ROW_MAJOR: fprintf(fp, "row_major"); break; case GLSL_MATRIX_LAYOUT_COLUMN_MAJOR: fprintf(fp, "col_major"); break; default: fprintf(fp, "unknown"); break; } break; } case NIR_INTRINSIC_CMAT_DESC: { struct glsl_cmat_description desc = nir_intrinsic_cmat_desc(instr); const struct glsl_type *t = glsl_cmat_type(&desc); fprintf(fp, "%s", glsl_get_type_name(t)); break; } case NIR_INTRINSIC_CMAT_SIGNED_MASK: { fprintf(fp, "cmat_signed="); unsigned int mask = nir_intrinsic_cmat_signed_mask(instr); if (mask == 0) fputc('0', fp); while (mask) { nir_cmat_signed i = 1u << u_bit_scan(&mask); switch (i) { case NIR_CMAT_A_SIGNED: fputc('A', fp); break; case NIR_CMAT_B_SIGNED: fputc('B', fp); break; case NIR_CMAT_C_SIGNED: fputc('C', fp); break; case NIR_CMAT_RESULT_SIGNED: fprintf(fp, "Result"); break; default: fprintf(fp, "unknown"); break; } fprintf(fp, "%s", mask ? "|" : ""); } break; } case NIR_INTRINSIC_ALU_OP: { nir_op alu_op = nir_intrinsic_alu_op(instr); fprintf(fp, "alu_op=%s", nir_op_infos[alu_op].name); break; } default: { unsigned off = info->index_map[idx] - 1; fprintf(fp, "%s=%d", nir_intrinsic_index_names[idx], instr->const_index[off]); break; } } } if (info->num_indices) fprintf(fp, ")"); if (!state->shader) return; nir_variable_mode var_mode; switch (instr->intrinsic) { case nir_intrinsic_load_uniform: var_mode = nir_var_uniform; break; case nir_intrinsic_load_input: case nir_intrinsic_load_per_primitive_input: case nir_intrinsic_load_interpolated_input: case nir_intrinsic_load_per_vertex_input: var_mode = nir_var_shader_in; break; case nir_intrinsic_load_output: case nir_intrinsic_store_output: case nir_intrinsic_store_per_vertex_output: var_mode = nir_var_shader_out; break; default: return; } if (instr->name) { fprintf(fp, " // %s", instr->name); return; } nir_foreach_variable_with_modes(var, state->shader, var_mode) { if (!var->name) continue; bool match; if (instr->intrinsic == nir_intrinsic_load_uniform) { match = var->data.driver_location == nir_intrinsic_base(instr); } else { match = nir_intrinsic_component(instr) >= var->data.location_frac && nir_intrinsic_component(instr) < (var->data.location_frac + glsl_get_components(var->type)); } if (match) { fprintf(fp, " // %s", var->name); break; } } } static void print_tex_instr(nir_tex_instr *instr, print_state *state) { FILE *fp = state->fp; print_def(&instr->def, state); fprintf(fp, " = ("); print_alu_type(instr->dest_type, state); fprintf(fp, ")"); switch (instr->op) { case nir_texop_tex: fprintf(fp, "tex "); break; case nir_texop_txb: fprintf(fp, "txb "); break; case nir_texop_txl: fprintf(fp, "txl "); break; case nir_texop_txd: fprintf(fp, "txd "); break; case nir_texop_txf: fprintf(fp, "txf "); break; case nir_texop_txf_ms: fprintf(fp, "txf_ms "); break; case nir_texop_txf_ms_fb: fprintf(fp, "txf_ms_fb "); break; case nir_texop_txf_ms_mcs_intel: fprintf(fp, "txf_ms_mcs_intel "); break; case nir_texop_txs: fprintf(fp, "txs "); break; case nir_texop_lod: fprintf(fp, "lod "); break; case nir_texop_tg4: fprintf(fp, "tg4 "); break; case nir_texop_query_levels: fprintf(fp, "query_levels "); break; case nir_texop_texture_samples: fprintf(fp, "texture_samples "); break; case nir_texop_samples_identical: fprintf(fp, "samples_identical "); break; case nir_texop_tex_prefetch: fprintf(fp, "tex (pre-dispatchable) "); break; case nir_texop_fragment_fetch_amd: fprintf(fp, "fragment_fetch_amd "); break; case nir_texop_fragment_mask_fetch_amd: fprintf(fp, "fragment_mask_fetch_amd "); break; case nir_texop_descriptor_amd: fprintf(fp, "descriptor_amd "); break; case nir_texop_sampler_descriptor_amd: fprintf(fp, "sampler_descriptor_amd "); break; case nir_texop_lod_bias_agx: fprintf(fp, "lod_bias_agx "); break; case nir_texop_has_custom_border_color_agx: fprintf(fp, "has_custom_border_color_agx "); break; case nir_texop_custom_border_color_agx: fprintf(fp, "custom_border_color_agx "); break; case nir_texop_hdr_dim_nv: fprintf(fp, "hdr_dim_nv "); break; case nir_texop_tex_type_nv: fprintf(fp, "tex_type_nv "); break; default: unreachable("Invalid texture operation"); break; } bool has_texture_deref = false, has_sampler_deref = false; for (unsigned i = 0; i < instr->num_srcs; i++) { if (i > 0) { fprintf(fp, ", "); } print_src(&instr->src[i].src, state, nir_tex_instr_src_type(instr, i)); fprintf(fp, " "); switch (instr->src[i].src_type) { case nir_tex_src_backend1: fprintf(fp, "(backend1)"); break; case nir_tex_src_backend2: fprintf(fp, "(backend2)"); break; case nir_tex_src_coord: fprintf(fp, "(coord)"); break; case nir_tex_src_projector: fprintf(fp, "(projector)"); break; case nir_tex_src_comparator: fprintf(fp, "(comparator)"); break; case nir_tex_src_offset: fprintf(fp, "(offset)"); break; case nir_tex_src_bias: fprintf(fp, "(bias)"); break; case nir_tex_src_lod: fprintf(fp, "(lod)"); break; case nir_tex_src_min_lod: fprintf(fp, "(min_lod)"); break; case nir_tex_src_ms_index: fprintf(fp, "(ms_index)"); break; case nir_tex_src_ms_mcs_intel: fprintf(fp, "(ms_mcs_intel)"); break; case nir_tex_src_ddx: fprintf(fp, "(ddx)"); break; case nir_tex_src_ddy: fprintf(fp, "(ddy)"); break; case nir_tex_src_sampler_deref_intrinsic: has_texture_deref = true; fprintf(fp, "(sampler_deref_intrinsic)"); break; case nir_tex_src_texture_deref_intrinsic: has_texture_deref = true; fprintf(fp, "(texture_deref_intrinsic)"); break; case nir_tex_src_texture_deref: has_texture_deref = true; fprintf(fp, "(texture_deref)"); break; case nir_tex_src_sampler_deref: has_sampler_deref = true; fprintf(fp, "(sampler_deref)"); break; case nir_tex_src_texture_offset: fprintf(fp, "(texture_offset)"); break; case nir_tex_src_sampler_offset: fprintf(fp, "(sampler_offset)"); break; case nir_tex_src_texture_handle: fprintf(fp, "(texture_handle)"); break; case nir_tex_src_sampler_handle: fprintf(fp, "(sampler_handle)"); break; case nir_tex_src_plane: fprintf(fp, "(plane)"); break; default: unreachable("Invalid texture source type"); break; } } if (instr->is_gather_implicit_lod) fprintf(fp, ", implicit lod"); if (instr->op == nir_texop_tg4) { fprintf(fp, ", %u (gather_component)", instr->component); } if (nir_tex_instr_has_explicit_tg4_offsets(instr)) { fprintf(fp, ", { (%i, %i)", instr->tg4_offsets[0][0], instr->tg4_offsets[0][1]); for (unsigned i = 1; i < 4; ++i) fprintf(fp, ", (%i, %i)", instr->tg4_offsets[i][0], instr->tg4_offsets[i][1]); fprintf(fp, " } (offsets)"); } if (instr->op != nir_texop_txf_ms_fb && !has_texture_deref) { fprintf(fp, ", %u (texture)", instr->texture_index); } if (nir_tex_instr_need_sampler(instr) && !has_sampler_deref) { fprintf(fp, ", %u (sampler)", instr->sampler_index); } if (instr->texture_non_uniform) { fprintf(fp, ", texture non-uniform"); } if (instr->sampler_non_uniform) { fprintf(fp, ", sampler non-uniform"); } if (instr->is_sparse) { fprintf(fp, ", sparse"); } } static void print_call_instr(nir_call_instr *instr, print_state *state) { FILE *fp = state->fp; print_no_dest_padding(state); fprintf(fp, "call %s ", instr->callee->name); for (unsigned i = 0; i < instr->num_params; i++) { if (i != 0) fprintf(fp, ", "); print_src(&instr->params[i], state, nir_type_invalid); } } static void print_jump_instr(nir_jump_instr *instr, print_state *state) { FILE *fp = state->fp; print_no_dest_padding(state); switch (instr->type) { case nir_jump_break: fprintf(fp, "break"); break; case nir_jump_continue: fprintf(fp, "continue"); break; case nir_jump_return: fprintf(fp, "return"); break; case nir_jump_halt: fprintf(fp, "halt"); break; case nir_jump_goto: fprintf(fp, "goto b%u", instr->target ? instr->target->index : -1); break; case nir_jump_goto_if: fprintf(fp, "goto b%u if ", instr->target ? instr->target->index : -1); print_src(&instr->condition, state, nir_type_invalid); fprintf(fp, " else b%u", instr->else_target ? instr->else_target->index : -1); break; } } static void print_ssa_undef_instr(nir_undef_instr *instr, print_state *state) { FILE *fp = state->fp; print_def(&instr->def, state); fprintf(fp, " = undefined"); } static void print_phi_instr(nir_phi_instr *instr, print_state *state) { FILE *fp = state->fp; print_def(&instr->def, state); fprintf(fp, " = phi "); nir_foreach_phi_src(src, instr) { if (&src->node != exec_list_get_head(&instr->srcs)) fprintf(fp, ", "); fprintf(fp, "b%u: ", src->pred->index); print_src(&src->src, state, nir_type_invalid); } } static void print_parallel_copy_instr(nir_parallel_copy_instr *instr, print_state *state) { FILE *fp = state->fp; nir_foreach_parallel_copy_entry(entry, instr) { if (&entry->node != exec_list_get_head(&instr->entries)) fprintf(fp, "; "); if (entry->dest_is_reg) { fprintf(fp, "*"); print_src(&entry->dest.reg, state, nir_type_invalid); } else { print_def(&entry->dest.def, state); } fprintf(fp, " = "); if (entry->src_is_reg) fprintf(fp, "*"); print_src(&entry->src, state, nir_type_invalid); } } static void print_debug_info_instr(nir_debug_info_instr *instr, print_state *state) { FILE *fp = state->fp; switch (instr->type) { case nir_debug_info_src_loc: fprintf(fp, "// 0x%x", instr->src_loc.spirv_offset); if (instr->src_loc.line) fprintf(fp, " %s:%u:%u", nir_src_as_string(instr->src_loc.filename), instr->src_loc.line, instr->src_loc.column); return; case nir_debug_info_string: return; /* Strings are printed for their uses. */ } unreachable("Unimplemented nir_debug_info_type"); } static void print_instr(const nir_instr *instr, print_state *state, unsigned tabs) { FILE *fp = state->fp; if (state->debug_info) { nir_debug_info_instr *di = state->debug_info[instr->index]; di->src_loc.column = (uint32_t)ftell(fp); } print_indentation(tabs, fp); switch (instr->type) { case nir_instr_type_alu: print_alu_instr(nir_instr_as_alu(instr), state); break; case nir_instr_type_deref: print_deref_instr(nir_instr_as_deref(instr), state); break; case nir_instr_type_call: print_call_instr(nir_instr_as_call(instr), state); break; case nir_instr_type_intrinsic: print_intrinsic_instr(nir_instr_as_intrinsic(instr), state); break; case nir_instr_type_tex: print_tex_instr(nir_instr_as_tex(instr), state); break; case nir_instr_type_load_const: print_load_const_instr(nir_instr_as_load_const(instr), state); break; case nir_instr_type_jump: print_jump_instr(nir_instr_as_jump(instr), state); break; case nir_instr_type_undef: print_ssa_undef_instr(nir_instr_as_undef(instr), state); break; case nir_instr_type_phi: print_phi_instr(nir_instr_as_phi(instr), state); break; case nir_instr_type_parallel_copy: print_parallel_copy_instr(nir_instr_as_parallel_copy(instr), state); break; case nir_instr_type_debug_info: print_debug_info_instr(nir_instr_as_debug_info(instr), state); break; default: unreachable("Invalid instruction type"); break; } if (NIR_DEBUG(PRINT_PASS_FLAGS) && instr->pass_flags) fprintf(fp, " (pass_flags: 0x%x)", instr->pass_flags); } static bool block_has_instruction_with_dest(nir_block *block) { nir_foreach_instr(instr, block) { switch (instr->type) { case nir_instr_type_load_const: case nir_instr_type_deref: case nir_instr_type_alu: case nir_instr_type_tex: case nir_instr_type_undef: case nir_instr_type_phi: case nir_instr_type_parallel_copy: return true; case nir_instr_type_intrinsic: { nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr); const nir_intrinsic_info *info = &nir_intrinsic_infos[intrin->intrinsic]; if (info->has_dest) return true; /* Doesn't define a new value. */ break; } case nir_instr_type_jump: case nir_instr_type_call: case nir_instr_type_debug_info: /* Doesn't define a new value. */ break; } } return false; } static void print_cf_node(nir_cf_node *node, print_state *state, unsigned tabs); static void print_block_preds(nir_block *block, print_state *state) { FILE *fp = state->fp; nir_block **preds = nir_block_get_predecessors_sorted(block, NULL); for (unsigned i = 0; i < block->predecessors->entries; i++) { if (i != 0) fprintf(fp, " "); fprintf(fp, "b%u", preds[i]->index); } ralloc_free(preds); } static void print_block_succs(nir_block *block, print_state *state) { FILE *fp = state->fp; for (unsigned i = 0; i < 2; i++) { if (block->successors[i]) { fprintf(fp, "b%u ", block->successors[i]->index); } } } static void print_block(nir_block *block, print_state *state, unsigned tabs) { FILE *fp = state->fp; if (block_has_instruction_with_dest(block)) state->padding_for_no_dest = calculate_padding_for_no_dest(state); else state->padding_for_no_dest = 0; print_indentation(tabs, fp); fprintf(fp, "%sblock b%u:", divergence_status(state, block->divergent), block->index); const bool empty_block = exec_list_is_empty(&block->instr_list); if (empty_block) { fprintf(fp, " // preds: "); print_block_preds(block, state); fprintf(fp, ", succs: "); print_block_succs(block, state); fprintf(fp, "\n"); return; } const unsigned block_length = 7 + count_digits(block->index) + 1; const unsigned pred_padding = block_length < state->padding_for_no_dest ? state->padding_for_no_dest - block_length : 0; fprintf(fp, "%*s// preds: ", pred_padding, ""); print_block_preds(block, state); fprintf(fp, "\n"); nir_foreach_instr(instr, block) { print_instr(instr, state, tabs); fprintf(fp, "\n"); print_annotation(state, instr); } print_indentation(tabs, fp); fprintf(fp, "%*s// succs: ", state->padding_for_no_dest, ""); print_block_succs(block, state); fprintf(fp, "\n"); } static void print_if(nir_if *if_stmt, print_state *state, unsigned tabs) { FILE *fp = state->fp; print_indentation(tabs, fp); fprintf(fp, "if "); print_src(&if_stmt->condition, state, nir_type_invalid); switch (if_stmt->control) { case nir_selection_control_flatten: fprintf(fp, " // flatten"); break; case nir_selection_control_dont_flatten: fprintf(fp, " // don't flatten"); break; case nir_selection_control_divergent_always_taken: fprintf(fp, " // divergent always taken"); break; case nir_selection_control_none: default: break; } fprintf(fp, " {\n"); foreach_list_typed(nir_cf_node, node, node, &if_stmt->then_list) { print_cf_node(node, state, tabs + 1); } print_indentation(tabs, fp); fprintf(fp, "} else {\n"); foreach_list_typed(nir_cf_node, node, node, &if_stmt->else_list) { print_cf_node(node, state, tabs + 1); } print_indentation(tabs, fp); fprintf(fp, "}\n"); } static void print_loop(nir_loop *loop, print_state *state, unsigned tabs) { FILE *fp = state->fp; print_indentation(tabs, fp); fprintf(fp, "%sloop {\n", divergence_status(state, loop->divergent)); foreach_list_typed(nir_cf_node, node, node, &loop->body) { print_cf_node(node, state, tabs + 1); } print_indentation(tabs, fp); if (nir_loop_has_continue_construct(loop)) { fprintf(fp, "} continue {\n"); foreach_list_typed(nir_cf_node, node, node, &loop->continue_list) { print_cf_node(node, state, tabs + 1); } print_indentation(tabs, fp); } fprintf(fp, "}\n"); } static void print_cf_node(nir_cf_node *node, print_state *state, unsigned int tabs) { switch (node->type) { case nir_cf_node_block: print_block(nir_cf_node_as_block(node), state, tabs); break; case nir_cf_node_if: print_if(nir_cf_node_as_if(node), state, tabs); break; case nir_cf_node_loop: print_loop(nir_cf_node_as_loop(node), state, tabs); break; default: unreachable("Invalid CFG node type"); } } static void print_function_impl(nir_function_impl *impl, print_state *state) { FILE *fp = state->fp; state->max_dest_index = impl->ssa_alloc; fprintf(fp, "\nimpl %s ", impl->function->name); fprintf(fp, "{\n"); if (impl->preamble) { print_indentation(1, fp); fprintf(fp, "preamble %s\n", impl->preamble->name); } if (!NIR_DEBUG(PRINT_NO_INLINE_CONSTS)) { /* Don't reindex the SSA as suggested by nir_gather_types() because * nir_print don't modify the shader. If needed, a limit for ssa_alloc * can be added. */ state->float_types = calloc(BITSET_WORDS(impl->ssa_alloc), sizeof(BITSET_WORD)); state->int_types = calloc(BITSET_WORDS(impl->ssa_alloc), sizeof(BITSET_WORD)); nir_gather_types(impl, state->float_types, state->int_types); } nir_foreach_function_temp_variable(var, impl) { print_indentation(1, fp); print_var_decl(var, state); } nir_index_blocks(impl); foreach_list_typed(nir_cf_node, node, node, &impl->body) { print_cf_node(node, state, 1); } print_indentation(1, fp); fprintf(fp, "block b%u:\n}\n\n", impl->end_block->index); free(state->float_types); free(state->int_types); state->max_dest_index = 0; } static void print_function(nir_function *function, print_state *state) { FILE *fp = state->fp; /* clang-format off */ fprintf(fp, "decl_function %s (%d params)%s%s", function->name, function->num_params, function->dont_inline ? " (noinline)" : function->should_inline ? " (inline)" : "", function->is_exported ? " (exported)" : ""); /* clang-format on */ fprintf(fp, "\n"); if (function->impl != NULL) { print_function_impl(function->impl, state); return; } } static void init_print_state(print_state *state, nir_shader *shader, FILE *fp) { state->fp = fp; state->shader = shader; state->ht = _mesa_pointer_hash_table_create(NULL); state->syms = _mesa_set_create(NULL, _mesa_hash_string, _mesa_key_string_equal); state->index = 0; state->int_types = NULL; state->float_types = NULL; state->max_dest_index = 0; state->padding_for_no_dest = 0; } static void destroy_print_state(print_state *state) { _mesa_hash_table_destroy(state->ht, NULL); _mesa_set_destroy(state->syms, NULL); } static const char * primitive_name(unsigned primitive) { #define PRIM(X) \ case MESA_PRIM_##X: \ return #X switch (primitive) { PRIM(POINTS); PRIM(LINES); PRIM(LINE_LOOP); PRIM(LINE_STRIP); PRIM(TRIANGLES); PRIM(TRIANGLE_STRIP); PRIM(TRIANGLE_FAN); PRIM(QUADS); PRIM(QUAD_STRIP); PRIM(POLYGON); PRIM(LINES_ADJACENCY); PRIM(TRIANGLES_ADJACENCY); default: return "UNKNOWN"; } } static void print_bitset(FILE *fp, const char *label, const unsigned *words, int size) { fprintf(fp, "%s: ", label); /* Iterate back-to-front to get proper digit order (most significant first). */ for (int i = size - 1; i >= 0; --i) { fprintf(fp, (i == size - 1) ? "0x%08x" : "'%08x", words[i]); } fprintf(fp, "\n"); } /* Print bitset, only if some bits are set */ static void print_nz_bitset(FILE *fp, const char *label, const unsigned *words, int size) { bool is_all_zero = true; for (int i = 0; i < size; ++i) { if (words[i]) { is_all_zero = false; break; } } if (!is_all_zero) print_bitset(fp, label, words, size); } /* Print uint64_t value, only if non-zero. * The value is printed by enumerating the ranges of bits that are set. * E.g. inputs_read: 0,15-17 */ static void print_nz_x64(FILE *fp, const char *label, uint64_t value) { if (value) { char acc[256] = { 0 }; char buf[32]; int start = 0; int count = 0; while (value) { u_bit_scan_consecutive_range64(&value, &start, &count); assert(count > 0); bool is_first = !acc[0]; if (count > 1) { snprintf(buf, sizeof(buf), is_first ? "%d-%d" : ",%d-%d", start, start + count - 1); } else { snprintf(buf, sizeof(buf), is_first ? "%d" : ",%d", start); } assert(strlen(acc) + strlen(buf) + 1 < sizeof(acc)); strcat(acc, buf); } fprintf(fp, "%s: %s\n", label, acc); } } /* Print uint32_t value in hex, only if non-zero */ static void print_nz_x32(FILE *fp, const char *label, uint32_t value) { if (value) fprintf(fp, "%s: 0x%08" PRIx32 "\n", label, value); } /* Print uint16_t value in hex, only if non-zero */ static void print_nz_x16(FILE *fp, const char *label, uint16_t value) { if (value) fprintf(fp, "%s: 0x%04x\n", label, value); } /* Print uint8_t value in hex, only if non-zero */ static void print_nz_x8(FILE *fp, const char *label, uint8_t value) { if (value) fprintf(fp, "%s: 0x%02x\n", label, value); } /* Print unsigned value in decimal, only if non-zero */ static void print_nz_unsigned(FILE *fp, const char *label, unsigned value) { if (value) fprintf(fp, "%s: %u\n", label, value); } /* Print bool only if set */ static void print_nz_bool(FILE *fp, const char *label, bool value) { if (value) fprintf(fp, "%s: true\n", label); } static void print_shader_info(const struct shader_info *info, FILE *fp) { fprintf(fp, "shader: %s\n", gl_shader_stage_name(info->stage)); fprintf(fp, "source_blake3: {"); _mesa_blake3_print(fp, info->source_blake3); fprintf(fp, "}\n"); if (info->name) fprintf(fp, "name: %s\n", info->name); if (info->label) fprintf(fp, "label: %s\n", info->label); fprintf(fp, "internal: %s\n", info->internal ? "true" : "false"); if (gl_shader_stage_uses_workgroup(info->stage)) { fprintf(fp, "workgroup_size: %u, %u, %u%s\n", info->workgroup_size[0], info->workgroup_size[1], info->workgroup_size[2], info->workgroup_size_variable ? " (variable)" : ""); } fprintf(fp, "stage: %d\n" "next_stage: %d\n", info->stage, info->next_stage); print_nz_unsigned(fp, "num_textures", info->num_textures); print_nz_unsigned(fp, "num_ubos", info->num_ubos); print_nz_unsigned(fp, "num_abos", info->num_abos); print_nz_unsigned(fp, "num_ssbos", info->num_ssbos); print_nz_unsigned(fp, "num_images", info->num_images); print_nz_x64(fp, "inputs_read", info->inputs_read); print_nz_x64(fp, "dual_slot_inputs", info->dual_slot_inputs); print_nz_x64(fp, "outputs_written", info->outputs_written); print_nz_x64(fp, "outputs_read", info->outputs_read); print_nz_bitset(fp, "system_values_read", info->system_values_read, ARRAY_SIZE(info->system_values_read)); print_nz_x64(fp, "per_primitive_inputs", info->per_primitive_inputs); print_nz_x64(fp, "per_primitive_outputs", info->per_primitive_outputs); print_nz_x64(fp, "per_view_outputs", info->per_view_outputs); print_nz_x16(fp, "inputs_read_16bit", info->inputs_read_16bit); print_nz_x16(fp, "outputs_written_16bit", info->outputs_written_16bit); print_nz_x16(fp, "outputs_read_16bit", info->outputs_read_16bit); print_nz_x16(fp, "inputs_read_indirectly_16bit", info->inputs_read_indirectly_16bit); print_nz_x16(fp, "outputs_accessed_indirectly_16bit", info->outputs_accessed_indirectly_16bit); print_nz_x32(fp, "patch_inputs_read", info->patch_inputs_read); print_nz_x32(fp, "patch_outputs_written", info->patch_outputs_written); print_nz_x32(fp, "patch_outputs_read", info->patch_outputs_read); print_nz_x64(fp, "inputs_read_indirectly", info->inputs_read_indirectly); print_nz_x64(fp, "outputs_accessed_indirectly", info->outputs_accessed_indirectly); print_nz_x64(fp, "patch_inputs_read_indirectly", info->patch_inputs_read_indirectly); print_nz_x64(fp, "patch_outputs_accessed_indirectly", info->patch_outputs_accessed_indirectly); print_nz_bitset(fp, "textures_used", info->textures_used, ARRAY_SIZE(info->textures_used)); print_nz_bitset(fp, "textures_used_by_txf", info->textures_used_by_txf, ARRAY_SIZE(info->textures_used_by_txf)); print_nz_bitset(fp, "samplers_used", info->samplers_used, ARRAY_SIZE(info->samplers_used)); print_nz_bitset(fp, "images_used", info->images_used, ARRAY_SIZE(info->images_used)); print_nz_bitset(fp, "image_buffers", info->image_buffers, ARRAY_SIZE(info->image_buffers)); print_nz_bitset(fp, "msaa_images", info->msaa_images, ARRAY_SIZE(info->msaa_images)); print_nz_x32(fp, "float_controls_execution_mode", info->float_controls_execution_mode); print_nz_unsigned(fp, "shared_size", info->shared_size); if (info->stage == MESA_SHADER_MESH || info->stage == MESA_SHADER_TASK) { fprintf(fp, "task_payload_size: %u\n", info->task_payload_size); } print_nz_unsigned(fp, "ray queries", info->ray_queries); fprintf(fp, "subgroup_size: %u\n", info->subgroup_size); print_nz_bool(fp, "uses_wide_subgroup_intrinsics", info->uses_wide_subgroup_intrinsics); bool has_xfb_stride = info->xfb_stride[0] || info->xfb_stride[1] || info->xfb_stride[2] || info->xfb_stride[3]; if (has_xfb_stride) fprintf(fp, "xfb_stride: {%u, %u, %u, %u}\n", info->xfb_stride[0], info->xfb_stride[1], info->xfb_stride[2], info->xfb_stride[3]); bool has_inlinable_uniform_dw_offsets = info->inlinable_uniform_dw_offsets[0] || info->inlinable_uniform_dw_offsets[1] || info->inlinable_uniform_dw_offsets[2] || info->inlinable_uniform_dw_offsets[3]; if (has_inlinable_uniform_dw_offsets) fprintf(fp, "inlinable_uniform_dw_offsets: {%u, %u, %u, %u}\n", info->inlinable_uniform_dw_offsets[0], info->inlinable_uniform_dw_offsets[1], info->inlinable_uniform_dw_offsets[2], info->inlinable_uniform_dw_offsets[3]); print_nz_unsigned(fp, "num_inlinable_uniforms", info->num_inlinable_uniforms); print_nz_unsigned(fp, "clip_distance_array_size", info->clip_distance_array_size); print_nz_unsigned(fp, "cull_distance_array_size", info->cull_distance_array_size); print_nz_bool(fp, "uses_texture_gather", info->uses_texture_gather); print_nz_bool(fp, "uses_resource_info_query", info->uses_resource_info_query); print_nz_bool(fp, "uses_fddx_fddy", info->uses_fddx_fddy); print_nz_bool(fp, "divergence_analysis_run", info->divergence_analysis_run); print_nz_x8(fp, "bit_sizes_float", info->bit_sizes_float); print_nz_x8(fp, "bit_sizes_int", info->bit_sizes_int); print_nz_bool(fp, "first_ubo_is_default_ubo", info->first_ubo_is_default_ubo); print_nz_bool(fp, "separate_shader", info->separate_shader); print_nz_bool(fp, "has_transform_feedback_varyings", info->has_transform_feedback_varyings); print_nz_bool(fp, "flrp_lowered", info->flrp_lowered); print_nz_bool(fp, "io_lowered", info->io_lowered); print_nz_bool(fp, "writes_memory", info->writes_memory); print_nz_unsigned(fp, "derivative_group", info->derivative_group); switch (info->stage) { case MESA_SHADER_VERTEX: print_nz_x64(fp, "double_inputs", info->vs.double_inputs); print_nz_unsigned(fp, "blit_sgprs_amd", info->vs.blit_sgprs_amd); print_nz_bool(fp, "window_space_position", info->vs.window_space_position); print_nz_bool(fp, "needs_edge_flag", info->vs.needs_edge_flag); break; case MESA_SHADER_TESS_CTRL: case MESA_SHADER_TESS_EVAL: fprintf(fp, "primitive_mode: %u\n", info->tess._primitive_mode); fprintf(fp, "tcs_vertices_out: %u\n", info->tess.tcs_vertices_out); fprintf(fp, "spacing: %u\n", info->tess.spacing); print_nz_bool(fp, "ccw", info->tess.ccw); print_nz_bool(fp, "point_mode", info->tess.point_mode); print_nz_x64(fp, "tcs_cross_invocation_inputs_read", info->tess.tcs_cross_invocation_inputs_read); print_nz_x64(fp, "tcs_cross_invocation_outputs_read", info->tess.tcs_cross_invocation_outputs_read); break; case MESA_SHADER_GEOMETRY: fprintf(fp, "output_primitive: %s\n", primitive_name(info->gs.output_primitive)); fprintf(fp, "input_primitive: %s\n", primitive_name(info->gs.input_primitive)); fprintf(fp, "vertices_out: %u\n", info->gs.vertices_out); fprintf(fp, "invocations: %u\n", info->gs.invocations); fprintf(fp, "vertices_in: %u\n", info->gs.vertices_in); print_nz_bool(fp, "uses_end_primitive", info->gs.uses_end_primitive); fprintf(fp, "active_stream_mask: 0x%02x\n", info->gs.active_stream_mask); break; case MESA_SHADER_FRAGMENT: print_nz_bool(fp, "uses_discard", info->fs.uses_discard); print_nz_bool(fp, "uses_fbfetch_output", info->fs.uses_fbfetch_output); print_nz_bool(fp, "color_is_dual_source", info->fs.color_is_dual_source); print_nz_bool(fp, "require_full_quads", info->fs.require_full_quads); print_nz_bool(fp, "needs_quad_helper_invocations", info->fs.needs_quad_helper_invocations); print_nz_bool(fp, "uses_sample_qualifier", info->fs.uses_sample_qualifier); print_nz_bool(fp, "uses_sample_shading", info->fs.uses_sample_shading); print_nz_bool(fp, "early_fragment_tests", info->fs.early_fragment_tests); print_nz_bool(fp, "inner_coverage", info->fs.inner_coverage); print_nz_bool(fp, "post_depth_coverage", info->fs.post_depth_coverage); print_nz_bool(fp, "pixel_center_integer", info->fs.pixel_center_integer); print_nz_bool(fp, "origin_upper_left", info->fs.origin_upper_left); print_nz_bool(fp, "pixel_interlock_ordered", info->fs.pixel_interlock_ordered); print_nz_bool(fp, "pixel_interlock_unordered", info->fs.pixel_interlock_unordered); print_nz_bool(fp, "sample_interlock_ordered", info->fs.sample_interlock_ordered); print_nz_bool(fp, "sample_interlock_unordered", info->fs.sample_interlock_unordered); print_nz_bool(fp, "untyped_color_outputs", info->fs.untyped_color_outputs); print_nz_unsigned(fp, "depth_layout", info->fs.depth_layout); if (info->fs.color0_interp != INTERP_MODE_NONE) { fprintf(fp, "color0_interp: %s\n", glsl_interp_mode_name(info->fs.color0_interp)); } print_nz_bool(fp, "color0_sample", info->fs.color0_sample); print_nz_bool(fp, "color0_centroid", info->fs.color0_centroid); if (info->fs.color1_interp != INTERP_MODE_NONE) { fprintf(fp, "color1_interp: %s\n", glsl_interp_mode_name(info->fs.color1_interp)); } print_nz_bool(fp, "color1_sample", info->fs.color1_sample); print_nz_bool(fp, "color1_centroid", info->fs.color1_centroid); print_nz_x32(fp, "advanced_blend_modes", info->fs.advanced_blend_modes); break; case MESA_SHADER_COMPUTE: case MESA_SHADER_KERNEL: if (info->cs.workgroup_size_hint[0] || info->cs.workgroup_size_hint[1] || info->cs.workgroup_size_hint[2]) fprintf(fp, "workgroup_size_hint: {%u, %u, %u}\n", info->cs.workgroup_size_hint[0], info->cs.workgroup_size_hint[1], info->cs.workgroup_size_hint[2]); print_nz_unsigned(fp, "user_data_components_amd", info->cs.user_data_components_amd); fprintf(fp, "ptr_size: %u\n", info->cs.ptr_size); break; case MESA_SHADER_MESH: print_nz_x64(fp, "ms_cross_invocation_output_access", info->mesh.ms_cross_invocation_output_access); fprintf(fp, "max_vertices_out: %u\n", info->mesh.max_vertices_out); fprintf(fp, "max_primitives_out: %u\n", info->mesh.max_primitives_out); fprintf(fp, "primitive_type: %s\n", primitive_name(info->mesh.primitive_type)); print_nz_bool(fp, "nv", info->mesh.nv); break; default: fprintf(fp, "Unhandled stage %d\n", info->stage); } } static void _nir_print_shader_annotated(nir_shader *shader, FILE *fp, struct hash_table *annotations, nir_debug_info_instr **debug_info) { print_state state; init_print_state(&state, shader, fp); state.def_prefix = debug_info ? "ssa_" : "%"; state.annotations = annotations; state.debug_info = debug_info; print_shader_info(&shader->info, fp); fprintf(fp, "inputs: %u\n", shader->num_inputs); fprintf(fp, "outputs: %u\n", shader->num_outputs); fprintf(fp, "uniforms: %u\n", shader->num_uniforms); if (shader->scratch_size) fprintf(fp, "scratch: %u\n", shader->scratch_size); if (shader->constant_data_size) fprintf(fp, "constants: %u\n", shader->constant_data_size); for (unsigned i = 0; i < nir_num_variable_modes; i++) { nir_variable_mode mode = BITFIELD_BIT(i); if (mode == nir_var_function_temp) continue; if (mode == nir_var_shader_in || mode == nir_var_shader_out) { for (unsigned j = 0; j < 128; j++) { nir_variable *vars[NIR_MAX_VEC_COMPONENTS] = {0}; nir_foreach_variable_with_modes(var, shader, mode) { if (var->data.location == j) vars[var->data.location_frac] = var; } for (unsigned j = 0; j < ARRAY_SIZE(vars); j++) if (vars[j]) { print_var_decl(vars[j], &state); } } } else { nir_foreach_variable_with_modes(var, shader, mode) print_var_decl(var, &state); } } foreach_list_typed(nir_function, func, node, &shader->functions) { print_function(func, &state); } destroy_print_state(&state); } void nir_print_shader_annotated(nir_shader *shader, FILE *fp, struct hash_table *annotations) { _nir_print_shader_annotated(shader, fp, annotations, NULL); } void nir_print_shader(nir_shader *shader, FILE *fp) { nir_print_shader_annotated(shader, fp, NULL); fflush(fp); } static char * _nir_shader_as_str_annotated(nir_shader *nir, struct hash_table *annotations, void *mem_ctx, nir_debug_info_instr **debug_info) { char *stream_data = NULL; size_t stream_size = 0; struct u_memstream mem; if (u_memstream_open(&mem, &stream_data, &stream_size)) { FILE *const stream = u_memstream_get(&mem); _nir_print_shader_annotated(nir, stream, annotations, debug_info); u_memstream_close(&mem); } char *str = ralloc_size(mem_ctx, stream_size + 1); memcpy(str, stream_data, stream_size); str[stream_size] = '\0'; free(stream_data); return str; } char * nir_shader_as_str_annotated(nir_shader *nir, struct hash_table *annotations, void *mem_ctx) { return _nir_shader_as_str_annotated(nir, annotations, mem_ctx, NULL); } char * nir_shader_as_str(nir_shader *nir, void *mem_ctx) { return nir_shader_as_str_annotated(nir, NULL, mem_ctx); } void nir_print_instr(const nir_instr *instr, FILE *fp) { print_state state = { .fp = fp, .def_prefix = "%", }; if (instr->block) { nir_function_impl *impl = nir_cf_node_get_function(&instr->block->cf_node); state.shader = impl->function->shader; } print_instr(instr, &state, 0); } char * nir_instr_as_str(const nir_instr *instr, void *mem_ctx) { char *stream_data = NULL; size_t stream_size = 0; struct u_memstream mem; if (u_memstream_open(&mem, &stream_data, &stream_size)) { FILE *const stream = u_memstream_get(&mem); nir_print_instr(instr, stream); u_memstream_close(&mem); } char *str = ralloc_size(mem_ctx, stream_size + 1); memcpy(str, stream_data, stream_size); str[stream_size] = '\0'; free(stream_data); return str; } void nir_print_deref(const nir_deref_instr *deref, FILE *fp) { print_state state = { .fp = fp, .def_prefix = "%", }; print_deref_link(deref, true, &state); } void nir_log_shader_annotated_tagged(enum mesa_log_level level, const char *tag, nir_shader *shader, struct hash_table *annotations) { char *str = nir_shader_as_str_annotated(shader, annotations, NULL); _mesa_log_multiline(level, tag, str); ralloc_free(str); } char * nir_shader_gather_debug_info(nir_shader *shader, const char *filename) { uint32_t instr_count = 0; nir_foreach_function_impl(impl, shader) { nir_foreach_block(block, impl) { nir_foreach_instr(instr, block) { instr->index = instr_count; instr_count++; } } } if (!instr_count) return nir_shader_as_str(shader, NULL); nir_debug_info_instr **debug_info = rzalloc_array(shader, nir_debug_info_instr *, instr_count); instr_count = 0; nir_foreach_function_impl(impl, shader) { nir_builder b = nir_builder_at(nir_before_cf_list(&impl->body)); nir_def *filename_def = nir_build_string(&b, filename); nir_foreach_block(block, impl) { nir_foreach_instr_safe(instr, block) { if (instr->type == nir_instr_type_debug_info) continue; nir_debug_info_instr *di = nir_debug_info_instr_create(shader, nir_debug_info_src_loc, 0); di->src_loc.filename = nir_src_for_ssa(filename_def); di->src_loc.source = nir_debug_info_nir; debug_info[instr_count++] = di; } } } char *str = _nir_shader_as_str_annotated(shader, NULL, NULL, debug_info); uint32_t line = 1; uint32_t character_index = 0; for (uint32_t i = 0; i < instr_count; i++) { nir_debug_info_instr *di = debug_info[i]; while (character_index < di->src_loc.column) { if (str[character_index] == '\n') line++; character_index++; } di->src_loc.line = line; di->src_loc.column = 0; } instr_count = 0; nir_foreach_function_impl(impl, shader) { nir_foreach_block(block, impl) { nir_foreach_instr_safe(instr, block) { if (instr->type != nir_instr_type_debug_info) nir_instr_insert_before(instr, &debug_info[instr_count++]->instr); } } } return str; }