static void
print_annotation(print_state *state, void *obj)
{
+ FILE *fp = state->fp;
+
if (!state->annotations)
return;
const char *note = entry->data;
_mesa_hash_table_remove(state->annotations, entry);
- fprintf(stderr, "%s\n\n", note);
+ fprintf(fp, "%s\n\n", note);
}
static void
FILE *fp = state->fp;
if (reg->name != NULL)
fprintf(fp, "/* %s */ ", reg->name);
- if (reg->is_global)
- fprintf(fp, "gr%u", reg->index);
- else
- fprintf(fp, "r%u", reg->index);
+ fprintf(fp, "r%u", reg->index);
}
static const char *sizes[] = { "error", "vec1", "vec2", "vec3", "vec4",
fprintf(fp, "!");
if (instr->dest.saturate)
fprintf(fp, ".sat");
+ 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++) {
FILE *fp = state->fp;
const unsigned rows = glsl_get_vector_elements(type);
const unsigned cols = glsl_get_matrix_columns(type);
- unsigned i, j;
+ unsigned i;
switch (glsl_get_base_type(type)) {
case GLSL_TYPE_BOOL:
for (i = 0; i < rows; i++) {
if (i > 0) fprintf(fp, ", ");
- fprintf(fp, "%s", c->values[0].b[i] ? "true" : "false");
+ fprintf(fp, "%s", c->values[i].b ? "true" : "false");
}
break;
for (i = 0; i < rows; i++) {
if (i > 0) fprintf(fp, ", ");
- fprintf(fp, "0x%02x", c->values[0].u8[i]);
+ fprintf(fp, "0x%02x", c->values[i].u8);
}
break;
for (i = 0; i < rows; i++) {
if (i > 0) fprintf(fp, ", ");
- fprintf(fp, "0x%04x", c->values[0].u16[i]);
+ fprintf(fp, "0x%04x", c->values[i].u16);
}
break;
for (i = 0; i < rows; i++) {
if (i > 0) fprintf(fp, ", ");
- fprintf(fp, "0x%08x", c->values[0].u32[i]);
+ fprintf(fp, "0x%08x", c->values[i].u32);
}
break;
case GLSL_TYPE_FLOAT16:
- for (i = 0; i < cols; i++) {
- for (j = 0; j < rows; j++) {
- if (i + j > 0) fprintf(fp, ", ");
- fprintf(fp, "%f", _mesa_half_to_float(c->values[i].u16[j]));
- }
- }
- break;
-
case GLSL_TYPE_FLOAT:
- for (i = 0; i < cols; i++) {
- for (j = 0; j < rows; j++) {
- if (i + j > 0) fprintf(fp, ", ");
- fprintf(fp, "%f", c->values[i].f32[j]);
- }
- }
- break;
-
case GLSL_TYPE_DOUBLE:
- for (i = 0; i < cols; i++) {
- for (j = 0; j < rows; j++) {
- if (i + j > 0) fprintf(fp, ", ");
- fprintf(fp, "%f", c->values[i].f64[j]);
+ 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;
for (i = 0; i < cols; i++) {
if (i > 0) fprintf(fp, ", ");
- fprintf(fp, "0x%08" PRIx64, c->values[0].u64[i]);
+ fprintf(fp, "0x%08" PRIx64, c->values[i].u64);
}
break;
cent, samp, patch, inv, get_variable_mode_str(var->data.mode, false),
glsl_interp_mode_name(var->data.interpolation));
- enum gl_access_qualifier access = var->data.image.access;
+ enum gl_access_qualifier access = var->data.access;
const char *const coher = (access & ACCESS_COHERENT) ? "coherent " : "";
const char *const volat = (access & ACCESS_VOLATILE) ? "volatile " : "";
const char *const restr = (access & ACCESS_RESTRICT) ? "restrict " : "";
const char *const ronly = (access & ACCESS_NON_WRITEABLE) ? "readonly " : "";
const char *const wonly = (access & ACCESS_NON_READABLE) ? "writeonly " : "";
- fprintf(fp, "%s%s%s%s%s", coher, volat, restr, ronly, wonly);
+ const char *const reorder = (access & ACCESS_CAN_REORDER) ? "reorderable " : "";
+ fprintf(fp, "%s%s%s%s%s%s", coher, volat, restr, ronly, wonly, reorder);
-#define FORMAT_CASE(x) case x: fprintf(stderr, #x " "); break
+#define FORMAT_CASE(x) case x: fprintf(fp, #x " "); break
switch (var->data.image.format) {
FORMAT_CASE(GL_RGBA32F);
FORMAT_CASE(GL_RGBA32UI);
case nir_deref_type_array:
case nir_deref_type_ptr_as_array: {
- nir_const_value *const_index = nir_src_as_const_value(instr->arr.index);
- if (const_index) {
- fprintf(fp, "[%u]", const_index->u32[0]);
+ 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);
print_deref_link(instr, true, state);
fprintf(fp, " */");
}
+
+ if (instr->deref_type == nir_deref_type_cast) {
+ fprintf(fp, " /* ptr_stride=%u */", instr->cast.ptr_stride);
+ }
}
static const char *
[NIR_INTRINSIC_IMAGE_DIM] = "image_dim",
[NIR_INTRINSIC_IMAGE_ARRAY] = "image_array",
[NIR_INTRINSIC_ACCESS] = "access",
+ [NIR_INTRINSIC_SRC_ACCESS] = "src-access",
+ [NIR_INTRINSIC_DST_ACCESS] = "dst-access",
[NIR_INTRINSIC_FORMAT] = "format",
[NIR_INTRINSIC_ALIGN_MUL] = "align_mul",
[NIR_INTRINSIC_ALIGN_OFFSET] = "align_offset",
[NIR_INTRINSIC_DESC_TYPE] = "desc_type",
+ [NIR_INTRINSIC_TYPE] = "type",
+ [NIR_INTRINSIC_SWIZZLE_MASK] = "swizzle_mask",
+ [NIR_INTRINSIC_DRIVER_LOCATION] = "driver_location",
+ [NIR_INTRINSIC_MEMORY_SEMANTICS] = "mem_semantics",
+ [NIR_INTRINSIC_MEMORY_MODES] = "mem_modes",
+ [NIR_INTRINSIC_MEMORY_SCOPE] = "mem_scope",
};
for (unsigned idx = 1; idx < NIR_INTRINSIC_NUM_INDEX_FLAGS; idx++) {
if (!info->index_map[idx])
continue;
fprintf(fp, " /*");
- if (idx == NIR_INTRINSIC_WRMASK) {
+ switch (idx) {
+ case NIR_INTRINSIC_WRMASK: {
/* special case wrmask to show it as a writemask.. */
unsigned wrmask = nir_intrinsic_write_mask(instr);
fprintf(fp, " wrmask=");
for (unsigned i = 0; i < 4; i++)
if ((wrmask >> i) & 1)
fprintf(fp, "%c", "xyzw"[i]);
- } else if (idx == NIR_INTRINSIC_REDUCTION_OP) {
+ 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);
- } else if (idx == NIR_INTRINSIC_IMAGE_DIM) {
+ break;
+ }
+
+ case NIR_INTRINSIC_IMAGE_DIM: {
static const char *dim_name[] = {
[GLSL_SAMPLER_DIM_1D] = "1D",
[GLSL_SAMPLER_DIM_2D] = "2D",
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]);
- } else if (idx == NIR_INTRINSIC_IMAGE_ARRAY) {
+ break;
+ }
+
+ case NIR_INTRINSIC_IMAGE_ARRAY: {
bool array = nir_intrinsic_image_array(instr);
fprintf(fp, " image_array=%s", array ? "true" : "false");
- } else if (idx == NIR_INTRINSIC_DESC_TYPE) {
+ 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));
- } else {
+ break;
+ }
+
+ case NIR_INTRINSIC_TYPE: {
+ nir_alu_type type = nir_intrinsic_type(instr);
+ 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, " type=%s%u", name, size);
+ else
+ fprintf(fp, " type=%s", name);
+ 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);
+ 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_MEMORY_SCOPE: {
+ fprintf(fp, " mem_scope=");
+ switch (nir_intrinsic_memory_scope(instr)) {
+ case NIR_SCOPE_DEVICE: fprintf(fp, "DEVICE"); break;
+ case NIR_SCOPE_QUEUE_FAMILY: fprintf(fp, "QUEUE_FAMILY"); break;
+ case NIR_SCOPE_WORKGROUP: fprintf(fp, "WORKGROUP"); break;
+ case NIR_SCOPE_SUBGROUP: fprintf(fp, "SUBGROUP"); break;
+ case NIR_SCOPE_INVOCATION: fprintf(fp, "INVOCATION"); break;
+ }
+ break;
+ }
+
+ default: {
unsigned off = info->index_map[idx] - 1;
assert(index_name[idx]); /* forgot to update index_name table? */
fprintf(fp, " %s=%d", index_name[idx], instr->const_index[off]);
+ break;
+ }
}
fprintf(fp, " */");
}
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:
fprintf(fp, "txf_ms_mcs ");
break;
case nir_texop_samples_identical:
fprintf(fp, "samples_identical ");
break;
+ case nir_texop_tex_prefetch:
+ fprintf(fp, "tex (pre-dispatchable) ");
+ 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++) {
- print_src(&instr->src[i].src, state);
+ if (i > 0) {
+ fprintf(fp, ", ");
+ }
+ print_src(&instr->src[i].src, state);
fprintf(fp, " ");
switch(instr->src[i].src_type) {
unreachable("Invalid texture source type");
break;
}
-
- fprintf(fp, ", ");
}
if (instr->op == nir_texop_tg4) {
- fprintf(fp, "%u (gather_component), ", instr->component);
+ 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]);
+ 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), ");
+ fprintf(fp, " } (offsets)");
}
- if (!has_texture_deref) {
- fprintf(fp, "%u (texture), ", instr->texture_index);
- }
+ if (instr->op != nir_texop_txf_ms_fb) {
+ if (!has_texture_deref) {
+ fprintf(fp, ", %u (texture)", instr->texture_index);
+ }
- if (!has_sampler_deref) {
- fprintf(fp, "%u (sampler), ", instr->sampler_index);
+ if (!has_sampler_deref) {
+ fprintf(fp, ", %u (sampler)", instr->sampler_index);
+ }
}
}
switch (instr->def.bit_size) {
case 64:
- fprintf(fp, "0x%16" PRIx64 " /* %f */", instr->value.u64[i],
- instr->value.f64[i]);
+ fprintf(fp, "0x%16" PRIx64 " /* %f */", instr->value[i].u64,
+ instr->value[i].f64);
break;
case 32:
- fprintf(fp, "0x%08x /* %f */", instr->value.u32[i], instr->value.f32[i]);
+ fprintf(fp, "0x%08x /* %f */", instr->value[i].u32, instr->value[i].f32);
break;
case 16:
- fprintf(fp, "0x%04x /* %f */", instr->value.u16[i],
- _mesa_half_to_float(instr->value.u16[i]));
+ fprintf(fp, "0x%04x /* %f */", instr->value[i].u16,
+ _mesa_half_to_float(instr->value[i].u16));
break;
case 8:
- fprintf(fp, "0x%02x", instr->value.u8[i]);
+ fprintf(fp, "0x%02x", instr->value[i].u8);
break;
case 1:
- fprintf(fp, "%s", instr->value.b[i] ? "true" : "false");
+ fprintf(fp, "%s", instr->value[i].b ? "true" : "false");
break;
}
}
fprintf(fp, "outputs: %u\n", shader->num_outputs);
fprintf(fp, "uniforms: %u\n", shader->num_uniforms);
fprintf(fp, "shared: %u\n", shader->num_shared);
+ if (shader->scratch_size)
+ fprintf(fp, "scratch: %u\n", shader->scratch_size);
nir_foreach_variable(var, &shader->uniforms) {
print_var_decl(var, &state);
print_var_decl(var, &state);
}
- foreach_list_typed(nir_register, reg, node, &shader->registers) {
- print_register_decl(reg, &state);
- }
-
foreach_list_typed(nir_function, func, node, &shader->functions) {
print_function(func, &state);
}
projects / mesa.git / blobdiff