1 //
2 // Copyright (C) 2015 LunarG, Inc.
3 //
4 // All rights reserved.
5 //
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions
8 // are met:
9 //
10 // Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 //
13 // Redistributions in binary form must reproduce the above
14 // copyright notice, this list of conditions and the following
15 // disclaimer in the documentation and/or other materials provided
16 // with the distribution.
17 //
18 // Neither the name of 3Dlabs Inc. Ltd. nor the names of its
19 // contributors may be used to endorse or promote products derived
20 // from this software without specific prior written permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26 // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
28 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
30 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33 // POSSIBILITY OF SUCH DAMAGE.
34 //
35
36 #include <iostream>
37 #include <fstream>
38 #include <cstring>
39 #include <stdexcept>
40
41 #include "../SPIRV/SPVRemapper.h"
42
43 namespace {
44
45 typedef unsigned int SpvWord;
46
47 // Poor man's basename: given a complete path, return file portion.
48 // E.g:
49 // Linux: /foo/bar/test -> test
50 // Win: c:\foo\bar\test -> test
51 // It's not very efficient, but that doesn't matter for our minimal-duty use.
52 // Using boost::filesystem would be better in many ways, but want to avoid that dependency.
53
54 // OS dependent path separator (avoiding boost::filesystem dependency)
55 #if defined(_WIN32)
path_sep_char()56 char path_sep_char() { return '\\'; }
57 #else
path_sep_char()58 char path_sep_char() { return '/'; }
59 #endif
60
basename(const std::string filename)61 std::string basename(const std::string filename)
62 {
63 const size_t sepLoc = filename.find_last_of(path_sep_char());
64
65 return (sepLoc == filename.npos) ? filename : filename.substr(sepLoc+1);
66 }
67
errHandler(const std::string & str)68 void errHandler(const std::string& str) {
69 std::cout << str << std::endl;
70 exit(5);
71 }
72
logHandler(const std::string & str)73 void logHandler(const std::string& str) {
74 std::cout << str << std::endl;
75 }
76
77 // Read word stream from disk
read(std::vector<SpvWord> & spv,const std::string & inFilename,int verbosity)78 void read(std::vector<SpvWord>& spv, const std::string& inFilename, int verbosity)
79 {
80 std::ifstream fp;
81
82 if (verbosity > 0)
83 logHandler(std::string(" reading: ") + inFilename);
84
85 spv.clear();
86 fp.open(inFilename, std::fstream::in | std::fstream::binary);
87
88 if (fp.fail())
89 errHandler("error opening file for read: ");
90
91 // Reserve space (for efficiency, not for correctness)
92 fp.seekg(0, fp.end);
93 spv.reserve(size_t(fp.tellg()) / sizeof(SpvWord));
94 fp.seekg(0, fp.beg);
95
96 while (!fp.eof()) {
97 SpvWord inWord;
98 fp.read((char *)&inWord, sizeof(inWord));
99
100 if (!fp.eof()) {
101 spv.push_back(inWord);
102 if (fp.fail())
103 errHandler(std::string("error reading file: ") + inFilename);
104 }
105 }
106 }
107
write(std::vector<SpvWord> & spv,const std::string & outFile,int verbosity)108 void write(std::vector<SpvWord>& spv, const std::string& outFile, int verbosity)
109 {
110 if (outFile.empty())
111 errHandler("missing output filename.");
112
113 std::ofstream fp;
114
115 if (verbosity > 0)
116 logHandler(std::string(" writing: ") + outFile);
117
118 fp.open(outFile, std::fstream::out | std::fstream::binary);
119
120 if (fp.fail())
121 errHandler(std::string("error opening file for write: ") + outFile);
122
123 for (auto it = spv.cbegin(); it != spv.cend(); ++it) {
124 SpvWord word = *it;
125 fp.write((char *)&word, sizeof(word));
126 if (fp.fail())
127 errHandler(std::string("error writing file: ") + outFile);
128 }
129
130 // file is closed by destructor
131 }
132
133 // Print helpful usage message to stdout, and exit
usage(const char * const name,const char * const msg=0)134 void usage(const char* const name, const char* const msg = 0)
135 {
136 if (msg)
137 std::cout << msg << std::endl << std::endl;
138
139 std::cout << "Usage: " << std::endl;
140
141 std::cout << " " << basename(name)
142 << " [-v[v[...]] | --verbose [int]]"
143 << " [--map (all|types|names|funcs)]"
144 << " [--dce (all|types|funcs)]"
145 << " [--opt (all|loadstore)]"
146 << " [--strip-all | --strip all | -s]"
147 << " [--do-everything]"
148 << " --input | -i file1 [file2...] --output|-o DESTDIR"
149 << std::endl;
150
151 std::cout << " " << basename(name) << " [--version | -V]" << std::endl;
152 std::cout << " " << basename(name) << " [--help | -?]" << std::endl;
153
154 exit(5);
155 }
156
157 // grind through each SPIR in turn
execute(const std::vector<std::string> & inputFile,const std::string & outputDir,int opts,int verbosity)158 void execute(const std::vector<std::string>& inputFile, const std::string& outputDir,
159 int opts, int verbosity)
160 {
161 for (auto it = inputFile.cbegin(); it != inputFile.cend(); ++it) {
162 const std::string &filename = *it;
163 std::vector<SpvWord> spv;
164 read(spv, filename, verbosity);
165 spv::spirvbin_t(verbosity).remap(spv, opts);
166
167 const std::string outfile = outputDir + path_sep_char() + basename(filename);
168
169 write(spv, outfile, verbosity);
170 }
171
172 if (verbosity > 0)
173 std::cout << "Done: " << inputFile.size() << " file(s) processed" << std::endl;
174 }
175
176 // Parse command line options
parseCmdLine(int argc,char ** argv,std::vector<std::string> & inputFile,std::string & outputDir,int & options,int & verbosity)177 void parseCmdLine(int argc, char** argv, std::vector<std::string>& inputFile,
178 std::string& outputDir,
179 int& options,
180 int& verbosity)
181 {
182 if (argc < 2)
183 usage(argv[0]);
184
185 verbosity = 0;
186 options = spv::spirvbin_t::NONE;
187
188 // Parse command line.
189 // boost::program_options would be quite a bit nicer, but we don't want to
190 // introduce a dependency on boost.
191 for (int a=1; a<argc; ) {
192 const std::string arg = argv[a];
193
194 if (arg == "--output" || arg == "-o") {
195 // Output directory
196 if (++a >= argc)
197 usage(argv[0], "--output requires an argument");
198 if (!outputDir.empty())
199 usage(argv[0], "--output can be provided only once");
200
201 outputDir = argv[a++];
202
203 // Remove trailing directory separator characters
204 while (!outputDir.empty() && outputDir.back() == path_sep_char())
205 outputDir.pop_back();
206
207 }
208 else if (arg == "-vv") { verbosity = 2; ++a; } // verbosity shortcuts
209 else if (arg == "-vvv") { verbosity = 3; ++a; } // ...
210 else if (arg == "-vvvv") { verbosity = 4; ++a; } // ...
211 else if (arg == "-vvvvv") { verbosity = 5; ++a; } // ...
212
213 else if (arg == "--verbose" || arg == "-v") {
214 ++a;
215 verbosity = 1;
216
217 if (a < argc) {
218 char* end_ptr = 0;
219 int verb = ::strtol(argv[a], &end_ptr, 10);
220 // If we have not read to the end of the string or
221 // the string contained no elements, then we do not want to
222 // store the value.
223 if (*end_ptr == '\0' && end_ptr != argv[a]) {
224 verbosity = verb;
225 ++a;
226 }
227 }
228 }
229 else if (arg == "--version" || arg == "-V") {
230 std::cout << basename(argv[0]) << " version 0.97 " << __DATE__ << " " << __TIME__ << std::endl;
231 exit(0);
232 } else if (arg == "--input" || arg == "-i") {
233 // Collect input files
234 for (++a; a < argc && argv[a][0] != '-'; ++a)
235 inputFile.push_back(argv[a]);
236 } else if (arg == "--do-everything") {
237 ++a;
238 options = options | spv::spirvbin_t::DO_EVERYTHING;
239 } else if (arg == "--strip-all" || arg == "-s") {
240 ++a;
241 options = options | spv::spirvbin_t::STRIP;
242 } else if (arg == "--strip") {
243 ++a;
244 if (strncmp(argv[a], "all", 3) == 0) {
245 options = options | spv::spirvbin_t::STRIP;
246 ++a;
247 }
248 } else if (arg == "--dce") {
249 // Parse comma (or colon, etc) separated list of things to dce
250 ++a;
251 for (const char* c = argv[a]; *c; ++c) {
252 if (strncmp(c, "all", 3) == 0) {
253 options = (options | spv::spirvbin_t::DCE_ALL);
254 c += 3;
255 } else if (strncmp(c, "*", 1) == 0) {
256 options = (options | spv::spirvbin_t::DCE_ALL);
257 c += 1;
258 } else if (strncmp(c, "funcs", 5) == 0) {
259 options = (options | spv::spirvbin_t::DCE_FUNCS);
260 c += 5;
261 } else if (strncmp(c, "types", 5) == 0) {
262 options = (options | spv::spirvbin_t::DCE_TYPES);
263 c += 5;
264 }
265 }
266 ++a;
267 } else if (arg == "--map") {
268 // Parse comma (or colon, etc) separated list of things to map
269 ++a;
270 for (const char* c = argv[a]; *c; ++c) {
271 if (strncmp(c, "all", 3) == 0) {
272 options = (options | spv::spirvbin_t::MAP_ALL);
273 c += 3;
274 } else if (strncmp(c, "*", 1) == 0) {
275 options = (options | spv::spirvbin_t::MAP_ALL);
276 c += 1;
277 } else if (strncmp(c, "types", 5) == 0) {
278 options = (options | spv::spirvbin_t::MAP_TYPES);
279 c += 5;
280 } else if (strncmp(c, "names", 5) == 0) {
281 options = (options | spv::spirvbin_t::MAP_NAMES);
282 c += 5;
283 } else if (strncmp(c, "funcs", 5) == 0) {
284 options = (options | spv::spirvbin_t::MAP_FUNCS);
285 c += 5;
286 }
287 }
288 ++a;
289 } else if (arg == "--opt") {
290 ++a;
291 for (const char* c = argv[a]; *c; ++c) {
292 if (strncmp(c, "all", 3) == 0) {
293 options = (options | spv::spirvbin_t::OPT_ALL);
294 c += 3;
295 } else if (strncmp(c, "*", 1) == 0) {
296 options = (options | spv::spirvbin_t::OPT_ALL);
297 c += 1;
298 } else if (strncmp(c, "loadstore", 9) == 0) {
299 options = (options | spv::spirvbin_t::OPT_LOADSTORE);
300 c += 9;
301 }
302 }
303 ++a;
304 } else if (arg == "--help" || arg == "-?") {
305 usage(argv[0]);
306 } else {
307 usage(argv[0], "Unknown command line option");
308 }
309 }
310 }
311
312 } // namespace
313
main(int argc,char ** argv)314 int main(int argc, char** argv)
315 {
316 std::vector<std::string> inputFile;
317 std::string outputDir;
318 int opts;
319 int verbosity;
320
321 #ifdef use_cpp11
322 // handle errors by exiting
323 spv::spirvbin_t::registerErrorHandler(errHandler);
324
325 // Log messages to std::cout
326 spv::spirvbin_t::registerLogHandler(logHandler);
327 #endif
328
329 if (argc < 2)
330 usage(argv[0]);
331
332 parseCmdLine(argc, argv, inputFile, outputDir, opts, verbosity);
333
334 if (outputDir.empty())
335 usage(argv[0], "Output directory required");
336
337 std::string errmsg;
338
339 // Main operations: read, remap, and write.
340 execute(inputFile, outputDir, opts, verbosity);
341
342 // If we get here, everything went OK! Nothing more to be done.
343 }
344