#include "gen_decoder.h"
+#include "isl/isl.h"
#include "genxml/genX_xml.h"
#define XML_BUFFER_SIZE 4096
create_group(struct parser_context *ctx,
const char *name,
const char **atts,
- struct gen_group *parent)
+ struct gen_group *parent,
+ bool fixed_length)
{
struct gen_group *group;
group->spec = ctx->spec;
group->variable = false;
+ group->fixed_length = fixed_length;
for (int i = 0; atts[i]; i += 2) {
char *p;
minor = 0;
ctx->spec->gen = gen_make_gen(major, minor);
- } else if (strcmp(element_name, "instruction") == 0 ||
- strcmp(element_name, "struct") == 0) {
- ctx->group = create_group(ctx, name, atts, NULL);
+ } else if (strcmp(element_name, "instruction") == 0) {
+ ctx->group = create_group(ctx, name, atts, NULL, false);
+ } else if (strcmp(element_name, "struct") == 0) {
+ ctx->group = create_group(ctx, name, atts, NULL, true);
} else if (strcmp(element_name, "register") == 0) {
- ctx->group = create_group(ctx, name, atts, NULL);
+ ctx->group = create_group(ctx, name, atts, NULL, true);
get_register_offset(atts, &ctx->group->register_offset);
} else if (strcmp(element_name, "group") == 0) {
struct gen_group *previous_group = ctx->group;
while (previous_group->next)
previous_group = previous_group->next;
- struct gen_group *group = create_group(ctx, "", atts, ctx->group);
+ struct gen_group *group = create_group(ctx, "", atts, ctx->group, false);
previous_group->next = group;
ctx->group = group;
} else if (strcmp(element_name, "field") == 0) {
struct parser_context ctx;
void *buf;
uint8_t *text_data = NULL;
- uint32_t text_offset = 0, text_length = 0, total_length;
+ uint32_t text_offset = 0, text_length = 0;
+ MAYBE_UNUSED uint32_t total_length;
uint32_t gen_10 = devinfo_to_gen(devinfo);
for (int i = 0; i < ARRAY_SIZE(genxml_files_table); i++) {
int
gen_group_get_length(struct gen_group *group, const uint32_t *p)
{
+ if (group && group->fixed_length)
+ return group->dw_length;
+
uint32_t h = p[0];
uint32_t type = field_value(h, 29, 31);
}
if (iter->field->name)
- strncpy(iter->name, iter->field->name, sizeof(iter->name));
+ snprintf(iter->name, sizeof(iter->name), "%s", iter->field->name);
else
memset(iter->name, 0, sizeof(iter->name));
int group_member_offset = iter_group_offset_bits(iter, iter->group_iter);
- iter->start = group_member_offset + iter->field->start;
- iter->end = group_member_offset + iter->field->end;
- iter->dword = iter->start / 32;
+ iter->start_bit = group_member_offset + iter->field->start;
+ iter->end_bit = group_member_offset + iter->field->end;
iter->struct_desc = NULL;
return true;
}
-static uint64_t
-iter_decode_field_raw(struct gen_field *field,
- const uint32_t *p,
- const uint32_t *end)
+static bool
+iter_decode_field_raw(struct gen_field_iterator *iter, uint64_t *qw)
{
- uint64_t qw = 0;
+ *qw = 0;
- if ((field->end - field->start) > 32) {
- if ((p + 1) < end)
- qw = ((uint64_t) p[1]) << 32;
- qw |= p[0];
+ int field_start = iter->p_bit + iter->start_bit;
+ int field_end = iter->p_bit + iter->end_bit;
+
+ const uint32_t *p = iter->p + (iter->start_bit / 32);
+ if (iter->p_end && p >= iter->p_end)
+ return false;
+
+ if ((field_end - field_start) > 32) {
+ if (!iter->p_end || (p + 1) < iter->p_end)
+ *qw = ((uint64_t) p[1]) << 32;
+ *qw |= p[0];
} else
- qw = p[0];
+ *qw = p[0];
- qw = field_value(qw, field->start, field->end);
+ *qw = field_value(*qw, field_start, field_end);
/* Address & offset types have to be aligned to dwords, their start bit is
* a reminder of the alignment requirement.
*/
- if (field->type.kind == GEN_TYPE_ADDRESS ||
- field->type.kind == GEN_TYPE_OFFSET)
- qw <<= field->start % 32;
+ if (iter->field->type.kind == GEN_TYPE_ADDRESS ||
+ iter->field->type.kind == GEN_TYPE_OFFSET)
+ *qw <<= field_start % 32;
- return qw;
+ return true;
}
-static void
+static bool
iter_decode_field(struct gen_field_iterator *iter)
{
union {
} v;
if (iter->field->name)
- strncpy(iter->name, iter->field->name, sizeof(iter->name));
+ snprintf(iter->name, sizeof(iter->name), "%s", iter->field->name);
else
memset(iter->name, 0, sizeof(iter->name));
memset(&v, 0, sizeof(v));
- v.qw = iter_decode_field_raw(iter->field,
- &iter->p[iter->dword], iter->p_end);
+ if (!iter_decode_field_raw(iter, &iter->raw_value))
+ return false;
const char *enum_name = NULL;
+ v.qw = iter->raw_value;
switch (iter->field->type.kind) {
case GEN_TYPE_UNKNOWN:
case GEN_TYPE_INT: {
snprintf(iter->value, sizeof(iter->value), "%f",
(float) v.qw / (1 << iter->field->type.f));
break;
- case GEN_TYPE_SFIXED:
- /* FIXME: Sign extend extracted field. */
- snprintf(iter->value, sizeof(iter->value), "%s", "foo");
+ case GEN_TYPE_SFIXED: {
+ /* Sign extend before converting */
+ int bits = iter->field->type.i + iter->field->type.f + 1;
+ int64_t v_sign_extend = ((int64_t)(v.qw << (64 - bits))) >> (64 - bits);
+ snprintf(iter->value, sizeof(iter->value), "%f",
+ (float) v_sign_extend / (1 << iter->field->type.f));
break;
+ }
case GEN_TYPE_MBO:
break;
case GEN_TYPE_ENUM: {
int length = strlen(iter->value);
snprintf(iter->value + length, sizeof(iter->value) - length,
" (%s)", enum_name);
+ } else if (strcmp(iter->name, "Surface Format") == 0) {
+ if (isl_format_is_valid((enum isl_format)v.qw)) {
+ const char *fmt_name = isl_format_get_name((enum isl_format)v.qw);
+ int length = strlen(iter->value);
+ snprintf(iter->value + length, sizeof(iter->value) - length,
+ " (%s)", fmt_name);
+ }
}
+
+ return true;
}
void
gen_field_iterator_init(struct gen_field_iterator *iter,
struct gen_group *group,
- const uint32_t *p,
+ const uint32_t *p, int p_bit,
bool print_colors)
{
memset(iter, 0, sizeof(*iter));
iter->group = group;
- if (group->fields)
- iter->field = group->fields;
- else
- iter->field = group->next->fields;
iter->p = p;
- iter->p_end = &p[gen_group_get_length(iter->group, iter->p)];
- iter->print_colors = print_colors;
+ iter->p_bit = p_bit;
- iter_decode_field(iter);
+ int length = gen_group_get_length(iter->group, iter->p);
+ iter->p_end = length > 0 ? &p[length] : NULL;
+ iter->print_colors = print_colors;
}
bool
gen_field_iterator_next(struct gen_field_iterator *iter)
{
+ /* Initial condition */
+ if (!iter->field) {
+ if (iter->group->fields)
+ iter->field = iter->group->fields;
+ else
+ iter->field = iter->group->next->fields;
+
+ bool result = iter_decode_field(iter);
+ if (iter->p_end)
+ assert(result);
+
+ return true;
+ }
+
if (!iter_advance_field(iter))
return false;
- iter_decode_field(iter);
+ if (!iter_decode_field(iter))
+ return false;
return true;
}
return (field->parent->opcode_mask & bits) != 0;
}
-void gen_field_decode(struct gen_field *field,
- const uint32_t *p, const uint32_t *end,
- union gen_field_value *value)
-{
- uint32_t dword = field->start / 32;
- value->u64 = iter_decode_field_raw(field, &p[dword], end);
-}
-
void
-gen_print_group(FILE *outfile, struct gen_group *group,
- uint64_t offset, const uint32_t *p, bool color)
+gen_print_group(FILE *outfile, struct gen_group *group, uint64_t offset,
+ const uint32_t *p, int p_bit, bool color)
{
struct gen_field_iterator iter;
int last_dword = -1;
- gen_field_iterator_init(&iter, group, p, color);
- do {
- if (last_dword != iter.dword) {
- for (int i = last_dword + 1; i <= iter.dword; i++)
+ gen_field_iterator_init(&iter, group, p, p_bit, color);
+ while (gen_field_iterator_next(&iter)) {
+ int iter_dword = iter.end_bit / 32;
+ if (last_dword != iter_dword) {
+ for (int i = last_dword + 1; i <= iter_dword; i++)
print_dword_header(outfile, &iter, offset, i);
- last_dword = iter.dword;
+ last_dword = iter_dword;
}
if (!gen_field_is_header(iter.field)) {
fprintf(outfile, " %s: %s\n", iter.name, iter.value);
if (iter.struct_desc) {
- uint64_t struct_offset = offset + 4 * iter.dword;
+ int struct_dword = iter.start_bit / 32;
+ uint64_t struct_offset = offset + 4 * struct_dword;
gen_print_group(outfile, iter.struct_desc, struct_offset,
- &p[iter.dword], color);
+ &p[struct_dword], iter.start_bit % 32, color);
}
}
- } while (gen_field_iterator_next(&iter));
+ }
}