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