SPIRV-Tools/source/comp/markv_codec.cpp

// Copyright (c) 2017 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Contains
//   - SPIR-V to MARK-V encoder
//   - MARK-V to SPIR-V decoder
//
// MARK-V is a compression format for SPIR-V binaries. It strips away
// non-essential information (such as result ids which can be regenerated) and
// uses various bit reduction techiniques to reduce the size of the binary.
//
// MarkvModel is a flatbuffers object containing a set of rules defining how
// compression/decompression is done (coding schemes, dictionaries).

#include <algorithm>
#include <cassert>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <memory>
#include <numeric>
#include <string>
#include <vector>

#include "binary.h"
#include "diagnostic.h"
#include "enum_string_mapping.h"
#include "extensions.h"
#include "ext_inst.h"
#include "instruction.h"
#include "opcode.h"
#include "operand.h"
#include "spirv-tools/libspirv.h"
#include "spirv-tools/markv.h"
#include "spirv_endian.h"
#include "spirv_validator_options.h"
#include "util/bit_stream.h"
#include "util/parse_number.h"
#include "validate.h"
#include "val/instruction.h"
#include "val/validation_state.h"

using libspirv::Instruction;
using libspirv::ValidationState_t;
using spvtools::ValidateInstructionAndUpdateValidationState;
using spvutils::BitReaderWord64;
using spvutils::BitWriterWord64;

struct spv_markv_encoder_options_t {
};

struct spv_markv_decoder_options_t {
};

namespace {

const uint32_t kSpirvMagicNumber = SpvMagicNumber;
const uint32_t kMarkvMagicNumber = 0x07230303;

enum {
  kMarkvFirstOpcode = 65536,
  kMarkvOpNextInstructionEncodesResultId = 65536,
};

const size_t kCommentNumWhitespaces = 2;

// TODO(atgoo@github.com): This is a placeholder for an autogenerated flatbuffer
// containing MARK-V model for a specific dataset.
class MarkvModel {
 public:
  size_t opcode_chunk_length() const { return 7; }
  size_t num_operands_chunk_length() const { return 3; }
  size_t id_index_chunk_length() const { return 3; }

  size_t u16_chunk_length() const { return 4; }
  size_t s16_chunk_length() const { return 4; }
  size_t s16_block_exponent() const { return 6; }

  size_t u32_chunk_length() const { return 8; }
  size_t s32_chunk_length() const { return 8; }
  size_t s32_block_exponent() const { return 10; }

  size_t u64_chunk_length() const { return 8; }
  size_t s64_chunk_length() const { return 8; }
  size_t s64_block_exponent() const { return 10; }
};

const MarkvModel* GetDefaultModel() {
  static MarkvModel model;
  return &model;
}

// Returns chunk length used for variable length encoding of spirv operand
// words. Returns zero if operand type corresponds to potentially multiple
// words or a word which is not expected to profit from variable width encoding.
// Chunk length is selected based on the size of expected value.
// Most of these values will later be encoded with probability-based coding,
// but variable width integer coding is a good quick solution.
// TODO(atgoo@github.com): Put this in MarkvModel flatbuffer.
size_t GetOperandVariableWidthChunkLength(spv_operand_type_t type) {
  switch (type) {
    case SPV_OPERAND_TYPE_TYPE_ID:
      return 4;
    case SPV_OPERAND_TYPE_RESULT_ID:
    case SPV_OPERAND_TYPE_ID:
    case SPV_OPERAND_TYPE_SCOPE_ID:
    case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID:
      return 8;
    case SPV_OPERAND_TYPE_LITERAL_INTEGER:
    case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER:
      return 6;
    case SPV_OPERAND_TYPE_CAPABILITY:
      return 6;
    case SPV_OPERAND_TYPE_SOURCE_LANGUAGE:
    case SPV_OPERAND_TYPE_EXECUTION_MODEL:
      return 3;
    case SPV_OPERAND_TYPE_ADDRESSING_MODEL:
    case SPV_OPERAND_TYPE_MEMORY_MODEL:
      return 2;
    case SPV_OPERAND_TYPE_EXECUTION_MODE:
      return 6;
    case SPV_OPERAND_TYPE_STORAGE_CLASS:
      return 4;
    case SPV_OPERAND_TYPE_DIMENSIONALITY:
    case SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE:
      return 3;
    case SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE:
      return 2;
    case SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT:
      return 6;
    case SPV_OPERAND_TYPE_FP_ROUNDING_MODE:
    case SPV_OPERAND_TYPE_LINKAGE_TYPE:
    case SPV_OPERAND_TYPE_ACCESS_QUALIFIER:
    case SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER:
      return 2;
    case SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE:
      return 3;
    case SPV_OPERAND_TYPE_DECORATION:
    case SPV_OPERAND_TYPE_BUILT_IN:
      return 6;
    case SPV_OPERAND_TYPE_GROUP_OPERATION:
    case SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS:
    case SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO:
      return 2;
    case SPV_OPERAND_TYPE_FP_FAST_MATH_MODE:
    case SPV_OPERAND_TYPE_FUNCTION_CONTROL:
    case SPV_OPERAND_TYPE_LOOP_CONTROL:
    case SPV_OPERAND_TYPE_IMAGE:
    case SPV_OPERAND_TYPE_OPTIONAL_IMAGE:
    case SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS:
    case SPV_OPERAND_TYPE_SELECTION_CONTROL:
      return 4;
    case SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER:
      return 6;
    default:
      return 0;
  }
  return 0;
}

// Returns true if the opcode has a fixed number of operands. May return a
// false negative.
bool OpcodeHasFixedNumberOfOperands(SpvOp opcode) {
  switch (opcode) {
    // TODO(atgoo@github.com) This is not a complete list.
    case SpvOpNop:
    case SpvOpName:
    case SpvOpUndef:
    case SpvOpSizeOf:
    case SpvOpLine:
    case SpvOpNoLine:
    case SpvOpDecorationGroup:
    case SpvOpExtension:
    case SpvOpExtInstImport:
    case SpvOpMemoryModel:
    case SpvOpCapability:
    case SpvOpTypeVoid:
    case SpvOpTypeBool:
    case SpvOpTypeInt:
    case SpvOpTypeFloat:
    case SpvOpTypeVector:
    case SpvOpTypeMatrix:
    case SpvOpTypeSampler:
    case SpvOpTypeSampledImage:
    case SpvOpTypeArray:
    case SpvOpTypePointer:
    case SpvOpConstantTrue:
    case SpvOpConstantFalse:
    case SpvOpLabel:
    case SpvOpBranch:
    case SpvOpFunction:
    case SpvOpFunctionParameter:
    case SpvOpFunctionEnd:
    case SpvOpBitcast:
    case SpvOpCopyObject:
    case SpvOpTranspose:
    case SpvOpSNegate:
    case SpvOpFNegate:
    case SpvOpIAdd:
    case SpvOpFAdd:
    case SpvOpISub:
    case SpvOpFSub:
    case SpvOpIMul:
    case SpvOpFMul:
    case SpvOpUDiv:
    case SpvOpSDiv:
    case SpvOpFDiv:
    case SpvOpUMod:
    case SpvOpSRem:
    case SpvOpSMod:
    case SpvOpFRem:
    case SpvOpFMod:
    case SpvOpVectorTimesScalar:
    case SpvOpMatrixTimesScalar:
    case SpvOpVectorTimesMatrix:
    case SpvOpMatrixTimesVector:
    case SpvOpMatrixTimesMatrix:
    case SpvOpOuterProduct:
    case SpvOpDot:
      return true;
    default:
      break;
  }
  return false;
}

size_t GetNumBitsToNextByte(size_t bit_pos) {
  return (8 - (bit_pos % 8)) % 8;
}

bool ShouldByteBreak(size_t bit_pos) {
  const size_t num_bits_to_next_byte = GetNumBitsToNextByte(bit_pos);
  return num_bits_to_next_byte > 0; // && num_bits_to_next_byte <= 2;
}

// Defines and returns current MARK-V version.
uint32_t GetMarkvVersion() {
  const uint32_t kVersionMajor = 1;
  const uint32_t kVersionMinor = 0;
  return kVersionMinor | (kVersionMajor << 16);
}

class CommentLogger {
 public:
  void AppendText(const std::string& str) {
    Append(str);
    use_delimiter_ = false;
  }

  void AppendTextNewLine(const std::string& str) {
    Append(str);
    Append("\n");
    use_delimiter_ = false;
  }

  void AppendBitSequence(const std::string& str) {
    if (use_delimiter_)
      Append("-");
    Append(str);
    use_delimiter_ = true;
  }

  void AppendWhitespaces(size_t num) {
    Append(std::string(num, ' '));
    use_delimiter_ = false;
  }

  void NewLine() {
    Append("\n");
    use_delimiter_ = false;
  }

  std::string GetText() const {
    return ss_.str();
  }

 private:
  void Append(const std::string& str) {
    ss_ << str;
    // std::cerr << str;
  }

  std::stringstream ss_;

  // If true a delimiter will be appended before the next bit sequence.
  // Used to generate outputs like: 1100-0 1110-1-1100-1-1111-0 110-0.
  bool use_delimiter_ = false;
};

// Creates spv_text object containing text from |str|.
// The returned value is owned by the caller and needs to be destroyed with
// spvTextDestroy.
spv_text CreateSpvText(const std::string& str) {
  spv_text out = new spv_text_t();
  assert(out);
  char* cstr = new char[str.length() + 1];
  assert(cstr);
  std::strncpy(cstr, str.c_str(), str.length());
  cstr[str.length()] = '\0';
  out->str = cstr;
  out->length = str.length();
  return out;
}

// Base class for MARK-V encoder and decoder. Contains common functionality
// such as:
// - Validator connection and validation state.
// - SPIR-V grammar and helper functions.
class MarkvCodecBase {
 public:
  virtual ~MarkvCodecBase() {
    spvValidatorOptionsDestroy(validator_options_);
  }

  MarkvCodecBase() = delete;

  void SetModel(const MarkvModel* model) {
    model_ = model;
  }

 protected:
  struct MarkvHeader {
    MarkvHeader() {
      magic_number = kMarkvMagicNumber;
      markv_version = GetMarkvVersion();
      markv_model = 0;
      markv_length_in_bits = 0;
      spirv_version = 0;
      spirv_generator = 0;
    }

    uint32_t magic_number;
    uint32_t markv_version;
    // Magic number to identify or verify MarkvModel used for encoding.
    uint32_t markv_model;
    uint32_t markv_length_in_bits;
    uint32_t spirv_version;
    uint32_t spirv_generator;
  };

  explicit MarkvCodecBase(spv_const_context context,
                          spv_validator_options validator_options)
      : validator_options_(validator_options),
        vstate_(context, validator_options_), grammar_(context),
        model_(GetDefaultModel()) {}

  // Validates a single instruction and updates validation state of the module.
  spv_result_t UpdateValidationState(const spv_parsed_instruction_t& inst) {
    return ValidateInstructionAndUpdateValidationState(&vstate_, &inst);
  }

  // Returns the current instruction (the one last processed by the validator).
  const Instruction& GetCurrentInstruction() const {
    return vstate_.ordered_instructions().back();
  }

  spv_validator_options validator_options_;
  ValidationState_t vstate_;
  const libspirv::AssemblyGrammar grammar_;
  MarkvHeader header_;
  const MarkvModel* model_;

  // Move-to-front list of all ids.
  // TODO(atgoo@github.com) Consider a better move-to-front implementation.
  std::list<uint32_t> move_to_front_ids_;
};

// SPIR-V to MARK-V encoder. Exposes functions EncodeHeader and
// EncodeInstruction which can be used as callback by spvBinaryParse.
// Encoded binary is written to an internally maintained bitstream.
// After the last instruction is encoded, the resulting MARK-V binary can be
// acquired by calling GetMarkvBinary().
// The encoder uses SPIR-V validator to keep internal state, therefore
// SPIR-V binary needs to be able to pass validator checks.
// CreateCommentsLogger() can be used to enable the encoder to write comments
// on how encoding was done, which can later be accessed with GetComments().
class MarkvEncoder : public MarkvCodecBase {
 public:
  MarkvEncoder(spv_const_context context,
               spv_const_markv_encoder_options options)
      : MarkvCodecBase(context, GetValidatorOptions(options)),
        options_(options) {
    (void) options_;
  }

  // Writes data from SPIR-V header to MARK-V header.
  spv_result_t EncodeHeader(
      spv_endianness_t /* endian */, uint32_t /* magic */,
      uint32_t version, uint32_t generator, uint32_t id_bound,
      uint32_t /* schema */) {
    vstate_.setIdBound(id_bound);
    header_.spirv_version = version;
    header_.spirv_generator = generator;
    return SPV_SUCCESS;
  }

  // Encodes SPIR-V instruction to MARK-V and writes to bit stream.
  // Operation can fail if the instruction fails to pass the validator or if
  // the encoder stubmles on something unexpected.
  spv_result_t EncodeInstruction(const spv_parsed_instruction_t& inst);

  // Concatenates MARK-V header and the bit stream with encoded instructions
  // into a single buffer and returns it as spv_markv_binary. The returned
  // value is owned by the caller and needs to be destroyed with
  // spvMarkvBinaryDestroy().
  spv_markv_binary GetMarkvBinary() {
    header_.markv_length_in_bits =
        static_cast<uint32_t>(sizeof(header_) * 8 + writer_.GetNumBits());
    const size_t num_bytes = sizeof(header_) + writer_.GetDataSizeBytes();

    spv_markv_binary markv_binary = new spv_markv_binary_t();
    markv_binary->data = new uint8_t[num_bytes];
    markv_binary->length = num_bytes;
    assert(writer_.GetData());
    std::memcpy(markv_binary->data, &header_, sizeof(header_));
    std::memcpy(markv_binary->data + sizeof(header_),
           writer_.GetData(), writer_.GetDataSizeBytes());
    return markv_binary;
  }

  // Creates an internal logger which writes comments on the encoding process.
  // Output can later be accessed with GetComments().
  void CreateCommentsLogger() {
    logger_.reset(new CommentLogger());
    writer_.SetCallback([this](const std::string& str){
      logger_->AppendBitSequence(str);
    });
  }

  // Optionally adds disassembly to the comments.
  // Disassembly should contain all instructions in the module separated by
  // \n, and no header.
  void SetDisassembly(std::string&& disassembly) {
    disassembly_.reset(new std::stringstream(std::move(disassembly)));
  }

  // Extracts the next instruction line from the disassembly and logs it.
  void LogDisassemblyInstruction() {
    if (logger_ && disassembly_) {
      std::string line;
      std::getline(*disassembly_, line, '\n');
      logger_->AppendTextNewLine(line);
    }
  }

  // Extracts the text from the comment logger.
  std::string GetComments() const {
    if (!logger_)
      return "";
    return logger_->GetText();
  }

 private:
  // Creates and returns validator options. Return value owned by the caller.
  static spv_validator_options GetValidatorOptions(
      spv_const_markv_encoder_options) {
    return spvValidatorOptionsCreate();
  }

  // Writes a single word to bit stream. |type| determines if the word is
  // encoded and how.
  void EncodeOperandWord(spv_operand_type_t type, uint32_t word) {
    const size_t chunk_length =
        GetOperandVariableWidthChunkLength(type);
    if (chunk_length) {
      writer_.WriteVariableWidthU32(word, chunk_length);
    } else {
      writer_.WriteUnencoded(word);
    }
  }

  // Returns id index and updates move-to-front.
  // Index is uint16 as SPIR-V module is guaranteed to have no more than 65535
  // instructions.
  uint16_t GetIdIndex(uint32_t id) {
    if (all_known_ids_.count(id)) {
      uint16_t index = 0;
      for (auto it = move_to_front_ids_.begin();
           it != move_to_front_ids_.end(); ++it) {
        if (*it == id) {
          if (index != 0) {
            move_to_front_ids_.erase(it);
            move_to_front_ids_.push_front(id);
          }
          return index;
        }
        ++index;
      }
      assert(0 && "Id not found in move_to_front_ids_");
      return 0;
    } else {
      all_known_ids_.insert(id);
      move_to_front_ids_.push_front(id);
      return static_cast<uint16_t>(move_to_front_ids_.size() - 1);
    }
  }

  void AddByteBreakIfAgreed() {
    if (!ShouldByteBreak(writer_.GetNumBits()))
      return;

    if (logger_) {
      logger_->AppendWhitespaces(kCommentNumWhitespaces);
      logger_->AppendText("ByteBreak:");
    }

    writer_.WriteBits(0, GetNumBitsToNextByte(writer_.GetNumBits()));
  }

  // Encodes a literal number operand and writes it to the bit stream.
  void EncodeLiteralNumber(const Instruction& instruction,
                           const spv_parsed_operand_t& operand);

  spv_const_markv_encoder_options options_;

  // Bit stream where encoded instructions are written.
  BitWriterWord64 writer_;

  // If not nullptr, encoder will write comments.
  std::unique_ptr<CommentLogger> logger_;

  // If not nullptr, disassembled instruction lines will be written to comments.
  // Format: \n separated instruction lines, no header.
  std::unique_ptr<std::stringstream> disassembly_;

  // All ids which were previosly encountered in the module.
  std::unordered_set<uint32_t> all_known_ids_;
};

// Decodes MARK-V buffers written by MarkvEncoder.
class MarkvDecoder : public MarkvCodecBase {
 public:
  MarkvDecoder(spv_const_context context,
               const uint8_t* markv_data,
               size_t markv_size_bytes,
               spv_const_markv_decoder_options options)
      : MarkvCodecBase(context, GetValidatorOptions(options)),
        options_(options), reader_(markv_data, markv_size_bytes) {
    (void) options_;
    vstate_.setIdBound(1);
    parsed_operands_.reserve(25);
  }

  // Decodes SPIR-V from MARK-V and stores the words in |spirv_binary|.
  // Can be called only once. Fails if data of wrong format or ends prematurely,
  // of if validation fails.
  spv_result_t DecodeModule(std::vector<uint32_t>* spirv_binary);

 private:
  // Describes the format of a typed literal number.
  struct NumberType {
    spv_number_kind_t type;
    uint32_t bit_width;
  };

  // Creates and returns validator options. Return value owned by the caller.
  static spv_validator_options GetValidatorOptions(
      spv_const_markv_decoder_options) {
    return spvValidatorOptionsCreate();
  }

  // Reads a single word from bit stream. |type| determines if the word needs
  // to be decoded and how. Returns false if read fails.
  bool DecodeOperandWord(spv_operand_type_t type, uint32_t* word) {
    const size_t chunk_length = GetOperandVariableWidthChunkLength(type);
    if (chunk_length) {
      return reader_.ReadVariableWidthU32(word, chunk_length);
    } else {
      return reader_.ReadUnencoded(word);
    }
  }

  // Fetches the id from the move-to-front list and moves it to front.
  uint32_t GetIdAndMoveToFront(uint16_t index) {
    if (index >= move_to_front_ids_.size()) {
      // Issue new id.
      const uint32_t id = vstate_.getIdBound();
      move_to_front_ids_.push_front(id);
      vstate_.setIdBound(id + 1);
      return id;
    } else {
      if (index == 0)
        return move_to_front_ids_.front();

      // Iterate to index.
      auto it = move_to_front_ids_.begin();
      for (size_t i = 0; i < index; ++i)
        ++it;
      const uint32_t id = *it;
      move_to_front_ids_.erase(it);
      move_to_front_ids_.push_front(id);
      return id;
    }
  }

  // Decodes id index and fetches the id from move-to-front list.
  bool DecodeId(uint32_t* id) {
    uint16_t index = 0;
    if (!reader_.ReadVariableWidthU16(&index, model_->id_index_chunk_length()))
       return false;

    *id = GetIdAndMoveToFront(index);
    return true;
  }

  bool ReadToByteBreakIfAgreed() {
    if (!ShouldByteBreak(reader_.GetNumReadBits()))
      return true;

    uint64_t bits = 0;
    if (!reader_.ReadBits(&bits,
                          GetNumBitsToNextByte(reader_.GetNumReadBits())))
      return false;

    if (bits != 0)
      return false;

    return true;
  }

  // Reads a literal number as it is described in |operand| from the bit stream,
  // decodes and writes it to spirv_.
  spv_result_t DecodeLiteralNumber(const spv_parsed_operand_t& operand);

  // Reads instruction from bit stream, decodes and validates it.
  // Decoded instruction is valid until the next call of DecodeInstruction().
  spv_result_t DecodeInstruction(spv_parsed_instruction_t* inst);

  // Read operand from the stream decodes and validates it.
  spv_result_t DecodeOperand(size_t instruction_offset, size_t operand_offset,
                             spv_parsed_instruction_t* inst,
                             const spv_operand_type_t type,
                             spv_operand_pattern_t* expected_operands,
                             bool read_result_id);

  // Records the numeric type for an operand according to the type information
  // associated with the given non-zero type Id.  This can fail if the type Id
  // is not a type Id, or if the type Id does not reference a scalar numeric
  // type.  On success, return SPV_SUCCESS and populates the num_words,
  // number_kind, and number_bit_width fields of parsed_operand.
  spv_result_t SetNumericTypeInfoForType(spv_parsed_operand_t* parsed_operand,
                                         uint32_t type_id);

  // Records the number type for the given instruction, if that
  // instruction generates a type.  For types that aren't scalar numbers,
  // record something with number kind SPV_NUMBER_NONE.
  void RecordNumberType(const spv_parsed_instruction_t& inst);

  spv_const_markv_decoder_options options_;

  // Temporary sink where decoded SPIR-V words are written. Once it contains the
  // entire module, the container is moved and returned.
  std::vector<uint32_t> spirv_;

  // Bit stream containing encoded data.
  BitReaderWord64 reader_;

  // Temporary storage for operands of the currently parsed instruction.
  // Valid until next DecodeInstruction call.
  std::vector<spv_parsed_operand_t> parsed_operands_;

  // Maps a result ID to its type ID.  By convention:
  //  - a result ID that is a type definition maps to itself.
  //  - a result ID without a type maps to 0.  (E.g. for OpLabel)
  std::unordered_map<uint32_t, uint32_t> id_to_type_id_;
  // Maps a type ID to its number type description.
  std::unordered_map<uint32_t, NumberType> type_id_to_number_type_info_;
  // Maps an ExtInstImport id to the extended instruction type.
  std::unordered_map<uint32_t, spv_ext_inst_type_t> import_id_to_ext_inst_type_;
};

void MarkvEncoder::EncodeLiteralNumber(const Instruction& instruction,
                                       const spv_parsed_operand_t& operand) {
  if (operand.number_bit_width == 32) {
    const uint32_t word = instruction.word(operand.offset);
    if (operand.number_kind == SPV_NUMBER_UNSIGNED_INT) {
      writer_.WriteVariableWidthU32(word, model_->u32_chunk_length());
    } else if (operand.number_kind == SPV_NUMBER_SIGNED_INT) {
      int32_t val = 0;
      std::memcpy(&val, &word, 4);
      writer_.WriteVariableWidthS32(val, model_->s32_chunk_length(),
                                    model_->s32_block_exponent());
    } else if (operand.number_kind == SPV_NUMBER_FLOATING) {
      writer_.WriteUnencoded(word);
    } else {
      assert(0);
    }
  } else if (operand.number_bit_width == 16) {
    const uint16_t word =
        static_cast<uint16_t>(instruction.word(operand.offset));
    if (operand.number_kind == SPV_NUMBER_UNSIGNED_INT) {
      writer_.WriteVariableWidthU16(word, model_->u16_chunk_length());
    } else if (operand.number_kind == SPV_NUMBER_SIGNED_INT) {
      int16_t val = 0;
      std::memcpy(&val, &word, 2);
      writer_.WriteVariableWidthS16(val, model_->s16_chunk_length(),
                                    model_->s16_block_exponent());
    } else if (operand.number_kind == SPV_NUMBER_FLOATING) {
      // TODO(atgoo@github.com) Write only 16 bits.
      writer_.WriteUnencoded(word);
    } else {
      assert(0);
    }
  } else {
    assert(operand.number_bit_width == 64);
    const uint64_t word =
        uint64_t(instruction.word(operand.offset)) |
        (uint64_t(instruction.word(operand.offset + 1)) << 32);
    if (operand.number_kind == SPV_NUMBER_UNSIGNED_INT) {
      writer_.WriteVariableWidthU64(word, model_->u64_chunk_length());
    } else if (operand.number_kind == SPV_NUMBER_SIGNED_INT) {
      int64_t val = 0;
      std::memcpy(&val, &word, 8);
      writer_.WriteVariableWidthS64(val, model_->s64_chunk_length(),
                                    model_->s64_block_exponent());
    } else if (operand.number_kind == SPV_NUMBER_FLOATING) {
      writer_.WriteUnencoded(word);
    } else {
      assert(0);
    }
  }
}

spv_result_t MarkvEncoder::EncodeInstruction(
    const spv_parsed_instruction_t& inst) {
  const spv_result_t validation_result = UpdateValidationState(inst);
  if (validation_result != SPV_SUCCESS)
    return validation_result;

  bool result_id_was_forward_declared = false;
  if (all_known_ids_.count(inst.result_id)) {
    // Result id of the instruction was forward declared.
    // Write a service opcode to signal this to the decoder.
    writer_.WriteVariableWidthU32(kMarkvOpNextInstructionEncodesResultId,
                                  model_->opcode_chunk_length());
    result_id_was_forward_declared = true;
  }

  const Instruction& instruction = GetCurrentInstruction();
  const auto& operands = instruction.operands();

  LogDisassemblyInstruction();

  // Write opcode.
  writer_.WriteVariableWidthU32(inst.opcode, model_->opcode_chunk_length());

  if (!OpcodeHasFixedNumberOfOperands(SpvOp(inst.opcode))) {
    // If the opcode has a variable number of operands, encode the number of
    // operands with the instruction.

    if (logger_)
      logger_->AppendWhitespaces(kCommentNumWhitespaces);

    writer_.WriteVariableWidthU16(inst.num_operands,
                                  model_->num_operands_chunk_length());
  }

  // Write operands.
  for (const auto& operand : operands) {
    if (operand.type == SPV_OPERAND_TYPE_RESULT_ID &&
        !result_id_was_forward_declared) {
      // Register the id, but don't encode it.
      GetIdIndex(instruction.word(operand.offset));
      continue;
    }

    if (logger_)
      logger_->AppendWhitespaces(kCommentNumWhitespaces);

    if (operand.type == SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER) {
      EncodeLiteralNumber(instruction, operand);
    } else if (operand.type == SPV_OPERAND_TYPE_LITERAL_STRING) {
      const char* src =
          reinterpret_cast<const char*>(&instruction.words()[operand.offset]);
      const size_t length = spv_strnlen_s(src, operand.num_words * 4);
      if (length == operand.num_words * 4)
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to find terminal character of literal string";
      for (size_t i = 0; i < length + 1; ++i)
        writer_.WriteUnencoded(src[i]);
    } else if (spvIsIdType(operand.type)) {
      const uint16_t id_index = GetIdIndex(instruction.word(operand.offset));
      writer_.WriteVariableWidthU16(id_index, model_->id_index_chunk_length());
    } else {
      for (int i = 0; i < operand.num_words; ++i) {
        const uint32_t word = instruction.word(operand.offset + i);
        EncodeOperandWord(operand.type, word);
      }
    }
  }

  AddByteBreakIfAgreed();

  if (logger_) {
    logger_->NewLine();
    logger_->NewLine();
  }

  return SPV_SUCCESS;
}

spv_result_t MarkvDecoder::DecodeLiteralNumber(
    const spv_parsed_operand_t& operand) {
  if (operand.number_bit_width == 32) {
    uint32_t word = 0;
    if (operand.number_kind == SPV_NUMBER_UNSIGNED_INT) {
      if (!reader_.ReadVariableWidthU32(&word, model_->u32_chunk_length()))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to read literal U32";
    } else if (operand.number_kind == SPV_NUMBER_SIGNED_INT) {
      int32_t val = 0;
      if (!reader_.ReadVariableWidthS32(&val, model_->s32_chunk_length(),
                                        model_->s32_block_exponent()))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to read literal S32";
      std::memcpy(&word, &val, 4);
    } else if (operand.number_kind == SPV_NUMBER_FLOATING) {
      if (!reader_.ReadUnencoded(&word))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to read literal F32";
    } else {
      assert(0);
    }
    spirv_.push_back(word);
  } else if (operand.number_bit_width == 16) {
    uint32_t word = 0;
    if (operand.number_kind == SPV_NUMBER_UNSIGNED_INT) {
      uint16_t val = 0;
      if (!reader_.ReadVariableWidthU16(&val, model_->u16_chunk_length()))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to read literal U16";
      word = val;
    } else if (operand.number_kind == SPV_NUMBER_SIGNED_INT) {
      int16_t val = 0;
      if (!reader_.ReadVariableWidthS16(&val, model_->s16_chunk_length(),
                                        model_->s16_block_exponent()))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to read literal S16";
      // Int16 is stored as int32 in SPIR-V, not as bits.
      int32_t val32 = val;
      std::memcpy(&word, &val32, 4);
    } else if (operand.number_kind == SPV_NUMBER_FLOATING) {
      uint16_t word16 = 0;
      if (!reader_.ReadUnencoded(&word16))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to read literal F16";
      word = word16;
    } else {
      assert(0);
    }
    spirv_.push_back(word);
  } else {
    assert(operand.number_bit_width == 64);
    uint64_t word = 0;
    if (operand.number_kind == SPV_NUMBER_UNSIGNED_INT) {
      if (!reader_.ReadVariableWidthU64(&word, model_->u64_chunk_length()))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to read literal U64";
    } else if (operand.number_kind == SPV_NUMBER_SIGNED_INT) {
      int64_t val = 0;
      if (!reader_.ReadVariableWidthS64(&val, model_->s64_chunk_length(),
                                        model_->s64_block_exponent()))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to read literal S64";
      std::memcpy(&word, &val, 8);
    } else if (operand.number_kind == SPV_NUMBER_FLOATING) {
      if (!reader_.ReadUnencoded(&word))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to read literal F64";
    } else {
      assert(0);
    }
    spirv_.push_back(static_cast<uint32_t>(word));
    spirv_.push_back(static_cast<uint32_t>(word >> 32));
  }
  return SPV_SUCCESS;
}

spv_result_t MarkvDecoder::DecodeModule(std::vector<uint32_t>* spirv_binary) {
  const bool header_read_success =
      reader_.ReadUnencoded(&header_.magic_number) &&
      reader_.ReadUnencoded(&header_.markv_version) &&
      reader_.ReadUnencoded(&header_.markv_model) &&
      reader_.ReadUnencoded(&header_.markv_length_in_bits) &&
      reader_.ReadUnencoded(&header_.spirv_version) &&
      reader_.ReadUnencoded(&header_.spirv_generator);

  if (!header_read_success)
    return vstate_.diag(SPV_ERROR_INVALID_BINARY)
        << "Unable to read MARK-V header";

  assert(header_.magic_number == kMarkvMagicNumber);
  assert(header_.markv_length_in_bits > 0);

  if (header_.magic_number != kMarkvMagicNumber)
    return vstate_.diag(SPV_ERROR_INVALID_BINARY)
        << "MARK-V binary has incorrect magic number";

  // TODO(atgoo@github.com): Print version strings.
  if (header_.markv_version != GetMarkvVersion())
    return vstate_.diag(SPV_ERROR_INVALID_BINARY)
        << "MARK-V binary and the codec have different versions";

  spirv_.reserve(header_.markv_length_in_bits / 2); // Heuristic.
  spirv_.resize(5, 0);
  spirv_[0] = kSpirvMagicNumber;
  spirv_[1] = header_.spirv_version;
  spirv_[2] = header_.spirv_generator;

  while (reader_.GetNumReadBits() < header_.markv_length_in_bits) {
    spv_parsed_instruction_t inst = {};
    const spv_result_t decode_result = DecodeInstruction(&inst);
    if (decode_result != SPV_SUCCESS)
      return decode_result;

    const spv_result_t validation_result = UpdateValidationState(inst);
    if (validation_result != SPV_SUCCESS)
      return validation_result;
  }


  if (reader_.GetNumReadBits() != header_.markv_length_in_bits ||
      !reader_.OnlyZeroesLeft()) {
    return vstate_.diag(SPV_ERROR_INVALID_BINARY)
        << "MARK-V binary has wrong stated bit length "
        << reader_.GetNumReadBits() << " " << header_.markv_length_in_bits;
  }

  // Decoding of the module is finished, validation state should have correct
  // id bound.
  spirv_[3] = vstate_.getIdBound();

  *spirv_binary = std::move(spirv_);
  return SPV_SUCCESS;
}

// TODO(atgoo@github.com): The implementation borrows heavily from
// Parser::parseOperand.
// Consider coupling them together in some way once MARK-V codec is more mature.
// For now it's better to keep the code independent for experimentation
// purposes.
spv_result_t MarkvDecoder::DecodeOperand(
    size_t instruction_offset, size_t operand_offset,
    spv_parsed_instruction_t* inst, const spv_operand_type_t type,
    spv_operand_pattern_t* expected_operands,
    bool read_result_id) {
  const SpvOp opcode = static_cast<SpvOp>(inst->opcode);

  spv_parsed_operand_t parsed_operand;
  memset(&parsed_operand, 0, sizeof(parsed_operand));

  assert((operand_offset >> 16) == 0);
  parsed_operand.offset = static_cast<uint16_t>(operand_offset);
  parsed_operand.type = type;

  // Set default values, may be updated later.
  parsed_operand.number_kind = SPV_NUMBER_NONE;
  parsed_operand.number_bit_width = 0;

  const size_t first_word_index = spirv_.size();

  switch (type) {
    case SPV_OPERAND_TYPE_TYPE_ID: {
      if (!DecodeId(&inst->type_id)) {
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to read type_id";
      }

      if (inst->type_id == 0)
        return vstate_.diag(SPV_ERROR_INVALID_BINARY) << "Decoded type_id is 0";

      spirv_.push_back(inst->type_id);
      vstate_.setIdBound(std::max(vstate_.getIdBound(), inst->type_id + 1));
      break;
    }

    case SPV_OPERAND_TYPE_RESULT_ID: {
      if (read_result_id) {
        if (!DecodeId(&inst->result_id))
          return vstate_.diag(SPV_ERROR_INVALID_BINARY)
              << "Failed to read result_id";
      } else {
        inst->result_id = vstate_.getIdBound();
        vstate_.setIdBound(inst->result_id + 1);
        move_to_front_ids_.push_front(inst->result_id);
      }

      spirv_.push_back(inst->result_id);

      // Save the result ID to type ID mapping.
      // In the grammar, type ID always appears before result ID.
      // A regular value maps to its type. Some instructions (e.g. OpLabel)
      // have no type Id, and will map to 0. The result Id for a
      // type-generating instruction (e.g. OpTypeInt) maps to itself.
      auto insertion_result = id_to_type_id_.emplace(
          inst->result_id,
          spvOpcodeGeneratesType(opcode) ? inst->result_id : inst->type_id);
      if(!insertion_result.second) {
        return vstate_.diag(SPV_ERROR_INVALID_ID)
            << "Unexpected behavior: id->type_id pair was already registered";
      }
      break;
    }

    case SPV_OPERAND_TYPE_ID:
    case SPV_OPERAND_TYPE_OPTIONAL_ID:
    case SPV_OPERAND_TYPE_SCOPE_ID:
    case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: {
      uint32_t id = 0;
      if (!DecodeId(&id))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY) << "Failed to read id";

      if (id == 0)
        return vstate_.diag(SPV_ERROR_INVALID_BINARY) << "Decoded id is 0";

      spirv_.push_back(id);
      vstate_.setIdBound(std::max(vstate_.getIdBound(), id + 1));

      if (type == SPV_OPERAND_TYPE_ID || type == SPV_OPERAND_TYPE_OPTIONAL_ID) {

        parsed_operand.type = SPV_OPERAND_TYPE_ID;

        if (opcode == SpvOpExtInst && parsed_operand.offset == 3) {
          // The current word is the extended instruction set id.
          // Set the extended instruction set type for the current instruction.
          auto ext_inst_type_iter = import_id_to_ext_inst_type_.find(id);
          if (ext_inst_type_iter == import_id_to_ext_inst_type_.end()) {
            return vstate_.diag(SPV_ERROR_INVALID_ID)
                << "OpExtInst set id " << id
                << " does not reference an OpExtInstImport result Id";
          }
          inst->ext_inst_type = ext_inst_type_iter->second;
        }
      }
      break;
    }

    case SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER: {
      uint32_t word = 0;
      if (!DecodeOperandWord(type, &word))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to read enum";

      spirv_.push_back(word);

      assert(SpvOpExtInst == opcode);
      assert(inst->ext_inst_type != SPV_EXT_INST_TYPE_NONE);
      spv_ext_inst_desc ext_inst;
      if (grammar_.lookupExtInst(inst->ext_inst_type, word, &ext_inst))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Invalid extended instruction number: " << word;
      spvPushOperandTypes(ext_inst->operandTypes, expected_operands);
      break;
    }

    case SPV_OPERAND_TYPE_LITERAL_INTEGER:
    case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER: {
      // These are regular single-word literal integer operands.
      // Post-parsing validation should check the range of the parsed value.
      parsed_operand.type = SPV_OPERAND_TYPE_LITERAL_INTEGER;
      // It turns out they are always unsigned integers!
      parsed_operand.number_kind = SPV_NUMBER_UNSIGNED_INT;
      parsed_operand.number_bit_width = 32;

      uint32_t word = 0;
      if (!DecodeOperandWord(type, &word))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to read literal integer";

      spirv_.push_back(word);
      break;
    }

    case SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER:
    case SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER:
      parsed_operand.type = SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER;
      if (opcode == SpvOpSwitch) {
        // The literal operands have the same type as the value
        // referenced by the selector Id.
        const uint32_t selector_id = spirv_.at(instruction_offset + 1);
        const auto type_id_iter = id_to_type_id_.find(selector_id);
        if (type_id_iter == id_to_type_id_.end() ||
            type_id_iter->second == 0) {
          return vstate_.diag(SPV_ERROR_INVALID_BINARY)
              << "Invalid OpSwitch: selector id " << selector_id
              << " has no type";
        }
        uint32_t type_id = type_id_iter->second;

        if (selector_id == type_id) {
          // Recall that by convention, a result ID that is a type definition
          // maps to itself.
          return vstate_.diag(SPV_ERROR_INVALID_BINARY)
              << "Invalid OpSwitch: selector id " << selector_id
              << " is a type, not a value";
        }
        if (auto error = SetNumericTypeInfoForType(&parsed_operand, type_id))
          return error;
        if (parsed_operand.number_kind != SPV_NUMBER_UNSIGNED_INT &&
            parsed_operand.number_kind != SPV_NUMBER_SIGNED_INT) {
          return vstate_.diag(SPV_ERROR_INVALID_BINARY)
              << "Invalid OpSwitch: selector id " << selector_id
              << " is not a scalar integer";
        }
      } else {
        assert(opcode == SpvOpConstant || opcode == SpvOpSpecConstant);
        // The literal number type is determined by the type Id for the
        // constant.
        assert(inst->type_id);
        if (auto error =
            SetNumericTypeInfoForType(&parsed_operand, inst->type_id))
          return error;
      }

      if (auto error = DecodeLiteralNumber(parsed_operand))
        return error;

      break;

    case SPV_OPERAND_TYPE_LITERAL_STRING:
    case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_STRING: {
      parsed_operand.type = SPV_OPERAND_TYPE_LITERAL_STRING;
      std::vector<char> str;
      // The loop is expected to terminate once we encounter '\0' or exhaust
      // the bit stream.
      while (true) {
        char ch = 0;
        if (!reader_.ReadUnencoded(&ch))
          return vstate_.diag(SPV_ERROR_INVALID_BINARY)
              << "Failed to read literal string";

        str.push_back(ch);

        if (ch == '\0')
          break;
      }

      while (str.size() % 4 != 0)
        str.push_back('\0');

      spirv_.resize(spirv_.size() + str.size() / 4);
      std::memcpy(&spirv_[first_word_index], str.data(), str.size());

      if (SpvOpExtInstImport == opcode) {
        // Record the extended instruction type for the ID for this import.
        // There is only one string literal argument to OpExtInstImport,
        // so it's sufficient to guard this just on the opcode.
        const spv_ext_inst_type_t ext_inst_type =
            spvExtInstImportTypeGet(str.data());
        if (SPV_EXT_INST_TYPE_NONE == ext_inst_type) {
          return vstate_.diag(SPV_ERROR_INVALID_BINARY)
              << "Invalid extended instruction import '" << str.data() << "'";
        }
        // We must have parsed a valid result ID.  It's a condition
        // of the grammar, and we only accept non-zero result Ids.
        assert(inst->result_id);
        const bool inserted = import_id_to_ext_inst_type_.emplace(
            inst->result_id, ext_inst_type).second;
        (void)inserted;
        assert(inserted);
      }
      break;
    }

    case SPV_OPERAND_TYPE_CAPABILITY:
    case SPV_OPERAND_TYPE_SOURCE_LANGUAGE:
    case SPV_OPERAND_TYPE_EXECUTION_MODEL:
    case SPV_OPERAND_TYPE_ADDRESSING_MODEL:
    case SPV_OPERAND_TYPE_MEMORY_MODEL:
    case SPV_OPERAND_TYPE_EXECUTION_MODE:
    case SPV_OPERAND_TYPE_STORAGE_CLASS:
    case SPV_OPERAND_TYPE_DIMENSIONALITY:
    case SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE:
    case SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE:
    case SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT:
    case SPV_OPERAND_TYPE_FP_ROUNDING_MODE:
    case SPV_OPERAND_TYPE_LINKAGE_TYPE:
    case SPV_OPERAND_TYPE_ACCESS_QUALIFIER:
    case SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER:
    case SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE:
    case SPV_OPERAND_TYPE_DECORATION:
    case SPV_OPERAND_TYPE_BUILT_IN:
    case SPV_OPERAND_TYPE_GROUP_OPERATION:
    case SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS:
    case SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO: {
      // A single word that is a plain enum value.
      uint32_t word = 0;
      if (!DecodeOperandWord(type, &word))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to read enum";

      spirv_.push_back(word);

      // Map an optional operand type to its corresponding concrete type.
      if (type == SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER)
        parsed_operand.type = SPV_OPERAND_TYPE_ACCESS_QUALIFIER;

      spv_operand_desc entry;
      if (grammar_.lookupOperand(type, word, &entry)) {
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Invalid "
            << spvOperandTypeStr(parsed_operand.type)
            << " operand: " << word;
      }

      // Prepare to accept operands to this operand, if needed.
      spvPushOperandTypes(entry->operandTypes, expected_operands);
      break;
    }

    case SPV_OPERAND_TYPE_FP_FAST_MATH_MODE:
    case SPV_OPERAND_TYPE_FUNCTION_CONTROL:
    case SPV_OPERAND_TYPE_LOOP_CONTROL:
    case SPV_OPERAND_TYPE_IMAGE:
    case SPV_OPERAND_TYPE_OPTIONAL_IMAGE:
    case SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS:
    case SPV_OPERAND_TYPE_SELECTION_CONTROL: {
      // This operand is a mask.
      uint32_t word = 0;
      if (!DecodeOperandWord(type, &word))
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Failed to read " << spvOperandTypeStr(type)
            << " for " << spvOpcodeString(SpvOp(inst->opcode));

      spirv_.push_back(word);

      // Map an optional operand type to its corresponding concrete type.
      if (type == SPV_OPERAND_TYPE_OPTIONAL_IMAGE)
        parsed_operand.type = SPV_OPERAND_TYPE_IMAGE;
      else if (type == SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS)
        parsed_operand.type = SPV_OPERAND_TYPE_MEMORY_ACCESS;

      // Check validity of set mask bits. Also prepare for operands for those
      // masks if they have any.  To get operand order correct, scan from
      // MSB to LSB since we can only prepend operands to a pattern.
      // The only case in the grammar where you have more than one mask bit
      // having an operand is for image operands.  See SPIR-V 3.14 Image
      // Operands.
      uint32_t remaining_word = word;
      for (uint32_t mask = (1u << 31); remaining_word; mask >>= 1) {
        if (remaining_word & mask) {
          spv_operand_desc entry;
          if (grammar_.lookupOperand(type, mask, &entry)) {
            return vstate_.diag(SPV_ERROR_INVALID_BINARY)
                   << "Invalid " << spvOperandTypeStr(parsed_operand.type)
                   << " operand: " << word << " has invalid mask component "
                   << mask;
          }
          remaining_word ^= mask;
          spvPushOperandTypes(entry->operandTypes, expected_operands);
        }
      }
      if (word == 0) {
        // An all-zeroes mask *might* also be valid.
        spv_operand_desc entry;
        if (SPV_SUCCESS == grammar_.lookupOperand(type, 0, &entry)) {
          // Prepare for its operands, if any.
          spvPushOperandTypes(entry->operandTypes, expected_operands);
        }
      }
      break;
    }
    default:
      return vstate_.diag(SPV_ERROR_INVALID_BINARY)
          << "Internal error: Unhandled operand type: " << type;
  }

  parsed_operand.num_words = uint16_t(spirv_.size() - first_word_index);

  assert(int(SPV_OPERAND_TYPE_FIRST_CONCRETE_TYPE) <= int(parsed_operand.type));
  assert(int(SPV_OPERAND_TYPE_LAST_CONCRETE_TYPE) >= int(parsed_operand.type));

  parsed_operands_.push_back(parsed_operand);

  return SPV_SUCCESS;
}

spv_result_t MarkvDecoder::DecodeInstruction(spv_parsed_instruction_t* inst) {
  parsed_operands_.clear();
  const size_t instruction_offset = spirv_.size();

  bool read_result_id = false;

  while (true) {
    uint32_t word = 0;
    if (!reader_.ReadVariableWidthU32(&word,
                                      model_->opcode_chunk_length())) {
      return vstate_.diag(SPV_ERROR_INVALID_BINARY)
          << "Failed to read opcode of instruction";
    }

    if (word >= kMarkvFirstOpcode) {
      if (word == kMarkvOpNextInstructionEncodesResultId) {
        read_result_id = true;
      } else {
        return vstate_.diag(SPV_ERROR_INVALID_BINARY)
            << "Encountered unknown MARK-V opcode";
      }
    } else {
      inst->opcode = static_cast<uint16_t>(word);
      break;
    }
  }

  const SpvOp opcode = static_cast<SpvOp>(inst->opcode);

  // Opcode/num_words placeholder, the word will be filled in later.
  spirv_.push_back(0);

  spv_opcode_desc opcode_desc;
  if (grammar_.lookupOpcode(opcode, &opcode_desc)
      != SPV_SUCCESS) {
    return vstate_.diag(SPV_ERROR_INVALID_BINARY) << "Invalid opcode";
  }

  spv_operand_pattern_t expected_operands;
  expected_operands.reserve(opcode_desc->numTypes);
  for (auto i = 0; i < opcode_desc->numTypes; i++)
    expected_operands.push_back(opcode_desc->operandTypes[opcode_desc->numTypes - i - 1]);

  if (!OpcodeHasFixedNumberOfOperands(opcode)) {
    if (!reader_.ReadVariableWidthU16(&inst->num_operands,
                                      model_->num_operands_chunk_length()))
      return vstate_.diag(SPV_ERROR_INVALID_BINARY)
          << "Failed to read num_operands of instruction";
  } else {
    inst->num_operands = static_cast<uint16_t>(expected_operands.size());
  }

  for (size_t operand_index = 0;
       operand_index < static_cast<size_t>(inst->num_operands);
       ++operand_index) {
    assert(!expected_operands.empty());
    const spv_operand_type_t type =
        spvTakeFirstMatchableOperand(&expected_operands);

    const size_t operand_offset = spirv_.size() - instruction_offset;

    const spv_result_t decode_result =
        DecodeOperand(instruction_offset, operand_offset, inst, type,
                      &expected_operands, read_result_id);

    if (decode_result != SPV_SUCCESS)
      return decode_result;
  }

  assert(inst->num_operands == parsed_operands_.size());

  // Only valid while spirv_ and parsed_operands_ remain unchanged.
  inst->words = &spirv_[instruction_offset];
  inst->operands = parsed_operands_.empty() ? nullptr : parsed_operands_.data();
  inst->num_words = static_cast<uint16_t>(spirv_.size() - instruction_offset);
  spirv_[instruction_offset] =
      spvOpcodeMake(inst->num_words, SpvOp(inst->opcode));

  assert(inst->num_words == std::accumulate(
      parsed_operands_.begin(), parsed_operands_.end(), 1,
      [](int num_words, const spv_parsed_operand_t& operand) {
        return num_words += operand.num_words;
  }) && "num_words in instruction doesn't correspond to the sum of num_words"
        "in the operands");

  RecordNumberType(*inst);

  if (!ReadToByteBreakIfAgreed())
    return vstate_.diag(SPV_ERROR_INVALID_BINARY)
        << "Failed to read to byte break";

  return SPV_SUCCESS;
}

spv_result_t MarkvDecoder::SetNumericTypeInfoForType(
    spv_parsed_operand_t* parsed_operand, uint32_t type_id) {
  assert(type_id != 0);
  auto type_info_iter = type_id_to_number_type_info_.find(type_id);
  if (type_info_iter == type_id_to_number_type_info_.end()) {
    return vstate_.diag(SPV_ERROR_INVALID_BINARY)
        << "Type Id " << type_id << " is not a type";
  }

  const NumberType& info = type_info_iter->second;
  if (info.type == SPV_NUMBER_NONE) {
    // This is a valid type, but for something other than a scalar number.
    return vstate_.diag(SPV_ERROR_INVALID_BINARY)
        << "Type Id " << type_id << " is not a scalar numeric type";
  }

  parsed_operand->number_kind = info.type;
  parsed_operand->number_bit_width = info.bit_width;
  // Round up the word count.
  parsed_operand->num_words = static_cast<uint16_t>((info.bit_width + 31) / 32);
  return SPV_SUCCESS;
}

void MarkvDecoder::RecordNumberType(const spv_parsed_instruction_t& inst) {
  const SpvOp opcode = static_cast<SpvOp>(inst.opcode);
  if (spvOpcodeGeneratesType(opcode)) {
    NumberType info = {SPV_NUMBER_NONE, 0};
    if (SpvOpTypeInt == opcode) {
      info.bit_width = inst.words[inst.operands[1].offset];
      info.type = inst.words[inst.operands[2].offset] ?
          SPV_NUMBER_SIGNED_INT : SPV_NUMBER_UNSIGNED_INT;
    } else if (SpvOpTypeFloat == opcode) {
      info.bit_width = inst.words[inst.operands[1].offset];
      info.type = SPV_NUMBER_FLOATING;
    }
    // The *result* Id of a type generating instruction is the type Id.
    type_id_to_number_type_info_[inst.result_id] = info;
  }
}

spv_result_t EncodeHeader(
    void* user_data, spv_endianness_t endian, uint32_t magic,
    uint32_t version, uint32_t generator, uint32_t id_bound,
    uint32_t schema) {
  MarkvEncoder* encoder = reinterpret_cast<MarkvEncoder*>(user_data);
  return encoder->EncodeHeader(
      endian, magic, version, generator, id_bound, schema);
}

spv_result_t EncodeInstruction(
    void* user_data, const spv_parsed_instruction_t* inst) {
  MarkvEncoder* encoder = reinterpret_cast<MarkvEncoder*>(user_data);
  return encoder->EncodeInstruction(*inst);
}

}  // namespace

spv_result_t spvSpirvToMarkv(spv_const_context context,
                             const uint32_t* spirv_words,
                             const size_t spirv_num_words,
                             spv_const_markv_encoder_options options,
                             spv_markv_binary* markv_binary,
                             spv_text* comments, spv_diagnostic* diagnostic) {
  spv_context_t hijack_context = *context;
  if (diagnostic) {
    *diagnostic = nullptr;
    libspirv::UseDiagnosticAsMessageConsumer(&hijack_context, diagnostic);
  }

  spv_const_binary_t spirv_binary = {spirv_words, spirv_num_words};

  spv_endianness_t endian;
  spv_position_t position = {};
  if (spvBinaryEndianness(&spirv_binary, &endian)) {
    return libspirv::DiagnosticStream(position, hijack_context.consumer,
                                      SPV_ERROR_INVALID_BINARY)
        << "Invalid SPIR-V magic number.";
  }

  spv_header_t header;
  if (spvBinaryHeaderGet(&spirv_binary, endian, &header)) {
    return libspirv::DiagnosticStream(position, hijack_context.consumer,
                                      SPV_ERROR_INVALID_BINARY)
        << "Invalid SPIR-V header.";
  }

  MarkvEncoder encoder(&hijack_context, options);

  if (comments) {
    encoder.CreateCommentsLogger();

    spv_text text = nullptr;
    if (spvBinaryToText(&hijack_context, spirv_words, spirv_num_words,
                        SPV_BINARY_TO_TEXT_OPTION_NO_HEADER, &text, nullptr)
        != SPV_SUCCESS) {
      return libspirv::DiagnosticStream(position, hijack_context.consumer,
                                        SPV_ERROR_INVALID_BINARY)
          << "Failed to disassemble SPIR-V binary.";
    }
    assert(text);
    encoder.SetDisassembly(std::string(text->str, text->length));
    spvTextDestroy(text);
  }

  if (spvBinaryParse(
      &hijack_context, &encoder, spirv_words, spirv_num_words, EncodeHeader,
      EncodeInstruction, diagnostic) != SPV_SUCCESS) {
    return libspirv::DiagnosticStream(position, hijack_context.consumer,
                                      SPV_ERROR_INVALID_BINARY)
        << "Unable to encode to MARK-V.";
  }

  if (comments)
    *comments = CreateSpvText(encoder.GetComments());

  *markv_binary = encoder.GetMarkvBinary();
  return SPV_SUCCESS;
}

spv_result_t spvMarkvToSpirv(spv_const_context context,
                             const uint8_t* markv_data,
                             size_t markv_size_bytes,
                             spv_const_markv_decoder_options options,
                             spv_binary* spirv_binary,
                             spv_text* /* comments */, spv_diagnostic* diagnostic) {
  spv_position_t position = {};
  spv_context_t hijack_context = *context;
  if (diagnostic) {
    *diagnostic = nullptr;
    libspirv::UseDiagnosticAsMessageConsumer(&hijack_context, diagnostic);
  }

  MarkvDecoder decoder(&hijack_context, markv_data, markv_size_bytes, options);

  std::vector<uint32_t> words;

  if (decoder.DecodeModule(&words) != SPV_SUCCESS) {
    return libspirv::DiagnosticStream(position, hijack_context.consumer,
                                      SPV_ERROR_INVALID_BINARY)
        << "Unable to decode MARK-V.";
  }

  assert(!words.empty());

  *spirv_binary = new spv_binary_t();
  (*spirv_binary)->code = new uint32_t[words.size()];
  (*spirv_binary)->wordCount = words.size();
  std::memcpy((*spirv_binary)->code, words.data(), 4 * words.size());

  return SPV_SUCCESS;
}

void spvMarkvBinaryDestroy(spv_markv_binary binary) {
  if (!binary) return;
  delete[] binary->data;
  delete binary;
}

spv_markv_encoder_options spvMarkvEncoderOptionsCreate() {
  return new spv_markv_encoder_options_t;
}

void spvMarkvEncoderOptionsDestroy(spv_markv_encoder_options options) {
  delete options;
}

spv_markv_decoder_options spvMarkvDecoderOptionsCreate() {
  return new spv_markv_decoder_options_t;
}

void spvMarkvDecoderOptionsDestroy(spv_markv_decoder_options options) {
  delete options;
}