Method parseInstruction

source/binary.cpp:310–468

}

spv_result_t Parser::parseInstruction() {
  _.instruction_count++;

  // The zero values for all members except for opcode are the
  // correct initial values.
  spv_parsed_instruction_t inst = {};

  const uint32_t first_word = peek();

  // If the module's endianness is different from the host native endianness,
  // then converted_words contains the endian-translated words in the
  // instruction.
  _.endian_converted_words.clear();
  _.endian_converted_words.push_back(first_word);

  // After a successful parse of the instruction, the inst.operands member
  // will point to this vector's storage.
  _.operands.clear();

  assert(_.word_index < _.num_words);
  // Decompose and check the first word.
  uint16_t inst_word_count = 0;
  spvOpcodeSplit(first_word, &inst_word_count, &inst.opcode);
  if (inst_word_count < 1) {
    return diagnostic() << "Invalid instruction word count: "
                        << inst_word_count;
  }
  const spvtools::InstructionDesc* opcode_desc = nullptr;
  const bool opcode_known =
      spvtools::LookupOpcode(static_cast<spv::Op>(inst.opcode), &opcode_desc) ==
      SPV_SUCCESS;
  if (!opcode_known && !handle_unknown_opcodes_)
    return diagnostic() << "Invalid opcode: " << inst.opcode;

  // Advance past the opcode word.  But remember the start of the instruction.
  const size_t inst_offset = _.word_index;
  _.word_index++;

  // Emits the instruction at inst_offset as raw data with no decoded operands.
  auto emitAsUnknown = [&]() -> spv_result_t {
    if (inst_offset + inst_word_count > _.num_words) {
      return diagnostic() << "Truncated binary: instruction at word "
                          << inst_offset << " claims " << inst_word_count
                          << " words but binary ends at " << _.num_words;
    }
    // Repopulate endian_converted_words from scratch.  The operand loop may
    // have partially filled it before the unknown enum was detected.
    _.endian_converted_words.clear();
    _.endian_converted_words.push_back(first_word);
    if (_.requires_endian_conversion) {
      for (uint16_t i = 1; i < inst_word_count; i++) {
        _.endian_converted_words.push_back(peekAt(inst_offset + i));
      }
    }
    _.word_index = inst_offset + inst_word_count;
    inst.words = _.requires_endian_conversion ? _.endian_converted_words.data()
                                              : _.words + inst_offset;
    inst.num_words = inst_word_count;