third_party/SPIRV-Tools/tools/comp/markv.cpp - SwiftShader - Git at Google

 // 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.

 #include <algorithm>
 #include <cassert>
 #include <cstdio>
 #include <cstring>
 #include <functional>
 #include <iostream>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>

 #include "source/comp/markv.h"
 #include "source/spirv_target_env.h"
 #include "source/table.h"
 #include "spirv-tools/optimizer.hpp"
 #include "tools/comp/markv_model_factory.h"
 #include "tools/io.h"

 namespace {

 const auto kSpvEnv = SPV_ENV_UNIVERSAL_1_2;

 enum Task {
   kNoTask = 0,
   kEncode,
   kDecode,
   kTest,
 };

 struct ScopedContext {
   ScopedContext(spv_target_env env) : context(spvContextCreate(env)) {}
   ~ScopedContext() { spvContextDestroy(context); }
   spv_context context;
 };

 void print_usage(char* argv0) {
   printf(
       R"(%s - Encodes or decodes a SPIR-V binary to or from a MARK-V binary.

 USAGE: %s [e|d|t] [options] [<filename>]

 The input binary is read from <filename>. If no file is specified,
 or if the filename is "-", then the binary is read from standard input.

 If no output is specified then the output is printed to stdout in a human
 readable format.

 WIP: MARK-V codec is in early stages of development. At the moment it only
 can encode and decode some SPIR-V files and only if exacly the same build of
 software is used (is doesn't write or handle version numbers yet).

 Tasks:
   e               Encode SPIR-V to MARK-V.
   d               Decode MARK-V to SPIR-V.
   t               Test the codec by first encoding the given SPIR-V file to
                   MARK-V, then decoding it back to SPIR-V and comparing results.

 Options:
   -h, --help      Print this help.
   --comments      Write codec comments to stderr.
   --version       Display MARK-V codec version.
   --validate      Validate SPIR-V while encoding or decoding.
   --model=<model-name>
                   Compression model, possible values:
                   shader_lite - fast, poor compression ratio
                   shader_mid - balanced
                   shader_max - best compression ratio
                   Default: shader_lite

   -o <filename>   Set the output filename.
                   Output goes to standard output if this option is
                   not specified, or if the filename is "-".
                   Not needed for 't' task (testing).
 )",
       argv0, argv0);
 }

 void DiagnosticsMessageHandler(spv_message_level_t level, const char*,
                                const spv_position_t& position,
                                const char* message) {
   switch (level) {
     case SPV_MSG_FATAL:
     case SPV_MSG_INTERNAL_ERROR:
     case SPV_MSG_ERROR:
       std::cerr << "error: " << position.index << ": " << message << std::endl;
       break;
     case SPV_MSG_WARNING:
       std::cerr << "warning: " << position.index << ": " << message
                 << std::endl;
       break;
     case SPV_MSG_INFO:
       std::cerr << "info: " << position.index << ": " << message << std::endl;
       break;
     default:
       break;
   }
 }

 }  // namespace

 int main(int argc, char** argv) {
   const char* input_filename = nullptr;
   const char* output_filename = nullptr;

   Task task = kNoTask;

   if (argc < 3) {
     print_usage(argv[0]);
     return 0;
   }

   const char* task_char = argv[1];
   if (0 == strcmp("e", task_char)) {
     task = kEncode;
   } else if (0 == strcmp("d", task_char)) {
     task = kDecode;
   } else if (0 == strcmp("t", task_char)) {
     task = kTest;
   }

   if (task == kNoTask) {
     print_usage(argv[0]);
     return 1;
   }

   bool want_comments = false;
   bool validate_spirv_binary = false;

   spvtools::comp::MarkvModelType model_type =
       spvtools::comp::kMarkvModelUnknown;

   for (int argi = 2; argi < argc; ++argi) {
     if ('-' == argv[argi][0]) {
       switch (argv[argi][1]) {
         case 'h':
           print_usage(argv[0]);
           return 0;
         case 'o': {
           if (!output_filename && argi + 1 < argc &&
               (task == kEncode || task == kDecode)) {
             output_filename = argv[++argi];
           } else {
             print_usage(argv[0]);
             return 1;
           }
         } break;
         case '-': {
           if (0 == strcmp(argv[argi], "--help")) {
             print_usage(argv[0]);
             return 0;
           } else if (0 == strcmp(argv[argi], "--comments")) {
             want_comments = true;
           } else if (0 == strcmp(argv[argi], "--version")) {
             fprintf(stderr, "error: Not implemented\n");
             return 1;
           } else if (0 == strcmp(argv[argi], "--validate")) {
             validate_spirv_binary = true;
           } else if (0 == strcmp(argv[argi], "--model=shader_lite")) {
             if (model_type != spvtools::comp::kMarkvModelUnknown)
               fprintf(stderr, "error: More than one model specified\n");
             model_type = spvtools::comp::kMarkvModelShaderLite;
           } else if (0 == strcmp(argv[argi], "--model=shader_mid")) {
             if (model_type != spvtools::comp::kMarkvModelUnknown)
               fprintf(stderr, "error: More than one model specified\n");
             model_type = spvtools::comp::kMarkvModelShaderMid;
           } else if (0 == strcmp(argv[argi], "--model=shader_max")) {
             if (model_type != spvtools::comp::kMarkvModelUnknown)
               fprintf(stderr, "error: More than one model specified\n");
             model_type = spvtools::comp::kMarkvModelShaderMax;
           } else {
             print_usage(argv[0]);
             return 1;
           }
         } break;
         case '\0': {
           // Setting a filename of "-" to indicate stdin.
           if (!input_filename) {
             input_filename = argv[argi];
           } else {
             fprintf(stderr, "error: More than one input file specified\n");
             return 1;
           }
         } break;
         default:
           print_usage(argv[0]);
           return 1;
       }
     } else {
       if (!input_filename) {
         input_filename = argv[argi];
       } else {
         fprintf(stderr, "error: More than one input file specified\n");
         return 1;
       }
     }
   }

   if (model_type == spvtools::comp::kMarkvModelUnknown)
     model_type = spvtools::comp::kMarkvModelShaderLite;

   const auto no_comments = spvtools::comp::MarkvLogConsumer();
   const auto output_to_stderr = [](const std::string& str) {
     std::cerr << str;
   };

   ScopedContext ctx(kSpvEnv);

   std::unique_ptr<spvtools::comp::MarkvModel> model =
       spvtools::comp::CreateMarkvModel(model_type);

   std::vector<uint32_t> spirv;
   std::vector<uint8_t> markv;

   spvtools::comp::MarkvCodecOptions options;
   options.validate_spirv_binary = validate_spirv_binary;

   if (task == kEncode) {
     if (!ReadFile<uint32_t>(input_filename, "rb", &spirv)) return 1;
     assert(!spirv.empty());

     if (SPV_SUCCESS != spvtools::comp::SpirvToMarkv(
                            ctx.context, spirv, options, *model,
                            DiagnosticsMessageHandler,
                            want_comments ? output_to_stderr : no_comments,
                            spvtools::comp::MarkvDebugConsumer(), &markv)) {
       std::cerr << "error: Failed to encode " << input_filename << " to MARK-V "
                 << std::endl;
       return 1;
     }

     if (!WriteFile<uint8_t>(output_filename, "wb", markv.data(), markv.size()))
       return 1;
   } else if (task == kDecode) {
     if (!ReadFile<uint8_t>(input_filename, "rb", &markv)) return 1;
     assert(!markv.empty());

     if (SPV_SUCCESS != spvtools::comp::MarkvToSpirv(
                            ctx.context, markv, options, *model,
                            DiagnosticsMessageHandler,
                            want_comments ? output_to_stderr : no_comments,
                            spvtools::comp::MarkvDebugConsumer(), &spirv)) {
       std::cerr << "error: Failed to decode " << input_filename << " to SPIR-V "
                 << std::endl;
       return 1;
     }

     if (!WriteFile<uint32_t>(output_filename, "wb", spirv.data(), spirv.size()))
       return 1;
   } else if (task == kTest) {
     if (!ReadFile<uint32_t>(input_filename, "rb", &spirv)) return 1;
     assert(!spirv.empty());

     std::vector<uint32_t> spirv_before;
     spvtools::Optimizer optimizer(kSpvEnv);
     optimizer.RegisterPass(spvtools::CreateCompactIdsPass());
     if (!optimizer.Run(spirv.data(), spirv.size(), &spirv_before)) {
       std::cerr << "error: Optimizer failure on: " << input_filename
                 << std::endl;
     }

     std::vector<std::string> encoder_instruction_bits;
     std::vector<std::string> encoder_instruction_comments;
     std::vector<std::vector<uint32_t>> encoder_instruction_words;
     std::vector<std::string> decoder_instruction_bits;
     std::vector<std::string> decoder_instruction_comments;
     std::vector<std::vector<uint32_t>> decoder_instruction_words;

     const auto encoder_debug_consumer = [&](const std::vector<uint32_t>& words,
                                             const std::string& bits,
                                             const std::string& comment) {
       encoder_instruction_words.push_back(words);
       encoder_instruction_bits.push_back(bits);
       encoder_instruction_comments.push_back(comment);
       return true;
     };

     if (SPV_SUCCESS != spvtools::comp::SpirvToMarkv(
                            ctx.context, spirv_before, options, *model,
                            DiagnosticsMessageHandler,
                            want_comments ? output_to_stderr : no_comments,
                            encoder_debug_consumer, &markv)) {
       std::cerr << "error: Failed to encode " << input_filename << " to MARK-V "
                 << std::endl;
       return 1;
     }

     const auto write_bug_report = [&]() {
       for (size_t inst_index = 0; inst_index < decoder_instruction_words.size();
            ++inst_index) {
         std::cerr << "\nInstruction #" << inst_index << std::endl;
         std::cerr << "\nEncoder words: ";
         for (uint32_t word : encoder_instruction_words[inst_index])
           std::cerr << word << " ";
         std::cerr << "\nDecoder words: ";
         for (uint32_t word : decoder_instruction_words[inst_index])
           std::cerr << word << " ";
         std::cerr << std::endl;

         std::cerr << "\nEncoder bits: " << encoder_instruction_bits[inst_index];
         std::cerr << "\nDecoder bits: " << decoder_instruction_bits[inst_index];
         std::cerr << std::endl;

         std::cerr << "\nEncoder comments:\n"
                   << encoder_instruction_comments[inst_index];
         std::cerr << "Decoder comments:\n"
                   << decoder_instruction_comments[inst_index];
         std::cerr << std::endl;
       }
     };

     const auto decoder_debug_consumer = [&](const std::vector<uint32_t>& words,
                                             const std::string& bits,
                                             const std::string& comment) {
       const size_t inst_index = decoder_instruction_words.size();
       if (inst_index >= encoder_instruction_words.size()) {
         write_bug_report();
         std::cerr << "error: Decoder has more instructions than encoder: "
                   << input_filename << std::endl;
         return false;
       }

       decoder_instruction_words.push_back(words);
       decoder_instruction_bits.push_back(bits);
       decoder_instruction_comments.push_back(comment);

       if (encoder_instruction_words[inst_index] !=
           decoder_instruction_words[inst_index]) {
         write_bug_report();
         std::cerr << "error: Words of the last decoded instruction differ from "
                      "reference: "
                   << input_filename << std::endl;
         return false;
       }

       if (encoder_instruction_bits[inst_index] !=
           decoder_instruction_bits[inst_index]) {
         write_bug_report();
         std::cerr << "error: Bits of the last decoded instruction differ from "
                      "reference: "
                   << input_filename << std::endl;
         return false;
       }
       return true;
     };

     std::vector<uint32_t> spirv_after;
     const spv_result_t decoding_result = spvtools::comp::MarkvToSpirv(
         ctx.context, markv, options, *model, DiagnosticsMessageHandler,
         want_comments ? output_to_stderr : no_comments, decoder_debug_consumer,
         &spirv_after);

     if (decoding_result == SPV_REQUESTED_TERMINATION) {
       std::cerr << "error: Decoding interrupted by the debugger: "
                 << input_filename << std::endl;
       return 1;
     }

     if (decoding_result != SPV_SUCCESS) {
       std::cerr << "error: Failed to decode encoded " << input_filename
                 << " back to SPIR-V " << std::endl;
       return 1;
     }

     assert(spirv_before.size() == spirv_after.size());
     assert(std::mismatch(std::next(spirv_before.begin(), 5), spirv_before.end(),
                          std::next(spirv_after.begin(), 5)) ==
            std::make_pair(spirv_before.end(), spirv_after.end()));
   }

   return 0;
 }
	// 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.

	#include <algorithm>
	#include <cassert>
	#include <cstdio>
	#include <cstring>
	#include <functional>
	#include <iostream>
	#include <memory>
	#include <string>
	#include <utility>
	#include <vector>

	#include "source/comp/markv.h"
	#include "source/spirv_target_env.h"
	#include "source/table.h"
	#include "spirv-tools/optimizer.hpp"
	#include "tools/comp/markv_model_factory.h"
	#include "tools/io.h"

	namespace {

	const auto kSpvEnv = SPV_ENV_UNIVERSAL_1_2;

	enum Task {
	kNoTask = 0,
	kEncode,
	kDecode,
	kTest,
	};

	struct ScopedContext {
	ScopedContext(spv_target_env env) : context(spvContextCreate(env)) {}
	~ScopedContext() { spvContextDestroy(context); }
	spv_context context;
	};

	void print_usage(char* argv0) {
	printf(
	R"(%s - Encodes or decodes a SPIR-V binary to or from a MARK-V binary.

	USAGE: %s [e\|d\|t] [options] [<filename>]

	The input binary is read from <filename>. If no file is specified,
	or if the filename is "-", then the binary is read from standard input.

	If no output is specified then the output is printed to stdout in a human
	readable format.

	WIP: MARK-V codec is in early stages of development. At the moment it only
	can encode and decode some SPIR-V files and only if exacly the same build of
	software is used (is doesn't write or handle version numbers yet).

	Tasks:
	e Encode SPIR-V to MARK-V.
	d Decode MARK-V to SPIR-V.
	t Test the codec by first encoding the given SPIR-V file to
	MARK-V, then decoding it back to SPIR-V and comparing results.

	Options:
	-h, --help Print this help.
	--comments Write codec comments to stderr.
	--version Display MARK-V codec version.
	--validate Validate SPIR-V while encoding or decoding.
	--model=<model-name>
	Compression model, possible values:
	shader_lite - fast, poor compression ratio
	shader_mid - balanced
	shader_max - best compression ratio
	Default: shader_lite

	-o <filename> Set the output filename.
	Output goes to standard output if this option is
	not specified, or if the filename is "-".
	Not needed for 't' task (testing).
	)",
	argv0, argv0);
	}

	void DiagnosticsMessageHandler(spv_message_level_t level, const char*,
	const spv_position_t& position,
	const char* message) {
	switch (level) {
	case SPV_MSG_FATAL:
	case SPV_MSG_INTERNAL_ERROR:
	case SPV_MSG_ERROR:
	std::cerr << "error: " << position.index << ": " << message << std::endl;
	break;
	case SPV_MSG_WARNING:
	std::cerr << "warning: " << position.index << ": " << message
	<< std::endl;
	break;
	case SPV_MSG_INFO:
	std::cerr << "info: " << position.index << ": " << message << std::endl;
	break;
	default:
	break;
	}
	}

	} // namespace

	int main(int argc, char** argv) {
	const char* input_filename = nullptr;
	const char* output_filename = nullptr;

	Task task = kNoTask;

	if (argc < 3) {
	print_usage(argv[0]);
	return 0;
	}

	const char* task_char = argv[1];
	if (0 == strcmp("e", task_char)) {
	task = kEncode;
	} else if (0 == strcmp("d", task_char)) {
	task = kDecode;
	} else if (0 == strcmp("t", task_char)) {
	task = kTest;
	}

	if (task == kNoTask) {
	print_usage(argv[0]);
	return 1;
	}

	bool want_comments = false;
	bool validate_spirv_binary = false;

	spvtools::comp::MarkvModelType model_type =
	spvtools::comp::kMarkvModelUnknown;

	for (int argi = 2; argi < argc; ++argi) {
	if ('-' == argv[argi][0]) {
	switch (argv[argi][1]) {
	case 'h':
	print_usage(argv[0]);
	return 0;
	case 'o': {
	if (!output_filename && argi + 1 < argc &&
	(task == kEncode \|\| task == kDecode)) {
	output_filename = argv[++argi];
	} else {
	print_usage(argv[0]);
	return 1;
	}
	} break;
	case '-': {
	if (0 == strcmp(argv[argi], "--help")) {
	print_usage(argv[0]);
	return 0;
	} else if (0 == strcmp(argv[argi], "--comments")) {
	want_comments = true;
	} else if (0 == strcmp(argv[argi], "--version")) {
	fprintf(stderr, "error: Not implemented\n");
	return 1;
	} else if (0 == strcmp(argv[argi], "--validate")) {
	validate_spirv_binary = true;
	} else if (0 == strcmp(argv[argi], "--model=shader_lite")) {
	if (model_type != spvtools::comp::kMarkvModelUnknown)
	fprintf(stderr, "error: More than one model specified\n");
	model_type = spvtools::comp::kMarkvModelShaderLite;
	} else if (0 == strcmp(argv[argi], "--model=shader_mid")) {
	if (model_type != spvtools::comp::kMarkvModelUnknown)
	fprintf(stderr, "error: More than one model specified\n");
	model_type = spvtools::comp::kMarkvModelShaderMid;
	} else if (0 == strcmp(argv[argi], "--model=shader_max")) {
	if (model_type != spvtools::comp::kMarkvModelUnknown)
	fprintf(stderr, "error: More than one model specified\n");
	model_type = spvtools::comp::kMarkvModelShaderMax;
	} else {
	print_usage(argv[0]);
	return 1;
	}
	} break;
	case '\0': {
	// Setting a filename of "-" to indicate stdin.
	if (!input_filename) {
	input_filename = argv[argi];
	} else {
	fprintf(stderr, "error: More than one input file specified\n");
	return 1;
	}
	} break;
	default:
	print_usage(argv[0]);
	return 1;
	}
	} else {
	if (!input_filename) {
	input_filename = argv[argi];
	} else {
	fprintf(stderr, "error: More than one input file specified\n");
	return 1;
	}
	}
	}

	if (model_type == spvtools::comp::kMarkvModelUnknown)
	model_type = spvtools::comp::kMarkvModelShaderLite;

	const auto no_comments = spvtools::comp::MarkvLogConsumer();
	const auto output_to_stderr = [](const std::string& str) {
	std::cerr << str;
	};

	ScopedContext ctx(kSpvEnv);

	std::unique_ptr<spvtools::comp::MarkvModel> model =
	spvtools::comp::CreateMarkvModel(model_type);

	std::vector<uint32_t> spirv;
	std::vector<uint8_t> markv;

	spvtools::comp::MarkvCodecOptions options;
	options.validate_spirv_binary = validate_spirv_binary;

	if (task == kEncode) {
	if (!ReadFile<uint32_t>(input_filename, "rb", &spirv)) return 1;
	assert(!spirv.empty());

	if (SPV_SUCCESS != spvtools::comp::SpirvToMarkv(
	ctx.context, spirv, options, *model,
	DiagnosticsMessageHandler,
	want_comments ? output_to_stderr : no_comments,
	spvtools::comp::MarkvDebugConsumer(), &markv)) {
	std::cerr << "error: Failed to encode " << input_filename << " to MARK-V "
	<< std::endl;
	return 1;
	}

	if (!WriteFile<uint8_t>(output_filename, "wb", markv.data(), markv.size()))
	return 1;
	} else if (task == kDecode) {
	if (!ReadFile<uint8_t>(input_filename, "rb", &markv)) return 1;
	assert(!markv.empty());

	if (SPV_SUCCESS != spvtools::comp::MarkvToSpirv(
	ctx.context, markv, options, *model,
	DiagnosticsMessageHandler,
	want_comments ? output_to_stderr : no_comments,
	spvtools::comp::MarkvDebugConsumer(), &spirv)) {
	std::cerr << "error: Failed to decode " << input_filename << " to SPIR-V "
	<< std::endl;
	return 1;
	}

	if (!WriteFile<uint32_t>(output_filename, "wb", spirv.data(), spirv.size()))
	return 1;
	} else if (task == kTest) {
	if (!ReadFile<uint32_t>(input_filename, "rb", &spirv)) return 1;
	assert(!spirv.empty());

	std::vector<uint32_t> spirv_before;
	spvtools::Optimizer optimizer(kSpvEnv);
	optimizer.RegisterPass(spvtools::CreateCompactIdsPass());
	if (!optimizer.Run(spirv.data(), spirv.size(), &spirv_before)) {
	std::cerr << "error: Optimizer failure on: " << input_filename
	<< std::endl;
	}

	std::vector<std::string> encoder_instruction_bits;
	std::vector<std::string> encoder_instruction_comments;
	std::vector<std::vector<uint32_t>> encoder_instruction_words;
	std::vector<std::string> decoder_instruction_bits;
	std::vector<std::string> decoder_instruction_comments;
	std::vector<std::vector<uint32_t>> decoder_instruction_words;

	const auto encoder_debug_consumer = [&](const std::vector<uint32_t>& words,
	const std::string& bits,
	const std::string& comment) {
	encoder_instruction_words.push_back(words);
	encoder_instruction_bits.push_back(bits);
	encoder_instruction_comments.push_back(comment);
	return true;
	};

	if (SPV_SUCCESS != spvtools::comp::SpirvToMarkv(
	ctx.context, spirv_before, options, *model,
	DiagnosticsMessageHandler,
	want_comments ? output_to_stderr : no_comments,
	encoder_debug_consumer, &markv)) {
	std::cerr << "error: Failed to encode " << input_filename << " to MARK-V "
	<< std::endl;
	return 1;
	}

	const auto write_bug_report = [&]() {
	for (size_t inst_index = 0; inst_index < decoder_instruction_words.size();
	++inst_index) {
	std::cerr << "\nInstruction #" << inst_index << std::endl;
	std::cerr << "\nEncoder words: ";
	for (uint32_t word : encoder_instruction_words[inst_index])
	std::cerr << word << " ";
	std::cerr << "\nDecoder words: ";
	for (uint32_t word : decoder_instruction_words[inst_index])
	std::cerr << word << " ";
	std::cerr << std::endl;

	std::cerr << "\nEncoder bits: " << encoder_instruction_bits[inst_index];
	std::cerr << "\nDecoder bits: " << decoder_instruction_bits[inst_index];
	std::cerr << std::endl;

	std::cerr << "\nEncoder comments:\n"
	<< encoder_instruction_comments[inst_index];
	std::cerr << "Decoder comments:\n"
	<< decoder_instruction_comments[inst_index];
	std::cerr << std::endl;
	}
	};

	const auto decoder_debug_consumer = [&](const std::vector<uint32_t>& words,
	const std::string& bits,
	const std::string& comment) {
	const size_t inst_index = decoder_instruction_words.size();
	if (inst_index >= encoder_instruction_words.size()) {
	write_bug_report();
	std::cerr << "error: Decoder has more instructions than encoder: "
	<< input_filename << std::endl;
	return false;
	}

	decoder_instruction_words.push_back(words);
	decoder_instruction_bits.push_back(bits);
	decoder_instruction_comments.push_back(comment);

	if (encoder_instruction_words[inst_index] !=
	decoder_instruction_words[inst_index]) {
	write_bug_report();
	std::cerr << "error: Words of the last decoded instruction differ from "
	"reference: "
	<< input_filename << std::endl;
	return false;
	}

	if (encoder_instruction_bits[inst_index] !=
	decoder_instruction_bits[inst_index]) {
	write_bug_report();
	std::cerr << "error: Bits of the last decoded instruction differ from "
	"reference: "
	<< input_filename << std::endl;
	return false;
	}
	return true;
	};

	std::vector<uint32_t> spirv_after;
	const spv_result_t decoding_result = spvtools::comp::MarkvToSpirv(
	ctx.context, markv, options, *model, DiagnosticsMessageHandler,
	want_comments ? output_to_stderr : no_comments, decoder_debug_consumer,
	&spirv_after);

	if (decoding_result == SPV_REQUESTED_TERMINATION) {
	std::cerr << "error: Decoding interrupted by the debugger: "
	<< input_filename << std::endl;
	return 1;
	}

	if (decoding_result != SPV_SUCCESS) {
	std::cerr << "error: Failed to decode encoded " << input_filename
	<< " back to SPIR-V " << std::endl;
	return 1;
	}

	assert(spirv_before.size() == spirv_after.size());
	assert(std::mismatch(std::next(spirv_before.begin(), 5), spirv_before.end(),
	std::next(spirv_after.begin(), 5)) ==
	std::make_pair(spirv_before.end(), spirv_after.end()));
	}

	return 0;
	}