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