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