src/compiler/nir/nir_serialize.c

   1 /*
   2  * Copyright © 2017 Connor Abbott
   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 "nir_serialize.h"
  25 #include "nir_control_flow.h"
  26 #include "util/u_dynarray.h"
  27 #include "util/u_math.h"
  28
  29 #define NIR_SERIALIZE_FUNC_HAS_IMPL ((void *)(intptr_t)1)
  30 #define MAX_OBJECT_IDS (1 << 20)
  31
  32 typedef struct {
  33    size_t blob_offset;
  34    nir_ssa_def *src;
  35    nir_block *block;
  36 } write_phi_fixup;
  37
  38 typedef struct {
  39    const nir_shader *nir;
  40
  41    struct blob *blob;
  42
  43    /* maps pointer to index */
  44    struct hash_table *remap_table;
  45
  46    /* the next index to assign to a NIR in-memory object */
  47    uint32_t next_idx;
  48
  49    /* Array of write_phi_fixup structs representing phi sources that need to
  50     * be resolved in the second pass.
  51     */
  52    struct util_dynarray phi_fixups;
  53
  54    /* The last serialized type. */
  55    const struct glsl_type *last_type;
  56    const struct glsl_type *last_interface_type;
  57    struct nir_variable_data last_var_data;
  58
  59    /* Don't write optional data such as variable names. */
  60    bool strip;
  61 } write_ctx;
  62
  63 typedef struct {
  64    nir_shader *nir;
  65
  66    struct blob_reader *blob;
  67
  68    /* the next index to assign to a NIR in-memory object */
  69    uint32_t next_idx;
  70
  71    /* The length of the index -> object table */
  72    uint32_t idx_table_len;
  73
  74    /* map from index to deserialized pointer */
  75    void **idx_table;
  76
  77    /* List of phi sources. */
  78    struct list_head phi_srcs;
  79
  80    /* The last deserialized type. */
  81    const struct glsl_type *last_type;
  82    const struct glsl_type *last_interface_type;
  83    struct nir_variable_data last_var_data;
  84 } read_ctx;
  85
  86 static void
  87 write_add_object(write_ctx *ctx, const void *obj)
  88 {
  89    uint32_t index = ctx->next_idx++;
  90    assert(index != MAX_OBJECT_IDS);
  91    _mesa_hash_table_insert(ctx->remap_table, obj, (void *)(uintptr_t) index);
  92 }
  93
  94 static uint32_t
  95 write_lookup_object(write_ctx *ctx, const void *obj)
  96 {
  97    struct hash_entry *entry = _mesa_hash_table_search(ctx->remap_table, obj);
  98    assert(entry);
  99    return (uint32_t)(uintptr_t) entry->data;
 100 }
 101
 102 static void
 103 write_object(write_ctx *ctx, const void *obj)
 104 {
 105    blob_write_uint32(ctx->blob, write_lookup_object(ctx, obj));
 106 }
 107
 108 static void
 109 read_add_object(read_ctx *ctx, void *obj)
 110 {
 111    assert(ctx->next_idx < ctx->idx_table_len);
 112    ctx->idx_table[ctx->next_idx++] = obj;
 113 }
 114
 115 static void *
 116 read_lookup_object(read_ctx *ctx, uint32_t idx)
 117 {
 118    assert(idx < ctx->idx_table_len);
 119    return ctx->idx_table[idx];
 120 }
 121
 122 static void *
 123 read_object(read_ctx *ctx)
 124 {
 125    return read_lookup_object(ctx, blob_read_uint32(ctx->blob));
 126 }
 127
 128 static uint32_t
 129 encode_bit_size_3bits(uint8_t bit_size)
 130 {
 131    /* Encode values of 0, 1, 2, 4, 8, 16, 32, 64 in 3 bits. */
 132    assert(bit_size <= 64 && util_is_power_of_two_or_zero(bit_size));
 133    if (bit_size)
 134       return util_logbase2(bit_size) + 1;
 135    return 0;
 136 }
 137
 138 static uint8_t
 139 decode_bit_size_3bits(uint8_t bit_size)
 140 {
 141    if (bit_size)
 142       return 1 << (bit_size - 1);
 143    return 0;
 144 }
 145
 146 static uint8_t
 147 encode_num_components_in_3bits(uint8_t num_components)
 148 {
 149    if (num_components <= 4)
 150       return num_components;
 151    if (num_components == 8)
 152       return 5;
 153    if (num_components == 16)
 154       return 6;
 155
 156    unreachable("invalid number in num_components");
 157    return 0;
 158 }
 159
 160 static uint8_t
 161 decode_num_components_in_3bits(uint8_t value)
 162 {
 163    if (value <= 4)
 164       return value;
 165    if (value == 5)
 166       return 8;
 167    if (value == 6)
 168       return 16;
 169
 170    unreachable("invalid num_components encoding");
 171    return 0;
 172 }
 173
 174 static void
 175 write_constant(write_ctx *ctx, const nir_constant *c)
 176 {
 177    blob_write_bytes(ctx->blob, c->values, sizeof(c->values));
 178    blob_write_uint32(ctx->blob, c->num_elements);
 179    for (unsigned i = 0; i < c->num_elements; i++)
 180       write_constant(ctx, c->elements[i]);
 181 }
 182
 183 static nir_constant *
 184 read_constant(read_ctx *ctx, nir_variable *nvar)
 185 {
 186    nir_constant *c = ralloc(nvar, nir_constant);
 187
 188    blob_copy_bytes(ctx->blob, (uint8_t *)c->values, sizeof(c->values));
 189    c->num_elements = blob_read_uint32(ctx->blob);
 190    c->elements = ralloc_array(nvar, nir_constant *, c->num_elements);
 191    for (unsigned i = 0; i < c->num_elements; i++)
 192       c->elements[i] = read_constant(ctx, nvar);
 193
 194    return c;
 195 }
 196
 197 enum var_data_encoding {
 198    var_encode_full,
 199    var_encode_shader_temp,
 200    var_encode_function_temp,
 201    var_encode_location_diff,
 202 };
 203
 204 union packed_var {
 205    uint32_t u32;
 206    struct {
 207       unsigned has_name:1;
 208       unsigned has_constant_initializer:1;
 209       unsigned has_interface_type:1;
 210       unsigned num_state_slots:7;
 211       unsigned data_encoding:2;
 212       unsigned type_same_as_last:1;
 213       unsigned interface_type_same_as_last:1;
 214       unsigned _pad:2;
 215       unsigned num_members:16;
 216    } u;
 217 };
 218
 219 union packed_var_data_diff {
 220    uint32_t u32;
 221    struct {
 222       int location:13;
 223       int location_frac:3;
 224       int driver_location:16;
 225    } u;
 226 };
 227
 228 static void
 229 write_variable(write_ctx *ctx, const nir_variable *var)
 230 {
 231    write_add_object(ctx, var);
 232
 233    assert(var->num_state_slots < (1 << 7));
 234    assert(var->num_members < (1 << 16));
 235
 236    STATIC_ASSERT(sizeof(union packed_var) == 4);
 237    union packed_var flags;
 238    flags.u32 = 0;
 239
 240    flags.u.has_name = !ctx->strip && var->name;
 241    flags.u.has_constant_initializer = !!(var->constant_initializer);
 242    flags.u.has_interface_type = !!(var->interface_type);
 243    flags.u.type_same_as_last = var->type == ctx->last_type;
 244    flags.u.interface_type_same_as_last =
 245       var->interface_type && var->interface_type == ctx->last_interface_type;
 246    flags.u.num_state_slots = var->num_state_slots;
 247    flags.u.num_members = var->num_members;
 248
 249    struct nir_variable_data data = var->data;
 250
 251    /* When stripping, we expect that the location is no longer needed,
 252     * which is typically after shaders are linked.
 253     */
 254    if (ctx->strip &&
 255        data.mode != nir_var_shader_in &&
 256        data.mode != nir_var_shader_out)
 257       data.location = 0;
 258
 259    /* Temporary variables don't serialize var->data. */
 260    if (data.mode == nir_var_shader_temp)
 261       flags.u.data_encoding = var_encode_shader_temp;
 262    else if (data.mode == nir_var_function_temp)
 263       flags.u.data_encoding = var_encode_function_temp;
 264    else {
 265       struct nir_variable_data tmp = data;
 266
 267       tmp.location = ctx->last_var_data.location;
 268       tmp.location_frac = ctx->last_var_data.location_frac;
 269       tmp.driver_location = ctx->last_var_data.driver_location;
 270
 271       /* See if we can encode only the difference in locations from the last
 272        * variable.
 273        */
 274       if (memcmp(&ctx->last_var_data, &tmp, sizeof(tmp)) == 0 &&
 275           abs((int)data.location -
 276               (int)ctx->last_var_data.location) < (1 << 12) &&
 277           abs((int)data.driver_location -
 278               (int)ctx->last_var_data.driver_location) < (1 << 15))
 279          flags.u.data_encoding = var_encode_location_diff;
 280       else
 281          flags.u.data_encoding = var_encode_full;
 282    }
 283
 284    blob_write_uint32(ctx->blob, flags.u32);
 285
 286    if (!flags.u.type_same_as_last) {
 287       encode_type_to_blob(ctx->blob, var->type);
 288       ctx->last_type = var->type;
 289    }
 290
 291    if (var->interface_type && !flags.u.interface_type_same_as_last) {
 292       encode_type_to_blob(ctx->blob, var->interface_type);
 293       ctx->last_interface_type = var->interface_type;
 294    }
 295
 296    if (flags.u.has_name)
 297       blob_write_string(ctx->blob, var->name);
 298
 299    if (flags.u.data_encoding == var_encode_full ||
 300        flags.u.data_encoding == var_encode_location_diff) {
 301       if (flags.u.data_encoding == var_encode_full) {
 302          blob_write_bytes(ctx->blob, &data, sizeof(data));
 303       } else {
 304          /* Serialize only the difference in locations from the last variable.
 305           */
 306          union packed_var_data_diff diff;
 307
 308          diff.u.location = data.location - ctx->last_var_data.location;
 309          diff.u.location_frac = data.location_frac -
 310                                 ctx->last_var_data.location_frac;
 311          diff.u.driver_location = data.driver_location -
 312                                   ctx->last_var_data.driver_location;
 313
 314          blob_write_uint32(ctx->blob, diff.u32);
 315       }
 316
 317       ctx->last_var_data = data;
 318    }
 319
 320    for (unsigned i = 0; i < var->num_state_slots; i++) {
 321       blob_write_bytes(ctx->blob, &var->state_slots[i],
 322                        sizeof(var->state_slots[i]));
 323    }
 324    if (var->constant_initializer)
 325       write_constant(ctx, var->constant_initializer);
 326    if (var->num_members > 0) {
 327       blob_write_bytes(ctx->blob, (uint8_t *) var->members,
 328                        var->num_members * sizeof(*var->members));
 329    }
 330 }
 331
 332 static nir_variable *
 333 read_variable(read_ctx *ctx)
 334 {
 335    nir_variable *var = rzalloc(ctx->nir, nir_variable);
 336    read_add_object(ctx, var);
 337
 338    union packed_var flags;
 339    flags.u32 = blob_read_uint32(ctx->blob);
 340
 341    if (flags.u.type_same_as_last) {
 342       var->type = ctx->last_type;
 343    } else {
 344       var->type = decode_type_from_blob(ctx->blob);
 345       ctx->last_type = var->type;
 346    }
 347
 348    if (flags.u.has_interface_type) {
 349       if (flags.u.interface_type_same_as_last) {
 350          var->interface_type = ctx->last_interface_type;
 351       } else {
 352          var->interface_type = decode_type_from_blob(ctx->blob);
 353          ctx->last_interface_type = var->interface_type;
 354       }
 355    }
 356
 357    if (flags.u.has_name) {
 358       const char *name = blob_read_string(ctx->blob);
 359       var->name = ralloc_strdup(var, name);
 360    } else {
 361       var->name = NULL;
 362    }
 363
 364    if (flags.u.data_encoding == var_encode_shader_temp)
 365       var->data.mode = nir_var_shader_temp;
 366    else if (flags.u.data_encoding == var_encode_function_temp)
 367       var->data.mode = nir_var_function_temp;
 368    else if (flags.u.data_encoding == var_encode_full) {
 369       blob_copy_bytes(ctx->blob, (uint8_t *) &var->data, sizeof(var->data));
 370       ctx->last_var_data = var->data;
 371    } else { /* var_encode_location_diff */
 372       union packed_var_data_diff diff;
 373       diff.u32 = blob_read_uint32(ctx->blob);
 374
 375       var->data = ctx->last_var_data;
 376       var->data.location += diff.u.location;
 377       var->data.location_frac += diff.u.location_frac;
 378       var->data.driver_location += diff.u.driver_location;
 379
 380       ctx->last_var_data = var->data;
 381    }
 382
 383    var->num_state_slots = flags.u.num_state_slots;
 384    if (var->num_state_slots != 0) {
 385       var->state_slots = ralloc_array(var, nir_state_slot,
 386                                       var->num_state_slots);
 387       for (unsigned i = 0; i < var->num_state_slots; i++) {
 388          blob_copy_bytes(ctx->blob, &var->state_slots[i],
 389                          sizeof(var->state_slots[i]));
 390       }
 391    }
 392    if (flags.u.has_constant_initializer)
 393       var->constant_initializer = read_constant(ctx, var);
 394    else
 395       var->constant_initializer = NULL;
 396    var->num_members = flags.u.num_members;
 397    if (var->num_members > 0) {
 398       var->members = ralloc_array(var, struct nir_variable_data,
 399                                   var->num_members);
 400       blob_copy_bytes(ctx->blob, (uint8_t *) var->members,
 401                       var->num_members * sizeof(*var->members));
 402    }
 403
 404    return var;
 405 }
 406
 407 static void
 408 write_var_list(write_ctx *ctx, const struct exec_list *src)
 409 {
 410    blob_write_uint32(ctx->blob, exec_list_length(src));
 411    foreach_list_typed(nir_variable, var, node, src) {
 412       write_variable(ctx, var);
 413    }
 414 }
 415
 416 static void
 417 read_var_list(read_ctx *ctx, struct exec_list *dst)
 418 {
 419    exec_list_make_empty(dst);
 420    unsigned num_vars = blob_read_uint32(ctx->blob);
 421    for (unsigned i = 0; i < num_vars; i++) {
 422       nir_variable *var = read_variable(ctx);
 423       exec_list_push_tail(dst, &var->node);
 424    }
 425 }
 426
 427 static void
 428 write_register(write_ctx *ctx, const nir_register *reg)
 429 {
 430    write_add_object(ctx, reg);
 431    blob_write_uint32(ctx->blob, reg->num_components);
 432    blob_write_uint32(ctx->blob, reg->bit_size);
 433    blob_write_uint32(ctx->blob, reg->num_array_elems);
 434    blob_write_uint32(ctx->blob, reg->index);
 435    blob_write_uint32(ctx->blob, !ctx->strip && reg->name);
 436    if (!ctx->strip && reg->name)
 437       blob_write_string(ctx->blob, reg->name);
 438 }
 439
 440 static nir_register *
 441 read_register(read_ctx *ctx)
 442 {
 443    nir_register *reg = ralloc(ctx->nir, nir_register);
 444    read_add_object(ctx, reg);
 445    reg->num_components = blob_read_uint32(ctx->blob);
 446    reg->bit_size = blob_read_uint32(ctx->blob);
 447    reg->num_array_elems = blob_read_uint32(ctx->blob);
 448    reg->index = blob_read_uint32(ctx->blob);
 449    bool has_name = blob_read_uint32(ctx->blob);
 450    if (has_name) {
 451       const char *name = blob_read_string(ctx->blob);
 452       reg->name = ralloc_strdup(reg, name);
 453    } else {
 454       reg->name = NULL;
 455    }
 456
 457    list_inithead(&reg->uses);
 458    list_inithead(&reg->defs);
 459    list_inithead(&reg->if_uses);
 460
 461    return reg;
 462 }
 463
 464 static void
 465 write_reg_list(write_ctx *ctx, const struct exec_list *src)
 466 {
 467    blob_write_uint32(ctx->blob, exec_list_length(src));
 468    foreach_list_typed(nir_register, reg, node, src)
 469       write_register(ctx, reg);
 470 }
 471
 472 static void
 473 read_reg_list(read_ctx *ctx, struct exec_list *dst)
 474 {
 475    exec_list_make_empty(dst);
 476    unsigned num_regs = blob_read_uint32(ctx->blob);
 477    for (unsigned i = 0; i < num_regs; i++) {
 478       nir_register *reg = read_register(ctx);
 479       exec_list_push_tail(dst, &reg->node);
 480    }
 481 }
 482
 483 union packed_src {
 484    uint32_t u32;
 485    struct {
 486       unsigned is_ssa:1;   /* <-- Header */
 487       unsigned is_indirect:1;
 488       unsigned object_idx:20;
 489       unsigned _footer:10; /* <-- Footer */
 490    } any;
 491    struct {
 492       unsigned _header:22; /* <-- Header */
 493       unsigned negate:1;   /* <-- Footer */
 494       unsigned abs:1;
 495       unsigned swizzle_x:2;
 496       unsigned swizzle_y:2;
 497       unsigned swizzle_z:2;
 498       unsigned swizzle_w:2;
 499    } alu;
 500    struct {
 501       unsigned _header:22; /* <-- Header */
 502       unsigned src_type:5; /* <-- Footer */
 503       unsigned _pad:5;
 504    } tex;
 505 };
 506
 507 static void
 508 write_src_full(write_ctx *ctx, const nir_src *src, union packed_src header)
 509 {
 510    /* Since sources are very frequent, we try to save some space when storing
 511     * them. In particular, we store whether the source is a register and
 512     * whether the register has an indirect index in the low two bits. We can
 513     * assume that the high two bits of the index are zero, since otherwise our
 514     * address space would've been exhausted allocating the remap table!
 515     */
 516    header.any.is_ssa = src->is_ssa;
 517    if (src->is_ssa) {
 518       header.any.object_idx = write_lookup_object(ctx, src->ssa);
 519       blob_write_uint32(ctx->blob, header.u32);
 520    } else {
 521       header.any.object_idx = write_lookup_object(ctx, src->reg.reg);
 522       header.any.is_indirect = !!src->reg.indirect;
 523       blob_write_uint32(ctx->blob, header.u32);
 524       blob_write_uint32(ctx->blob, src->reg.base_offset);
 525       if (src->reg.indirect) {
 526          union packed_src header = {0};
 527          write_src_full(ctx, src->reg.indirect, header);
 528       }
 529    }
 530 }
 531
 532 static void
 533 write_src(write_ctx *ctx, const nir_src *src)
 534 {
 535    union packed_src header = {0};
 536    write_src_full(ctx, src, header);
 537 }
 538
 539 static union packed_src
 540 read_src(read_ctx *ctx, nir_src *src, void *mem_ctx)
 541 {
 542    STATIC_ASSERT(sizeof(union packed_src) == 4);
 543    union packed_src header;
 544    header.u32 = blob_read_uint32(ctx->blob);
 545
 546    src->is_ssa = header.any.is_ssa;
 547    if (src->is_ssa) {
 548       src->ssa = read_lookup_object(ctx, header.any.object_idx);
 549    } else {
 550       src->reg.reg = read_lookup_object(ctx, header.any.object_idx);
 551       src->reg.base_offset = blob_read_uint32(ctx->blob);
 552       if (header.any.is_indirect) {
 553          src->reg.indirect = ralloc(mem_ctx, nir_src);
 554          read_src(ctx, src->reg.indirect, mem_ctx);
 555       } else {
 556          src->reg.indirect = NULL;
 557       }
 558    }
 559    return header;
 560 }
 561
 562 union packed_dest {
 563    uint8_t u8;
 564    struct {
 565       uint8_t is_ssa:1;
 566       uint8_t has_name:1;
 567       uint8_t num_components:3;
 568       uint8_t bit_size:3;
 569    } ssa;
 570    struct {
 571       uint8_t is_ssa:1;
 572       uint8_t is_indirect:1;
 573       uint8_t _pad:6;
 574    } reg;
 575 };
 576
 577 union packed_instr {
 578    uint32_t u32;
 579    struct {
 580       unsigned instr_type:4; /* always present */
 581       unsigned _pad:20;
 582       unsigned dest:8;       /* always last */
 583    } any;
 584    struct {
 585       unsigned instr_type:4;
 586       unsigned exact:1;
 587       unsigned no_signed_wrap:1;
 588       unsigned no_unsigned_wrap:1;
 589       unsigned saturate:1;
 590       unsigned writemask:4;
 591       unsigned op:9;
 592       unsigned _pad:3;
 593       unsigned dest:8;
 594    } alu;
 595    struct {
 596       unsigned instr_type:4;
 597       unsigned deref_type:3;
 598       unsigned mode:10;
 599       unsigned _pad:7;
 600       unsigned dest:8;
 601    } deref;
 602    struct {
 603       unsigned instr_type:4;
 604       unsigned intrinsic:9;
 605       unsigned num_components:3;
 606       unsigned _pad:8;
 607       unsigned dest:8;
 608    } intrinsic;
 609    struct {
 610       unsigned instr_type:4;
 611       unsigned last_component:4;
 612       unsigned bit_size:3;
 613       unsigned _pad:21;
 614    } load_const;
 615    struct {
 616       unsigned instr_type:4;
 617       unsigned last_component:4;
 618       unsigned bit_size:3;
 619       unsigned _pad:21;
 620    } undef;
 621    struct {
 622       unsigned instr_type:4;
 623       unsigned num_srcs:4;
 624       unsigned op:4;
 625       unsigned texture_array_size:12;
 626       unsigned dest:8;
 627    } tex;
 628    struct {
 629       unsigned instr_type:4;
 630       unsigned num_srcs:20;
 631       unsigned dest:8;
 632    } phi;
 633    struct {
 634       unsigned instr_type:4;
 635       unsigned type:2;
 636       unsigned _pad:26;
 637    } jump;
 638 };
 639
 640 /* Write "lo24" as low 24 bits in the first uint32. */
 641 static void
 642 write_dest(write_ctx *ctx, const nir_dest *dst, union packed_instr header)
 643 {
 644    STATIC_ASSERT(sizeof(union packed_dest) == 1);
 645    union packed_dest dest;
 646    dest.u8 = 0;
 647
 648    dest.ssa.is_ssa = dst->is_ssa;
 649    if (dst->is_ssa) {
 650       dest.ssa.has_name = !ctx->strip && dst->ssa.name;
 651       dest.ssa.num_components =
 652          encode_num_components_in_3bits(dst->ssa.num_components);
 653       dest.ssa.bit_size = encode_bit_size_3bits(dst->ssa.bit_size);
 654    } else {
 655       dest.reg.is_indirect = !!(dst->reg.indirect);
 656    }
 657
 658    header.any.dest = dest.u8;
 659    blob_write_uint32(ctx->blob, header.u32);
 660
 661    if (dst->is_ssa) {
 662       write_add_object(ctx, &dst->ssa);
 663       if (dest.ssa.has_name)
 664          blob_write_string(ctx->blob, dst->ssa.name);
 665    } else {
 666       blob_write_uint32(ctx->blob, write_lookup_object(ctx, dst->reg.reg));
 667       blob_write_uint32(ctx->blob, dst->reg.base_offset);
 668       if (dst->reg.indirect)
 669          write_src(ctx, dst->reg.indirect);
 670    }
 671 }
 672
 673 static void
 674 read_dest(read_ctx *ctx, nir_dest *dst, nir_instr *instr,
 675           union packed_instr header)
 676 {
 677    union packed_dest dest;
 678    dest.u8 = header.any.dest;
 679
 680    if (dest.ssa.is_ssa) {
 681       unsigned bit_size = decode_bit_size_3bits(dest.ssa.bit_size);
 682       unsigned num_components =
 683          decode_num_components_in_3bits(dest.ssa.num_components);
 684       char *name = dest.ssa.has_name ? blob_read_string(ctx->blob) : NULL;
 685       nir_ssa_dest_init(instr, dst, num_components, bit_size, name);
 686       read_add_object(ctx, &dst->ssa);
 687    } else {
 688       dst->reg.reg = read_object(ctx);
 689       dst->reg.base_offset = blob_read_uint32(ctx->blob);
 690       if (dest.reg.is_indirect) {
 691          dst->reg.indirect = ralloc(instr, nir_src);
 692          read_src(ctx, dst->reg.indirect, instr);
 693       }
 694    }
 695 }
 696
 697 static void
 698 write_alu(write_ctx *ctx, const nir_alu_instr *alu)
 699 {
 700    /* 9 bits for nir_op */
 701    STATIC_ASSERT(nir_num_opcodes <= 512);
 702    union packed_instr header;
 703    header.u32 = 0;
 704
 705    header.alu.instr_type = alu->instr.type;
 706    header.alu.exact = alu->exact;
 707    header.alu.no_signed_wrap = alu->no_signed_wrap;
 708    header.alu.no_unsigned_wrap = alu->no_unsigned_wrap;
 709    header.alu.saturate = alu->dest.saturate;
 710    header.alu.writemask = alu->dest.write_mask;
 711    header.alu.op = alu->op;
 712
 713    write_dest(ctx, &alu->dest.dest, header);
 714
 715    for (unsigned i = 0; i < nir_op_infos[alu->op].num_inputs; i++) {
 716       union packed_src src;
 717       src.u32 = 0;
 718
 719       src.alu.negate = alu->src[i].negate;
 720       src.alu.abs = alu->src[i].abs;
 721       src.alu.swizzle_x = alu->src[i].swizzle[0];
 722       src.alu.swizzle_y = alu->src[i].swizzle[1];
 723       src.alu.swizzle_z = alu->src[i].swizzle[2];
 724       src.alu.swizzle_w = alu->src[i].swizzle[3];
 725
 726       write_src_full(ctx, &alu->src[i].src, src);
 727    }
 728 }
 729
 730 static nir_alu_instr *
 731 read_alu(read_ctx *ctx, union packed_instr header)
 732 {
 733    nir_alu_instr *alu = nir_alu_instr_create(ctx->nir, header.alu.op);
 734
 735    alu->exact = header.alu.exact;
 736    alu->no_signed_wrap = header.alu.no_signed_wrap;
 737    alu->no_unsigned_wrap = header.alu.no_unsigned_wrap;
 738    alu->dest.saturate = header.alu.saturate;
 739    alu->dest.write_mask = header.alu.writemask;
 740
 741    read_dest(ctx, &alu->dest.dest, &alu->instr, header);
 742
 743    for (unsigned i = 0; i < nir_op_infos[header.alu.op].num_inputs; i++) {
 744       union packed_src src = read_src(ctx, &alu->src[i].src, &alu->instr);
 745
 746       alu->src[i].negate = src.alu.negate;
 747       alu->src[i].abs = src.alu.abs;
 748       alu->src[i].swizzle[0] = src.alu.swizzle_x;
 749       alu->src[i].swizzle[1] = src.alu.swizzle_y;
 750       alu->src[i].swizzle[2] = src.alu.swizzle_z;
 751       alu->src[i].swizzle[3] = src.alu.swizzle_w;
 752    }
 753
 754    return alu;
 755 }
 756
 757 static void
 758 write_deref(write_ctx *ctx, const nir_deref_instr *deref)
 759 {
 760    assert(deref->deref_type < 8);
 761    assert(deref->mode < (1 << 10));
 762
 763    union packed_instr header;
 764    header.u32 = 0;
 765
 766    header.deref.instr_type = deref->instr.type;
 767    header.deref.deref_type = deref->deref_type;
 768    header.deref.mode = deref->mode;
 769
 770    write_dest(ctx, &deref->dest, header);
 771    encode_type_to_blob(ctx->blob, deref->type);
 772
 773    if (deref->deref_type == nir_deref_type_var) {
 774       write_object(ctx, deref->var);
 775       return;
 776    }
 777
 778    write_src(ctx, &deref->parent);
 779
 780    switch (deref->deref_type) {
 781    case nir_deref_type_struct:
 782       blob_write_uint32(ctx->blob, deref->strct.index);
 783       break;
 784
 785    case nir_deref_type_array:
 786    case nir_deref_type_ptr_as_array:
 787       write_src(ctx, &deref->arr.index);
 788       break;
 789
 790    case nir_deref_type_cast:
 791       blob_write_uint32(ctx->blob, deref->cast.ptr_stride);
 792       break;
 793
 794    case nir_deref_type_array_wildcard:
 795       /* Nothing to do */
 796       break;
 797
 798    default:
 799       unreachable("Invalid deref type");
 800    }
 801 }
 802
 803 static nir_deref_instr *
 804 read_deref(read_ctx *ctx, union packed_instr header)
 805 {
 806    nir_deref_type deref_type = header.deref.deref_type;
 807    nir_deref_instr *deref = nir_deref_instr_create(ctx->nir, deref_type);
 808
 809    read_dest(ctx, &deref->dest, &deref->instr, header);
 810
 811    deref->mode = header.deref.mode;
 812    deref->type = decode_type_from_blob(ctx->blob);
 813
 814    if (deref_type == nir_deref_type_var) {
 815       deref->var = read_object(ctx);
 816       return deref;
 817    }
 818
 819    read_src(ctx, &deref->parent, &deref->instr);
 820
 821    switch (deref->deref_type) {
 822    case nir_deref_type_struct:
 823       deref->strct.index = blob_read_uint32(ctx->blob);
 824       break;
 825
 826    case nir_deref_type_array:
 827    case nir_deref_type_ptr_as_array:
 828       read_src(ctx, &deref->arr.index, &deref->instr);
 829       break;
 830
 831    case nir_deref_type_cast:
 832       deref->cast.ptr_stride = blob_read_uint32(ctx->blob);
 833       break;
 834
 835    case nir_deref_type_array_wildcard:
 836       /* Nothing to do */
 837       break;
 838
 839    default:
 840       unreachable("Invalid deref type");
 841    }
 842
 843    return deref;
 844 }
 845
 846 static void
 847 write_intrinsic(write_ctx *ctx, const nir_intrinsic_instr *intrin)
 848 {
 849    /* 9 bits for nir_intrinsic_op */
 850    STATIC_ASSERT(nir_num_intrinsics <= 512);
 851    unsigned num_srcs = nir_intrinsic_infos[intrin->intrinsic].num_srcs;
 852    unsigned num_indices = nir_intrinsic_infos[intrin->intrinsic].num_indices;
 853    assert(intrin->intrinsic < 512);
 854
 855    union packed_instr header;
 856    header.u32 = 0;
 857
 858    header.intrinsic.instr_type = intrin->instr.type;
 859    header.intrinsic.intrinsic = intrin->intrinsic;
 860    header.intrinsic.num_components =
 861       encode_num_components_in_3bits(intrin->num_components);
 862
 863    if (nir_intrinsic_infos[intrin->intrinsic].has_dest)
 864       write_dest(ctx, &intrin->dest, header);
 865    else
 866       blob_write_uint32(ctx->blob, header.u32);
 867
 868    for (unsigned i = 0; i < num_srcs; i++)
 869       write_src(ctx, &intrin->src[i]);
 870
 871    for (unsigned i = 0; i < num_indices; i++)
 872       blob_write_uint32(ctx->blob, intrin->const_index[i]);
 873 }
 874
 875 static nir_intrinsic_instr *
 876 read_intrinsic(read_ctx *ctx, union packed_instr header)
 877 {
 878    nir_intrinsic_op op = header.intrinsic.intrinsic;
 879    nir_intrinsic_instr *intrin = nir_intrinsic_instr_create(ctx->nir, op);
 880
 881    unsigned num_srcs = nir_intrinsic_infos[op].num_srcs;
 882    unsigned num_indices = nir_intrinsic_infos[op].num_indices;
 883
 884    intrin->num_components =
 885       decode_num_components_in_3bits(header.intrinsic.num_components);
 886
 887    if (nir_intrinsic_infos[op].has_dest)
 888       read_dest(ctx, &intrin->dest, &intrin->instr, header);
 889
 890    for (unsigned i = 0; i < num_srcs; i++)
 891       read_src(ctx, &intrin->src[i], &intrin->instr);
 892
 893    for (unsigned i = 0; i < num_indices; i++)
 894       intrin->const_index[i] = blob_read_uint32(ctx->blob);
 895
 896    return intrin;
 897 }
 898
 899 static void
 900 write_load_const(write_ctx *ctx, const nir_load_const_instr *lc)
 901 {
 902    assert(lc->def.num_components >= 1 && lc->def.num_components <= 16);
 903    union packed_instr header;
 904    header.u32 = 0;
 905
 906    header.load_const.instr_type = lc->instr.type;
 907    header.load_const.last_component = lc->def.num_components - 1;
 908    header.load_const.bit_size = encode_bit_size_3bits(lc->def.bit_size);
 909
 910    blob_write_uint32(ctx->blob, header.u32);
 911    blob_write_bytes(ctx->blob, lc->value, sizeof(*lc->value) * lc->def.num_components);
 912    write_add_object(ctx, &lc->def);
 913 }
 914
 915 static nir_load_const_instr *
 916 read_load_const(read_ctx *ctx, union packed_instr header)
 917 {
 918    nir_load_const_instr *lc =
 919       nir_load_const_instr_create(ctx->nir, header.load_const.last_component + 1,
 920                                   decode_bit_size_3bits(header.load_const.bit_size));
 921
 922    blob_copy_bytes(ctx->blob, lc->value, sizeof(*lc->value) * lc->def.num_components);
 923    read_add_object(ctx, &lc->def);
 924    return lc;
 925 }
 926
 927 static void
 928 write_ssa_undef(write_ctx *ctx, const nir_ssa_undef_instr *undef)
 929 {
 930    assert(undef->def.num_components >= 1 && undef->def.num_components <= 16);
 931
 932    union packed_instr header;
 933    header.u32 = 0;
 934
 935    header.undef.instr_type = undef->instr.type;
 936    header.undef.last_component = undef->def.num_components - 1;
 937    header.undef.bit_size = encode_bit_size_3bits(undef->def.bit_size);
 938
 939    blob_write_uint32(ctx->blob, header.u32);
 940    write_add_object(ctx, &undef->def);
 941 }
 942
 943 static nir_ssa_undef_instr *
 944 read_ssa_undef(read_ctx *ctx, union packed_instr header)
 945 {
 946    nir_ssa_undef_instr *undef =
 947       nir_ssa_undef_instr_create(ctx->nir, header.undef.last_component + 1,
 948                                  decode_bit_size_3bits(header.undef.bit_size));
 949
 950    read_add_object(ctx, &undef->def);
 951    return undef;
 952 }
 953
 954 union packed_tex_data {
 955    uint32_t u32;
 956    struct {
 957       enum glsl_sampler_dim sampler_dim:4;
 958       nir_alu_type dest_type:8;
 959       unsigned coord_components:3;
 960       unsigned is_array:1;
 961       unsigned is_shadow:1;
 962       unsigned is_new_style_shadow:1;
 963       unsigned component:2;
 964       unsigned unused:10; /* Mark unused for valgrind. */
 965    } u;
 966 };
 967
 968 static void
 969 write_tex(write_ctx *ctx, const nir_tex_instr *tex)
 970 {
 971    assert(tex->num_srcs < 16);
 972    assert(tex->op < 16);
 973    assert(tex->texture_array_size < 1024);
 974
 975    union packed_instr header;
 976    header.u32 = 0;
 977
 978    header.tex.instr_type = tex->instr.type;
 979    header.tex.num_srcs = tex->num_srcs;
 980    header.tex.op = tex->op;
 981    header.tex.texture_array_size = tex->texture_array_size;
 982
 983    write_dest(ctx, &tex->dest, header);
 984
 985    blob_write_uint32(ctx->blob, tex->texture_index);
 986    blob_write_uint32(ctx->blob, tex->sampler_index);
 987    if (tex->op == nir_texop_tg4)
 988       blob_write_bytes(ctx->blob, tex->tg4_offsets, sizeof(tex->tg4_offsets));
 989
 990    STATIC_ASSERT(sizeof(union packed_tex_data) == sizeof(uint32_t));
 991    union packed_tex_data packed = {
 992       .u.sampler_dim = tex->sampler_dim,
 993       .u.dest_type = tex->dest_type,
 994       .u.coord_components = tex->coord_components,
 995       .u.is_array = tex->is_array,
 996       .u.is_shadow = tex->is_shadow,
 997       .u.is_new_style_shadow = tex->is_new_style_shadow,
 998       .u.component = tex->component,
 999    };
1000    blob_write_uint32(ctx->blob, packed.u32);
1001
1002    for (unsigned i = 0; i < tex->num_srcs; i++) {
1003       union packed_src src;
1004       src.u32 = 0;
1005       src.tex.src_type = tex->src[i].src_type;
1006       write_src_full(ctx, &tex->src[i].src, src);
1007    }
1008 }
1009
1010 static nir_tex_instr *
1011 read_tex(read_ctx *ctx, union packed_instr header)
1012 {
1013    nir_tex_instr *tex = nir_tex_instr_create(ctx->nir, header.tex.num_srcs);
1014
1015    read_dest(ctx, &tex->dest, &tex->instr, header);
1016
1017    tex->op = header.tex.op;
1018    tex->texture_index = blob_read_uint32(ctx->blob);
1019    tex->texture_array_size = header.tex.texture_array_size;
1020    tex->sampler_index = blob_read_uint32(ctx->blob);
1021    if (tex->op == nir_texop_tg4)
1022       blob_copy_bytes(ctx->blob, tex->tg4_offsets, sizeof(tex->tg4_offsets));
1023
1024    union packed_tex_data packed;
1025    packed.u32 = blob_read_uint32(ctx->blob);
1026    tex->sampler_dim = packed.u.sampler_dim;
1027    tex->dest_type = packed.u.dest_type;
1028    tex->coord_components = packed.u.coord_components;
1029    tex->is_array = packed.u.is_array;
1030    tex->is_shadow = packed.u.is_shadow;
1031    tex->is_new_style_shadow = packed.u.is_new_style_shadow;
1032    tex->component = packed.u.component;
1033
1034    for (unsigned i = 0; i < tex->num_srcs; i++) {
1035       union packed_src src = read_src(ctx, &tex->src[i].src, &tex->instr);
1036       tex->src[i].src_type = src.tex.src_type;
1037    }
1038
1039    return tex;
1040 }
1041
1042 static void
1043 write_phi(write_ctx *ctx, const nir_phi_instr *phi)
1044 {
1045    union packed_instr header;
1046    header.u32 = 0;
1047
1048    header.phi.instr_type = phi->instr.type;
1049    header.phi.num_srcs = exec_list_length(&phi->srcs);
1050
1051    /* Phi nodes are special, since they may reference SSA definitions and
1052     * basic blocks that don't exist yet. We leave two empty uint32_t's here,
1053     * and then store enough information so that a later fixup pass can fill
1054     * them in correctly.
1055     */
1056    write_dest(ctx, &phi->dest, header);
1057
1058    nir_foreach_phi_src(src, phi) {
1059       assert(src->src.is_ssa);
1060       size_t blob_offset = blob_reserve_uint32(ctx->blob);
1061       ASSERTED size_t blob_offset2 = blob_reserve_uint32(ctx->blob);
1062       assert(blob_offset + sizeof(uint32_t) == blob_offset2);
1063       write_phi_fixup fixup = {
1064          .blob_offset = blob_offset,
1065          .src = src->src.ssa,
1066          .block = src->pred,
1067       };
1068       util_dynarray_append(&ctx->phi_fixups, write_phi_fixup, fixup);
1069    }
1070 }
1071
1072 static void
1073 write_fixup_phis(write_ctx *ctx)
1074 {
1075    util_dynarray_foreach(&ctx->phi_fixups, write_phi_fixup, fixup) {
1076       uint32_t *blob_ptr = (uint32_t *)(ctx->blob->data + fixup->blob_offset);
1077       blob_ptr[0] = write_lookup_object(ctx, fixup->src);
1078       blob_ptr[1] = write_lookup_object(ctx, fixup->block);
1079    }
1080
1081    util_dynarray_clear(&ctx->phi_fixups);
1082 }
1083
1084 static nir_phi_instr *
1085 read_phi(read_ctx *ctx, nir_block *blk, union packed_instr header)
1086 {
1087    nir_phi_instr *phi = nir_phi_instr_create(ctx->nir);
1088
1089    read_dest(ctx, &phi->dest, &phi->instr, header);
1090
1091    /* For similar reasons as before, we just store the index directly into the
1092     * pointer, and let a later pass resolve the phi sources.
1093     *
1094     * In order to ensure that the copied sources (which are just the indices
1095     * from the blob for now) don't get inserted into the old shader's use-def
1096     * lists, we have to add the phi instruction *before* we set up its
1097     * sources.
1098     */
1099    nir_instr_insert_after_block(blk, &phi->instr);
1100
1101    for (unsigned i = 0; i < header.phi.num_srcs; i++) {
1102       nir_phi_src *src = ralloc(phi, nir_phi_src);
1103
1104       src->src.is_ssa = true;
1105       src->src.ssa = (nir_ssa_def *)(uintptr_t) blob_read_uint32(ctx->blob);
1106       src->pred = (nir_block *)(uintptr_t) blob_read_uint32(ctx->blob);
1107
1108       /* Since we're not letting nir_insert_instr handle use/def stuff for us,
1109        * we have to set the parent_instr manually.  It doesn't really matter
1110        * when we do it, so we might as well do it here.
1111        */
1112       src->src.parent_instr = &phi->instr;
1113
1114       /* Stash it in the list of phi sources.  We'll walk this list and fix up
1115        * sources at the very end of read_function_impl.
1116        */
1117       list_add(&src->src.use_link, &ctx->phi_srcs);
1118
1119       exec_list_push_tail(&phi->srcs, &src->node);
1120    }
1121
1122    return phi;
1123 }
1124
1125 static void
1126 read_fixup_phis(read_ctx *ctx)
1127 {
1128    list_for_each_entry_safe(nir_phi_src, src, &ctx->phi_srcs, src.use_link) {
1129       src->pred = read_lookup_object(ctx, (uintptr_t)src->pred);
1130       src->src.ssa = read_lookup_object(ctx, (uintptr_t)src->src.ssa);
1131
1132       /* Remove from this list */
1133       list_del(&src->src.use_link);
1134
1135       list_addtail(&src->src.use_link, &src->src.ssa->uses);
1136    }
1137    assert(list_is_empty(&ctx->phi_srcs));
1138 }
1139
1140 static void
1141 write_jump(write_ctx *ctx, const nir_jump_instr *jmp)
1142 {
1143    assert(jmp->type < 4);
1144
1145    union packed_instr header;
1146    header.u32 = 0;
1147
1148    header.jump.instr_type = jmp->instr.type;
1149    header.jump.type = jmp->type;
1150
1151    blob_write_uint32(ctx->blob, header.u32);
1152 }
1153
1154 static nir_jump_instr *
1155 read_jump(read_ctx *ctx, union packed_instr header)
1156 {
1157    nir_jump_instr *jmp = nir_jump_instr_create(ctx->nir, header.jump.type);
1158    return jmp;
1159 }
1160
1161 static void
1162 write_call(write_ctx *ctx, const nir_call_instr *call)
1163 {
1164    blob_write_uint32(ctx->blob, write_lookup_object(ctx, call->callee));
1165
1166    for (unsigned i = 0; i < call->num_params; i++)
1167       write_src(ctx, &call->params[i]);
1168 }
1169
1170 static nir_call_instr *
1171 read_call(read_ctx *ctx)
1172 {
1173    nir_function *callee = read_object(ctx);
1174    nir_call_instr *call = nir_call_instr_create(ctx->nir, callee);
1175
1176    for (unsigned i = 0; i < call->num_params; i++)
1177       read_src(ctx, &call->params[i], call);
1178
1179    return call;
1180 }
1181
1182 static void
1183 write_instr(write_ctx *ctx, const nir_instr *instr)
1184 {
1185    /* We have only 4 bits for the instruction type. */
1186    assert(instr->type < 16);
1187
1188    switch (instr->type) {
1189    case nir_instr_type_alu:
1190       write_alu(ctx, nir_instr_as_alu(instr));
1191       break;
1192    case nir_instr_type_deref:
1193       write_deref(ctx, nir_instr_as_deref(instr));
1194       break;
1195    case nir_instr_type_intrinsic:
1196       write_intrinsic(ctx, nir_instr_as_intrinsic(instr));
1197       break;
1198    case nir_instr_type_load_const:
1199       write_load_const(ctx, nir_instr_as_load_const(instr));
1200       break;
1201    case nir_instr_type_ssa_undef:
1202       write_ssa_undef(ctx, nir_instr_as_ssa_undef(instr));
1203       break;
1204    case nir_instr_type_tex:
1205       write_tex(ctx, nir_instr_as_tex(instr));
1206       break;
1207    case nir_instr_type_phi:
1208       write_phi(ctx, nir_instr_as_phi(instr));
1209       break;
1210    case nir_instr_type_jump:
1211       write_jump(ctx, nir_instr_as_jump(instr));
1212       break;
1213    case nir_instr_type_call:
1214       blob_write_uint32(ctx->blob, instr->type);
1215       write_call(ctx, nir_instr_as_call(instr));
1216       break;
1217    case nir_instr_type_parallel_copy:
1218       unreachable("Cannot write parallel copies");
1219    default:
1220       unreachable("bad instr type");
1221    }
1222 }
1223
1224 static void
1225 read_instr(read_ctx *ctx, nir_block *block)
1226 {
1227    STATIC_ASSERT(sizeof(union packed_instr) == 4);
1228    union packed_instr header;
1229    header.u32 = blob_read_uint32(ctx->blob);
1230    nir_instr *instr;
1231
1232    switch (header.any.instr_type) {
1233    case nir_instr_type_alu:
1234       instr = &read_alu(ctx, header)->instr;
1235       break;
1236    case nir_instr_type_deref:
1237       instr = &read_deref(ctx, header)->instr;
1238       break;
1239    case nir_instr_type_intrinsic:
1240       instr = &read_intrinsic(ctx, header)->instr;
1241       break;
1242    case nir_instr_type_load_const:
1243       instr = &read_load_const(ctx, header)->instr;
1244       break;
1245    case nir_instr_type_ssa_undef:
1246       instr = &read_ssa_undef(ctx, header)->instr;
1247       break;
1248    case nir_instr_type_tex:
1249       instr = &read_tex(ctx, header)->instr;
1250       break;
1251    case nir_instr_type_phi:
1252       /* Phi instructions are a bit of a special case when reading because we
1253        * don't want inserting the instruction to automatically handle use/defs
1254        * for us.  Instead, we need to wait until all the blocks/instructions
1255        * are read so that we can set their sources up.
1256        */
1257       read_phi(ctx, block, header);
1258       return;
1259    case nir_instr_type_jump:
1260       instr = &read_jump(ctx, header)->instr;
1261       break;
1262    case nir_instr_type_call:
1263       instr = &read_call(ctx)->instr;
1264       break;
1265    case nir_instr_type_parallel_copy:
1266       unreachable("Cannot read parallel copies");
1267    default:
1268       unreachable("bad instr type");
1269    }
1270
1271    nir_instr_insert_after_block(block, instr);
1272 }
1273
1274 static void
1275 write_block(write_ctx *ctx, const nir_block *block)
1276 {
1277    write_add_object(ctx, block);
1278    blob_write_uint32(ctx->blob, exec_list_length(&block->instr_list));
1279    nir_foreach_instr(instr, block)
1280       write_instr(ctx, instr);
1281 }
1282
1283 static void
1284 read_block(read_ctx *ctx, struct exec_list *cf_list)
1285 {
1286    /* Don't actually create a new block.  Just use the one from the tail of
1287     * the list.  NIR guarantees that the tail of the list is a block and that
1288     * no two blocks are side-by-side in the IR;  It should be empty.
1289     */
1290    nir_block *block =
1291       exec_node_data(nir_block, exec_list_get_tail(cf_list), cf_node.node);
1292
1293    read_add_object(ctx, block);
1294    unsigned num_instrs = blob_read_uint32(ctx->blob);
1295    for (unsigned i = 0; i < num_instrs; i++) {
1296       read_instr(ctx, block);
1297    }
1298 }
1299
1300 static void
1301 write_cf_list(write_ctx *ctx, const struct exec_list *cf_list);
1302
1303 static void
1304 read_cf_list(read_ctx *ctx, struct exec_list *cf_list);
1305
1306 static void
1307 write_if(write_ctx *ctx, nir_if *nif)
1308 {
1309    write_src(ctx, &nif->condition);
1310
1311    write_cf_list(ctx, &nif->then_list);
1312    write_cf_list(ctx, &nif->else_list);
1313 }
1314
1315 static void
1316 read_if(read_ctx *ctx, struct exec_list *cf_list)
1317 {
1318    nir_if *nif = nir_if_create(ctx->nir);
1319
1320    read_src(ctx, &nif->condition, nif);
1321
1322    nir_cf_node_insert_end(cf_list, &nif->cf_node);
1323
1324    read_cf_list(ctx, &nif->then_list);
1325    read_cf_list(ctx, &nif->else_list);
1326 }
1327
1328 static void
1329 write_loop(write_ctx *ctx, nir_loop *loop)
1330 {
1331    write_cf_list(ctx, &loop->body);
1332 }
1333
1334 static void
1335 read_loop(read_ctx *ctx, struct exec_list *cf_list)
1336 {
1337    nir_loop *loop = nir_loop_create(ctx->nir);
1338
1339    nir_cf_node_insert_end(cf_list, &loop->cf_node);
1340
1341    read_cf_list(ctx, &loop->body);
1342 }
1343
1344 static void
1345 write_cf_node(write_ctx *ctx, nir_cf_node *cf)
1346 {
1347    blob_write_uint32(ctx->blob, cf->type);
1348
1349    switch (cf->type) {
1350    case nir_cf_node_block:
1351       write_block(ctx, nir_cf_node_as_block(cf));
1352       break;
1353    case nir_cf_node_if:
1354       write_if(ctx, nir_cf_node_as_if(cf));
1355       break;
1356    case nir_cf_node_loop:
1357       write_loop(ctx, nir_cf_node_as_loop(cf));
1358       break;
1359    default:
1360       unreachable("bad cf type");
1361    }
1362 }
1363
1364 static void
1365 read_cf_node(read_ctx *ctx, struct exec_list *list)
1366 {
1367    nir_cf_node_type type = blob_read_uint32(ctx->blob);
1368
1369    switch (type) {
1370    case nir_cf_node_block:
1371       read_block(ctx, list);
1372       break;
1373    case nir_cf_node_if:
1374       read_if(ctx, list);
1375       break;
1376    case nir_cf_node_loop:
1377       read_loop(ctx, list);
1378       break;
1379    default:
1380       unreachable("bad cf type");
1381    }
1382 }
1383
1384 static void
1385 write_cf_list(write_ctx *ctx, const struct exec_list *cf_list)
1386 {
1387    blob_write_uint32(ctx->blob, exec_list_length(cf_list));
1388    foreach_list_typed(nir_cf_node, cf, node, cf_list) {
1389       write_cf_node(ctx, cf);
1390    }
1391 }
1392
1393 static void
1394 read_cf_list(read_ctx *ctx, struct exec_list *cf_list)
1395 {
1396    uint32_t num_cf_nodes = blob_read_uint32(ctx->blob);
1397    for (unsigned i = 0; i < num_cf_nodes; i++)
1398       read_cf_node(ctx, cf_list);
1399 }
1400
1401 static void
1402 write_function_impl(write_ctx *ctx, const nir_function_impl *fi)
1403 {
1404    write_var_list(ctx, &fi->locals);
1405    write_reg_list(ctx, &fi->registers);
1406    blob_write_uint32(ctx->blob, fi->reg_alloc);
1407
1408    write_cf_list(ctx, &fi->body);
1409    write_fixup_phis(ctx);
1410 }
1411
1412 static nir_function_impl *
1413 read_function_impl(read_ctx *ctx, nir_function *fxn)
1414 {
1415    nir_function_impl *fi = nir_function_impl_create_bare(ctx->nir);
1416    fi->function = fxn;
1417
1418    read_var_list(ctx, &fi->locals);
1419    read_reg_list(ctx, &fi->registers);
1420    fi->reg_alloc = blob_read_uint32(ctx->blob);
1421
1422    read_cf_list(ctx, &fi->body);
1423    read_fixup_phis(ctx);
1424
1425    fi->valid_metadata = 0;
1426
1427    return fi;
1428 }
1429
1430 static void
1431 write_function(write_ctx *ctx, const nir_function *fxn)
1432 {
1433    uint32_t flags = fxn->is_entrypoint;
1434    if (fxn->name)
1435       flags |= 0x2;
1436    if (fxn->impl)
1437       flags |= 0x4;
1438    blob_write_uint32(ctx->blob, flags);
1439    if (fxn->name)
1440       blob_write_string(ctx->blob, fxn->name);
1441
1442    write_add_object(ctx, fxn);
1443
1444    blob_write_uint32(ctx->blob, fxn->num_params);
1445    for (unsigned i = 0; i < fxn->num_params; i++) {
1446       uint32_t val =
1447          ((uint32_t)fxn->params[i].num_components) |
1448          ((uint32_t)fxn->params[i].bit_size) << 8;
1449       blob_write_uint32(ctx->blob, val);
1450    }
1451
1452    /* At first glance, it looks like we should write the function_impl here.
1453     * However, call instructions need to be able to reference at least the
1454     * function and those will get processed as we write the function_impls.
1455     * We stop here and write function_impls as a second pass.
1456     */
1457 }
1458
1459 static void
1460 read_function(read_ctx *ctx)
1461 {
1462    uint32_t flags = blob_read_uint32(ctx->blob);
1463    bool has_name = flags & 0x2;
1464    char *name = has_name ? blob_read_string(ctx->blob) : NULL;
1465
1466    nir_function *fxn = nir_function_create(ctx->nir, name);
1467
1468    read_add_object(ctx, fxn);
1469
1470    fxn->num_params = blob_read_uint32(ctx->blob);
1471    fxn->params = ralloc_array(fxn, nir_parameter, fxn->num_params);
1472    for (unsigned i = 0; i < fxn->num_params; i++) {
1473       uint32_t val = blob_read_uint32(ctx->blob);
1474       fxn->params[i].num_components = val & 0xff;
1475       fxn->params[i].bit_size = (val >> 8) & 0xff;
1476    }
1477
1478    fxn->is_entrypoint = flags & 0x1;
1479    if (flags & 0x4)
1480       fxn->impl = NIR_SERIALIZE_FUNC_HAS_IMPL;
1481 }
1482
1483 /**
1484  * Serialize NIR into a binary blob.
1485  *
1486  * \param strip  Don't serialize information only useful for debugging,
1487  *               such as variable names, making cache hits from similar
1488  *               shaders more likely.
1489  */
1490 void
1491 nir_serialize(struct blob *blob, const nir_shader *nir, bool strip)
1492 {
1493    write_ctx ctx = {0};
1494    ctx.remap_table = _mesa_pointer_hash_table_create(NULL);
1495    ctx.blob = blob;
1496    ctx.nir = nir;
1497    ctx.strip = strip;
1498    util_dynarray_init(&ctx.phi_fixups, NULL);
1499
1500    size_t idx_size_offset = blob_reserve_uint32(blob);
1501
1502    struct shader_info info = nir->info;
1503    uint32_t strings = 0;
1504    if (!strip && info.name)
1505       strings |= 0x1;
1506    if (!strip && info.label)
1507       strings |= 0x2;
1508    blob_write_uint32(blob, strings);
1509    if (!strip && info.name)
1510       blob_write_string(blob, info.name);
1511    if (!strip && info.label)
1512       blob_write_string(blob, info.label);
1513    info.name = info.label = NULL;
1514    blob_write_bytes(blob, (uint8_t *) &info, sizeof(info));
1515
1516    write_var_list(&ctx, &nir->uniforms);
1517    write_var_list(&ctx, &nir->inputs);
1518    write_var_list(&ctx, &nir->outputs);
1519    write_var_list(&ctx, &nir->shared);
1520    write_var_list(&ctx, &nir->globals);
1521    write_var_list(&ctx, &nir->system_values);
1522
1523    blob_write_uint32(blob, nir->num_inputs);
1524    blob_write_uint32(blob, nir->num_uniforms);
1525    blob_write_uint32(blob, nir->num_outputs);
1526    blob_write_uint32(blob, nir->num_shared);
1527    blob_write_uint32(blob, nir->scratch_size);
1528
1529    blob_write_uint32(blob, exec_list_length(&nir->functions));
1530    nir_foreach_function(fxn, nir) {
1531       write_function(&ctx, fxn);
1532    }
1533
1534    nir_foreach_function(fxn, nir) {
1535       if (fxn->impl)
1536          write_function_impl(&ctx, fxn->impl);
1537    }
1538
1539    blob_write_uint32(blob, nir->constant_data_size);
1540    if (nir->constant_data_size > 0)
1541       blob_write_bytes(blob, nir->constant_data, nir->constant_data_size);
1542
1543    *(uint32_t *)(blob->data + idx_size_offset) = ctx.next_idx;
1544
1545    _mesa_hash_table_destroy(ctx.remap_table, NULL);
1546    util_dynarray_fini(&ctx.phi_fixups);
1547 }
1548
1549 nir_shader *
1550 nir_deserialize(void *mem_ctx,
1551                 const struct nir_shader_compiler_options *options,
1552                 struct blob_reader *blob)
1553 {
1554    read_ctx ctx = {0};
1555    ctx.blob = blob;
1556    list_inithead(&ctx.phi_srcs);
1557    ctx.idx_table_len = blob_read_uint32(blob);
1558    ctx.idx_table = calloc(ctx.idx_table_len, sizeof(uintptr_t));
1559
1560    uint32_t strings = blob_read_uint32(blob);
1561    char *name = (strings & 0x1) ? blob_read_string(blob) : NULL;
1562    char *label = (strings & 0x2) ? blob_read_string(blob) : NULL;
1563
1564    struct shader_info info;
1565    blob_copy_bytes(blob, (uint8_t *) &info, sizeof(info));
1566
1567    ctx.nir = nir_shader_create(mem_ctx, info.stage, options, NULL);
1568
1569    info.name = name ? ralloc_strdup(ctx.nir, name) : NULL;
1570    info.label = label ? ralloc_strdup(ctx.nir, label) : NULL;
1571
1572    ctx.nir->info = info;
1573
1574    read_var_list(&ctx, &ctx.nir->uniforms);
1575    read_var_list(&ctx, &ctx.nir->inputs);
1576    read_var_list(&ctx, &ctx.nir->outputs);
1577    read_var_list(&ctx, &ctx.nir->shared);
1578    read_var_list(&ctx, &ctx.nir->globals);
1579    read_var_list(&ctx, &ctx.nir->system_values);
1580
1581    ctx.nir->num_inputs = blob_read_uint32(blob);
1582    ctx.nir->num_uniforms = blob_read_uint32(blob);
1583    ctx.nir->num_outputs = blob_read_uint32(blob);
1584    ctx.nir->num_shared = blob_read_uint32(blob);
1585    ctx.nir->scratch_size = blob_read_uint32(blob);
1586
1587    unsigned num_functions = blob_read_uint32(blob);
1588    for (unsigned i = 0; i < num_functions; i++)
1589       read_function(&ctx);
1590
1591    nir_foreach_function(fxn, ctx.nir) {
1592       if (fxn->impl == NIR_SERIALIZE_FUNC_HAS_IMPL)
1593          fxn->impl = read_function_impl(&ctx, fxn);
1594    }
1595
1596    ctx.nir->constant_data_size = blob_read_uint32(blob);
1597    if (ctx.nir->constant_data_size > 0) {
1598       ctx.nir->constant_data =
1599          ralloc_size(ctx.nir, ctx.nir->constant_data_size);
1600       blob_copy_bytes(blob, ctx.nir->constant_data,
1601                       ctx.nir->constant_data_size);
1602    }
1603
1604    free(ctx.idx_table);
1605
1606    return ctx.nir;
1607 }
1608
1609 void
1610 nir_shader_serialize_deserialize(nir_shader *shader)
1611 {
1612    const struct nir_shader_compiler_options *options = shader->options;
1613
1614    struct blob writer;
1615    blob_init(&writer);
1616    nir_serialize(&writer, shader, false);
1617
1618    /* Delete all of dest's ralloc children but leave dest alone */
1619    void *dead_ctx = ralloc_context(NULL);
1620    ralloc_adopt(dead_ctx, shader);
1621    ralloc_free(dead_ctx);
1622
1623    dead_ctx = ralloc_context(NULL);
1624
1625    struct blob_reader reader;
1626    blob_reader_init(&reader, writer.data, writer.size);
1627    nir_shader *copy = nir_deserialize(dead_ctx, options, &reader);
1628
1629    blob_finish(&writer);
1630
1631    nir_shader_replace(shader, copy);
1632    ralloc_free(dead_ctx);
1633 }