344 lines
12 KiB
C++
344 lines
12 KiB
C++
//
|
|
// 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.
|
|
}
|