Run array specialization in a sperate pass. (#1449)

* Run array specialization in a sperate pass.

* rename specializeFunctionCall->specializeFunctionCalls

Co-authored-by: Tim Foley <tfoleyNV@users.noreply.github.com>

8 files changed, 973 insertions, 832 deletions

diff --git a/source/slang/slang-emit.cpp b/source/slang/slang-emit.cpp
index 72b2e07c5..b08f26137 100644
--- a/source/slang/slang-emit.cpp
+++ b/source/slang/slang-emit.cpp
@@ -20,6 +20,7 @@
 #include "slang-ir-restructure.h"
 #include "slang-ir-restructure-scoping.h"
 #include "slang-ir-specialize.h"
+#include "slang-ir-specialize-arrays.h"
 #include "slang-ir-specialize-resources.h"
 #include "slang-ir-ssa.h"
 #include "slang-ir-strip-witness-tables.h"
@@ -454,6 +455,14 @@ Result linkAndOptimizeIR(
     //
     specializeResourceParameters(compileRequest, targetRequest, irModule);
 
+    // For GLSL targets, we also want to specialize calls to functions that
+    // takes array parameters if possible, to avoid performance issues on
+    // those platforms.
+    if (isKhronosTarget(targetRequest))
+    {
+        specializeArrayParameters(compileRequest, targetRequest, irModule);
+    }
+
 #if 0
     dumpIRIfEnabled(compileRequest, irModule, "AFTER RESOURCE SPECIALIZATION");
 #endif
diff --git a/source/slang/slang-ir-specialize-arrays.cpp b/source/slang/slang-ir-specialize-arrays.cpp
new file mode 100644
index 000000000..53e317b81
--- /dev/null
+++ b/source/slang/slang-ir-specialize-arrays.cpp
@@ -0,0 +1,53 @@
+// slang-ir-specialize-arrays.cpp
+#include "slang-ir-specialize-arrays.h"
+
+#include "slang-ir-specialize-function-call.h"
+#include "slang-ir.h"
+#include "slang-ir-insts.h"
+
+namespace Slang
+{
+
+struct ArrayParameterSpecializationCondition : FunctionCallSpecializeCondition
+{
+    // This pass is intended to specialize functions
+    // with struct parameters that has array fields
+    // to avoid performance problems for GLSL targets.
+
+    // Returns true if `type` is an `IRStructType` with array-typed fields.
+    bool isStructTypeWithArray(IRType* type)
+    {
+        if (auto structType = as<IRStructType>(type))
+        {
+            for (auto field : structType->getFields())
+            {
+                if (auto arrayType = as<IRArrayType>(field->getFieldType()))
+                {
+                    return true;
+                }
+                if (auto subStructType = as<IRStructType>(field->getFieldType()))
+                {
+                    if (isStructTypeWithArray(subStructType))
+                        return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    bool doesParamNeedSpecialization(IRParam* param)
+    {
+        return isStructTypeWithArray(param->getDataType());
+    }
+};
+
+void specializeArrayParameters(
+    BackEndCompileRequest* compileRequest,
+    TargetRequest*  targetRequest,
+    IRModule*       module)
+{
+    ArrayParameterSpecializationCondition condition;
+    specializeFunctionCalls(compileRequest, targetRequest, module, &condition);
+}
+
+} // namesapce Slang
diff --git a/source/slang/slang-ir-specialize-arrays.h b/source/slang/slang-ir-specialize-arrays.h
new file mode 100644
index 000000000..6373abb1d
--- /dev/null
+++ b/source/slang/slang-ir-specialize-arrays.h
@@ -0,0 +1,25 @@
+// slang-ir-specialize-arrays.h
+#pragma once
+
+namespace Slang
+{
+    class BackEndCompileRequest;
+    class TargetRequest;
+    struct IRModule;
+
+    /// Specialize calls to functions that take parameters of
+    /// `struct` type with array fields.
+    ///
+    /// For any function that has such input parameters, this pass
+    /// will rewrite any call sites that pass suitable arguments
+    /// (e.g., direct references to global shader parameters) to
+    /// instead call a specialized variant of the function that does
+    /// not have those array parameters, if the array can be referenced
+    /// from global shader parameters directly.
+    /// This is an optimization for GL/VK backend since the downstream
+    /// compiler doesn't seem to optimize such code well.
+    void specializeArrayParameters(
+        BackEndCompileRequest* compileRequest,
+        TargetRequest* targetRequest,
+        IRModule* module);
+}
diff --git a/source/slang/slang-ir-specialize-function-call.cpp b/source/slang/slang-ir-specialize-function-call.cpp
new file mode 100644
index 000000000..7e6c819d3
--- /dev/null
+++ b/source/slang/slang-ir-specialize-function-call.cpp
@@ -0,0 +1,830 @@
+// slang-ir-specialize-function-call.cpp
+#include "slang-ir-specialize-function-call.h"
+
+#include "slang-ir.h"
+#include "slang-ir-clone.h"
+#include "slang-ir-insts.h"
+
+namespace Slang
+{
+
+struct FunctionParameterSpecializationContext
+{
+    // This type implements a pass to specialize functions
+    // with specific types of parameters (identified by
+    // `condition`) to ensure that they are
+    // legal or optimized for a given target.
+    //
+    // We start with member variables to stand in for
+    // the parameters that were passed to the top-level
+    // `specializeFunctionParameters` function.
+    //
+    BackEndCompileRequest* compileRequest;
+    TargetRequest*  targetRequest;
+    IRModule*       module;
+
+    // The condition on which parameters to specialize.
+    FunctionCallSpecializeCondition* condition;
+
+    // Our general approach will be to think in terms
+    // of specializing call sites, which amount to
+    // `IRCall` instructions. We will keep a work list
+    // of call sites in the program that may be worth
+    // considering for specialization.
+    //
+    List<IRCall*>   workList;
+
+    // Because we may need to generate specialized functions
+    // and generate new calls to those functions, we'll
+    // need some IR building state to get our work done.
+    //
+    SharedIRBuilder sharedBuilderStorage;
+    IRBuilder       builderStorage;
+    IRBuilder* getBuilder() { return &builderStorage; }
+
+    // With the basic state out of the way, let's walk
+    // through the overall flow of the pass.
+    //
+    void processModule()
+    {
+        // We will start by initializing our IR building state.
+        //
+        sharedBuilderStorage.module = module;
+        sharedBuilderStorage.session = module->getSession();
+        builderStorage.sharedBuilder = &sharedBuilderStorage;
+
+        // Next we will populate our initial work list by
+        // recursively finding every single call site in the module.
+        //
+        addCallsToWorkListRec(module->getModuleInst());
+
+        // We will process the work list until it goes dry,
+        // treating it like a stack of work items.
+        //
+        while( workList.getCount() )
+        {
+            auto call = workList.getLast();
+            workList.removeLast();
+
+            // At each call site we first check whether it
+            // is something we can (and should) specialize,
+            // and if so, do it. The process of specializing
+            // a function may introduce new call sites that
+            // become candidates for specialization, so
+            // our work list may grow along the way.
+            //
+            if( canSpecializeCall(call) )
+            {
+                specializeCall(call);
+            }
+        }
+    }
+
+    // Setting up the work list is a simple recursive procedure.
+    //
+    void addCallsToWorkListRec(IRInst* inst)
+    {
+        // If we have a call site, then add it to the list.
+        //
+        if( auto call = as<IRCall>(inst) )
+        {
+            workList.add(call);
+        }
+
+        // Recursively walk through any children, to
+        // see if we uncover more call sites.
+        //
+        for( auto child : inst->getChildren() )
+        {
+            addCallsToWorkListRec(child);
+        }
+    }
+
+    // We need a way to decide for a given call site
+    // whether we can/must specialize it.
+    //
+    bool canSpecializeCall(IRCall* call)
+    {
+        // We can only specialize calls where the callee
+        // func can be statically identified, and where
+        // the callee is a definition (with body) rather
+        // than a declaration. Otherwise there is no
+        // way to generate a specialized callee function.
+        //
+        auto func = as<IRFunc>(call->getCallee());
+        if(!func)
+            return false;
+        if(!func->isDefinition())
+            return false;
+
+        // With the basic checks out of the way, there are
+        // two conditions we care about:
+        //
+        // 1. Should we specialize? This amounts to whether
+        // `func` has any parameters that need specialization.
+        // We will call those "specializable" parameters for
+        // lack of a better name.
+        //
+        // 2. Can we specialize? This amounts to whether the
+        // arguments in `call` that correspond to those
+        // specializable parameters are "suitable" for use
+        // in specialization.
+        //
+        // We are going to answer both of these queries in
+        // a single loop that walks over the parameters of
+        // `func` as well as the arguments to `call`.
+        //
+        // The loop may seem a bit awkward because we are
+        // doing a parallel iteration over a linked list
+        // (the parameters of `func`) and an array (the
+        // arguments of `call`).
+        //
+        bool anySpecializableParam = false;
+        UInt argCounter = 0;
+        for( auto param : func->getParams() )
+        {
+            UInt argIndex = argCounter++;
+            SLANG_ASSERT(argIndex < call->getArgCount());
+            auto arg = call->getArg(argIndex);
+
+            // If the given parameter doesn't need specialization,
+            // then we need to keep looking.
+            //
+            if(!doesParamNeedSpecialization(param))
+                continue;
+
+            // If we have run into a `param` that needs specialization,
+            // then our first condition is met.
+            //
+            anySpecializableParam = true;
+
+            // Now we need to check whether `arg` is actually suitable
+            // for specialization (our second condition). If not, we
+            // can bail out immediately because our second condition
+            // cannot be met.
+            //
+            if(!isArgSuitableForSpecialization(arg))
+                return false;
+        }
+
+        // If we exit the loop, then the second condition must have
+        // been met (all the arguments for specializable parameters
+        // were suitable for specialization), and the result of the
+        // query comes down to the first condition.
+        //
+        return anySpecializableParam;
+    }
+
+    // Of course, now we need to back-fill the predicates that
+    // the above function used to evaluate prameters and arguments.
+
+    bool doesParamNeedSpecialization(IRParam* param)
+    {
+        return condition->doesParamNeedSpecialization(param);
+    }
+
+    bool isArgSuitableForSpecialization(IRInst* inArg)
+    {
+        // Determining if an argument is suitable for
+        // specializing a callee function requires
+        // looking at its (recurisve) structure.
+        //
+        // Rather than write a recursively procedure
+        // here, we will be tail-recursive by using
+        // a simple loop.
+        //
+        IRInst* arg = inArg;
+        for(;;)
+        {
+            // The leaf case we care about is when the
+            // argument at the call site is a global
+            // shader parameter, because then we can
+            // specialize a callee to refer to the same
+            // global parameter directly.
+            //
+            if(as<IRGlobalParam>(arg)) return true;
+
+            // As we will see later, we can also
+            // specialize a call when the argument
+            // is the result of indexing into an
+            // array (`base[index]`) *if* the `base`
+            // of the indexing operation is also
+            // suitable for specialization.
+            //
+            if( arg->op == kIROp_getElement || arg->op == kIROp_Load )
+            {
+                auto base = arg->getOperand(0);
+
+                // We will "recurse" on the base of
+                // the indexing operation by continuing
+                // our loop with the `base` as our new
+                // argument.
+                //
+                arg = base;
+                continue;
+            }
+
+            // By default, we will *not* consider an argument
+            // suitable for specialization.
+            //
+            // TODO: There may be other cases that are worth
+            // handling here. The current code is based on
+            // observation of what simple shaders do in
+            // practice.
+            //
+            return false;
+        }
+    }
+
+    // Once we'e determined that a given call site can/should
+    // be specialized, we need to perform the actual specialization.
+    // This is where things are going to get more involved.
+    //
+    // There are a few different concerns we need to deal with
+    // that mean we end up having two different passes that walk
+    // over the parameters/arguments of the call (in addition to
+    // the ones we had above for determining if we can/should
+    // specialize in the first place).
+    //
+    // The first of the two passes determines information
+    // relevant to the call site, comprising both the arguments
+    // that will be passed to the specialized function as
+    // well as a "key" to identify the specialized function
+    // that is required.
+    //
+    // We will use the key type defined as part of the IR cloning
+    // infrastructure, which uses a sequence of `IRInst*`s
+    // to hold the state of the key:
+    //
+    typedef IRSimpleSpecializationKey Key;
+
+    // As indicated above, the information we collect about a call
+    // site consists of the key for the specialized function we
+    // will call, and a list of the arguments that will be passed
+    // to the call.
+    //
+    struct CallSpecializationInfo
+    {
+        Key             key;
+        List<IRInst*>   newArgs;
+    };
+
+    // Once we've collected the information about a call site
+    // we can use a dictionary to see if we already created
+    // a specialized version of the callee that matches its
+    // requirements.
+    //
+    Dictionary<Key, IRFunc*> specializedFuncs;
+
+    // If the dictionary didn't have a specialized function
+    // suitable for a call site, we need a second information-gathering
+    // pass to decide what the new parameters of the specialized
+    // functions should be, and what instructions the new function
+    // must execute in its body to set up the replacements for the
+    // old parameters.
+    //
+    struct FuncSpecializationInfo
+    {
+        List<IRParam*>  newParams;
+        List<IRInst*>   newBodyInsts;
+        List<IRInst*>   replacementsForOldParameters;
+    };
+
+    // Before diving into how the different passes collect
+    // their information, we will dive into the main
+    // specialization logic first.
+    //
+    void specializeCall(IRCall* oldCall)
+    {
+        // We have an existing call site `oldCall` that
+        // we know can and should be specialized.
+        //
+        // That means the callee should be a known function
+        // definition, or else `canSpecializeCall` didn't
+        // correctly check the preconditions.
+        //
+        auto oldFunc = as<IRFunc>(oldCall->getCallee());
+        SLANG_ASSERT(oldFunc);
+        SLANG_ASSERT(oldFunc->isDefinition());
+
+        // Our first information-gathering pass will
+        // compute the key for the specialized function
+        // we want to call, and the arguments we will
+        // use for that call.
+        //
+        CallSpecializationInfo callInfo;
+        gatherCallInfo(oldCall, oldFunc, callInfo);
+
+        // Once we have gathered information on the call,
+        // we can check if we have an existing specialization
+        // that we generated before (for another call site)
+        // that is suitable to this call site.
+        //
+        IRFunc* newFunc = nullptr;
+        if( !specializedFuncs.TryGetValue(callInfo.key, newFunc) )
+        {
+            // If we didn't find a pre-existing specialized
+            // function, then we will go ahead and create one.
+            //
+            // We start by gathering the information from the call
+            // site that is relevant to generating a specialized
+            // callee function, which we avoided doing earlier
+            // because it might have been throwaway work.
+            //
+            FuncSpecializationInfo funcInfo;
+            gatherFuncInfo(oldCall, oldFunc, funcInfo);
+
+            // Now we use the gathered information to generate
+            // a new callee function based on the original
+            // function and the information we gathered.
+            //
+            newFunc = generateSpecializedFunc(oldFunc, funcInfo);
+            specializedFuncs.Add(callInfo.key, newFunc);
+        }
+
+        // Once we've other found or generated a specialized function
+        // we need to generate a call to it, and then use the new
+        // call as a replacement for the old one.
+        //
+        auto newCall = getBuilder()->emitCallInst(
+            oldCall->getFullType(),
+            newFunc,
+            callInfo.newArgs.getCount(),
+            callInfo.newArgs.getBuffer());
+
+        newCall->insertBefore(oldCall);
+        oldCall->replaceUsesWith(newCall);
+        oldCall->removeAndDeallocate();
+    }
+
+    // Before diving into the details on how we gather information
+    // and specialize callees, lets stop to think about what we'd
+    // like to do in terms of individual parameters and arguments.
+    //
+    // Suppose we are specializing both a call site C and the callee
+    // function F, and we are consisering a particular pair of
+    // a parmeter P of F, and an argument A at the call site.
+    //
+    // The full extent of information we might want to know given
+    // P and A is:
+    //
+    // * What arguments need to be added to the specialized call?
+    // * What parameters need to be added to the specialized callee?
+    // * What instructions are needed in the body of the specialized
+    //   callee to synthesize the value that will stand in for P?
+    // * What information, if any, needs to be used to distinguish
+    //   this specialized callee from others that might be generated for F?
+    //
+    // An easy case is when P is a parameter that doesn't need
+    // specialization. In that case:
+    //
+    // * The existing argument A should be used as an argument in
+    //   the specialized call.
+    // * A clone P' of the existing parameter P should be used as a
+    //   parameter of the specialized callee.
+    // * No additional instructions are needed in the body of
+    //   the callee; the cloned parameter P' should stand in for P.
+    // * No information should be added to the specialization key
+    //   based on P and A.
+    //
+    // The more interesting case is when P has a resource type, and
+    // A is some global shader parameter G.
+    //
+    // * No argument should be added at the new call site
+    // * No parameter should be added to the specialized callee
+    // * No additional instructions are needed in the body of
+    //   the callee; the global G should stand in for P.
+    // * The global G should be used to distinguish this specialized
+    //   callee from those that might be specialized for a different
+    //   global shader parameter.
+    //
+    // As a final example, imagine that P is still a resource type,
+    // but A is now an indexing operation into an array: `G[idx]`:
+    //
+    // * An argument for `idx` should be added at the call site
+    // * A parameter `p_idx` with the same type as `idx` should be added
+    //   to the specialized callee.
+    // * An instruction should be added to the specialized callee
+    //   to compute `G[p_idx]` and use that to stand in for P.
+    // * The global G should still be used to distinguish this specialized
+    //   call site from others.
+    //
+    // That's a lot of examples, I know, but hopefully it gives a
+    // sense of the information we are tracking and how it differs
+    // across the various cases. While the example only covered one
+    // level of indexing, the actual implementation will handle the
+    // case of arbitrarily many levels of indexing, which can mean
+    // piping through any number of additional integer parameters
+    // to the callee.
+
+    // The information we gather for a call site (before we know
+    // whether a specialize calle is needed) is just the new
+    // argument list, and the "key" information that distinguishes
+    // what specialized callee we want/need.
+    //
+    void gatherCallInfo(
+        IRCall*                 oldCall,
+        IRFunc*                 oldFunc,
+        CallSpecializationInfo& callInfo)
+    {
+        // The specialized callee key always needs to include
+        // the original function, since different functions
+        // will always yield different specializations.
+        //
+        callInfo.key.vals.add(oldFunc);
+
+        // The rest of the information is gathered by looking
+        // at parameter and argument pairs.
+        //
+        UInt oldArgCounter = 0;
+        for( auto oldParam : oldFunc->getParams() )
+        {
+            UInt oldArgIndex = oldArgCounter++;
+            auto oldArg = oldCall->getArg(oldArgIndex);
+
+            getCallInfoForParam(callInfo, oldParam, oldArg);
+        }
+    }
+
+    void getCallInfoForParam(
+        CallSpecializationInfo& ioInfo,
+        IRParam*                oldParam,
+        IRInst*                 oldArg)
+    {
+        // We know that the case where a parameter
+        // doesn't need specialization is easy.
+        //
+        if( !doesParamNeedSpecialization(oldParam) )
+        {
+            // The new call site will use the same argument
+            // value as the old one, and we don't need
+            // to add any information to distinguish the
+            // specialized callee based on this paramter.
+            //
+            ioInfo.newArgs.add(oldArg);
+        }
+        else
+        {
+            // If specialization is needed, we need
+            // to inspect the argument value. This
+            // is handled with a different function
+            // because it needs to recurse in some cases.
+            //
+            getCallInfoForArg(ioInfo, oldArg);
+        }
+    }
+
+    void getCallInfoForArg(
+        CallSpecializationInfo& ioInfo,
+        IRInst*                 oldArg)
+    {
+        // The base case we care about is when the original
+        // argument is a global shader parameter.
+        //
+        if( auto oldGlobalParam = as<IRGlobalParam>(oldArg) )
+        {
+            // In this case we don't need to pass anything
+            // as an argument at the new call site (the
+            // global parameter will get specialized into
+            // the callee), but we *do* need to make sure
+            // that our key for identifying the specialized
+            // callee reflects that we are specializing
+            // to the chosen parameter.
+            //
+            ioInfo.key.vals.add(oldGlobalParam);
+        }
+        else if( oldArg->op == kIROp_getElement )
+        {
+            // This is the case where the `oldArg` is
+            // in the form `oldBase[oldIndex]`
+            //
+            auto oldBase  = oldArg->getOperand(0);
+            auto oldIndex = oldArg->getOperand(1);
+
+            // Effectively, we act as if `oldBase` and
+            // `oldIndex` were passed to the callee separately,
+            // so that `oldBase` is an array-of-resouces and
+            // `oldIndex` is an ordinary integer argument.
+            //
+            // We start by recursively setting up whatever
+            // `oldBase` needs:
+            //
+            getCallInfoForArg(ioInfo, oldBase);
+
+            // Then we process `oldIndex` just like we
+            // would have an ordinary argument that doesn't
+            // involve specialization: add its value to
+            // the arguments at the new call site, and
+            // don't add anything to the specialization key.
+            //
+            ioInfo.newArgs.add(oldIndex);
+        }
+        else if (oldArg->op == kIROp_Load)
+        {
+            auto oldBase = oldArg->getOperand(0);
+            getCallInfoForArg(ioInfo, oldBase);
+        }
+        else
+        {
+            // If we fail to match any of the cases above
+            // then a precondition was violated in that
+            // `isArgSuitableForSpecialization` is allowing
+            // a case that this routine is not covering.
+            //
+            SLANG_UNEXPECTED("mising case in 'getCallInfoForArg'");
+        }
+    }
+
+    // The remaining information we've discussed is only
+    // gathered once we decide we want to generate a
+    // specialized function, but it follows much the same flow.
+    //
+    void gatherFuncInfo(
+        IRCall*                 oldCall,
+        IRFunc*                 oldFunc,
+        FuncSpecializationInfo& funcInfo)
+    {
+        UInt oldArgCounter = 0;
+        for( auto oldParam : oldFunc->getParams() )
+        {
+            UInt oldArgIndex = oldArgCounter++;
+            auto oldArg = oldCall->getArg(oldArgIndex);
+
+            // For each parameter and argument pair we will
+            // frame the main task as producing a value that
+            // will stand in for the parameter in the specialized
+            // function.
+            //
+            auto newVal = getSpecializedValueForParam(funcInfo, oldParam, oldArg);
+
+            // We will collect the replacement value to use
+            // for each of the original parameters in an array.
+            //
+            funcInfo.replacementsForOldParameters.add(newVal);
+        }
+    }
+
+    IRInst* getSpecializedValueForParam(
+        FuncSpecializationInfo& ioInfo,
+        IRParam*                oldParam,
+        IRInst*                 oldArg)
+    {
+        // As always, the easy case is when the parameter of
+        // the original function doesn't need specialization.
+        //
+        if( !doesParamNeedSpecialization(oldParam) )
+        {
+            // The specialized callee will need a new parameter
+            // that fills the same role as the old one, so we
+            // create it here.
+            //
+            auto newParam = getBuilder()->createParam(oldParam->getFullType());
+            ioInfo.newParams.add(newParam);
+
+            // The new parameter will be used as the replacement
+            // for the old one in the specialized function.
+            //
+            return newParam;
+        }
+        else
+        {
+            // If the parameter requires specialization, then it
+            // is time to look at the structure of the argument.
+            //
+            return getSpecializedValueForArg(ioInfo, oldArg);
+        }
+    }
+
+    IRInst* getSpecializedValueForArg(
+        FuncSpecializationInfo& ioInfo,
+        IRInst*                 oldArg)
+    {
+        // The logic here parallels `gatherCallInfoForArg`,
+        // and only differs in what information it is gathering.
+        //
+        // As before, the base case is when we have a global
+        // shader parameter.
+        //
+        if( auto globalParam = as<IRGlobalParam>(oldArg) )
+        {
+            // The specialized function will not need any
+            // parameter in this case, and the global itself
+            // should be used to stand in for the original
+            // parameter in the specialized function.
+            //
+            return globalParam;
+        }
+        else if( oldArg->op == kIROp_getElement )
+        {
+            // This is the case where the argument is
+            // in the form `oldBase[oldIndex]`.
+            //
+            auto oldBase  = oldArg->getOperand(0);
+            auto oldIndex = oldArg->getOperand(1);
+
+            // In `gatherCallInfoForArg` this case was
+            // handled by acting as if `oldBase` and
+            // `oldIndex` were being passed as two
+            // separate arguments.
+            //
+            // We'll follow the same structure here,
+            // starting by recursively processing `oldBase`
+            // to get a value that can stand in for it
+            // in the specialized callee.
+            //
+            auto newBase = getSpecializedValueForArg(ioInfo, oldBase);
+
+            // Next we'll process `oldIndex` as if it
+            // was an ordinary argument (not a specialized one),
+            // which means creating a parameter to receive its value,
+            // which will also stand in for `oldIndex` in
+            // the body of the specialized callee.
+            //
+            auto builder = getBuilder();
+            auto newIndex = builder->createParam(oldIndex->getFullType());
+            ioInfo.newParams.add(newIndex);
+
+            // Finally, we need to compute a value that
+            // can stand in for `oldArg` (which was
+            // `oldBase[oldIndex]`) in the body of the
+            // specialized callee.
+            //
+            // Because we have both a `newBase` and a
+            // `newIndex` it is natural to construct
+            // `newBase[newIndex]` and use that.
+            //
+            // The only complication is that we need
+            // to make sure that our IR builder isn't
+            // set to insert newly created instructions
+            // anywhere, since the `emit*` functions
+            // will try to automatically insert new
+            // instructions if an insertion location
+            // is set.
+            //
+            builder->setInsertInto(nullptr);
+            auto newVal = builder->emitElementExtract(
+                oldArg->getFullType(),
+                newBase,
+                newIndex);
+
+            // Because our new instruction wasn't
+            // actually inserted anywhere, we need to
+            // add it to our gathered list of instructions
+            // that should be inserted into the body of
+            // the specialized callee.
+            //
+            ioInfo.newBodyInsts.add(newVal);
+
+            return newVal;
+        }
+        else if (oldArg->op == kIROp_Load)
+        {
+            return getSpecializedValueForArg(ioInfo, oldArg->getOperand(0));
+        }
+        else
+        {
+            // If we don't match one of the above cases,
+            // then `isArgSuitableForSpecialization` is
+            // letting through cases that this function
+            // hasn't been updated to handle.
+            //
+            SLANG_UNEXPECTED("mising case in 'getSpecializedValueForArg'");
+            UNREACHABLE_RETURN(nullptr);
+        }
+    }
+
+    // With all of that data-gathering code out of the way,
+    // we are now prepared to walk through the process of
+    // specializing a given callee function based on
+    // the information we have gathered.
+    //
+    IRFunc* generateSpecializedFunc(
+        IRFunc*                         oldFunc,
+        FuncSpecializationInfo const&   funcInfo)
+    {
+        // We will make use of the infrastructure for cloning
+        // IR code, that is defined in `ir-clone.{h,cpp}`.
+        //
+        // In order to do the cloning work we need an
+        // "environment" that will map old values to
+        // their replacements.
+        //
+        IRCloneEnv cloneEnv;
+
+        // Next we iterate over the parameters of the old
+        // function, and register each as being mapped
+        // to its replacement in the `funcInfo` that was
+        // already gathered.
+        //
+        UInt paramCounter = 0;
+        for( auto oldParam : oldFunc->getParams() )
+        {
+            UInt paramIndex = paramCounter++;
+            auto newVal = funcInfo.replacementsForOldParameters[paramIndex];
+            cloneEnv.mapOldValToNew.Add(oldParam, newVal);
+        }
+
+        // Next we will create the skeleton of the new
+        // specialized function, including its type.
+        //
+        // To get the type of the new function we will
+        // iterate over the collected list of new
+        // parameters (which may differ greatly from the
+        // parameter list of the original) and extract
+        // their types.
+        //
+        List<IRType*> paramTypes;
+        for( auto param : funcInfo.newParams )
+        {
+            paramTypes.add(param->getFullType());
+        }
+
+        auto builder = getBuilder();
+        IRType* funcType = builder->getFuncType(
+            paramTypes.getCount(),
+            paramTypes.getBuffer(),
+            oldFunc->getResultType());
+
+        IRFunc* newFunc = builder->createFunc();
+        newFunc->setFullType(funcType);
+
+        // The above step has accomplished the "first phase"
+        // of cloning the function (since `IRFunc`s have no
+        // operands).
+        //
+        // We can now use the shared IR cloning infrastructure
+        // to perform the second phase of cloning, which will recursively
+        // clone any nested decorations, blocks, and instructions.
+        //
+        cloneInstDecorationsAndChildren(
+            &cloneEnv,
+            builder->sharedBuilder,
+            oldFunc,
+            newFunc);
+
+        // We are almost done at this point, except that `newFunc`
+        // is lacking its parameters, as well as any of the body
+        // instructions that we decided were needed during
+        // the information-gathering steps.
+        //
+        // We will insert these instructions into the first block
+        // of the function, before its first ordinary instruction.
+        // We know that these should exist because we had as
+        // a precondition that `oldFunc` was a definition (so it
+        // has at least one block), and in valid IR every block
+        // has at least one ordinary instruction (its terminator).
+        //
+        auto newEntryBlock = newFunc->getFirstBlock();
+        SLANG_ASSERT(newEntryBlock);
+        auto newFirstOrdinary = newEntryBlock->getFirstOrdinaryInst();
+        SLANG_ASSERT(newFirstOrdinary);
+
+        // We simply iterate over the list of parameters and then
+        // body instructions that were produced in the information
+        // gathering step, and insert each before `newFirstOrdinary`,
+        // which has the effect or arranging them in the output
+        // in the order they are enumerated here.
+        //
+        for( auto newParam : funcInfo.newParams )
+        {
+            newParam->insertBefore(newFirstOrdinary);
+        }
+        for( auto newBodyInst : funcInfo.newBodyInsts )
+        {
+            newBodyInst->insertBefore(newFirstOrdinary);
+        }
+
+        // At this point we've created a new specialized function,
+        // and as such it may contain call sites that were not
+        // covered when we built our initial work list.
+        //
+        // Before handing the specialized function back to the
+        // caller, we will make sure to recursively add any
+        // potentially-specializable call sites to our work list.
+        //
+        addCallsToWorkListRec(newFunc);
+
+        return newFunc;
+    }
+};
+
+// The top-level function for invoking the specialization pass
+// is straighforward. We set up the context object
+// and then defer to it for the real work.
+//
+void specializeFunctionCalls(
+    BackEndCompileRequest* compileRequest,
+    TargetRequest*  targetRequest,
+    IRModule*       module,
+    FunctionCallSpecializeCondition* condition)
+{
+    FunctionParameterSpecializationContext context;
+    context.compileRequest = compileRequest;
+    context.targetRequest = targetRequest;
+    context.module = module;
+    context.condition = condition;
+
+    context.processModule();
+}
+
+} // namesapce Slang
diff --git a/source/slang/slang-ir-specialize-function-call.h b/source/slang/slang-ir-specialize-function-call.h
new file mode 100644
index 000000000..90c463374
--- /dev/null
+++ b/source/slang/slang-ir-specialize-function-call.h
@@ -0,0 +1,32 @@
+// slang-ir-specialize-function-call.h
+#pragma once
+
+namespace Slang
+{
+    class BackEndCompileRequest;
+    class TargetRequest;
+    struct IRModule;
+    struct IRParam;
+
+    class FunctionCallSpecializeCondition
+    {
+    public:
+        virtual bool doesParamNeedSpecialization(IRParam* param) = 0;
+    };
+
+
+    /// Specialize calls to functions with certain type of parameters.
+    ///
+    /// For any function that has a specific type of input parameters
+    /// this pass will rewrite its call sites that pass suitable arguments
+    /// (e.g., direct references to global shader parameters) to instead call
+    /// a specialized variant of the function that does not have
+    /// those resource parameters (and instead, e.g, refers to the
+    /// global shader parameters directly).
+    ///
+    void specializeFunctionCalls(
+        BackEndCompileRequest* compileRequest,
+        TargetRequest* targetRequest,
+        IRModule* module,
+        FunctionCallSpecializeCondition* condition);
+}
diff --git a/source/slang/slang-ir-specialize-resources.cpp b/source/slang/slang-ir-specialize-resources.cpp
index 2d84cfd8c..8a917eee3 100644
--- a/source/slang/slang-ir-specialize-resources.cpp
+++ b/source/slang/slang-ir-specialize-resources.cpp
@@ -1,199 +1,20 @@
 // slang-ir-specialize-resources.cpp
 #include "slang-ir-specialize-resources.h"
 
+#include "slang-ir-specialize-function-call.h"
 #include "slang-ir.h"
-#include "slang-ir-clone.h"
 #include "slang-ir-insts.h"
 
 namespace Slang
 {
 
-struct ResourceParameterSpecializationContext
+struct ResourceParameterSpecializationCondition : FunctionCallSpecializeCondition
 {
-    // This type implements a pass to specialize functions
+    // This pass is intended to specialize functions
     // with resource parameters to ensure that they are
     // legal for a given target.
-    //
-    // We start with member variables to stand in for
-    // the parameters that were passed to the top-level
-    // `specializeResourceParameters` function.
-    //
-    BackEndCompileRequest* compileRequest;
-    TargetRequest*  targetRequest;
-    IRModule*       module;
 
-    // Our general approach will be to think in terms
-    // of specializing call sites, which amount to
-    // `IRCall` instructions. We will keep a work list
-    // of call sites in the program that may be worth
-    // considering for specialization.
-    //
-    List<IRCall*>   workList;
-
-    // Because we may need to generate specialized functions
-    // and generate new calls to those functions, we'll
-    // need some IR building state to get our work done.
-    //
-    SharedIRBuilder sharedBuilderStorage;
-    IRBuilder       builderStorage;
-    IRBuilder* getBuilder() { return &builderStorage; }
-
-    // With the basic state out of the way, let's walk
-    // through the overall flow of the pass.
-    //
-    void processModule()
-    {
-        // We will start by initializing our IR building state.
-        //
-        sharedBuilderStorage.module = module;
-        sharedBuilderStorage.session = module->getSession();
-        builderStorage.sharedBuilder = &sharedBuilderStorage;
-
-        // Next we will populate our initial work list by
-        // recursively finding every single call site in the module.
-        //
-        addCallsToWorkListRec(module->getModuleInst());
-
-        // We will process the work list until it goes dry,
-        // treating it like a stack of work items.
-        //
-        while( workList.getCount() )
-        {
-            auto call = workList.getLast();
-            workList.removeLast();
-
-            // At each call site we first check whether it
-            // is something we can (and should) specialize,
-            // and if so, do it. The process of specializing
-            // a function may introduce new call sites that
-            // become candidates for specialization, so
-            // our work list may grow along the way.
-            //
-            if( canSpecializeCall(call) )
-            {
-                specializeCall(call);
-            }
-        }
-    }
-
-    // Setting up the work list is a simple recursive procedure.
-    //
-    void addCallsToWorkListRec(IRInst* inst)
-    {
-        // If we have a call site, then add it to the list.
-        //
-        if( auto call = as<IRCall>(inst) )
-        {
-            workList.add(call);
-        }
-
-        // Recursively walk through any children, to
-        // see if we uncover more call sites.
-        //
-        for( auto child : inst->getChildren() )
-        {
-            addCallsToWorkListRec(child);
-        }
-    }
-
-    // We need a way to decide for a given call site
-    // whether we can/must specialize it.
-    //
-    bool canSpecializeCall(IRCall* call)
-    {
-        // We can only specialize calls where the callee
-        // func can be statically identified, and where
-        // the callee is a definition (with body) rather
-        // than a declaration. Otherwise there is no
-        // way to generate a specialized callee function.
-        //
-        auto func = as<IRFunc>(call->getCallee());
-        if(!func)
-            return false;
-        if(!func->isDefinition())
-            return false;
-
-        // With the basic checks out of the way, there are
-        // two conditions we care about:
-        //
-        // 1. Should we specialize? This amounts to whether
-        // `func` has any parameters that need specialization.
-        // We will call those "specializable" parameters for
-        // lack of a better name.
-        //
-        // 2. Can we specialize? This amounts to whether the
-        // arguments in `call` that correspond to those
-        // specializable parameters are "suitable" for use
-        // in specialization.
-        //
-        // We are going to answer both of these queries in
-        // a single loop that walks over the parameters of
-        // `func` as well as the arguments to `call`.
-        //
-        // The loop may seem a bit awkward because we are
-        // doing a parallel iteration over a linked list
-        // (the parameters of `func`) and an array (the
-        // arguments of `call`).
-        //
-        bool anySpecializableParam = false;
-        UInt argCounter = 0;
-        for( auto param : func->getParams() )
-        {
-            UInt argIndex = argCounter++;
-            SLANG_ASSERT(argIndex < call->getArgCount());
-            auto arg = call->getArg(argIndex);
-
-            // If the given parameter doesn't need specialization,
-            // then we need to keep looking.
-            //
-            if(!doesParamNeedSpecialization(param))
-                continue;
-
-            // If we have run into a `param` that needs specialization,
-            // then our first condition is met.
-            //
-            anySpecializableParam = true;
-
-            // Now we need to check whether `arg` is actually suitable
-            // for specialization (our second condition). If not, we
-            // can bail out immediately because our second condition
-            // cannot be met.
-            //
-            if(!isArgSuitableForSpecialization(arg))
-                return false;
-        }
-
-        // If we exit the loop, then the second condition must have
-        // been met (all the arguments for specializable parameters
-        // were suitable for specialization), and the result of the
-        // query comes down to the first condition.
-        //
-        return anySpecializableParam;
-    }
-
-    // Returns true if `type` is an `IRStructType` with array-typed fields.
-    bool isStructTypeWithArray(IRType* type)
-    {
-        if (auto structType = as<IRStructType>(type))
-        {
-            for (auto field : structType->getFields())
-            {
-                if (auto arrayType = as<IRArrayType>(field->getFieldType()))
-                {
-                    return true;
-                }
-                if (auto subStructType = as<IRStructType>(field->getFieldType()))
-                {
-                    if (isStructTypeWithArray(subStructType))
-                        return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    // Of course, now we need to back-fill the predicates that
-    // the above function used to evaluate prameters and arguments.
+    TargetRequest* targetRequest = nullptr;
 
     bool doesParamNeedSpecialization(IRParam* param)
     {
@@ -230,20 +51,6 @@ struct ResourceParameterSpecializationContext
                 return true;
             if(as<IRByteAddressBufferTypeBase>(type))
                 return true;
-
-#if 0
-            // This code is disabled, and is part of the optimization `Specialize function calls involving array arguments. (#1389)` on github.
-            // 
-            // It is disabled here because it causes a problem when a struct is passed to a function that contains a structured buffer *and*
-            // an array. It is specialized on the struct type, and so those types become parameters to the function.
-            // If the struct contains a structured buffer this is a problem on GLSL/VK based targets because currently
-            // structured buffers cannot be function parameters.
-            //
-            // The fix for now is to just disable this optimization. 
-
-            if (isStructTypeWithArray(type))
-                return true;
-#endif
         }
 
         // For now, we will not treat any other parameters as
@@ -263,647 +70,16 @@ struct ResourceParameterSpecializationContext
 
         return false;
     }
-
-    bool isArgSuitableForSpecialization(IRInst* inArg)
-    {
-        // Determining if an argument is suitable for
-        // specializing a callee function requires
-        // looking at its (recurisve) structure.
-        //
-        // Rather than write a recursively procedure
-        // here, we will be tail-recursive by using
-        // a simple loop.
-        //
-        IRInst* arg = inArg;
-        for(;;)
-        {
-            // The leaf case we care about is when the
-            // argument at the call site is a global
-            // shader parameter, because then we can
-            // specialize a callee to refer to the same
-            // global parameter directly.
-            //
-            if(as<IRGlobalParam>(arg)) return true;
-
-            // As we will see later, we can also
-            // specialize a call when the argument
-            // is the result of indexing into an
-            // array (`base[index]`) *if* the `base`
-            // of the indexing operation is also
-            // suitable for specialization.
-            //
-            if( arg->op == kIROp_getElement || arg->op == kIROp_Load )
-            {
-                auto base = arg->getOperand(0);
-
-                // We will "recurse" on the base of
-                // the indexing operation by continuing
-                // our loop with the `base` as our new
-                // argument.
-                //
-                arg = base;
-                continue;
-            }
-
-            // By default, we will *not* consider an argument
-            // suitable for specialization.
-            //
-            // TODO: There may be other cases that are worth
-            // handling here. The current code is based on
-            // observation of what simple shaders do in
-            // practice.
-            //
-            return false;
-        }
-    }
-
-    // Once we'e determined that a given call site can/should
-    // be specialized, we need to perform the actual specialization.
-    // This is where things are going to get more involved.
-    //
-    // There are a few different concerns we need to deal with
-    // that mean we end up having two different passes that walk
-    // over the parameters/arguments of the call (in addition to
-    // the ones we had above for determining if we can/should
-    // specialize in the first place).
-    //
-    // The first of the two passes determines information
-    // relevant to the call site, comprising both the arguments
-    // that will be passed to the specialized function as
-    // well as a "key" to identify the specialized function
-    // that is required.
-    //
-    // We will use the key type defined as part of the IR cloning
-    // infrastructure, which uses a sequence of `IRInst*`s
-    // to hold the state of the key:
-    //
-    typedef IRSimpleSpecializationKey Key;
-
-    // As indicated above, the information we collect about a call
-    // site consists of the key for the specialized function we
-    // will call, and a list of the arguments that will be passed
-    // to the call.
-    //
-    struct CallSpecializationInfo
-    {
-        Key             key;
-        List<IRInst*>   newArgs;
-    };
-
-    // Once we've collected the information about a call site
-    // we can use a dictionary to see if we already created
-    // a specialized version of the callee that matches its
-    // requirements.
-    //
-    Dictionary<Key, IRFunc*> specializedFuncs;
-
-    // If the dictionary didn't have a specialized function
-    // suitable for a call site, we need a second information-gathering
-    // pass to decide what the new parameters of the specialized
-    // functions should be, and what instructions the new function
-    // must execute in its body to set up the replacements for the
-    // old parameters.
-    //
-    struct FuncSpecializationInfo
-    {
-        List<IRParam*>  newParams;
-        List<IRInst*>   newBodyInsts;
-        List<IRInst*>   replacementsForOldParameters;
-    };
-
-    // Before diving into how the different passes collect
-    // their information, we will dive into the main
-    // specialization logic first.
-    //
-    void specializeCall(IRCall* oldCall)
-    {
-        // We have an existing call site `oldCall` that
-        // we know can and should be specialized.
-        //
-        // That means the callee should be a known function
-        // definition, or else `canSpecializeCall` didn't
-        // correctly check the preconditions.
-        //
-        auto oldFunc = as<IRFunc>(oldCall->getCallee());
-        SLANG_ASSERT(oldFunc);
-        SLANG_ASSERT(oldFunc->isDefinition());
-
-        // Our first information-gathering pass will
-        // compute the key for the specialized function
-        // we want to call, and the arguments we will
-        // use for that call.
-        //
-        CallSpecializationInfo callInfo;
-        gatherCallInfo(oldCall, oldFunc, callInfo);
-
-        // Once we have gathered information on the call,
-        // we can check if we have an existing specialization
-        // that we generated before (for another call site)
-        // that is suitable to this call site.
-        //
-        IRFunc* newFunc = nullptr;
-        if( !specializedFuncs.TryGetValue(callInfo.key, newFunc) )
-        {
-            // If we didn't find a pre-existing specialized
-            // function, then we will go ahead and create one.
-            //
-            // We start by gathering the information from the call
-            // site that is relevant to generating a specialized
-            // callee function, which we avoided doing earlier
-            // because it might have been throwaway work.
-            //
-            FuncSpecializationInfo funcInfo;
-            gatherFuncInfo(oldCall, oldFunc, funcInfo);
-
-            // Now we use the gathered information to generate
-            // a new callee function based on the original
-            // function and the information we gathered.
-            //
-            newFunc = generateSpecializedFunc(oldFunc, funcInfo);
-            specializedFuncs.Add(callInfo.key, newFunc);
-        }
-
-        // Once we've other found or generated a specialized function
-        // we need to generate a call to it, and then use the new
-        // call as a replacement for the old one.
-        //
-        auto newCall = getBuilder()->emitCallInst(
-            oldCall->getFullType(),
-            newFunc,
-            callInfo.newArgs.getCount(),
-            callInfo.newArgs.getBuffer());
-
-        newCall->insertBefore(oldCall);
-        oldCall->replaceUsesWith(newCall);
-        oldCall->removeAndDeallocate();
-    }
-
-    // Before diving into the details on how we gather information
-    // and specialize callees, lets stop to think about what we'd
-    // like to do in terms of individual parameters and arguments.
-    //
-    // Suppose we are specializing both a call site C and the callee
-    // function F, and we are consisering a particular pair of
-    // a parmeter P of F, and an argument A at the call site.
-    //
-    // The full extent of information we might want to know given
-    // P and A is:
-    //
-    // * What arguments need to be added to the specialized call?
-    // * What parameters need to be added to the specialized callee?
-    // * What instructions are needed in the body of the specialized
-    //   callee to synthesize the value that will stand in for P?
-    // * What information, if any, needs to be used to distinguish
-    //   this specialized callee from others that might be generated for F?
-    //
-    // An easy case is when P is a parameter that doesn't need
-    // specialization. In that case:
-    //
-    // * The existing argument A should be used as an argument in
-    //   the specialized call.
-    // * A clone P' of the existing parameter P should be used as a
-    //   parameter of the specialized callee.
-    // * No additional instructions are needed in the body of
-    //   the callee; the cloned parameter P' should stand in for P.
-    // * No information should be added to the specialization key
-    //   based on P and A.
-    //
-    // The more interesting case is when P has a resource type, and
-    // A is some global shader parameter G.
-    //
-    // * No argument should be added at the new call site
-    // * No parameter should be added to the specialized callee
-    // * No additional instructions are needed in the body of
-    //   the callee; the global G should stand in for P.
-    // * The global G should be used to distinguish this specialized
-    //   callee from those that might be specialized for a different
-    //   global shader parameter.
-    //
-    // As a final example, imagine that P is still a resource type,
-    // but A is now an indexing operation into an array: `G[idx]`:
-    //
-    // * An argument for `idx` should be added at the call site
-    // * A parameter `p_idx` with the same type as `idx` should be added
-    //   to the specialized callee.
-    // * An instruction should be added to the specialized callee
-    //   to compute `G[p_idx]` and use that to stand in for P.
-    // * The global G should still be used to distinguish this specialized
-    //   call site from others.
-    //
-    // That's a lot of examples, I know, but hopefully it gives a
-    // sense of the information we are tracking and how it differs
-    // across the various cases. While the example only covered one
-    // level of indexing, the actual implementation will handle the
-    // case of arbitrarily many levels of indexing, which can mean
-    // piping through any number of additional integer parameters
-    // to the callee.
-
-    // The information we gather for a call site (before we know
-    // whether a specialize calle is needed) is just the new
-    // argument list, and the "key" information that distinguishes
-    // what specialized callee we want/need.
-    //
-    void gatherCallInfo(
-        IRCall*                 oldCall,
-        IRFunc*                 oldFunc,
-        CallSpecializationInfo& callInfo)
-    {
-        // The specialized callee key always needs to include
-        // the original function, since different functions
-        // will always yield different specializations.
-        //
-        callInfo.key.vals.add(oldFunc);
-
-        // The rest of the information is gathered by looking
-        // at parameter and argument pairs.
-        //
-        UInt oldArgCounter = 0;
-        for( auto oldParam : oldFunc->getParams() )
-        {
-            UInt oldArgIndex = oldArgCounter++;
-            auto oldArg = oldCall->getArg(oldArgIndex);
-
-            getCallInfoForParam(callInfo, oldParam, oldArg);
-        }
-    }
-
-    void getCallInfoForParam(
-        CallSpecializationInfo& ioInfo,
-        IRParam*                oldParam,
-        IRInst*                 oldArg)
-    {
-        // We know that the case where a parameter
-        // doesn't need specialization is easy.
-        //
-        if( !doesParamNeedSpecialization(oldParam) )
-        {
-            // The new call site will use the same argument
-            // value as the old one, and we don't need
-            // to add any information to distinguish the
-            // specialized callee based on this paramter.
-            //
-            ioInfo.newArgs.add(oldArg);
-        }
-        else
-        {
-            // If specialization is needed, we need
-            // to inspect the argument value. This
-            // is handled with a different function
-            // because it needs to recurse in some cases.
-            //
-            getCallInfoForArg(ioInfo, oldArg);
-        }
-    }
-
-    void getCallInfoForArg(
-        CallSpecializationInfo& ioInfo,
-        IRInst*                 oldArg)
-    {
-        // The base case we care about is when the original
-        // argument is a global shader parameter.
-        //
-        if( auto oldGlobalParam = as<IRGlobalParam>(oldArg) )
-        {
-            // In this case we don't need to pass anything
-            // as an argument at the new call site (the
-            // global parameter will get specialized into
-            // the callee), but we *do* need to make sure
-            // that our key for identifying the specialized
-            // callee reflects that we are specializing
-            // to the chosen parameter.
-            //
-            ioInfo.key.vals.add(oldGlobalParam);
-        }
-        else if( oldArg->op == kIROp_getElement )
-        {
-            // This is the case where the `oldArg` is
-            // in the form `oldBase[oldIndex]`
-            //
-            auto oldBase  = oldArg->getOperand(0);
-            auto oldIndex = oldArg->getOperand(1);
-
-            // Effectively, we act as if `oldBase` and
-            // `oldIndex` were passed to the callee separately,
-            // so that `oldBase` is an array-of-resouces and
-            // `oldIndex` is an ordinary integer argument.
-            //
-            // We start by recursively setting up whatever
-            // `oldBase` needs:
-            //
-            getCallInfoForArg(ioInfo, oldBase);
-
-            // Then we process `oldIndex` just like we
-            // would have an ordinary argument that doesn't
-            // involve specialization: add its value to
-            // the arguments at the new call site, and
-            // don't add anything to the specialization key.
-            //
-            ioInfo.newArgs.add(oldIndex);
-        }
-        else if (oldArg->op == kIROp_Load)
-        {
-            auto oldBase = oldArg->getOperand(0);
-            getCallInfoForArg(ioInfo, oldBase);
-        }
-        else
-        {
-            // If we fail to match any of the cases above
-            // then a precondition was violated in that
-            // `isArgSuitableForSpecialization` is allowing
-            // a case that this routine is not covering.
-            //
-            SLANG_UNEXPECTED("mising case in 'getCallInfoForArg'");
-        }
-    }
-
-    // The remaining information we've discussed is only
-    // gathered once we decide we want to generate a
-    // specialized function, but it follows much the same flow.
-    //
-    void gatherFuncInfo(
-        IRCall*                 oldCall,
-        IRFunc*                 oldFunc,
-        FuncSpecializationInfo& funcInfo)
-    {
-        UInt oldArgCounter = 0;
-        for( auto oldParam : oldFunc->getParams() )
-        {
-            UInt oldArgIndex = oldArgCounter++;
-            auto oldArg = oldCall->getArg(oldArgIndex);
-
-            // For each parameter and argument pair we will
-            // frame the main task as producing a value that
-            // will stand in for the parameter in the specialized
-            // function.
-            //
-            auto newVal = getSpecializedValueForParam(funcInfo, oldParam, oldArg);
-
-            // We will collect the replacement value to use
-            // for each of the original parameters in an array.
-            //
-            funcInfo.replacementsForOldParameters.add(newVal);
-        }
-    }
-
-    IRInst* getSpecializedValueForParam(
-        FuncSpecializationInfo& ioInfo,
-        IRParam*                oldParam,
-        IRInst*                 oldArg)
-    {
-        // As always, the easy case is when the parameter of
-        // the original function doesn't need specialization.
-        //
-        if( !doesParamNeedSpecialization(oldParam) )
-        {
-            // The specialized callee will need a new parameter
-            // that fills the same role as the old one, so we
-            // create it here.
-            //
-            auto newParam = getBuilder()->createParam(oldParam->getFullType());
-            ioInfo.newParams.add(newParam);
-
-            // The new parameter will be used as the replacement
-            // for the old one in the specialized function.
-            //
-            return newParam;
-        }
-        else
-        {
-            // If the parameter requires specialization, then it
-            // is time to look at the structure of the argument.
-            //
-            return getSpecializedValueForArg(ioInfo, oldArg);
-        }
-    }
-
-    IRInst* getSpecializedValueForArg(
-        FuncSpecializationInfo& ioInfo,
-        IRInst*                 oldArg)
-    {
-        // The logic here parallels `gatherCallInfoForArg`,
-        // and only differs in what information it is gathering.
-        //
-        // As before, the base case is when we have a global
-        // shader parameter.
-        //
-        if( auto globalParam = as<IRGlobalParam>(oldArg) )
-        {
-            // The specialized function will not need any
-            // parameter in this case, and the global itself
-            // should be used to stand in for the original
-            // parameter in the specialized function.
-            //
-            return globalParam;
-        }
-        else if( oldArg->op == kIROp_getElement )
-        {
-            // This is the case where the argument is
-            // in the form `oldBase[oldIndex]`.
-            //
-            auto oldBase  = oldArg->getOperand(0);
-            auto oldIndex = oldArg->getOperand(1);
-
-            // In `gatherCallInfoForArg` this case was
-            // handled by acting as if `oldBase` and
-            // `oldIndex` were being passed as two
-            // separate arguments.
-            //
-            // We'll follow the same structure here,
-            // starting by recursively processing `oldBase`
-            // to get a value that can stand in for it
-            // in the specialized callee.
-            //
-            auto newBase = getSpecializedValueForArg(ioInfo, oldBase);
-
-            // Next we'll process `oldIndex` as if it
-            // was an ordinary argument (not a specialized one),
-            // which means creating a parameter to receive its value,
-            // which will also stand in for `oldIndex` in
-            // the body of the specialized callee.
-            //
-            auto builder = getBuilder();
-            auto newIndex = builder->createParam(oldIndex->getFullType());
-            ioInfo.newParams.add(newIndex);
-
-            // Finally, we need to compute a value that
-            // can stand in for `oldArg` (which was
-            // `oldBase[oldIndex]`) in the body of the
-            // specialized callee.
-            //
-            // Because we have both a `newBase` and a
-            // `newIndex` it is natural to construct
-            // `newBase[newIndex]` and use that.
-            //
-            // The only complication is that we need
-            // to make sure that our IR builder isn't
-            // set to insert newly created instructions
-            // anywhere, since the `emit*` functions
-            // will try to automatically insert new
-            // instructions if an insertion location
-            // is set.
-            //
-            builder->setInsertInto(nullptr);
-            auto newVal = builder->emitElementExtract(
-                oldArg->getFullType(),
-                newBase,
-                newIndex);
-
-            // Because our new instruction wasn't
-            // actually inserted anywhere, we need to
-            // add it to our gathered list of instructions
-            // that should be inserted into the body of
-            // the specialized callee.
-            //
-            ioInfo.newBodyInsts.add(newVal);
-
-            return newVal;
-        }
-        else if (oldArg->op == kIROp_Load)
-        {
-            return getSpecializedValueForArg(ioInfo, oldArg->getOperand(0));
-        }
-        else
-        {
-            // If we don't match one of the above cases,
-            // then `isArgSuitableForSpecialization` is
-            // letting through cases that this function
-            // hasn't been updated to handle.
-            //
-            SLANG_UNEXPECTED("mising case in 'getSpecializedValueForArg'");
-            UNREACHABLE_RETURN(nullptr);
-        }
-    }
-
-    // With all of that data-gathering code out of the way,
-    // we are now prepared to walk through the process of
-    // specializing a given callee function based on
-    // the information we have gathered.
-    //
-    IRFunc* generateSpecializedFunc(
-        IRFunc*                         oldFunc,
-        FuncSpecializationInfo const&   funcInfo)
-    {
-        // We will make use of the infrastructure for cloning
-        // IR code, that is defined in `ir-clone.{h,cpp}`.
-        //
-        // In order to do the cloning work we need an
-        // "environment" that will map old values to
-        // their replacements.
-        //
-        IRCloneEnv cloneEnv;
-
-        // Next we iterate over the parameters of the old
-        // function, and register each as being mapped
-        // to its replacement in the `funcInfo` that was
-        // already gathered.
-        //
-        UInt paramCounter = 0;
-        for( auto oldParam : oldFunc->getParams() )
-        {
-            UInt paramIndex = paramCounter++;
-            auto newVal = funcInfo.replacementsForOldParameters[paramIndex];
-            cloneEnv.mapOldValToNew.Add(oldParam, newVal);
-        }
-
-        // Next we will create the skeleton of the new
-        // specialized function, including its type.
-        //
-        // To get the type of the new function we will
-        // iterate over the collected list of new
-        // parameters (which may differ greatly from the
-        // parameter list of the original) and extract
-        // their types.
-        //
-        List<IRType*> paramTypes;
-        for( auto param : funcInfo.newParams )
-        {
-            paramTypes.add(param->getFullType());
-        }
-
-        auto builder = getBuilder();
-        IRType* funcType = builder->getFuncType(
-            paramTypes.getCount(),
-            paramTypes.getBuffer(),
-            oldFunc->getResultType());
-
-        IRFunc* newFunc = builder->createFunc();
-        newFunc->setFullType(funcType);
-
-        // The above step has accomplished the "first phase"
-        // of cloning the function (since `IRFunc`s have no
-        // operands).
-        //
-        // We can now use the shared IR cloning infrastructure
-        // to perform the second phase of cloning, which will recursively
-        // clone any nested decorations, blocks, and instructions.
-        //
-        cloneInstDecorationsAndChildren(
-            &cloneEnv,
-            builder->sharedBuilder,
-            oldFunc,
-            newFunc);
-
-        // We are almost done at this point, except that `newFunc`
-        // is lacking its parameters, as well as any of the body
-        // instructions that we decided were needed during
-        // the information-gathering steps.
-        //
-        // We will insert these instructions into the first block
-        // of the function, before its first ordinary instruction.
-        // We know that these should exist because we had as
-        // a precondition that `oldFunc` was a definition (so it
-        // has at least one block), and in valid IR every block
-        // has at least one ordinary instruction (its terminator).
-        //
-        auto newEntryBlock = newFunc->getFirstBlock();
-        SLANG_ASSERT(newEntryBlock);
-        auto newFirstOrdinary = newEntryBlock->getFirstOrdinaryInst();
-        SLANG_ASSERT(newFirstOrdinary);
-
-        // We simply iterate over the list of parameters and then
-        // body instructions that were produced in the information
-        // gathering step, and insert each before `newFirstOrdinary`,
-        // which has the effect or arranging them in the output
-        // in the order they are enumerated here.
-        //
-        for( auto newParam : funcInfo.newParams )
-        {
-            newParam->insertBefore(newFirstOrdinary);
-        }
-        for( auto newBodyInst : funcInfo.newBodyInsts )
-        {
-            newBodyInst->insertBefore(newFirstOrdinary);
-        }
-
-        // At this point we've created a new specialized function,
-        // and as such it may contain call sites that were not
-        // covered when we built our initial work list.
-        //
-        // Before handing the specialized function back to the
-        // caller, we will make sure to recursively add any
-        // potentially-specializable call sites to our work list.
-        //
-        addCallsToWorkListRec(newFunc);
-
-        return newFunc;
-    }
 };
 
-// The top-level function for invoking the specialization pass
-// is straighforward. We set up the context object
-// and then defer to it for the real work.
-//
 void specializeResourceParameters(
     BackEndCompileRequest* compileRequest,
     TargetRequest*  targetRequest,
     IRModule*       module)
 {
-    ResourceParameterSpecializationContext context;
-    context.compileRequest = compileRequest;
-    context.targetRequest = targetRequest;
-    context.module = module;
-
-    context.processModule();
+    ResourceParameterSpecializationCondition condition;
+    condition.targetRequest = targetRequest;
+    specializeFunctionCalls(compileRequest, targetRequest, module, &condition);
 }
 
 } // namesapce Slang
diff --git a/source/slang/slang.vcxproj b/source/slang/slang.vcxproj
index 65e0ba4aa..f20a4a322 100644
--- a/source/slang/slang.vcxproj
+++ b/source/slang/slang.vcxproj
@@ -250,6 +250,8 @@
     <ClInclude Include="slang-ir-sccp.h" />
     <ClInclude Include="slang-ir-serialize-types.h" />
     <ClInclude Include="slang-ir-serialize.h" />
+    <ClInclude Include="slang-ir-specialize-arrays.h" />
+    <ClInclude Include="slang-ir-specialize-function-call.h" />
     <ClInclude Include="slang-ir-specialize-resources.h" />
     <ClInclude Include="slang-ir-specialize.h" />
     <ClInclude Include="slang-ir-ssa.h" />
@@ -349,6 +351,8 @@
     <ClCompile Include="slang-ir-sccp.cpp" />
     <ClCompile Include="slang-ir-serialize-types.cpp" />
     <ClCompile Include="slang-ir-serialize.cpp" />
+    <ClCompile Include="slang-ir-specialize-arrays.cpp" />
+    <ClCompile Include="slang-ir-specialize-function-call.cpp" />
     <ClCompile Include="slang-ir-specialize-resources.cpp" />
     <ClCompile Include="slang-ir-specialize.cpp" />
     <ClCompile Include="slang-ir-ssa.cpp" />
@@ -400,4 +404,4 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
\ No newline at end of file
+</Project> 
\ No newline at end of file
diff --git a/source/slang/slang.vcxproj.filters b/source/slang/slang.vcxproj.filters
index 7b26d8ee1..9f3d9b32f 100644
--- a/source/slang/slang.vcxproj.filters
+++ b/source/slang/slang.vcxproj.filters
@@ -201,6 +201,12 @@
     <ClInclude Include="slang-ir-serialize.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="slang-ir-specialize-arrays.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="slang-ir-specialize-function-call.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="slang-ir-specialize-resources.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -494,6 +500,12 @@
     <ClCompile Include="slang-ir-serialize.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="slang-ir-specialize-arrays.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="slang-ir-specialize-function-call.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="slang-ir-specialize-resources.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>