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