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       for (int g = 0; g < MAX2(ctx->group->group_count, 1); g++) {
 418          ctx->fields[ctx->nfields++] = create_field(ctx, atts);
 419       }
 420    } else if (strcmp(element_name, "enum") == 0) {
 421       ctx->enoom = create_enum(ctx, name, atts);
 422    } else if (strcmp(element_name, "value") == 0) {
 423       ctx->values[ctx->nvalues++] = create_value(ctx, atts);
 424    }
 425 }
 426
 427 static void
 428 end_element(void *data, const char *name)
 429 {
 430    struct parser_context *ctx = data;
 431    struct gen_spec *spec = ctx->spec;
 432
 433    if (strcmp(name, "instruction") == 0 ||
 434        strcmp(name, "struct") == 0 ||
 435        strcmp(name, "register") == 0) {
 436       size_t size = ctx->nfields * sizeof(ctx->fields[0]);
 437       struct gen_group *group = ctx->group;
 438
 439       group->fields = xzalloc(size);
 440       group->nfields = ctx->nfields;
 441       memcpy(group->fields, ctx->fields, size);
 442       ctx->nfields = 0;
 443       ctx->group = NULL;
 444
 445       for (int i = 0; i < group->nfields; i++) {
 446          if (group->fields[i]->start >= 16 &&
 447              group->fields[i]->end <= 31 &&
 448              group->fields[i]->has_default) {
 449             group->opcode_mask |=
 450                mask(group->fields[i]->start % 32, group->fields[i]->end % 32);
 451             group->opcode |=
 452                group->fields[i]->default_value << group->fields[i]->start;
 453          }
 454       }
 455
 456       if (strcmp(name, "instruction") == 0)
 457          spec->commands[spec->ncommands++] = group;
 458       else if (strcmp(name, "struct") == 0)
 459          spec->structs[spec->nstructs++] = group;
 460       else if (strcmp(name, "register") == 0)
 461          spec->registers[spec->nregisters++] = group;
 462    } else if (strcmp(name, "group") == 0) {
 463       ctx->group->group_offset = 0;
 464       ctx->group->group_count = 0;
 465    } else if (strcmp(name, "field") == 0) {
 466       assert(ctx->nfields > 0);
 467       struct gen_field *field = ctx->fields[ctx->nfields - 1];
 468       size_t size = ctx->nvalues * sizeof(ctx->values[0]);
 469       field->inline_enum.values = xzalloc(size);
 470       field->inline_enum.nvalues = ctx->nvalues;
 471       memcpy(field->inline_enum.values, ctx->values, size);
 472       ctx->nvalues = 0;
 473    } else if (strcmp(name, "enum") == 0) {
 474       struct gen_enum *e = ctx->enoom;
 475       size_t size = ctx->nvalues * sizeof(ctx->values[0]);
 476       e->values = xzalloc(size);
 477       e->nvalues = ctx->nvalues;
 478       memcpy(e->values, ctx->values, size);
 479       ctx->nvalues = 0;
 480       ctx->enoom = NULL;
 481       spec->enums[spec->nenums++] = e;
 482    }
 483 }
 484
 485 static void
 486 character_data(void *data, const XML_Char *s, int len)
 487 {
 488 }
 489
 490 static int
 491 devinfo_to_gen(const struct gen_device_info *devinfo)
 492 {
 493    int value = 10 * devinfo->gen;
 494
 495    if (devinfo->is_baytrail || devinfo->is_haswell)
 496       value += 5;
 497
 498    return value;
 499 }
 500
 501 static uint32_t zlib_inflate(const void *compressed_data,
 502                              uint32_t compressed_len,
 503                              void **out_ptr)
 504 {
 505    struct z_stream_s zstream;
 506    void *out;
 507
 508    memset(&zstream, 0, sizeof(zstream));
 509
 510    zstream.next_in = (unsigned char *)compressed_data;
 511    zstream.avail_in = compressed_len;
 512
 513    if (inflateInit(&zstream) != Z_OK)
 514       return 0;
 515
 516    out = malloc(4096);
 517    zstream.next_out = out;
 518    zstream.avail_out = 4096;
 519
 520    do {
 521       switch (inflate(&zstream, Z_SYNC_FLUSH)) {
 522       case Z_STREAM_END:
 523          goto end;
 524       case Z_OK:
 525          break;
 526       default:
 527          inflateEnd(&zstream);
 528          return 0;
 529       }
 530
 531       if (zstream.avail_out)
 532          break;
 533
 534       out = realloc(out, 2*zstream.total_out);
 535       if (out == NULL) {
 536          inflateEnd(&zstream);
 537          return 0;
 538       }
 539
 540       zstream.next_out = (unsigned char *)out + zstream.total_out;
 541       zstream.avail_out = zstream.total_out;
 542    } while (1);
 543  end:
 544    inflateEnd(&zstream);
 545    *out_ptr = out;
 546    return zstream.total_out;
 547 }
 548
 549 struct gen_spec *
 550 gen_spec_load(const struct gen_device_info *devinfo)
 551 {
 552    struct parser_context ctx;
 553    void *buf;
 554    uint8_t *text_data;
 555    uint32_t text_offset = 0, text_length = 0, total_length;
 556    uint32_t gen_10 = devinfo_to_gen(devinfo);
 557
 558    for (int i = 0; i < ARRAY_SIZE(genxml_files_table); i++) {
 559       if (genxml_files_table[i].gen_10 == gen_10) {
 560          text_offset = genxml_files_table[i].offset;
 561          text_length = genxml_files_table[i].length;
 562          break;
 563       }
 564    }
 565
 566    if (text_length == 0) {
 567       fprintf(stderr, "unable to find gen (%u) data\n", gen_10);
 568       return NULL;
 569    }
 570
 571    memset(&ctx, 0, sizeof ctx);
 572    ctx.parser = XML_ParserCreate(NULL);
 573    XML_SetUserData(ctx.parser, &ctx);
 574    if (ctx.parser == NULL) {
 575       fprintf(stderr, "failed to create parser\n");
 576       return NULL;
 577    }
 578
 579    XML_SetElementHandler(ctx.parser, start_element, end_element);
 580    XML_SetCharacterDataHandler(ctx.parser, character_data);
 581
 582    ctx.spec = xzalloc(sizeof(*ctx.spec));
 583
 584    total_length = zlib_inflate(compress_genxmls,
 585                                sizeof(compress_genxmls),
 586                                (void **) &text_data);
 587    assert(text_offset + text_length <= total_length);
 588
 589    buf = XML_GetBuffer(ctx.parser, text_length);
 590    memcpy(buf, &text_data[text_offset], text_length);
 591
 592    if (XML_ParseBuffer(ctx.parser, text_length, true) == 0) {
 593       fprintf(stderr,
 594               "Error parsing XML at line %ld col %ld byte %ld/%u: %s\n",
 595               XML_GetCurrentLineNumber(ctx.parser),
 596               XML_GetCurrentColumnNumber(ctx.parser),
 597               XML_GetCurrentByteIndex(ctx.parser), text_length,
 598               XML_ErrorString(XML_GetErrorCode(ctx.parser)));
 599       XML_ParserFree(ctx.parser);
 600       free(text_data);
 601       return NULL;
 602    }
 603
 604    XML_ParserFree(ctx.parser);
 605    free(text_data);
 606
 607    return ctx.spec;
 608 }
 609
 610 struct gen_spec *
 611 gen_spec_load_from_path(const struct gen_device_info *devinfo,
 612                         const char *path)
 613 {
 614    struct parser_context ctx;
 615    size_t len, filename_len = strlen(path) + 20;
 616    char *filename = malloc(filename_len);
 617    void *buf;
 618    FILE *input;
 619
 620    len = snprintf(filename, filename_len, "%s/gen%i.xml",
 621                   path, devinfo_to_gen(devinfo));
 622    assert(len < filename_len);
 623
 624    input = fopen(filename, "r");
 625    if (input == NULL) {
 626       fprintf(stderr, "failed to open xml description\n");
 627       free(filename);
 628       return NULL;
 629    }
 630
 631    memset(&ctx, 0, sizeof ctx);
 632    ctx.parser = XML_ParserCreate(NULL);
 633    XML_SetUserData(ctx.parser, &ctx);
 634    if (ctx.parser == NULL) {
 635       fprintf(stderr, "failed to create parser\n");
 636       fclose(input);
 637       free(filename);
 638       return NULL;
 639    }
 640
 641    XML_SetElementHandler(ctx.parser, start_element, end_element);
 642    XML_SetCharacterDataHandler(ctx.parser, character_data);
 643    ctx.loc.filename = filename;
 644    ctx.spec = xzalloc(sizeof(*ctx.spec));
 645
 646    do {
 647       buf = XML_GetBuffer(ctx.parser, XML_BUFFER_SIZE);
 648       len = fread(buf, 1, XML_BUFFER_SIZE, input);
 649       if (len == 0) {
 650          fprintf(stderr, "fread: %m\n");
 651          free(ctx.spec);
 652          ctx.spec = NULL;
 653          goto end;
 654       }
 655       if (XML_ParseBuffer(ctx.parser, len, len == 0) == 0) {
 656          fprintf(stderr,
 657                  "Error parsing XML at line %ld col %ld: %s\n",
 658                  XML_GetCurrentLineNumber(ctx.parser),
 659                  XML_GetCurrentColumnNumber(ctx.parser),
 660                  XML_ErrorString(XML_GetErrorCode(ctx.parser)));
 661          free(ctx.spec);
 662          ctx.spec = NULL;
 663          goto end;
 664       }
 665    } while (len > 0);
 666
 667  end:
 668    XML_ParserFree(ctx.parser);
 669
 670    fclose(input);
 671    free(filename);
 672
 673    return ctx.spec;
 674 }
 675
 676 struct gen_group *
 677 gen_spec_find_instruction(struct gen_spec *spec, const uint32_t *p)
 678 {
 679    for (int i = 0; i < spec->ncommands; i++) {
 680       uint32_t opcode = *p & spec->commands[i]->opcode_mask;
 681       if (opcode == spec->commands[i]->opcode)
 682          return spec->commands[i];
 683    }
 684
 685    return NULL;
 686 }
 687
 688 int
 689 gen_group_get_length(struct gen_group *group, const uint32_t *p)
 690 {
 691    uint32_t h = p[0];
 692    uint32_t type = field(h, 29, 31);
 693
 694    switch (type) {
 695    case 0: /* MI */ {
 696       uint32_t opcode = field(h, 23, 28);
 697       if (opcode < 16)
 698          return 1;
 699       else
 700          return field(h, 0, 7) + 2;
 701       break;
 702    }
 703
 704    case 2: /* BLT */ {
 705       return field(h, 0, 7) + 2;
 706    }
 707
 708    case 3: /* Render */ {
 709       uint32_t subtype = field(h, 27, 28);
 710       uint32_t opcode = field(h, 24, 26);
 711       uint16_t whole_opcode = field(h, 16, 31);
 712       switch (subtype) {
 713       case 0:
 714          if (whole_opcode == 0x6104 /* PIPELINE_SELECT_965 */)
 715             return 1;
 716          else if (opcode < 2)
 717             return field(h, 0, 7) + 2;
 718          else
 719             return -1;
 720       case 1:
 721          if (opcode < 2)
 722             return 1;
 723          else
 724             return -1;
 725       case 2: {
 726          if (opcode == 0)
 727             return field(h, 0, 7) + 2;
 728          else if (opcode < 3)
 729             return field(h, 0, 15) + 2;
 730          else
 731             return -1;
 732       }
 733       case 3:
 734          if (whole_opcode == 0x780b)
 735             return 1;
 736          else if (opcode < 4)
 737             return field(h, 0, 7) + 2;
 738          else
 739             return -1;
 740       }
 741    }
 742    }
 743
 744    return -1;
 745 }
 746
 747 void
 748 gen_field_iterator_init(struct gen_field_iterator *iter,
 749                         struct gen_group *group,
 750                         const uint32_t *p,
 751                         bool print_colors)
 752 {
 753    iter->group = group;
 754    iter->p = p;
 755    iter->i = 0;
 756    iter->print_colors = print_colors;
 757    iter->repeat = false;
 758    iter->addr_inc = 0;
 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 bool
 773 gen_field_iterator_next(struct gen_field_iterator *iter)
 774 {
 775    union {
 776       uint64_t qw;
 777       float f;
 778    } v;
 779
 780    if (iter->i == iter->group->nfields) {
 781       if (iter->group->group_size > 0) {
 782          int iter_length = iter->group->elem_size;
 783
 784          iter->group->group_size -= iter_length / 32;
 785          iter->addr_inc += iter_length;
 786          iter->dword = (iter->field->start + iter->addr_inc) / 32;
 787          return true;
 788       }
 789       return false;
 790    }
 791
 792    iter->field = iter->group->fields[iter->i++];
 793    iter->name = iter->field->name;
 794    iter->dword = iter->field->start / 32;
 795    iter->struct_desc = NULL;
 796
 797    if ((iter->field->end - iter->field->start) > 32)
 798       v.qw = ((uint64_t) iter->p[iter->dword+1] << 32) | iter->p[iter->dword];
 799    else
 800       v.qw = iter->p[iter->dword];
 801
 802    const char *enum_name = NULL;
 803
 804    switch (iter->field->type.kind) {
 805    case GEN_TYPE_UNKNOWN:
 806    case GEN_TYPE_INT: {
 807       uint64_t value = field(v.qw, iter->field->start, iter->field->end);
 808       snprintf(iter->value, sizeof(iter->value), "%"PRId64, value);
 809       enum_name = gen_get_enum_name(&iter->field->inline_enum, value);
 810       break;
 811    }
 812    case GEN_TYPE_UINT: {
 813       uint64_t value = field(v.qw, iter->field->start, iter->field->end);
 814       snprintf(iter->value, sizeof(iter->value), "%"PRIu64, value);
 815       enum_name = gen_get_enum_name(&iter->field->inline_enum, value);
 816       break;
 817    }
 818    case GEN_TYPE_BOOL: {
 819       const char *true_string =
 820          iter->print_colors ? "\e[0;35mtrue\e[0m" : "true";
 821       snprintf(iter->value, sizeof(iter->value), "%s",
 822                field(v.qw, iter->field->start, iter->field->end) ?
 823                true_string : "false");
 824       break;
 825    }
 826    case GEN_TYPE_FLOAT:
 827       snprintf(iter->value, sizeof(iter->value), "%f", v.f);
 828       break;
 829    case GEN_TYPE_ADDRESS:
 830    case GEN_TYPE_OFFSET:
 831       snprintf(iter->value, sizeof(iter->value), "0x%08"PRIx64,
 832                field_address(v.qw, iter->field->start, iter->field->end));
 833       break;
 834    case GEN_TYPE_STRUCT:
 835       snprintf(iter->value, sizeof(iter->value), "<struct %s>",
 836                iter->field->type.gen_struct->name);
 837       iter->struct_desc =
 838          gen_spec_find_struct(iter->group->spec,
 839                               iter->field->type.gen_struct->name);
 840       break;
 841    case GEN_TYPE_UFIXED:
 842       snprintf(iter->value, sizeof(iter->value), "%f",
 843                (float) field(v.qw, iter->field->start,
 844                              iter->field->end) / (1 << iter->field->type.f));
 845       break;
 846    case GEN_TYPE_SFIXED:
 847       /* FIXME: Sign extend extracted field. */
 848       snprintf(iter->value, sizeof(iter->value), "%s", "foo");
 849       break;
 850    case GEN_TYPE_MBO:
 851        break;
 852    case GEN_TYPE_ENUM: {
 853       uint64_t value = field(v.qw, iter->field->start, iter->field->end);
 854       snprintf(iter->value, sizeof(iter->value),
 855                "%"PRId64, value);
 856       enum_name = gen_get_enum_name(iter->field->type.gen_enum, value);
 857       break;
 858    }
 859    }
 860
 861    if (enum_name) {
 862       int length = strlen(iter->value);
 863       snprintf(iter->value + length, sizeof(iter->value) - length,
 864                " (%s)", enum_name);
 865    }
 866
 867    return true;
 868 }
 869
 870 static void
 871 print_dword_header(FILE *outfile,
 872                    struct gen_field_iterator *iter, uint64_t offset)
 873 {
 874    fprintf(outfile, "0x%08"PRIx64":  0x%08x : Dword %d\n",
 875            offset + 4 * iter->dword, iter->p[iter->dword], iter->dword);
 876 }
 877
 878 static bool
 879 is_header_field(struct gen_group *group, struct gen_field *field)
 880 {
 881    uint32_t bits;
 882
 883    if (field->start >= 32)
 884       return false;
 885
 886    bits = (1U << (field->end - field->start + 1)) - 1;
 887    bits <<= field->start;
 888
 889    return (group->opcode_mask & bits) != 0;
 890 }
 891
 892 void
 893 gen_print_group(FILE *outfile, struct gen_group *group,
 894                 uint64_t offset, const uint32_t *p, bool color)
 895 {
 896    struct gen_field_iterator iter;
 897    int last_dword = 0;
 898
 899    gen_field_iterator_init(&iter, group, p, color);
 900    while (gen_field_iterator_next(&iter)) {
 901       if (last_dword != iter.dword) {
 902          print_dword_header(outfile, &iter, offset);
 903          last_dword = iter.dword;
 904       }
 905       if (!is_header_field(group, iter.field)) {
 906          fprintf(outfile, "    %s: %s\n", iter.name, iter.value);
 907          if (iter.struct_desc) {
 908             uint64_t struct_offset = offset + 4 * iter.dword;
 909             print_dword_header(outfile, &iter, struct_offset);
 910             gen_print_group(outfile, iter.struct_desc, struct_offset,
 911                             &p[iter.dword], color);
 912          }
 913       }
 914    }
 915 }