src/intel/common/gen_decoder.c

   1 /*
   2  * Copyright © 2016 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #include <stdio.h>
  25 #include <stdbool.h>
  26 #include <stdint.h>
  27 #include <stdarg.h>
  28 #include <string.h>
  29 #include <expat.h>
  30 #include <inttypes.h>
  31 #include <zlib.h>
  32
  33 #include <util/macros.h>
  34 #include <util/ralloc.h>
  35
  36 #include "gen_decoder.h"
  37
  38 #include "genxml/genX_xml.h"
  39
  40 #define XML_BUFFER_SIZE 4096
  41
  42 #define MAKE_GEN(major, minor) ( ((major) << 8) | (minor) )
  43
  44 struct gen_spec {
  45    uint32_t gen;
  46
  47    int ncommands;
  48    struct gen_group *commands[256];
  49    int nstructs;
  50    struct gen_group *structs[256];
  51    int nregisters;
  52    struct gen_group *registers[256];
  53    int nenums;
  54    struct gen_enum *enums[256];
  55 };
  56
  57 struct location {
  58    const char *filename;
  59    int line_number;
  60 };
  61
  62 struct parser_context {
  63    XML_Parser parser;
  64    int foo;
  65    struct location loc;
  66    const char *platform;
  67
  68    struct gen_group *group;
  69    struct gen_enum *enoom;
  70
  71    int nvalues;
  72    struct gen_value *values[256];
  73
  74    struct gen_spec *spec;
  75 };
  76
  77 const char *
  78 gen_group_get_name(struct gen_group *group)
  79 {
  80    return group->name;
  81 }
  82
  83 uint32_t
  84 gen_group_get_opcode(struct gen_group *group)
  85 {
  86    return group->opcode;
  87 }
  88
  89 struct gen_group *
  90 gen_spec_find_struct(struct gen_spec *spec, const char *name)
  91 {
  92    for (int i = 0; i < spec->nstructs; i++)
  93       if (strcmp(spec->structs[i]->name, name) == 0)
  94          return spec->structs[i];
  95
  96    return NULL;
  97 }
  98
  99 struct gen_group *
 100 gen_spec_find_register(struct gen_spec *spec, uint32_t offset)
 101 {
 102    for (int i = 0; i < spec->nregisters; i++)
 103       if (spec->registers[i]->register_offset == offset)
 104          return spec->registers[i];
 105
 106    return NULL;
 107 }
 108
 109 struct gen_group *
 110 gen_spec_find_register_by_name(struct gen_spec *spec, const char *name)
 111 {
 112    for (int i = 0; i < spec->nregisters; i++) {
 113       if (strcmp(spec->registers[i]->name, name) == 0)
 114          return spec->registers[i];
 115    }
 116
 117    return NULL;
 118 }
 119
 120 struct gen_enum *
 121 gen_spec_find_enum(struct gen_spec *spec, const char *name)
 122 {
 123    for (int i = 0; i < spec->nenums; i++)
 124       if (strcmp(spec->enums[i]->name, name) == 0)
 125          return spec->enums[i];
 126
 127    return NULL;
 128 }
 129
 130 uint32_t
 131 gen_spec_get_gen(struct gen_spec *spec)
 132 {
 133    return spec->gen;
 134 }
 135
 136 static void __attribute__((noreturn))
 137 fail(struct location *loc, const char *msg, ...)
 138 {
 139    va_list ap;
 140
 141    va_start(ap, msg);
 142    fprintf(stderr, "%s:%d: error: ",
 143            loc->filename, loc->line_number);
 144    vfprintf(stderr, msg, ap);
 145    fprintf(stderr, "\n");
 146    va_end(ap);
 147    exit(EXIT_FAILURE);
 148 }
 149
 150 static void *
 151 fail_on_null(void *p)
 152 {
 153    if (p == NULL) {
 154       fprintf(stderr, "aubinator: out of memory\n");
 155       exit(EXIT_FAILURE);
 156    }
 157
 158    return p;
 159 }
 160
 161 static char *
 162 xstrdup(const char *s)
 163 {
 164    return fail_on_null(strdup(s));
 165 }
 166
 167 static void *
 168 zalloc(size_t s)
 169 {
 170    return calloc(s, 1);
 171 }
 172
 173 static void *
 174 xzalloc(size_t s)
 175 {
 176    return fail_on_null(zalloc(s));
 177 }
 178
 179 static void
 180 get_group_offset_count(const char **atts, uint32_t *offset, uint32_t *count,
 181                        uint32_t *size, bool *variable)
 182 {
 183    char *p;
 184    int i;
 185
 186    for (i = 0; atts[i]; i += 2) {
 187       if (strcmp(atts[i], "count") == 0) {
 188          *count = strtoul(atts[i + 1], &p, 0);
 189          if (*count == 0)
 190             *variable = true;
 191       } else if (strcmp(atts[i], "start") == 0) {
 192          *offset = strtoul(atts[i + 1], &p, 0);
 193       } else if (strcmp(atts[i], "size") == 0) {
 194          *size = strtoul(atts[i + 1], &p, 0);
 195       }
 196    }
 197    return;
 198 }
 199
 200 static struct gen_group *
 201 create_group(struct parser_context *ctx,
 202              const char *name,
 203              const char **atts,
 204              struct gen_group *parent)
 205 {
 206    struct gen_group *group;
 207
 208    group = xzalloc(sizeof(*group));
 209    if (name)
 210       group->name = xstrdup(name);
 211
 212    group->spec = ctx->spec;
 213    group->group_offset = 0;
 214    group->group_count = 0;
 215    group->variable = false;
 216
 217    if (parent) {
 218       group->parent = parent;
 219       get_group_offset_count(atts,
 220                              &group->group_offset,
 221                              &group->group_count,
 222                              &group->group_size,
 223                              &group->variable);
 224    }
 225
 226    return group;
 227 }
 228
 229 static struct gen_enum *
 230 create_enum(struct parser_context *ctx, const char *name, const char **atts)
 231 {
 232    struct gen_enum *e;
 233
 234    e = xzalloc(sizeof(*e));
 235    if (name)
 236       e->name = xstrdup(name);
 237
 238    e->nvalues = 0;
 239
 240    return e;
 241 }
 242
 243 static void
 244 get_register_offset(const char **atts, uint32_t *offset)
 245 {
 246    char *p;
 247    int i;
 248
 249    for (i = 0; atts[i]; i += 2) {
 250       if (strcmp(atts[i], "num") == 0)
 251          *offset = strtoul(atts[i + 1], &p, 0);
 252    }
 253    return;
 254 }
 255
 256 static void
 257 get_start_end_pos(int *start, int *end)
 258 {
 259    /* start value has to be mod with 32 as we need the relative
 260     * start position in the first DWord. For the end position, add
 261     * the length of the field to the start position to get the
 262     * relative postion in the 64 bit address.
 263     */
 264    if (*end - *start > 32) {
 265       int len = *end - *start;
 266       *start = *start % 32;
 267       *end = *start + len;
 268    } else {
 269       *start = *start % 32;
 270       *end = *end % 32;
 271    }
 272
 273    return;
 274 }
 275
 276 static inline uint64_t
 277 mask(int start, int end)
 278 {
 279    uint64_t v;
 280
 281    v = ~0ULL >> (63 - end + start);
 282
 283    return v << start;
 284 }
 285
 286 static inline uint64_t
 287 field(uint64_t value, int start, int end)
 288 {
 289    get_start_end_pos(&start, &end);
 290    return (value & mask(start, end)) >> (start);
 291 }
 292
 293 static inline uint64_t
 294 field_address(uint64_t value, int start, int end)
 295 {
 296    /* no need to right shift for address/offset */
 297    get_start_end_pos(&start, &end);
 298    return (value & mask(start, end));
 299 }
 300
 301 static struct gen_type
 302 string_to_type(struct parser_context *ctx, const char *s)
 303 {
 304    int i, f;
 305    struct gen_group *g;
 306    struct gen_enum *e;
 307
 308    if (strcmp(s, "int") == 0)
 309       return (struct gen_type) { .kind = GEN_TYPE_INT };
 310    else if (strcmp(s, "uint") == 0)
 311       return (struct gen_type) { .kind = GEN_TYPE_UINT };
 312    else if (strcmp(s, "bool") == 0)
 313       return (struct gen_type) { .kind = GEN_TYPE_BOOL };
 314    else if (strcmp(s, "float") == 0)
 315       return (struct gen_type) { .kind = GEN_TYPE_FLOAT };
 316    else if (strcmp(s, "address") == 0)
 317       return (struct gen_type) { .kind = GEN_TYPE_ADDRESS };
 318    else if (strcmp(s, "offset") == 0)
 319       return (struct gen_type) { .kind = GEN_TYPE_OFFSET };
 320    else if (sscanf(s, "u%d.%d", &i, &f) == 2)
 321       return (struct gen_type) { .kind = GEN_TYPE_UFIXED, .i = i, .f = f };
 322    else if (sscanf(s, "s%d.%d", &i, &f) == 2)
 323       return (struct gen_type) { .kind = GEN_TYPE_SFIXED, .i = i, .f = f };
 324    else if (g = gen_spec_find_struct(ctx->spec, s), g != NULL)
 325       return (struct gen_type) { .kind = GEN_TYPE_STRUCT, .gen_struct = g };
 326    else if (e = gen_spec_find_enum(ctx->spec, s), e != NULL)
 327       return (struct gen_type) { .kind = GEN_TYPE_ENUM, .gen_enum = e };
 328    else if (strcmp(s, "mbo") == 0)
 329       return (struct gen_type) { .kind = GEN_TYPE_MBO };
 330    else
 331       fail(&ctx->loc, "invalid type: %s", s);
 332 }
 333
 334 static struct gen_field *
 335 create_field(struct parser_context *ctx, const char **atts)
 336 {
 337    struct gen_field *field;
 338    char *p;
 339    int i;
 340
 341    field = xzalloc(sizeof(*field));
 342
 343    for (i = 0; atts[i]; i += 2) {
 344       if (strcmp(atts[i], "name") == 0)
 345          field->name = xstrdup(atts[i + 1]);
 346       else if (strcmp(atts[i], "start") == 0)
 347          field->start = strtoul(atts[i + 1], &p, 0);
 348       else if (strcmp(atts[i], "end") == 0) {
 349          field->end = strtoul(atts[i + 1], &p, 0);
 350       } else if (strcmp(atts[i], "type") == 0)
 351          field->type = string_to_type(ctx, atts[i + 1]);
 352       else if (strcmp(atts[i], "default") == 0 &&
 353                field->start >= 16 && field->end <= 31) {
 354          field->has_default = true;
 355          field->default_value = strtoul(atts[i + 1], &p, 0);
 356       }
 357    }
 358
 359    return field;
 360 }
 361
 362 static struct gen_value *
 363 create_value(struct parser_context *ctx, const char **atts)
 364 {
 365    struct gen_value *value = xzalloc(sizeof(*value));
 366
 367    for (int i = 0; atts[i]; i += 2) {
 368       if (strcmp(atts[i], "name") == 0)
 369          value->name = xstrdup(atts[i + 1]);
 370       else if (strcmp(atts[i], "value") == 0)
 371          value->value = strtoul(atts[i + 1], NULL, 0);
 372    }
 373
 374    return value;
 375 }
 376
 377 static void
 378 create_and_append_field(struct parser_context *ctx,
 379                         const char **atts)
 380 {
 381    if (ctx->group->nfields == ctx->group->fields_size) {
 382       ctx->group->fields_size = MAX2(ctx->group->fields_size * 2, 2);
 383       ctx->group->fields =
 384          (struct gen_field **) realloc(ctx->group->fields,
 385                                        sizeof(ctx->group->fields[0]) *
 386                                        ctx->group->fields_size);
 387    }
 388
 389    ctx->group->fields[ctx->group->nfields++] = create_field(ctx, atts);
 390 }
 391
 392 static void
 393 start_element(void *data, const char *element_name, const char **atts)
 394 {
 395    struct parser_context *ctx = data;
 396    int i;
 397    const char *name = NULL;
 398    const char *gen = NULL;
 399
 400    ctx->loc.line_number = XML_GetCurrentLineNumber(ctx->parser);
 401
 402    for (i = 0; atts[i]; i += 2) {
 403       if (strcmp(atts[i], "name") == 0)
 404          name = atts[i + 1];
 405       else if (strcmp(atts[i], "gen") == 0)
 406          gen = atts[i + 1];
 407    }
 408
 409    if (strcmp(element_name, "genxml") == 0) {
 410       if (name == NULL)
 411          fail(&ctx->loc, "no platform name given");
 412       if (gen == NULL)
 413          fail(&ctx->loc, "no gen given");
 414
 415       ctx->platform = xstrdup(name);
 416       int major, minor;
 417       int n = sscanf(gen, "%d.%d", &major, &minor);
 418       if (n == 0)
 419          fail(&ctx->loc, "invalid gen given: %s", gen);
 420       if (n == 1)
 421          minor = 0;
 422
 423       ctx->spec->gen = MAKE_GEN(major, minor);
 424    } else if (strcmp(element_name, "instruction") == 0 ||
 425               strcmp(element_name, "struct") == 0) {
 426       ctx->group = create_group(ctx, name, atts, NULL);
 427    } else if (strcmp(element_name, "register") == 0) {
 428       ctx->group = create_group(ctx, name, atts, NULL);
 429       get_register_offset(atts, &ctx->group->register_offset);
 430    } else if (strcmp(element_name, "group") == 0) {
 431       struct gen_group *previous_group = ctx->group;
 432       while (previous_group->next)
 433          previous_group = previous_group->next;
 434
 435       struct gen_group *group = create_group(ctx, "", atts, ctx->group);
 436       previous_group->next = group;
 437       ctx->group = group;
 438    } else if (strcmp(element_name, "field") == 0) {
 439       create_and_append_field(ctx, atts);
 440    } else if (strcmp(element_name, "enum") == 0) {
 441       ctx->enoom = create_enum(ctx, name, atts);
 442    } else if (strcmp(element_name, "value") == 0) {
 443       ctx->values[ctx->nvalues++] = create_value(ctx, atts);
 444       assert(ctx->nvalues < ARRAY_SIZE(ctx->values));
 445    }
 446
 447 }
 448
 449 static void
 450 end_element(void *data, const char *name)
 451 {
 452    struct parser_context *ctx = data;
 453    struct gen_spec *spec = ctx->spec;
 454
 455    if (strcmp(name, "instruction") == 0 ||
 456        strcmp(name, "struct") == 0 ||
 457        strcmp(name, "register") == 0) {
 458       struct gen_group *group = ctx->group;
 459
 460       ctx->group = ctx->group->parent;
 461
 462       for (int i = 0; i < group->nfields; i++) {
 463          if (group->fields[i]->start >= 16 &&
 464              group->fields[i]->end <= 31 &&
 465              group->fields[i]->has_default) {
 466             group->opcode_mask |=
 467                mask(group->fields[i]->start % 32, group->fields[i]->end % 32);
 468             group->opcode |=
 469                group->fields[i]->default_value << group->fields[i]->start;
 470          }
 471       }
 472
 473       if (strcmp(name, "instruction") == 0)
 474          spec->commands[spec->ncommands++] = group;
 475       else if (strcmp(name, "struct") == 0)
 476          spec->structs[spec->nstructs++] = group;
 477       else if (strcmp(name, "register") == 0)
 478          spec->registers[spec->nregisters++] = group;
 479
 480       assert(spec->ncommands < ARRAY_SIZE(spec->commands));
 481       assert(spec->nstructs < ARRAY_SIZE(spec->structs));
 482       assert(spec->nregisters < ARRAY_SIZE(spec->registers));
 483    } else if (strcmp(name, "group") == 0) {
 484       ctx->group = ctx->group->parent;
 485    } else if (strcmp(name, "field") == 0) {
 486       assert(ctx->group->nfields > 0);
 487       struct gen_field *field = ctx->group->fields[ctx->group->nfields - 1];
 488       size_t size = ctx->nvalues * sizeof(ctx->values[0]);
 489       field->inline_enum.values = xzalloc(size);
 490       field->inline_enum.nvalues = ctx->nvalues;
 491       memcpy(field->inline_enum.values, ctx->values, size);
 492       ctx->nvalues = 0;
 493    } else if (strcmp(name, "enum") == 0) {
 494       struct gen_enum *e = ctx->enoom;
 495       size_t size = ctx->nvalues * sizeof(ctx->values[0]);
 496       e->values = xzalloc(size);
 497       e->nvalues = ctx->nvalues;
 498       memcpy(e->values, ctx->values, size);
 499       ctx->nvalues = 0;
 500       ctx->enoom = NULL;
 501       spec->enums[spec->nenums++] = e;
 502    }
 503 }
 504
 505 static void
 506 character_data(void *data, const XML_Char *s, int len)
 507 {
 508 }
 509
 510 static int
 511 devinfo_to_gen(const struct gen_device_info *devinfo)
 512 {
 513    int value = 10 * devinfo->gen;
 514
 515    if (devinfo->is_baytrail || devinfo->is_haswell)
 516       value += 5;
 517
 518    return value;
 519 }
 520
 521 static uint32_t zlib_inflate(const void *compressed_data,
 522                              uint32_t compressed_len,
 523                              void **out_ptr)
 524 {
 525    struct z_stream_s zstream;
 526    void *out;
 527
 528    memset(&zstream, 0, sizeof(zstream));
 529
 530    zstream.next_in = (unsigned char *)compressed_data;
 531    zstream.avail_in = compressed_len;
 532
 533    if (inflateInit(&zstream) != Z_OK)
 534       return 0;
 535
 536    out = malloc(4096);
 537    zstream.next_out = out;
 538    zstream.avail_out = 4096;
 539
 540    do {
 541       switch (inflate(&zstream, Z_SYNC_FLUSH)) {
 542       case Z_STREAM_END:
 543          goto end;
 544       case Z_OK:
 545          break;
 546       default:
 547          inflateEnd(&zstream);
 548          return 0;
 549       }
 550
 551       if (zstream.avail_out)
 552          break;
 553
 554       out = realloc(out, 2*zstream.total_out);
 555       if (out == NULL) {
 556          inflateEnd(&zstream);
 557          return 0;
 558       }
 559
 560       zstream.next_out = (unsigned char *)out + zstream.total_out;
 561       zstream.avail_out = zstream.total_out;
 562    } while (1);
 563  end:
 564    inflateEnd(&zstream);
 565    *out_ptr = out;
 566    return zstream.total_out;
 567 }
 568
 569 struct gen_spec *
 570 gen_spec_load(const struct gen_device_info *devinfo)
 571 {
 572    struct parser_context ctx;
 573    void *buf;
 574    uint8_t *text_data;
 575    uint32_t text_offset = 0, text_length = 0, total_length;
 576    uint32_t gen_10 = devinfo_to_gen(devinfo);
 577
 578    for (int i = 0; i < ARRAY_SIZE(genxml_files_table); i++) {
 579       if (genxml_files_table[i].gen_10 == gen_10) {
 580          text_offset = genxml_files_table[i].offset;
 581          text_length = genxml_files_table[i].length;
 582          break;
 583       }
 584    }
 585
 586    if (text_length == 0) {
 587       fprintf(stderr, "unable to find gen (%u) data\n", gen_10);
 588       return NULL;
 589    }
 590
 591    memset(&ctx, 0, sizeof ctx);
 592    ctx.parser = XML_ParserCreate(NULL);
 593    XML_SetUserData(ctx.parser, &ctx);
 594    if (ctx.parser == NULL) {
 595       fprintf(stderr, "failed to create parser\n");
 596       return NULL;
 597    }
 598
 599    XML_SetElementHandler(ctx.parser, start_element, end_element);
 600    XML_SetCharacterDataHandler(ctx.parser, character_data);
 601
 602    ctx.spec = xzalloc(sizeof(*ctx.spec));
 603
 604    total_length = zlib_inflate(compress_genxmls,
 605                                sizeof(compress_genxmls),
 606                                (void **) &text_data);
 607    assert(text_offset + text_length <= total_length);
 608
 609    buf = XML_GetBuffer(ctx.parser, text_length);
 610    memcpy(buf, &text_data[text_offset], text_length);
 611
 612    if (XML_ParseBuffer(ctx.parser, text_length, true) == 0) {
 613       fprintf(stderr,
 614               "Error parsing XML at line %ld col %ld byte %ld/%u: %s\n",
 615               XML_GetCurrentLineNumber(ctx.parser),
 616               XML_GetCurrentColumnNumber(ctx.parser),
 617               XML_GetCurrentByteIndex(ctx.parser), text_length,
 618               XML_ErrorString(XML_GetErrorCode(ctx.parser)));
 619       XML_ParserFree(ctx.parser);
 620       free(text_data);
 621       return NULL;
 622    }
 623
 624    XML_ParserFree(ctx.parser);
 625    free(text_data);
 626
 627    return ctx.spec;
 628 }
 629
 630 struct gen_spec *
 631 gen_spec_load_from_path(const struct gen_device_info *devinfo,
 632                         const char *path)
 633 {
 634    struct parser_context ctx;
 635    size_t len, filename_len = strlen(path) + 20;
 636    char *filename = malloc(filename_len);
 637    void *buf;
 638    FILE *input;
 639
 640    len = snprintf(filename, filename_len, "%s/gen%i.xml",
 641                   path, devinfo_to_gen(devinfo));
 642    assert(len < filename_len);
 643
 644    input = fopen(filename, "r");
 645    if (input == NULL) {
 646       fprintf(stderr, "failed to open xml description\n");
 647       free(filename);
 648       return NULL;
 649    }
 650
 651    memset(&ctx, 0, sizeof ctx);
 652    ctx.parser = XML_ParserCreate(NULL);
 653    XML_SetUserData(ctx.parser, &ctx);
 654    if (ctx.parser == NULL) {
 655       fprintf(stderr, "failed to create parser\n");
 656       fclose(input);
 657       free(filename);
 658       return NULL;
 659    }
 660
 661    XML_SetElementHandler(ctx.parser, start_element, end_element);
 662    XML_SetCharacterDataHandler(ctx.parser, character_data);
 663    ctx.loc.filename = filename;
 664    ctx.spec = xzalloc(sizeof(*ctx.spec));
 665
 666    do {
 667       buf = XML_GetBuffer(ctx.parser, XML_BUFFER_SIZE);
 668       len = fread(buf, 1, XML_BUFFER_SIZE, input);
 669       if (len == 0) {
 670          fprintf(stderr, "fread: %m\n");
 671          free(ctx.spec);
 672          ctx.spec = NULL;
 673          goto end;
 674       }
 675       if (XML_ParseBuffer(ctx.parser, len, len == 0) == 0) {
 676          fprintf(stderr,
 677                  "Error parsing XML at line %ld col %ld: %s\n",
 678                  XML_GetCurrentLineNumber(ctx.parser),
 679                  XML_GetCurrentColumnNumber(ctx.parser),
 680                  XML_ErrorString(XML_GetErrorCode(ctx.parser)));
 681          free(ctx.spec);
 682          ctx.spec = NULL;
 683          goto end;
 684       }
 685    } while (len > 0);
 686
 687  end:
 688    XML_ParserFree(ctx.parser);
 689
 690    fclose(input);
 691    free(filename);
 692
 693    return ctx.spec;
 694 }
 695
 696 struct gen_group *
 697 gen_spec_find_instruction(struct gen_spec *spec, const uint32_t *p)
 698 {
 699    for (int i = 0; i < spec->ncommands; i++) {
 700       uint32_t opcode = *p & spec->commands[i]->opcode_mask;
 701       if (opcode == spec->commands[i]->opcode)
 702          return spec->commands[i];
 703    }
 704
 705    return NULL;
 706 }
 707
 708 int
 709 gen_group_get_length(struct gen_group *group, const uint32_t *p)
 710 {
 711    uint32_t h = p[0];
 712    uint32_t type = field(h, 29, 31);
 713
 714    switch (type) {
 715    case 0: /* MI */ {
 716       uint32_t opcode = field(h, 23, 28);
 717       if (opcode < 16)
 718          return 1;
 719       else
 720          return field(h, 0, 7) + 2;
 721       break;
 722    }
 723
 724    case 2: /* BLT */ {
 725       return field(h, 0, 7) + 2;
 726    }
 727
 728    case 3: /* Render */ {
 729       uint32_t subtype = field(h, 27, 28);
 730       uint32_t opcode = field(h, 24, 26);
 731       uint16_t whole_opcode = field(h, 16, 31);
 732       switch (subtype) {
 733       case 0:
 734          if (whole_opcode == 0x6104 /* PIPELINE_SELECT_965 */)
 735             return 1;
 736          else if (opcode < 2)
 737             return field(h, 0, 7) + 2;
 738          else
 739             return -1;
 740       case 1:
 741          if (opcode < 2)
 742             return 1;
 743          else
 744             return -1;
 745       case 2: {
 746          if (opcode == 0)
 747             return field(h, 0, 7) + 2;
 748          else if (opcode < 3)
 749             return field(h, 0, 15) + 2;
 750          else
 751             return -1;
 752       }
 753       case 3:
 754          if (whole_opcode == 0x780b)
 755             return 1;
 756          else if (opcode < 4)
 757             return field(h, 0, 7) + 2;
 758          else
 759             return -1;
 760       }
 761    }
 762    }
 763
 764    return -1;
 765 }
 766
 767 void
 768 gen_field_iterator_init(struct gen_field_iterator *iter,
 769                         struct gen_group *group,
 770                         const uint32_t *p,
 771                         bool print_colors)
 772 {
 773    memset(iter, 0, sizeof(*iter));
 774
 775    iter->group = group;
 776    iter->p = p;
 777    iter->print_colors = print_colors;
 778 }
 779
 780 static const char *
 781 gen_get_enum_name(struct gen_enum *e, uint64_t value)
 782 {
 783    for (int i = 0; i < e->nvalues; i++) {
 784       if (e->values[i]->value == value) {
 785          return e->values[i]->name;
 786       }
 787    }
 788    return NULL;
 789 }
 790
 791 static bool
 792 iter_more_fields(const struct gen_field_iterator *iter)
 793 {
 794    return iter->field_iter < iter->group->nfields;
 795 }
 796
 797 static uint32_t
 798 iter_group_offset_bits(const struct gen_field_iterator *iter,
 799                        uint32_t group_iter)
 800 {
 801    return iter->group->group_offset + (group_iter * iter->group->group_size);
 802 }
 803
 804 static bool
 805 iter_more_groups(const struct gen_field_iterator *iter)
 806 {
 807    if (iter->group->variable) {
 808       return iter_group_offset_bits(iter, iter->group_iter + 1) <
 809               (gen_group_get_length(iter->group, iter->p) * 32);
 810    } else {
 811       return (iter->group_iter + 1) < iter->group->group_count ||
 812          iter->group->next != NULL;
 813    }
 814 }
 815
 816 static void
 817 iter_advance_group(struct gen_field_iterator *iter)
 818 {
 819    if (iter->group->variable)
 820       iter->group_iter++;
 821    else {
 822       if ((iter->group_iter + 1) < iter->group->group_count) {
 823          iter->group_iter++;
 824       } else {
 825          iter->group = iter->group->next;
 826          iter->group_iter = 0;
 827       }
 828    }
 829
 830    iter->field_iter = 0;
 831 }
 832
 833 static bool
 834 iter_advance_field(struct gen_field_iterator *iter)
 835 {
 836    while (!iter_more_fields(iter)) {
 837       if (!iter_more_groups(iter))
 838          return false;
 839
 840       iter_advance_group(iter);
 841    }
 842
 843    iter->field = iter->group->fields[iter->field_iter++];
 844    if (iter->field->name)
 845        strncpy(iter->name, iter->field->name, sizeof(iter->name));
 846    else
 847       memset(iter->name, 0, sizeof(iter->name));
 848    iter->dword = iter_group_offset_bits(iter, iter->group_iter) / 32 +
 849       iter->field->start / 32;
 850    iter->struct_desc = NULL;
 851
 852    return true;
 853 }
 854
 855 bool
 856 gen_field_iterator_next(struct gen_field_iterator *iter)
 857 {
 858    union {
 859       uint64_t qw;
 860       float f;
 861    } v;
 862
 863    if (!iter_advance_field(iter))
 864       return false;
 865
 866    if ((iter->field->end - iter->field->start) > 32)
 867       v.qw = ((uint64_t) iter->p[iter->dword+1] << 32) | iter->p[iter->dword];
 868    else
 869       v.qw = iter->p[iter->dword];
 870
 871    const char *enum_name = NULL;
 872
 873    switch (iter->field->type.kind) {
 874    case GEN_TYPE_UNKNOWN:
 875    case GEN_TYPE_INT: {
 876       uint64_t value = field(v.qw, iter->field->start, iter->field->end);
 877       snprintf(iter->value, sizeof(iter->value), "%"PRId64, value);
 878       enum_name = gen_get_enum_name(&iter->field->inline_enum, value);
 879       break;
 880    }
 881    case GEN_TYPE_UINT: {
 882       uint64_t value = field(v.qw, iter->field->start, iter->field->end);
 883       snprintf(iter->value, sizeof(iter->value), "%"PRIu64, value);
 884       enum_name = gen_get_enum_name(&iter->field->inline_enum, value);
 885       break;
 886    }
 887    case GEN_TYPE_BOOL: {
 888       const char *true_string =
 889          iter->print_colors ? "\e[0;35mtrue\e[0m" : "true";
 890       snprintf(iter->value, sizeof(iter->value), "%s",
 891                field(v.qw, iter->field->start, iter->field->end) ?
 892                true_string : "false");
 893       break;
 894    }
 895    case GEN_TYPE_FLOAT:
 896       snprintf(iter->value, sizeof(iter->value), "%f", v.f);
 897       break;
 898    case GEN_TYPE_ADDRESS:
 899    case GEN_TYPE_OFFSET:
 900       snprintf(iter->value, sizeof(iter->value), "0x%08"PRIx64,
 901                field_address(v.qw, iter->field->start, iter->field->end));
 902       break;
 903    case GEN_TYPE_STRUCT:
 904       snprintf(iter->value, sizeof(iter->value), "<struct %s>",
 905                iter->field->type.gen_struct->name);
 906       iter->struct_desc =
 907          gen_spec_find_struct(iter->group->spec,
 908                               iter->field->type.gen_struct->name);
 909       break;
 910    case GEN_TYPE_UFIXED:
 911       snprintf(iter->value, sizeof(iter->value), "%f",
 912                (float) field(v.qw, iter->field->start,
 913                              iter->field->end) / (1 << iter->field->type.f));
 914       break;
 915    case GEN_TYPE_SFIXED:
 916       /* FIXME: Sign extend extracted field. */
 917       snprintf(iter->value, sizeof(iter->value), "%s", "foo");
 918       break;
 919    case GEN_TYPE_MBO:
 920        break;
 921    case GEN_TYPE_ENUM: {
 922       uint64_t value = field(v.qw, iter->field->start, iter->field->end);
 923       snprintf(iter->value, sizeof(iter->value),
 924                "%"PRId64, value);
 925       enum_name = gen_get_enum_name(iter->field->type.gen_enum, value);
 926       break;
 927    }
 928    }
 929
 930    if (strlen(iter->group->name) == 0) {
 931       int length = strlen(iter->name);
 932       snprintf(iter->name + length, sizeof(iter->name) - length,
 933                "[%i]", iter->group_iter);
 934    }
 935
 936    if (enum_name) {
 937       int length = strlen(iter->value);
 938       snprintf(iter->value + length, sizeof(iter->value) - length,
 939                " (%s)", enum_name);
 940    }
 941
 942    return true;
 943 }
 944
 945 static void
 946 print_dword_header(FILE *outfile,
 947                    struct gen_field_iterator *iter, uint64_t offset)
 948 {
 949    fprintf(outfile, "0x%08"PRIx64":  0x%08x : Dword %d\n",
 950            offset + 4 * iter->dword, iter->p[iter->dword], iter->dword);
 951 }
 952
 953 static bool
 954 is_header_field(struct gen_group *group, struct gen_field *field)
 955 {
 956    uint32_t bits;
 957
 958    if (field->start >= 32)
 959       return false;
 960
 961    bits = (1U << (field->end - field->start + 1)) - 1;
 962    bits <<= field->start;
 963
 964    return (group->opcode_mask & bits) != 0;
 965 }
 966
 967 void
 968 gen_print_group(FILE *outfile, struct gen_group *group,
 969                 uint64_t offset, const uint32_t *p, bool color)
 970 {
 971    struct gen_field_iterator iter;
 972    int last_dword = 0;
 973
 974    gen_field_iterator_init(&iter, group, p, color);
 975    while (gen_field_iterator_next(&iter)) {
 976       if (last_dword != iter.dword) {
 977          print_dword_header(outfile, &iter, offset);
 978          last_dword = iter.dword;
 979       }
 980       if (!is_header_field(group, iter.field)) {
 981          fprintf(outfile, "    %s: %s\n", iter.name, iter.value);
 982          if (iter.struct_desc) {
 983             uint64_t struct_offset = offset + 4 * iter.dword;
 984             gen_print_group(outfile, iter.struct_desc, struct_offset,
 985                             &p[iter.dword], color);
 986          }
 987       }
 988    }
 989 }