}
static void
-get_group_offset_count(const char **atts, uint32_t *offset, uint32_t *count,
+get_array_offset_count(const char **atts, uint32_t *offset, uint32_t *count,
uint32_t *size, bool *variable)
{
for (int i = 0; atts[i]; i += 2) {
if (parent) {
group->parent = parent;
- get_group_offset_count(atts,
- &group->group_offset,
- &group->group_count,
- &group->group_size,
+ get_array_offset_count(atts,
+ &group->array_offset,
+ &group->array_count,
+ &group->array_item_size,
&group->variable);
}
return field;
}
+static struct gen_field *
+create_array_field(struct parser_context *ctx, struct gen_group *array)
+{
+ struct gen_field *field;
+
+ field = rzalloc(ctx->group, struct gen_field);
+ field->parent = ctx->group;
+
+ field->array = array;
+ field->start = field->array->array_offset;
+
+ return field;
+}
+
static struct gen_value *
create_value(struct parser_context *ctx, const char **atts)
{
static struct gen_field *
create_and_append_field(struct parser_context *ctx,
- const char **atts)
+ const char **atts,
+ struct gen_group *array)
{
- struct gen_field *field = create_field(ctx, atts);
+ struct gen_field *field = array ?
+ create_array_field(ctx, array) : create_field(ctx, atts);
struct gen_field *prev = NULL, *list = ctx->group->fields;
while (list && field->start > list->start) {
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, false);
- previous_group->next = group;
+ ctx->last_field = create_and_append_field(ctx, NULL, group);
ctx->group = group;
} else if (strcmp(element_name, "field") == 0) {
- ctx->last_field = create_and_append_field(ctx, atts);
+ ctx->last_field = create_and_append_field(ctx, atts, NULL);
} else if (strcmp(element_name, "enum") == 0) {
ctx->enoom = create_enum(ctx, name, atts);
} else if (strcmp(element_name, "value") == 0) {
void *buf;
uint8_t *text_data = NULL;
uint32_t text_offset = 0, text_length = 0;
- MAYBE_UNUSED uint32_t total_length;
+ ASSERTED uint32_t total_length;
uint32_t gen_10 = devinfo_to_gen(devinfo, true);
for (int i = 0; i < ARRAY_SIZE(genxml_files_table); i++) {
}
struct gen_spec *
-gen_spec_load_from_path(const struct gen_device_info *devinfo,
- const char *path)
+gen_spec_load_filename(const char *filename)
{
struct parser_context ctx;
- size_t len, filename_len = strlen(path) + 20;
- char *filename = malloc(filename_len);
- void *buf;
FILE *input;
-
- len = snprintf(filename, filename_len, "%s/gen%i.xml",
- path, devinfo_to_gen(devinfo, false));
- assert(len < filename_len);
+ void *buf;
+ size_t len;
input = fopen(filename, "r");
if (input == NULL) {
fprintf(stderr, "failed to open xml description\n");
- free(filename);
return NULL;
}
if (ctx.parser == NULL) {
fprintf(stderr, "failed to create parser\n");
fclose(input);
- free(filename);
return NULL;
}
gen_spec_destroy(ctx.spec);
ctx.spec = NULL;
goto end;
- } else if (feof(input))
+ } else if (len == 0 && feof(input))
goto end;
if (XML_ParseBuffer(ctx.parser, len, len == 0) == 0) {
XML_ParserFree(ctx.parser);
fclose(input);
- free(filename);
/* free ctx.spec if genxml is empty */
- if (ctx.spec && _mesa_hash_table_num_entries(ctx.spec->commands) == 0) {
+ if (ctx.spec &&
+ _mesa_hash_table_num_entries(ctx.spec->commands) == 0 &&
+ _mesa_hash_table_num_entries(ctx.spec->structs) == 0) {
+ fprintf(stderr,
+ "Error parsing XML: empty spec.\n");
gen_spec_destroy(ctx.spec);
return NULL;
}
return ctx.spec;
}
+struct gen_spec *
+gen_spec_load_from_path(const struct gen_device_info *devinfo,
+ const char *path)
+{
+ size_t filename_len = strlen(path) + 20;
+ char *filename = malloc(filename_len);
+
+ ASSERTED size_t len = snprintf(filename, filename_len, "%s/gen%i.xml",
+ path, devinfo_to_gen(devinfo, false));
+ assert(len < filename_len);
+
+ struct gen_spec *spec = gen_spec_load_filename(filename);
+ free(filename);
+
+ return spec;
+}
+
void gen_spec_destroy(struct gen_spec *spec)
{
ralloc_free(spec);
}
struct gen_group *
-gen_spec_find_instruction(struct gen_spec *spec, const uint32_t *p)
+gen_spec_find_instruction(struct gen_spec *spec,
+ enum drm_i915_gem_engine_class engine,
+ const uint32_t *p)
{
hash_table_foreach(spec->commands, entry) {
struct gen_group *command = entry->data;
uint32_t opcode = *p & command->opcode_mask;
- if (opcode == command->opcode)
+ if ((command->engine_mask & I915_ENGINE_CLASS_TO_MASK(engine)) &&
+ opcode == command->opcode)
return command;
}
}
static uint32_t
-iter_group_offset_bits(const struct gen_field_iterator *iter,
- uint32_t group_iter)
+iter_array_offset_bits(const struct gen_field_iterator *iter)
{
- return iter->group->group_offset + (group_iter * iter->group->group_size);
+ if (iter->level == 0)
+ return 0;
+
+ uint32_t offset = 0;
+ const struct gen_group *group = iter->groups[1];
+ for (int level = 1; level <= iter->level; level++, group = iter->groups[level]) {
+ uint32_t array_idx = iter->array_iter[level];
+ offset += group->array_offset + array_idx * group->array_item_size;
+ }
+
+ return offset;
}
-static bool
-iter_more_groups(const struct gen_field_iterator *iter)
+/* Checks whether we have more items in the array to iterate, or more arrays to
+ * iterate through.
+ */
+/* descend into a non-array field */
+static void
+iter_push_array(struct gen_field_iterator *iter)
{
- if (iter->group->variable) {
- int length = gen_group_get_length(iter->group, iter->p);
- assert(length >= 0 && "error the length is unknown!");
- return iter_group_offset_bits(iter, iter->group_iter + 1) <
- (length * 32);
- } else {
- return (iter->group_iter + 1) < iter->group->group_count ||
- iter->group->next != NULL;
- }
+ assert(iter->level >= 0);
+
+ iter->group = iter->field->array;
+ iter->level++;
+ assert(iter->level < DECODE_MAX_ARRAY_DEPTH);
+ iter->groups[iter->level] = iter->group;
+ iter->array_iter[iter->level] = 0;
+
+ assert(iter->group->fields != NULL); /* an empty <group> makes no sense */
+ iter->field = iter->group->fields;
+ iter->fields[iter->level] = iter->field;
+}
+
+static void
+iter_pop_array(struct gen_field_iterator *iter)
+{
+ assert(iter->level > 0);
+
+ iter->level--;
+ iter->field = iter->fields[iter->level];
+ iter->group = iter->groups[iter->level];
}
static void
iter_start_field(struct gen_field_iterator *iter, struct gen_field *field)
{
iter->field = field;
+ iter->fields[iter->level] = field;
+
+ while (iter->field->array)
+ iter_push_array(iter);
- int group_member_offset = iter_group_offset_bits(iter, iter->group_iter);
+ int array_member_offset = iter_array_offset_bits(iter);
- iter->start_bit = group_member_offset + iter->field->start;
- iter->end_bit = group_member_offset + iter->field->end;
+ iter->start_bit = array_member_offset + iter->field->start;
+ iter->end_bit = array_member_offset + iter->field->end;
iter->struct_desc = NULL;
}
static void
-iter_advance_group(struct gen_field_iterator *iter)
+iter_advance_array(struct gen_field_iterator *iter)
{
+ assert(iter->level > 0);
+ int lvl = iter->level;
+
if (iter->group->variable)
- iter->group_iter++;
+ iter->array_iter[lvl]++;
else {
- if ((iter->group_iter + 1) < iter->group->group_count) {
- iter->group_iter++;
- } else {
- iter->group = iter->group->next;
- iter->group_iter = 0;
+ if ((iter->array_iter[lvl] + 1) < iter->group->array_count) {
+ iter->array_iter[lvl]++;
}
}
}
static bool
-iter_advance_field(struct gen_field_iterator *iter)
+iter_more_array_elems(const struct gen_field_iterator *iter)
{
- if (iter_more_fields(iter)) {
- iter_start_field(iter, iter->field->next);
+ int lvl = iter->level;
+ assert(lvl >= 0);
+
+ if (iter->group->variable) {
+ int length = gen_group_get_length(iter->group, iter->p);
+ assert(length >= 0 && "error the length is unknown!");
+ return iter_array_offset_bits(iter) + iter->group->array_item_size <
+ (length * 32);
} else {
- if (!iter_more_groups(iter))
- return false;
+ return (iter->array_iter[lvl] + 1) < iter->group->array_count;
+ }
+}
- iter_advance_group(iter);
+static bool
+iter_advance_field(struct gen_field_iterator *iter)
+{
+ /* Keep looping while we either have more fields to look at, or we are
+ * inside a <group> and can go up a level.
+ */
+ while (iter_more_fields(iter) || iter->level > 0) {
+ if (iter_more_fields(iter)) {
+ iter_start_field(iter, iter->field->next);
+ return true;
+ }
+
+ assert(iter->level >= 0);
+
+ if (iter_more_array_elems(iter)) {
+ iter_advance_array(iter);
+ return true;
+ }
+
+ /* At this point, we reached the end of the <group> and were on the last
+ * iteration. So it's time to go back to the parent and then advance the
+ * field.
+ */
+ iter_pop_array(iter);
}
- return true;
+
+ return false;
}
static bool
if (strlen(iter->group->name) == 0) {
int length = strlen(iter->name);
- snprintf(iter->name + length, sizeof(iter->name) - length,
- "[%i]", iter->group_iter);
+ assert(iter->level >= 0);
+
+ int level = 1;
+ char *buf = iter->name + length;
+ while (level <= iter->level) {
+ int printed = snprintf(buf, sizeof(iter->name) - length,
+ "[%i]", iter->array_iter[level]);
+ level++;
+ length += printed;
+ buf += printed;
+ }
}
if (enum_name) {
{
memset(iter, 0, sizeof(*iter));
+ iter->groups[iter->level] = group;
iter->group = group;
iter->p = p;
iter->p_bit = p_bit;
if (!iter->field) {
if (iter->group->fields)
iter_start_field(iter, iter->group->fields);
- else
- iter_start_field(iter, iter->group->next->fields);
bool result = iter_decode_field(iter);
if (!result && iter->p_end) {
{
uint32_t bits;
- if (field->start >= 32)
+ /* Instructions are identified by the first DWord. */
+ if (field->start >= 32 ||
+ field->end >= 32)
return false;
- bits = (1U << (field->end - field->start + 1)) - 1;
+ bits = (1ULL << (field->end - field->start + 1)) - 1;
bits <<= field->start;
return (field->parent->opcode_mask & bits) != 0;
projects / mesa.git / blobdiff