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
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 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: {
if (nir_src_is_const(instr->arr.index)) {
- fprintf(fp, "[%"PRIx64"]", nir_src_as_int(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_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 if (idx == NIR_INTRINSIC_TYPE) {
+ 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;
fprintf(fp, " type=%s%u", name, size);
else
fprintf(fp, " type=%s", name);
- } else if (idx == NIR_INTRINSIC_SWIZZLE_MASK) {
+ 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) {
} else {
fprintf(fp, "%d", mask);
}
- } else {
+ 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_samples_identical:
fprintf(fp, "samples_identical ");
break;
+ case nir_texop_tex_prefetch:
+ fprintf(fp, "tex (pre-dispatchable) ");
+ break;
default:
unreachable("Invalid texture operation");
break;
projects / mesa.git / blobdiff