SPV compression: Final check-in enabling this on MSVC 2012. All compression…

README-spirv-remap.txt

@@ -48,11 +48,11 @@ for Linux.  Command line arguments can be provided in any order.
 Perform ID remapping on all shaders in "*.spv", writing new files with
 the same basenames to /tmp/out_dir.
 
-  spirv-remap --map all --input *.spv --output /tmp/out_dir
+  spirv-remap -v --map all --input *.spv --output /tmp/out_dir
 
 2. Perform all possible size reductions
 
-  spirv-remap-linux-64 --do-everything --input *.spv --output /tmp/out_dir
+  spirv-remap-linux-64 -v --do-everything --input *.spv --output /tmp/out_dir
 
 Note that --do-everything is a synonym for:
 

SPIRV/SPVRemapper.h

@@ -43,7 +43,7 @@ namespace spv {
 
 // MSVC defines __cplusplus as an older value, even when it supports almost all of 11.
 // We handle that here by making our own symbol.
-#if __cplusplus >= 201103L || _MSC_VER >= 1800
+#if __cplusplus >= 201103L || _MSC_VER >= 1700
 #   define use_cpp11 1
 #endif
 
@@ -84,6 +84,7 @@ public:
     void remap(std::vector<unsigned int>& /*spv*/, unsigned int /*opts = 0*/)
     {
         printf("Tool not compiled for C++11, which is required for SPIR-V remapping.\n");
+        exit(5);
     }
 };
 
@@ -137,9 +138,9 @@ private:
 
    typedef std::uint32_t spirword_t;
 
-   typedef std::pair<int, int> range_t;
+   typedef std::pair<unsigned, unsigned> range_t;
    typedef std::function<void(spv::Id&)>                idfn_t;
-   typedef std::function<bool(spv::Op, int start)> instfn_t;
+   typedef std::function<bool(spv::Op, unsigned start)> instfn_t;
 
    // Special Values for ID map:
    static const spv::Id unmapped;     // unchanged from default value
@@ -168,14 +169,14 @@ private:
    range_t typeRange(spv::Op opCode)       const;
    range_t constRange(spv::Op opCode)      const;
    
-   spv::Id&        asId(int word)                { return spv[word]; }
-   const spv::Id&  asId(int word)          const { return spv[word]; }
-   spv::Op         asOpCode(int word)      const { return opOpCode(spv[word]); }
-   std::uint32_t   asOpCodeHash(int word);
-   spv::Decoration asDecoration(int word)  const { return spv::Decoration(spv[word]); }
-   unsigned        asWordCount(int word)   const { return opWordCount(spv[word]); }
-   spv::Id         asTypeConstId(int word) const { return asId(word + (isTypeOp(asOpCode(word)) ? 1 : 2)); }
-   int             typePos(spv::Id id)     const;
+   spv::Id&        asId(unsigned word)                { return spv[word]; }
+   const spv::Id&  asId(unsigned word)          const { return spv[word]; }
+   spv::Op         asOpCode(unsigned word)      const { return opOpCode(spv[word]); }
+   std::uint32_t   asOpCodeHash(unsigned word);
+   spv::Decoration asDecoration(unsigned word)  const { return spv::Decoration(spv[word]); }
+   unsigned        asWordCount(unsigned word)   const { return opWordCount(spv[word]); }
+   spv::Id         asTypeConstId(unsigned word) const { return asId(word + (isTypeOp(asOpCode(word)) ? 1 : 2)); }
+   unsigned        typePos(spv::Id id)          const;
 
    static unsigned    opWordCount(spirword_t data) { return data >> spv::WordCountShift; }
    static spv::Op     opOpCode(spirword_t data)    { return spv::Op(data & spv::OpCodeMask); }
@@ -201,7 +202,7 @@ private:
    inline spv::Id   nextUnusedId(spv::Id id);
 
    void buildLocalMaps();
-   std::string literalString(int word) const; // Return literal as a std::string
+   std::string literalString(unsigned word) const; // Return literal as a std::string
    int literalStringWords(const std::string& str) const { return (int(str.size())+4)/4; }
 
    bool isNewIdMapped(spv::Id newId)   const { return isMapped(newId);            }
@@ -212,10 +213,10 @@ private:
 
    // bool    matchType(const globaltypes_t& globalTypes, spv::Id lt, spv::Id gt) const;
    // spv::Id findType(const globaltypes_t& globalTypes, spv::Id lt) const;
-   std::uint32_t hashType(int typeStart) const;
+   std::uint32_t hashType(unsigned typeStart) const;
 
-   spirvbin_t& process(instfn_t, idfn_t, int begin = 0, int end = 0);
-   int         processInstruction(int word, instfn_t, idfn_t);
+   spirvbin_t& process(instfn_t, idfn_t, unsigned begin = 0, unsigned end = 0);
+   int         processInstruction(unsigned word, instfn_t, idfn_t);
 
    void        validate() const;
    void        mapTypeConst();
@@ -251,12 +252,12 @@ private:
 
    // Add a strip range for a given instruction starting at 'start'
    // Note: avoiding brace initializers to please older versions os MSVC.
-   void stripInst(int start) { stripRange.push_back(std::pair<unsigned, unsigned>(start, start + asWordCount(start))); }
+   void stripInst(unsigned start) { stripRange.push_back(range_t(start, start + asWordCount(start))); }
 
    // Function start and end.  use unordered_map because we'll have
    // many fewer functions than IDs.
-   std::unordered_map<spv::Id, std::pair<int, int>> fnPos;
-   std::unordered_map<spv::Id, std::pair<int, int>> fnPosDCE; // deleted functions
+   std::unordered_map<spv::Id, range_t> fnPos;
+   std::unordered_map<spv::Id, range_t> fnPosDCE; // deleted functions
 
    // Which functions are called, anywhere in the module, with a call count
    std::unordered_map<spv::Id, int> fnCalls;
@@ -270,7 +271,7 @@ private:
    spv::Id largestNewId;    // biggest new ID we have mapped anything to
 
    // Sections of the binary to strip, given as [begin,end)
-   std::vector<std::pair<unsigned, unsigned>> stripRange;
+   std::vector<range_t> stripRange;
 
    // processing options:
    std::uint32_t options;

StandAlone/spirv-remap.cpp

@@ -75,11 +75,12 @@ namespace {
     }
 
     // Read word stream from disk
-    void read(std::vector<SpvWord>& spv, const std::string& inFilename)
+    void read(std::vector<SpvWord>& spv, const std::string& inFilename, int verbosity)
     {
         std::ifstream fp;
 
-        std::cout << "  reading: " << inFilename << std::endl;
+        if (verbosity > 0)
+            logHandler(std::string("  reading: ") + inFilename);
 
         spv.clear();
         fp.open(inFilename, std::fstream::in | std::fstream::binary);
@@ -104,14 +105,15 @@ namespace {
         }
     }
 
-    void write(std::vector<SpvWord>& spv, const std::string& outFile)
+    void write(std::vector<SpvWord>& spv, const std::string& outFile, int verbosity)
     {
         if (outFile.empty())
             errHandler("missing output filename.");
 
         std::ofstream fp;
 
-        std::cout << "  writing: " << outFile << std::endl;
+        if (verbosity > 0)
+            logHandler(std::string("  writing: ") + outFile);
 
         fp.open(outFile, std::fstream::out | std::fstream::binary);
 
@@ -157,12 +159,12 @@ namespace {
     {
         for (const auto& filename : inputFile) {
             std::vector<SpvWord> spv;
-            read(spv, filename);
+            read(spv, filename, verbosity);
             spv::spirvbin_t(verbosity).remap(spv, opts);
 
             const std::string outfile = outputDir + path_sep_char() + basename(filename);
 
-            write(spv, outfile);
+            write(spv, outfile, verbosity);
         }
 
         if (verbosity > 0)
@@ -305,17 +307,18 @@ namespace {
 
 int main(int argc, char** argv)
 {
-#ifdef use_cpp11
     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]);
@@ -330,7 +333,5 @@ int main(int argc, char** argv)
     // Main operations: read, remap, and write.
     execute(inputFile, outputDir, opts, verbosity);
 
-#endif
-
     // If we get here, everything went OK!  Nothing more to be done.
 }