Merge pull request #514 from steve-lunarg/binding-map-3

StandAlone/StandAlone.cpp

 //
 //Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
-//Copyright (C) 2013 LunarG, Inc.
+//Copyright (C) 2013-2016 LunarG, Inc.
 //
 //All rights reserved.
 //
@@ -48,7 +48,9 @@
 #include "../SPIRV/disassemble.h"
 #include <cstring>
 #include <cstdlib>
+#include <cctype>
 #include <cmath>
+#include <array>
 
 #include "../glslang/OSDependent/osinclude.h"
 
@@ -78,6 +80,7 @@ enum TOptions {
     EOptionOutputHexadecimal  = (1 << 16),
     EOptionReadHlsl           = (1 << 17),
     EOptionCascadingErrors    = (1 << 18),
+    EOptionAutoMapBindings    = (1 << 19),
 };
 
 //
@@ -96,7 +99,7 @@ enum TFailCode {
 //
 // Forward declarations.
 //
-EShLanguage FindLanguage(const std::string& name);
+EShLanguage FindLanguage(const std::string& name, bool parseSuffix=true);
 void CompileFile(const char* fileName, ShHandle);
 void usage();
 void FreeFileData(char** data);
@@ -157,6 +160,10 @@ const char* binaryFileName = nullptr;
 const char* entryPointName = nullptr;
 const char* shaderStageName = nullptr;
 
+std::array<unsigned int, EShLangCount> baseSamplerBinding;
+std::array<unsigned int, EShLangCount> baseTextureBinding;
+std::array<unsigned int, EShLangCount> baseUboBinding;
+
 //
 // Create the default name for saving a binary if -o is not provided.
 //
@@ -205,6 +212,35 @@ void Error(const char* message)
 }
 
 //
+// Process an optional binding base of the form:
+//   --argname [stage] base
+// Where stage is one of the forms accepted by FindLanguage, and base is an integer
+//
+void ProcessBindingBase(int& argc, char**& argv, std::array<unsigned int, EShLangCount>& base)
+{
+    if (argc < 2)
+        usage();
+
+    if (!isdigit(argv[1][0])) {
+        if (argc < 3) // this form needs one more argument
+            usage();
+    
+        // Parse form: --argname stage base
+        const EShLanguage lang = FindLanguage(argv[1], false);
+        base[lang] = atoi(argv[2]);
+        argc-= 2;
+        argv+= 2;
+    } else {
+        // Parse form: --argname base
+        for (int lang=0; lang<EShLangCount; ++lang)
+            base[lang] = atoi(argv[1]);
+
+        argc--;
+        argv++;
+    }
+}
+
+//
 // Do all command-line argument parsing.  This includes building up the work-items
 // to be processed later, and saving all the command-line options.
 //
@@ -212,6 +248,10 @@ void Error(const char* message)
 //
 void ProcessArguments(int argc, char* argv[])
 {
+    baseSamplerBinding.fill(0);
+    baseTextureBinding.fill(0);
+    baseUboBinding.fill(0);
+
     ExecutableName = argv[0];
     NumWorkItems = argc;  // will include some empties where the '-' options were, but it doesn't matter, they'll be 0
     Work = new glslang::TWorkItem*[NumWorkItems];
@@ -223,6 +263,33 @@ void ProcessArguments(int argc, char* argv[])
     for (; argc >= 1; argc--, argv++) {
         if (argv[0][0] == '-') {
             switch (argv[0][1]) {
+            case '-':
+                {
+                    std::string lowerword(argv[0]+2);
+                    std::transform(lowerword.begin(), lowerword.end(), lowerword.begin(), ::tolower);
+
+                    // handle --word style options
+                    if (lowerword == "shift-sampler-bindings" || // synonyms
+                        lowerword == "shift-sampler-binding"  ||
+                        lowerword == "ssb") {
+                        ProcessBindingBase(argc, argv, baseSamplerBinding);
+                    } else if (lowerword == "shift-texture-bindings" ||  // synonyms
+                               lowerword == "shift-texture-binding"  ||
+                               lowerword == "stb") {
+                        ProcessBindingBase(argc, argv, baseTextureBinding);
+                    } else if (lowerword == "shift-ubo-bindings" ||  // synonyms
+                               lowerword == "shift-ubo-binding"  ||
+                               lowerword == "sub") {
+                        ProcessBindingBase(argc, argv, baseUboBinding);
+                    } else if (lowerword == "auto-map-bindings" ||  // synonyms
+                               lowerword == "auto-map-binding"  || 
+                               lowerword == "amb") {
+                        Options |= EOptionAutoMapBindings;
+                    } else {
+                        usage();
+                    }
+                }
+                break;
             case 'H':
                 Options |= EOptionHumanReadableSpv;
                 if ((Options & EOptionSpv) == 0) {
@@ -461,6 +528,14 @@ void CompileAndLinkShaderUnits(std::vector<ShaderCompUnit> compUnits)
         shader->setStringsWithLengthsAndNames(compUnit.text, NULL, compUnit.fileNameList, 1);
         if (entryPointName) // HLSL todo: this needs to be tracked per compUnits
             shader->setEntryPoint(entryPointName);
+
+        shader->setShiftSamplerBinding(baseSamplerBinding[compUnit.stage]);
+        shader->setShiftTextureBinding(baseTextureBinding[compUnit.stage]);
+        shader->setShiftUboBinding(baseUboBinding[compUnit.stage]);
+
+        if (Options & EOptionAutoMapBindings)
+            shader->setAutoMapBindings(true);
+                
         shaders.push_back(shader);
 
         const int defaultVersion = Options & EOptionDefaultDesktop? 110: 100;
@@ -506,6 +581,10 @@ void CompileAndLinkShaderUnits(std::vector<ShaderCompUnit> compUnits)
         PutsIfNonEmpty(program.getInfoDebugLog());
     }
 
+    // Map IO
+    if (Options & EOptionSpv)
+        program.mapIO();
+    
     // Reflect
     if (Options & EOptionDumpReflection) {
         program.buildReflection();
@@ -705,15 +784,22 @@ int C_DECL main(int argc, char* argv[])
 //   .frag = fragment
 //   .comp = compute
 //
-EShLanguage FindLanguage(const std::string& name)
+EShLanguage FindLanguage(const std::string& name, bool parseSuffix)
 {
-    size_t ext = name.rfind('.');
-    if (ext == std::string::npos) {
-        usage();
-        return EShLangVertex;
+    size_t ext = 0;
+
+    // Search for a suffix on a filename: e.g, "myfile.frag".  If given
+    // the suffix directly, we skip looking the '.'
+    if (parseSuffix) {
+        ext = name.rfind('.');
+        if (ext == std::string::npos) {
+            usage();
+            return EShLangVertex;
+        }
+        ++ext;
     }
 
-    std::string suffix = name.substr(ext + 1, std::string::npos);
+    std::string suffix = name.substr(ext, std::string::npos);
     if (shaderStageName)
         suffix = shaderStageName;
 
@@ -831,6 +917,19 @@ void usage()
            "  -v          print version strings\n"
            "  -w          suppress warnings (except as required by #extension : warn)\n"
            "  -x          save 32-bit hexadecimal numbers as text, requires a binary option (e.g., -V)\n"
+           "\n"
+           "  --shift-sampler-binding [stage] num     set base binding number for samplers\n"
+           "  --ssb [stage] num                       synonym for --shift-sampler-binding\n"
+           "\n"
+           "  --shift-texture-binding [stage] num     set base binding number for textures\n"
+           "  --stb [stage] num                       synonym for --shift-texture-binding\n"
+           "\n"
+           "  --shift-UBO-binding [stage] num         set base binding number for UBOs\n"
+           "  --sub [stage] num                       synonym for --shift-UBO-binding\n"
+           "\n"
+           "  --auto-map-bindings                     automatically bind uniform variables without\n"
+           "                                          explicit bindings.\n"
+           "  --amb                                   synonym for --auto-map-bindings\n"
            );
 
     exit(EFailUsage);

Test/spv.register.autoassign.frag

+
+SamplerState       g_sSamp1 : register(s0);
+SamplerState       g_sSamp2;
+SamplerState       g_sSamp3[2] : register(s2);
+SamplerState       g_sSamp4[3];
+SamplerState       g_sSamp5;
+
+SamplerState       g_sSamp_unused1;
+SamplerState       g_sSamp_unused2;
+
+Texture1D          g_tTex1 : register(t1);
+const uniform Texture1D g_tTex2;
+Texture1D          g_tTex3[2] : register(t3);
+Texture1D          g_tTex4[3];
+Texture1D          g_tTex5;
+
+Texture1D          g_tTex_unused1 : register(t0);
+Texture1D          g_tTex_unused2 : register(t2);
+Texture1D          g_tTex_unused3;
+
+struct MyStruct_t {
+    int a;
+    float b;
+    float3 c;
+};
+
+uniform MyStruct_t mystruct : register(b4);
+
+struct PS_OUTPUT
+{
+    float4 Color : SV_Target0;
+};
+
+uniform float4 myfloat4_a;
+uniform float4 myfloat4_b;
+uniform int4 myint4_a;
+
+float4 Func1()
+{
+    return
+        g_tTex1    . Sample(g_sSamp1,    0.1) +
+        g_tTex2    . Sample(g_sSamp2,    0.2) +
+        g_tTex3[0] . Sample(g_sSamp3[0], 0.3) +
+        g_tTex3[1] . Sample(g_sSamp3[1], 0.3) +
+        g_tTex4[1] . Sample(g_sSamp4[1], 0.4) +
+        g_tTex4[2] . Sample(g_sSamp4[2], 0.4) +
+        g_tTex5    . Sample(g_sSamp5,    0.5) +
+        mystruct.c[1];
+}
+
+float4 Func2()
+{
+    return
+        g_tTex1    . Sample(g_sSamp1,    0.1) +
+        g_tTex3[1] . Sample(g_sSamp3[1], 0.3);
+}
+
+// Not called from entry point:
+float4 Func2_unused()
+{
+    return
+        g_tTex_unused1 . Sample(g_sSamp_unused1, 1.1) +
+        g_tTex_unused2 . Sample(g_sSamp_unused2, 1.2);
+}
+
+PS_OUTPUT main_ep()
+{
+    PS_OUTPUT psout;
+    psout.Color = Func1() + Func2();
+    return psout;
+}

Test/spv.register.noautoassign.frag

+
+SamplerState       g_sSamp1 : register(s0);
+SamplerState       g_sSamp2;
+SamplerState       g_sSamp3[2] : register(s2);
+SamplerState       g_sSamp4[3];
+SamplerState       g_sSamp5;
+
+SamplerState       g_sSamp_unused1;
+SamplerState       g_sSamp_unused2;
+
+Texture1D          g_tTex1 : register(t1);
+const uniform Texture1D g_tTex2;
+Texture1D          g_tTex3[2] : register(t3);
+Texture1D          g_tTex4[3];
+Texture1D          g_tTex5;
+
+Texture1D          g_tTex_unused1 : register(t0);
+Texture1D          g_tTex_unused2 : register(t2);
+Texture1D          g_tTex_unused3;
+
+struct MyStruct_t {
+    int a;
+    float b;
+    float3 c;
+};
+
+uniform MyStruct_t mystruct : register(b4);
+
+struct PS_OUTPUT
+{
+    float4 Color : SV_Target0;
+};
+
+uniform float4 myfloat4_a;
+uniform float4 myfloat4_b;
+uniform int4 myint4_a;
+
+float4 Func1()
+{
+    return
+        g_tTex1    . Sample(g_sSamp1,    0.1) +
+        g_tTex2    . Sample(g_sSamp2,    0.2) +
+        g_tTex3[0] . Sample(g_sSamp3[0], 0.3) +
+        g_tTex3[1] . Sample(g_sSamp3[1], 0.3) +
+        g_tTex4[1] . Sample(g_sSamp4[1], 0.4) +
+        g_tTex4[2] . Sample(g_sSamp4[2], 0.4) +
+        g_tTex5    . Sample(g_sSamp5,    0.5) +
+        mystruct.c[1];
+}
+
+float4 Func2()
+{
+    return
+        g_tTex1    . Sample(g_sSamp1,    0.1) +
+        g_tTex3[1] . Sample(g_sSamp3[1], 0.3);
+}
+
+// Not called from entry point:
+float4 Func2_unused()
+{
+    return
+        g_tTex_unused1 . Sample(g_sSamp_unused1, 1.1) +
+        g_tTex_unused2 . Sample(g_sSamp_unused2, 1.2);
+}
+
+PS_OUTPUT main_ep()
+{
+    PS_OUTPUT psout;
+    psout.Color = Func1() + Func2();
+    return psout;
+}

glslang/CMakeLists.txt

@@ -10,6 +10,7 @@ set(SOURCES
     MachineIndependent/glslang.y
     MachineIndependent/glslang_tab.cpp
     MachineIndependent/Constant.cpp
+    MachineIndependent/iomapper.cpp
     MachineIndependent/InfoSink.cpp
     MachineIndependent/Initialize.cpp
     MachineIndependent/IntermTraverse.cpp
@@ -55,6 +56,7 @@ set(HEADERS
     MachineIndependent/glslang_tab.cpp.h
     MachineIndependent/gl_types.h
     MachineIndependent/Initialize.h
+    MachineIndependent/iomapper.h
     MachineIndependent/LiveTraverser.h
     MachineIndependent/localintermediate.h
     MachineIndependent/ParseHelper.h

glslang/MachineIndependent/ShaderLang.cpp

@@ -60,6 +60,7 @@
 #define SH_EXPORTING
 #include "../Public/ShaderLang.h"
 #include "reflection.h"
+#include "iomapper.h"
 #include "Initialize.h"
 
 namespace { // anonymous namespace for file-local functions and symbols
@@ -1488,6 +1489,10 @@ void TShader::setEntryPoint(const char* entryPoint)
     intermediate->setEntryPointName(entryPoint);
 }
 
+void TShader::setShiftSamplerBinding(unsigned int base) { intermediate->setShiftSamplerBinding(base); }
+void TShader::setShiftTextureBinding(unsigned int base) { intermediate->setShiftTextureBinding(base); }
+void TShader::setShiftUboBinding(unsigned int base)     { intermediate->setShiftUboBinding(base); }
+void TShader::setAutoMapBindings(bool map)              { intermediate->setAutoMapBindings(map); }
 //
 // Turn the shader strings into a parse tree in the TIntermediate.
 //
@@ -1548,7 +1553,7 @@ const char* TShader::getInfoDebugLog()
     return infoSink->debug.c_str();
 }
 
-TProgram::TProgram() : pool(0), reflection(0), linked(false)
+TProgram::TProgram() : pool(0), reflection(0), ioMapper(nullptr), linked(false)
 {
     infoSink = new TInfoSink;
     for (int s = 0; s < EShLangCount; ++s) {
@@ -1700,4 +1705,24 @@ int TProgram::getAttributeType(int index)            { return reflection->getAtt
 
 void TProgram::dumpReflection()                      { reflection->dump(); }
 
+//
+// I/O mapping implementation.
+//
+bool TProgram::mapIO()
+{
+    if (! linked || ioMapper)
+        return false;
+
+    ioMapper = new TIoMapper;
+
+    for (int s = 0; s < EShLangCount; ++s) {
+        if (intermediate[s]) {
+            if (! ioMapper->addStage((EShLanguage)s, *intermediate[s]))
+                return false;
+        }
+    }
+
+    return true;
+}
+
 } // end namespace glslang

glslang/MachineIndependent/iomapper.cpp

+//
+//Copyright (C) 2016 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 "../Include/Common.h"
+#include "iomapper.h"
+#include "LiveTraverser.h"
+#include "localintermediate.h"
+
+#include "gl_types.h"
+
+#include <unordered_set>
+#include <unordered_map>
+
+//
+// Map IO bindings.
+//
+// High-level algorithm for one stage:
+//
+// 1. Traverse all code (live+dead) to find the explicitly provided bindings.
+//
+// 2. Traverse (just) the live code to determine which non-provided bindings
+//    require auto-numbering.  We do not auto-number dead ones.
+//
+// 3. Traverse all the code to apply the bindings:
+//    a. explicitly given bindings are offset according to their type
+//    b. implicit live bindings are auto-numbered into the holes, using
+//       any open binding slot.
+//    c. implicit dead bindings are left un-bound.
+//
+
+   
+namespace glslang {
+
+// Map of IDs to bindings
+typedef std::unordered_map<unsigned int, int> TBindingMap;
+typedef std::unordered_set<int> TUsedBindings;
+
+
+// This traverses the AST to determine which bindings are used, and which are implicit
+// (for subsequent auto-numbering)
+class TBindingTraverser : public TLiveTraverser {
+public:
+    TBindingTraverser(const TIntermediate& i, TBindingMap& bindingMap, TUsedBindings& usedBindings,
+                      bool traverseDeadCode = false) :
+        TLiveTraverser(i, traverseDeadCode),
+        bindingMap(bindingMap),
+        usedBindings(usedBindings)
+    { }
+
+protected:
+    virtual void visitSymbol(TIntermSymbol* base) {
+        if (base->getQualifier().storage == EvqUniform)
+            addUniform(*base);
+    }
+
+    // Return the right binding base given the variable type.
+    int getBindingBase(const TType& type) {
+        if (type.getBasicType() == EbtSampler) {
+            const TSampler& sampler = type.getSampler();
+            if (sampler.isPureSampler())
+                return intermediate.getShiftSamplerBinding();
+            if (sampler.isTexture())
+                return intermediate.getShiftTextureBinding();
+        }
+
+        if (type.getQualifier().isUniformOrBuffer())
+            return intermediate.getShiftUboBinding();
+
+        return -1;  // not a type with a binding
+    }
+
+    // Mark a given base symbol ID as being bound to 'binding'
+    void markBinding(const TIntermSymbol& base, int binding) {
+        bindingMap[base.getId()] = binding;
+
+        if (binding >= 0) {
+            // const TType& type = base.getType();
+            const unsigned int size = 1; // type.isArray() ? type.getCumulativeArraySize() : 1;
+
+            for (unsigned int offset=0; offset<size; ++offset)
+                usedBindings.insert(binding + offset);
+        }
+    }
+
+    // Mark the bindings that are given explicitly, and set ones that need
+    // implicit bindings to -1 for a subsequent pass.  (Can't happen in this
+    // pass because explicit bindings in dead code reserve the location).
+    virtual void addUniform(TIntermSymbol& base)
+    {
+        // Skip ones we've already seen.
+        if (bindingMap.find(base.getId()) != bindingMap.end())
+            return;
+
+        const TType& type = base.getType();
+        const int bindingBase = getBindingBase(type);
+
+        // Return if it's not a type we bind
+        if (bindingBase == -1)
+            return;
+
+        if (type.getQualifier().hasBinding()) {
+            // It has a binding: keep that one.
+            markBinding(base, type.getQualifier().layoutBinding + bindingBase);
+        } else if (!traverseAll) {
+            // Mark it as something we need to dynamically create a binding for,
+            // only if we're walking just the live code.  We don't auto-number
+            // in dead code.
+            markBinding(base, -1);
+        }
+    }
+
+    TBindingMap&         bindingMap;
+    TUsedBindings&       usedBindings;
+};
+
+
+// This traverses the AST and applies binding maps it's given.
+class TIoMappingTraverser : public TBindingTraverser {
+public:
+    TIoMappingTraverser(TIntermediate& i, TBindingMap& bindingMap, TUsedBindings& usedBindings,
+                        bool traverseDeadCode) :
+        TBindingTraverser(i, bindingMap, usedBindings, traverseDeadCode),
+        nextBinding(1)
+    { }
+
+protected:
+    void addUniform(TIntermSymbol& base) override
+    {
+        // Skip things we don't intend to bind.
+        if (bindingMap.find(base.getId()) == bindingMap.end())
+            return;
+
+        const int existingBinding = bindingMap[base.getId()];
+
+        // Apply existing binding, if we were given one or already made one up.
+        if (existingBinding != -1) {
+            base.getWritableType().getQualifier().layoutBinding = existingBinding;
+            return;
+        }
+
+        if (intermediate.getAutoMapBindings()) {
+            // Otherwise, find a free spot for it.
+            const int freeBinding = getFreeBinding(base.getType());
+
+            markBinding(base, freeBinding);
+            base.getWritableType().getQualifier().layoutBinding = freeBinding;
+        }
+    }
+
+    // Search for N free consecutive binding slots in [base, base+required).
+    // E.g, if we want to reserve consecutive bindings for flattened arrays.
+    bool hasNFreeSlots(int base, int required) {
+        for (int binding = base; binding < (base + required); ++binding)
+            if (usedBindings.find(binding) != usedBindings.end())
+                return false;
+        
+        return true;
+    }
+
+    // Find a free binding spot 
+    int getFreeBinding(const TType&) {
+        while (!hasNFreeSlots(nextBinding, 1))
+            ++nextBinding;
+
+        return nextBinding;
+    }
+
+    int nextBinding;
+};
+
+// Map I/O variables to provided offsets, and make bindings for
+// unbound but live variables.
+//
+// Returns false if the input is too malformed to do this.
+bool TIoMapper::addStage(EShLanguage, TIntermediate& intermediate)
+{
+    // Trivial return if there is nothing to do.
+    if (intermediate.getShiftSamplerBinding() == 0 &&
+        intermediate.getShiftTextureBinding() == 0 &&
+        intermediate.getShiftUboBinding() == 0 &&
+        intermediate.getAutoMapBindings() == false)
+        return true;
+
+    if (intermediate.getNumEntryPoints() != 1 || intermediate.isRecursive())
+        return false;
+
+    TIntermNode* root = intermediate.getTreeRoot();
+    if (root == nullptr)
+        return false;
+
+    // The lifetime of this data spans several passes.
+    TBindingMap   bindingMap;
+    TUsedBindings usedBindings;
+
+    TBindingTraverser it_binding_all(intermediate, bindingMap, usedBindings, true);
+    TBindingTraverser it_binding_live(intermediate, bindingMap, usedBindings, false);
+    TIoMappingTraverser it_iomap(intermediate, bindingMap, usedBindings, true);
+
+    // Traverse all (live+dead) code to find explicit bindings, so we can avoid those.
+    root->traverse(&it_binding_all);
+
+    // Traverse just live code to find things that need implicit bindings.
+    it_binding_live.pushFunction(intermediate.getEntryPointMangledName().c_str());
+
+    while (! it_binding_live.functions.empty()) {
+        TIntermNode* function = it_binding_live.functions.back();
+        it_binding_live.functions.pop_back();
+        function->traverse(&it_binding_live);
+    }
+
+    // Bind everything that needs a binding and doesn't have one.
+    root->traverse(&it_iomap);
+
+    return true;
+}
+
+} // end namespace glslang

glslang/MachineIndependent/iomapper.h

+//
+//Copyright (C) 2016 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.
+//
+
+#ifndef _IOMAPPER_INCLUDED
+#define _IOMAPPER_INCLUDED
+
+#include "../Public/ShaderLang.h"
+
+//
+// A reflection database and its interface, consistent with the OpenGL API reflection queries.
+//
+
+namespace glslang {
+
+class TIntermediate;
+
+// I/O mapper
+class TIoMapper {
+public:
+    TIoMapper() {}
+    virtual ~TIoMapper() {}
+
+    // grow the reflection stage by stage
+    bool addStage(EShLanguage, TIntermediate&);
+};
+
+} // end namespace glslang
+
+#endif // _IOMAPPER_INCLUDED

glslang/MachineIndependent/localintermediate.h

@@ -141,7 +141,11 @@ public:
         invocations(TQualifier::layoutNotSet), vertices(TQualifier::layoutNotSet), inputPrimitive(ElgNone), outputPrimitive(ElgNone),
         pixelCenterInteger(false), originUpperLeft(false),
         vertexSpacing(EvsNone), vertexOrder(EvoNone), pointMode(false), earlyFragmentTests(false), depthLayout(EldNone), depthReplacing(false), blendEquations(0),
-        multiStream(false), xfbMode(false)
+        multiStream(false), xfbMode(false),
+        shiftSamplerBinding(0),
+        shiftTextureBinding(0),
+        shiftUboBinding(0),
+        autoMapBindings(false)
     {
         localSize[0] = 1;
         localSize[1] = 1;
@@ -163,6 +167,16 @@ public:
     void setEntryPointMangledName(const char* ep) { entryPointMangledName = ep; }
     const std::string& getEntryPointName() const { return entryPointName; }
     const std::string& getEntryPointMangledName() const { return entryPointMangledName; }
+
+    void setShiftSamplerBinding(unsigned int shift) { shiftSamplerBinding = shift; }
+    unsigned int getShiftSamplerBinding() const { return shiftSamplerBinding; }
+    void setShiftTextureBinding(unsigned int shift) { shiftTextureBinding = shift; }
+    unsigned int getShiftTextureBinding() const { return shiftTextureBinding; }
+    void setShiftUboBinding(unsigned int shift)     { shiftUboBinding = shift; }
+    unsigned int getShiftUboBinding()     const { return shiftUboBinding; }
+    void setAutoMapBindings(bool map)               { autoMapBindings = map; }
+    bool getAutoMapBindings()             const { return autoMapBindings; }
+
     void setVersion(int v) { version = v; }
     int getVersion() const { return version; }
     void setProfile(EProfile p) { profile = p; }
@@ -367,6 +381,11 @@ protected:
     EShSource source;            // source language, known a bit later
     std::string entryPointName;
     std::string entryPointMangledName;
+    unsigned int shiftSamplerBinding;
+    unsigned int shiftTextureBinding;
+    unsigned int shiftUboBinding;
+    bool autoMapBindings;
+
     EProfile profile;
     int version;
     SpvVersion spvVersion;

glslang/Public/ShaderLang.h

@@ -300,6 +300,10 @@ public:
         const char* const* s, const int* l, const char* const* names, int n);
     void setPreamble(const char* s) { preamble = s; }
     void setEntryPoint(const char* entryPoint);
+    void setShiftSamplerBinding(unsigned int base);
+    void setShiftTextureBinding(unsigned int base);
+    void setShiftUboBinding(unsigned int base);
+    void setAutoMapBindings(bool map);
 
     // Interface to #include handlers.
     //
@@ -433,6 +437,7 @@ private:
 };
 
 class TReflection;
+class TIoMapper;
 
 // Make one TProgram per set of shaders that will get linked together.  Add all 
 // the shaders that are to be linked together.  After calling shader.parse()
@@ -470,6 +475,9 @@ public:
     int getAttributeType(int index);                 // can be used for glGetActiveAttrib()
     void dumpReflection();
 
+    // I/O mapping: apply base offsets and map live unbound variables
+    bool mapIO();
+
 protected:
     bool linkStage(EShLanguage, EShMessages);
 
@@ -479,6 +487,7 @@ protected:
     bool newedIntermediate[EShLangCount];      // track which intermediate were "new" versus reusing a singleton unit in a stage
     TInfoSink* infoSink;
     TReflection* reflection;
+    TIoMapper* ioMapper;
     bool linked;
 
 private:

gtests/Spv.FromFile.cpp

@@ -41,11 +41,30 @@
 namespace glslangtest {
 namespace {
 
+struct IoMapData {
+    const char* fileName;
+    const char* entryPoint;
+    int baseSamplerBinding;
+    int baseTextureBinding;
+    int baseUboBinding;
+    bool autoMapBindings;
+};
+
+std::string FileNameAsCustomTestSuffixIoMap(
+    const ::testing::TestParamInfo<IoMapData>& info) {
+    std::string name = info.param.fileName;
+    // A valid test case suffix cannot have '.' and '-' inside.
+    std::replace(name.begin(), name.end(), '.', '_');
+    std::replace(name.begin(), name.end(), '-', '_');
+    return name;
+}
+
 using CompileVulkanToSpirvTest = GlslangTest<::testing::TestWithParam<std::string>>;
 using CompileOpenGLToSpirvTest = GlslangTest<::testing::TestWithParam<std::string>>;
 using VulkanSemantics = GlslangTest<::testing::TestWithParam<std::string>>;
 using OpenGLSemantics = GlslangTest<::testing::TestWithParam<std::string>>;
 using VulkanAstSemantics = GlslangTest<::testing::TestWithParam<std::string>>;
+using HlslSemantics = GlslangTest<::testing::TestWithParam<IoMapData>>;
 
 // Compiling GLSL to SPIR-V under Vulkan semantics. Expected to successfully
 // generate SPIR-V.
@@ -91,6 +110,18 @@ TEST_P(VulkanAstSemantics, FromFile)
                             Target::AST);
 }
 
+// HLSL-level Vulkan semantics tests.
+TEST_P(HlslSemantics, FromFile)
+{
+    loadFileCompileIoMapAndCheck(GLSLANG_TEST_DIRECTORY, GetParam().fileName,
+                                 Source::HLSL, Semantics::Vulkan,
+                                 Target::Spv, GetParam().entryPoint,
+                                 GetParam().baseSamplerBinding,
+                                 GetParam().baseTextureBinding,
+                                 GetParam().baseUboBinding,
+                                 GetParam().autoMapBindings);
+}
+
 // clang-format off
 INSTANTIATE_TEST_CASE_P(
     Glsl, CompileVulkanToSpirvTest,
@@ -218,6 +249,16 @@ INSTANTIATE_TEST_CASE_P(
 
 // clang-format off
 INSTANTIATE_TEST_CASE_P(
+    Hlsl, HlslSemantics,
+    ::testing::ValuesIn(std::vector<IoMapData>{
+        { "spv.register.autoassign.frag", "main_ep", 5, 10, 15, true },
+        { "spv.register.noautoassign.frag", "main_ep", 5, 10, 15, false },
+    }),
+    FileNameAsCustomTestSuffixIoMap
+);
+
+// clang-format off
+INSTANTIATE_TEST_CASE_P(
     Glsl, CompileOpenGLToSpirvTest,
     ::testing::ValuesIn(std::vector<std::string>({
         "spv.atomic.comp",

gtests/TestFixture.h

@@ -234,6 +234,54 @@ public:
         }
     }
 
+    // Compiles and links the given source |code| of the given shader
+    // |stage| into the target under the semantics specified via |controls|.
+    // Returns a GlslangResult instance containing all the information generated
+    // during the process. If the target includes SPIR-V, also disassembles
+    // the result and returns disassembly text.
+    GlslangResult compileLinkIoMap(
+            const std::string shaderName, const std::string& code,
+            const std::string& entryPointName, EShMessages controls,
+            int baseSamplerBinding,
+            int baseTextureBinding,
+            int baseUboBinding,
+            bool autoMapBindings)
+    {
+        const EShLanguage kind = GetShaderStage(GetSuffix(shaderName));
+
+        glslang::TShader shader(kind);
+        shader.setShiftSamplerBinding(baseSamplerBinding);
+        shader.setShiftTextureBinding(baseTextureBinding);
+        shader.setShiftUboBinding(baseUboBinding);
+        shader.setAutoMapBindings(autoMapBindings);
+
+        bool success = compile(&shader, code, entryPointName, controls);
+
+        glslang::TProgram program;
+        program.addShader(&shader);
+        
+        success &= program.link(controls);
+        success &= program.mapIO();
+
+        spv::SpvBuildLogger logger;
+
+        if (success && (controls & EShMsgSpvRules)) {
+            std::vector<uint32_t> spirv_binary;
+            glslang::GlslangToSpv(*program.getIntermediate(kind),
+                                  spirv_binary, &logger);
+
+            std::ostringstream disassembly_stream;
+            spv::Parameterize();
+            spv::Disassemble(disassembly_stream, spirv_binary);
+            return {{{shaderName, shader.getInfoLog(), shader.getInfoDebugLog()},},
+                    program.getInfoLog(), program.getInfoDebugLog(),
+                    logger.getAllMessages(), disassembly_stream.str()};
+        } else {
+            return {{{shaderName, shader.getInfoLog(), shader.getInfoDebugLog()},},
+                    program.getInfoLog(), program.getInfoDebugLog(), "", ""};
+        }
+    }
+
     // This is like compileAndLink but with remapping of the SPV binary
     // through spirvbin_t::remap().  While technically this could be merged
     // with compileAndLink() above (with the remap step optionally being a no-op)
@@ -347,6 +395,38 @@ public:
                                     expectedOutputFname);
     }
 
+    void loadFileCompileIoMapAndCheck(const std::string& testDir,
+                                      const std::string& testName,
+                                      Source source,
+                                      Semantics semantics,
+                                      Target target,
+                                      const std::string& entryPointName,
+                                      int baseSamplerBinding,
+                                      int baseTextureBinding,
+                                      int baseUboBinding,
+                                      bool autoMapBindings)
+    {
+        const std::string inputFname = testDir + "/" + testName;
+        const std::string expectedOutputFname =
+            testDir + "/baseResults/" + testName + ".out";
+        std::string input, expectedOutput;
+
+        tryLoadFile(inputFname, "input", &input);
+        tryLoadFile(expectedOutputFname, "expected output", &expectedOutput);
+
+        const EShMessages controls = DeriveOptions(source, semantics, target);
+        GlslangResult result = compileLinkIoMap(testName, input, entryPointName, controls,
+                                                baseSamplerBinding, baseTextureBinding, baseUboBinding,
+                                                autoMapBindings);
+
+        // Generate the hybrid output in the way of glslangValidator.
+        std::ostringstream stream;
+        outputResultToStream(&stream, result, controls);
+
+        checkEqAndUpdateIfRequested(expectedOutput, stream.str(),
+                                    expectedOutputFname);
+    }
+
     void loadFileCompileRemapAndCheck(const std::string& testDir,
                                       const std::string& testName,
                                       Source source,