summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/bgfx/3rdparty/glslang/StandAlone/spirv-remap.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/bgfx/3rdparty/glslang/StandAlone/spirv-remap.cpp')
-rw-r--r--3rdparty/bgfx/3rdparty/glslang/StandAlone/spirv-remap.cpp344
1 files changed, 344 insertions, 0 deletions
diff --git a/3rdparty/bgfx/3rdparty/glslang/StandAlone/spirv-remap.cpp b/3rdparty/bgfx/3rdparty/glslang/StandAlone/spirv-remap.cpp
new file mode 100644
index 00000000000..f35b58eda99
--- /dev/null
+++ b/3rdparty/bgfx/3rdparty/glslang/StandAlone/spirv-remap.cpp
@@ -0,0 +1,344 @@
+//
+//Copyright (C) 2015 LunarG, Inc.
+//
+//All rights reserved.
+//
+//Redistribution and use in source and binary forms, with or without
+//modification, are permitted provided that the following conditions
+//are met:
+//
+// Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following
+// disclaimer in the documentation and/or other materials provided
+// with the distribution.
+//
+// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
+// contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission.
+//
+//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+//"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+//LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+//FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+//COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+//BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+//CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+//ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+//POSSIBILITY OF SUCH DAMAGE.
+//
+
+#include <iostream>
+#include <fstream>
+#include <cstring>
+#include <stdexcept>
+
+#include "../SPIRV/SPVRemapper.h"
+
+namespace {
+
+ typedef unsigned int SpvWord;
+
+ // Poor man's basename: given a complete path, return file portion.
+ // E.g:
+ // Linux: /foo/bar/test -> test
+ // Win: c:\foo\bar\test -> test
+ // It's not very efficient, but that doesn't matter for our minimal-duty use.
+ // Using boost::filesystem would be better in many ways, but want to avoid that dependency.
+
+ // OS dependent path separator (avoiding boost::filesystem dependency)
+#if defined(_WIN32)
+ char path_sep_char() { return '\\'; }
+#else
+ char path_sep_char() { return '/'; }
+#endif
+
+ std::string basename(const std::string filename)
+ {
+ const size_t sepLoc = filename.find_last_of(path_sep_char());
+
+ return (sepLoc == filename.npos) ? filename : filename.substr(sepLoc+1);
+ }
+
+ void errHandler(const std::string& str) {
+ std::cout << str << std::endl;
+ exit(5);
+ }
+
+ void logHandler(const std::string& str) {
+ std::cout << str << std::endl;
+ }
+
+ // Read word stream from disk
+ void read(std::vector<SpvWord>& spv, const std::string& inFilename, int verbosity)
+ {
+ std::ifstream fp;
+
+ if (verbosity > 0)
+ logHandler(std::string(" reading: ") + inFilename);
+
+ spv.clear();
+ fp.open(inFilename, std::fstream::in | std::fstream::binary);
+
+ if (fp.fail())
+ errHandler("error opening file for read: ");
+
+ // Reserve space (for efficiency, not for correctness)
+ fp.seekg(0, fp.end);
+ spv.reserve(size_t(fp.tellg()) / sizeof(SpvWord));
+ fp.seekg(0, fp.beg);
+
+ while (!fp.eof()) {
+ SpvWord inWord;
+ fp.read((char *)&inWord, sizeof(inWord));
+
+ if (!fp.eof()) {
+ spv.push_back(inWord);
+ if (fp.fail())
+ errHandler(std::string("error reading file: ") + inFilename);
+ }
+ }
+ }
+
+ void write(std::vector<SpvWord>& spv, const std::string& outFile, int verbosity)
+ {
+ if (outFile.empty())
+ errHandler("missing output filename.");
+
+ std::ofstream fp;
+
+ if (verbosity > 0)
+ logHandler(std::string(" writing: ") + outFile);
+
+ fp.open(outFile, std::fstream::out | std::fstream::binary);
+
+ if (fp.fail())
+ errHandler(std::string("error opening file for write: ") + outFile);
+
+ for (auto it = spv.cbegin(); it != spv.cend(); ++it) {
+ SpvWord word = *it;
+ fp.write((char *)&word, sizeof(word));
+ if (fp.fail())
+ errHandler(std::string("error writing file: ") + outFile);
+ }
+
+ // file is closed by destructor
+ }
+
+ // Print helpful usage message to stdout, and exit
+ void usage(const char* const name, const char* const msg = 0)
+ {
+ if (msg)
+ std::cout << msg << std::endl << std::endl;
+
+ std::cout << "Usage: " << std::endl;
+
+ std::cout << " " << basename(name)
+ << " [-v[v[...]] | --verbose [int]]"
+ << " [--map (all|types|names|funcs)]"
+ << " [--dce (all|types|funcs)]"
+ << " [--opt (all|loadstore)]"
+ << " [--strip-all | --strip all | -s]"
+ << " [--do-everything]"
+ << " --input | -i file1 [file2...] --output|-o DESTDIR"
+ << std::endl;
+
+ std::cout << " " << basename(name) << " [--version | -V]" << std::endl;
+ std::cout << " " << basename(name) << " [--help | -?]" << std::endl;
+
+ exit(5);
+ }
+
+ // grind through each SPIR in turn
+ void execute(const std::vector<std::string>& inputFile, const std::string& outputDir,
+ int opts, int verbosity)
+ {
+ for (auto it = inputFile.cbegin(); it != inputFile.cend(); ++it) {
+ const std::string &filename = *it;
+ std::vector<SpvWord> spv;
+ read(spv, filename, verbosity);
+ spv::spirvbin_t(verbosity).remap(spv, opts);
+
+ const std::string outfile = outputDir + path_sep_char() + basename(filename);
+
+ write(spv, outfile, verbosity);
+ }
+
+ if (verbosity > 0)
+ std::cout << "Done: " << inputFile.size() << " file(s) processed" << std::endl;
+ }
+
+ // Parse command line options
+ void parseCmdLine(int argc, char** argv, std::vector<std::string>& inputFile,
+ std::string& outputDir,
+ int& options,
+ int& verbosity)
+ {
+ if (argc < 2)
+ usage(argv[0]);
+
+ verbosity = 0;
+ options = spv::spirvbin_t::NONE;
+
+ // Parse command line.
+ // boost::program_options would be quite a bit nicer, but we don't want to
+ // introduce a dependency on boost.
+ for (int a=1; a<argc; ) {
+ const std::string arg = argv[a];
+
+ if (arg == "--output" || arg == "-o") {
+ // Output directory
+ if (++a >= argc)
+ usage(argv[0], "--output requires an argument");
+ if (!outputDir.empty())
+ usage(argv[0], "--output can be provided only once");
+
+ outputDir = argv[a++];
+
+ // Remove trailing directory separator characters
+ while (!outputDir.empty() && outputDir.back() == path_sep_char())
+ outputDir.pop_back();
+
+ }
+ else if (arg == "-vv") { verbosity = 2; ++a; } // verbosity shortcuts
+ else if (arg == "-vvv") { verbosity = 3; ++a; } // ...
+ else if (arg == "-vvvv") { verbosity = 4; ++a; } // ...
+ else if (arg == "-vvvvv") { verbosity = 5; ++a; } // ...
+
+ else if (arg == "--verbose" || arg == "-v") {
+ ++a;
+ verbosity = 1;
+
+ if (a < argc) {
+ char* end_ptr = 0;
+ int verb = ::strtol(argv[a], &end_ptr, 10);
+ // If we have not read to the end of the string or
+ // the string contained no elements, then we do not want to
+ // store the value.
+ if (*end_ptr == '\0' && end_ptr != argv[a]) {
+ verbosity = verb;
+ ++a;
+ }
+ }
+ }
+ else if (arg == "--version" || arg == "-V") {
+ std::cout << basename(argv[0]) << " version 0.97 " << __DATE__ << " " << __TIME__ << std::endl;
+ exit(0);
+ } else if (arg == "--input" || arg == "-i") {
+ // Collect input files
+ for (++a; a < argc && argv[a][0] != '-'; ++a)
+ inputFile.push_back(argv[a]);
+ } else if (arg == "--do-everything") {
+ ++a;
+ options = options | spv::spirvbin_t::DO_EVERYTHING;
+ } else if (arg == "--strip-all" || arg == "-s") {
+ ++a;
+ options = options | spv::spirvbin_t::STRIP;
+ } else if (arg == "--strip") {
+ ++a;
+ if (strncmp(argv[a], "all", 3) == 0) {
+ options = options | spv::spirvbin_t::STRIP;
+ ++a;
+ }
+ } else if (arg == "--dce") {
+ // Parse comma (or colon, etc) separated list of things to dce
+ ++a;
+ for (const char* c = argv[a]; *c; ++c) {
+ if (strncmp(c, "all", 3) == 0) {
+ options = (options | spv::spirvbin_t::DCE_ALL);
+ c += 3;
+ } else if (strncmp(c, "*", 1) == 0) {
+ options = (options | spv::spirvbin_t::DCE_ALL);
+ c += 1;
+ } else if (strncmp(c, "funcs", 5) == 0) {
+ options = (options | spv::spirvbin_t::DCE_FUNCS);
+ c += 5;
+ } else if (strncmp(c, "types", 5) == 0) {
+ options = (options | spv::spirvbin_t::DCE_TYPES);
+ c += 5;
+ }
+ }
+ ++a;
+ } else if (arg == "--map") {
+ // Parse comma (or colon, etc) separated list of things to map
+ ++a;
+ for (const char* c = argv[a]; *c; ++c) {
+ if (strncmp(c, "all", 3) == 0) {
+ options = (options | spv::spirvbin_t::MAP_ALL);
+ c += 3;
+ } else if (strncmp(c, "*", 1) == 0) {
+ options = (options | spv::spirvbin_t::MAP_ALL);
+ c += 1;
+ } else if (strncmp(c, "types", 5) == 0) {
+ options = (options | spv::spirvbin_t::MAP_TYPES);
+ c += 5;
+ } else if (strncmp(c, "names", 5) == 0) {
+ options = (options | spv::spirvbin_t::MAP_NAMES);
+ c += 5;
+ } else if (strncmp(c, "funcs", 5) == 0) {
+ options = (options | spv::spirvbin_t::MAP_FUNCS);
+ c += 5;
+ }
+ }
+ ++a;
+ } else if (arg == "--opt") {
+ ++a;
+ for (const char* c = argv[a]; *c; ++c) {
+ if (strncmp(c, "all", 3) == 0) {
+ options = (options | spv::spirvbin_t::OPT_ALL);
+ c += 3;
+ } else if (strncmp(c, "*", 1) == 0) {
+ options = (options | spv::spirvbin_t::OPT_ALL);
+ c += 1;
+ } else if (strncmp(c, "loadstore", 9) == 0) {
+ options = (options | spv::spirvbin_t::OPT_LOADSTORE);
+ c += 9;
+ }
+ }
+ ++a;
+ } else if (arg == "--help" || arg == "-?") {
+ usage(argv[0]);
+ } else {
+ usage(argv[0], "Unknown command line option");
+ }
+ }
+ }
+
+} // namespace
+
+
+int main(int argc, char** argv)
+{
+ std::vector<std::string> inputFile;
+ std::string outputDir;
+ int opts;
+ int verbosity;
+
+#ifdef use_cpp11
+ // handle errors by exiting
+ spv::spirvbin_t::registerErrorHandler(errHandler);
+
+ // Log messages to std::cout
+ spv::spirvbin_t::registerLogHandler(logHandler);
+#endif
+
+ if (argc < 2)
+ usage(argv[0]);
+
+ parseCmdLine(argc, argv, inputFile, outputDir, opts, verbosity);
+
+ if (outputDir.empty())
+ usage(argv[0], "Output directory required");
+
+ std::string errmsg;
+
+ // Main operations: read, remap, and write.
+ execute(inputFile, outputDir, opts, verbosity);
+
+ // If we get here, everything went OK! Nothing more to be done.
+}