Parameter blocks (#245)

* Rename existing ParameterBlock to ParameterGroup

We are planning to add a new `ParameterBlock<T>` type, which maps to the notion of a "parameter block" as used in the Spire research work.
Unfortunately, the compiler codebase already uses the term `ParameterBlock` as catch-all to encompass all of HLSL `cbuffer`/`tbuffer` and GLSL `uniform`/`buffer`/`in`/`out` blocks (all of which are lexical `{}`-enclosed blocks that define parameters...).

This change instead renames all of the existing concepts over to `ParameterGroup`, which isn't an ideal name, but at least doesn't directly overlap the new terminology or any existing terminology.

The new `ParameterBlockType` case will probably be a subclass of `ParameterGroupType`, since it is a logical extension of the underlying concept.

* Add Shader Model 5.1 profiles

The HLSL `register(..., space0)` syntax is only allowed on "SM5.1" and later profiles (which is supported by the newer version of `d3dcompiler_47.dll` that comes with the Win10 SDK, but not the older version of `d3dcompiler_47.dll` - good luck figuring out which you have!).

This change adds those profiles to our master list of profiles, and nothing else.

* First pass at support for `ParameterBlock<T>`

- Add the type declaration in stdlib

- Add a special case of `ParameterGroupType` for parameter blocks

- Handle parameter blocks in type layout (currently handling them identically to constant buffers for now, which isn't going to be right in the long term)

- Add an IR pass that basically replaces `ParameterBlock<T>` with `T`
  - Eventually this should replace it with either `T` or `ConstantBuffer<T>`, depending on whether the layout that was computed required a constant buffer to hold any "free" uniforms

- Add first stab at an IR pass to "scalarize" global variables using aggregate types with resources inside.
  - This currently only applies to global variables, so it won't handle things passed through functions, or used as local variables
  - It also only supports cases where the references to the original variable are always references to its fields, and not the whole value itself

- Add a single test case that technically passes with this level of support, but probably isn't very representative of what we need from the feature

* Fold parameter-block desugaring into a more complete "type legalization" pass

The basic problem that was arising is that once you desugar `ParameterBlock<T>` into `T`, you then need todeal with splitting `T` into its constituent fields if it contains any resource types.
Handling those transformations by following the usual use-def chains wasn't really helping, because you might need systematic rewriting that can really only be handled bottom-up.

This change adds a new pass that is intended to perform multiple kinds of type "legalization" at once:

- It will turn `ParameterBlock<T>` into `T`
  - It may at some point also convert `ConstantBuffer<T>` into `T` as well
- It will turn an value of an aggregate type that contains resources into N different values (one per field)
  - As a result of this, it will also deal with AOS-to-SOA conversion of these types

Legalization is applied to *every* function/instruction/value, so that it can make large-scale changes that would be tough to manage with a work list.

This pass needs to be run *after* generics have been fully specialized, so that we know we are always dealing with fully concrete types, so that their legalization for a given target is completely known.

This is still work in progress; there's more to be done to get this working with all our test cases, and finish the remaining `ParameterBlock<T>` work.

* Improve binding/layout information when using parameter blocks

- When doing type layout for a parameter block, don't include the resources consumed by the element type in the resource usage for the parameter block
  - Note that this is pretty much identical to how a `ConstantBuffer<T>` does not report any `LayoutResourceKind::Uniform` usage, except that `ParameterBlock<T>` is *also* going to hide underlying texture/sampler reigster usage
  - The one exception here is that any nested items that use up entire `space`s or `set`s those need to be exposed in the resource usage of the parent (I don't have a test for this)

- When type legalization needs to scalarize things, it must propagate layout information down to the new leaf variables. In general, the register/index for a new leaf parameter should be the sum of the offsets for all of the parent variables along the "chain" from the original variable down to the leaf (we aren't dealing with arrays here just yet).

- When type legalization decides to eliminate a pointer(-like) type (e.g., desugar `ParameterBlock<T>` over to `T`), actually deal with that in terms of the `LegalVal`s created, so that we can know to turn a `load` into a no-op when applied to a value that got indirection removed.

- Hack up the "complex" parameter-block test so that it actually passes (the big hack here is that the HLSL baseline is using names that are generated by the IR, and are unlikely to be stable as we add/remove transformations).
  - Note: I can't make these be compute tests right now, because regsiter spaces/sets are a feature of D3D12/Vulkan, and our test runner isn't using those APIs.

1 files changed, 1356 insertions, 0 deletions

diff --git a/source/slang/ir-legalize-types.cpp b/source/slang/ir-legalize-types.cpp
new file mode 100644
index 000000000..677ccedd3
--- /dev/null
+++ b/source/slang/ir-legalize-types.cpp
@@ -0,0 +1,1356 @@
+// ir-legalize-types.cpp
+
+// This file implements a pass that takes IR
+// that has been fully specialized (no more
+// generics/interfaces needing to be specialized
+// away) and replaces any types that can't actually
+// be used as-is on the target.
+//
+// The particular case we are focused on is
+// aggregate types (e.g., `struct` types) that
+// contain resources (textures, samplers, etc.)
+// or that mix resources and ordinary "uniform"
+// data.
+
+#include "ir.h"
+#include "ir-insts.h"
+
+namespace Slang
+{
+
+struct LegalTypeImpl : RefObject
+{
+};
+struct ImplicitDerefType;
+struct TupleType;
+
+struct LegalType
+{
+    enum class Flavor
+    {
+        // Nothing: a NULL type
+        none,
+
+        // A simple type that can be represented directly as a `Type`
+        simple,
+
+        // Logically, we have a pointer-like type, but we are
+        // going to represnet it as the pointed-to type
+        implicitDeref,
+
+        tuple,
+    };
+
+    Flavor              flavor = Flavor::none;
+    RefPtr<RefObject>   obj;
+
+    static LegalType simple(Type* type)
+    {
+        LegalType result;
+        result.flavor = Flavor::simple;
+        result.obj = type;
+        return result;
+    }
+
+    RefPtr<Type> getSimple()
+    {
+        assert(flavor == Flavor::simple);
+        return obj.As<Type>();
+    }
+
+    static LegalType implicitDeref(
+        LegalType const& valueType);
+
+    RefPtr<ImplicitDerefType> getImplicitDeref()
+    {
+        assert(flavor == Flavor::implicitDeref);
+        return obj.As<ImplicitDerefType>();
+    }
+
+    static LegalType tuple(
+        RefPtr<TupleType>   tupleType);
+
+    RefPtr<TupleType> getTuple()
+    {
+        assert(flavor == Flavor::tuple);
+        return obj.As<TupleType>();
+    }
+};
+
+struct ImplicitDerefType : LegalTypeImpl
+{
+    LegalType valueType;
+};
+
+LegalType LegalType::implicitDeref(
+    LegalType const& valueType)
+{
+    RefPtr<ImplicitDerefType> obj = new ImplicitDerefType();
+    obj->valueType = valueType;
+
+    LegalType result;
+    result.flavor = Flavor::implicitDeref;
+    result.obj = obj;
+    return result;
+}
+
+struct TupleType : LegalTypeImpl
+{
+    struct Element
+    {
+        DeclRef<VarDeclBase>    fieldDeclRef;
+        LegalType               type;
+    };
+
+    List<Element> elements;
+};
+
+LegalType LegalType::tuple(
+    RefPtr<TupleType>   tupleType)
+{
+    LegalType result;
+    result.flavor = Flavor::tuple;
+    result.obj = tupleType;
+    return result;
+}
+
+struct LegalValImpl : RefObject
+{
+};
+struct TupleVal;
+
+struct LegalVal
+{
+    enum class Flavor
+    {
+        none,
+        simple,
+        implicitDeref,
+        tuple,
+    };
+
+    Flavor              flavor;
+    RefPtr<RefObject>   obj;
+    IRValue*            irValue;
+
+    static LegalVal simple(IRValue* irValue)
+    {
+        LegalVal result;
+        result.flavor = Flavor::simple;
+        result.irValue = irValue;
+        return result;
+    }
+
+    IRValue* getSimple()
+    {
+        assert(flavor == Flavor::simple);
+        return irValue;
+    }
+
+    static LegalVal tuple(RefPtr<TupleVal> tupleVal);
+
+    RefPtr<TupleVal> getTuple()
+    {
+        assert(flavor == Flavor::tuple);
+        return obj.As<TupleVal>();
+    }
+
+    static LegalVal implicitDeref(LegalVal const& val);
+    LegalVal getImplicitDeref();
+};
+
+struct TupleVal : LegalValImpl
+{
+    struct Element
+    {
+        DeclRef<VarDeclBase>    fieldDeclRef;
+        LegalVal                val;
+    };
+
+    List<Element> elements;
+};
+
+LegalVal LegalVal::tuple(RefPtr<TupleVal> tupleVal)
+{
+    LegalVal result;
+    result.flavor = LegalVal::Flavor::tuple;
+    result.obj = tupleVal;
+    return result;
+}
+
+struct ImplicitDerefVal : LegalValImpl
+{
+    LegalVal val;
+};
+
+LegalVal LegalVal::implicitDeref(LegalVal const& val)
+{
+    RefPtr<ImplicitDerefVal> implicitDerefVal = new ImplicitDerefVal();
+    implicitDerefVal->val = val;
+
+    LegalVal result;
+    result.flavor = LegalVal::Flavor::implicitDeref;
+    result.obj = implicitDerefVal;
+    return result;
+}
+
+LegalVal LegalVal::getImplicitDeref()
+{
+    assert(flavor == Flavor::implicitDeref);
+    return obj.As<ImplicitDerefVal>()->val;
+}
+
+
+struct TypeLegalizationContext
+{
+    Session*    session;
+    IRModule*   module;
+    IRBuilder*  builder;
+
+    // When inserting new globals, put them before this one.
+    IRGlobalValue* insertBeforeGlobal = nullptr;
+
+    Dictionary<IRValue*, LegalVal> mapValToLegalVal;
+};
+
+static void registerLegalizedValue(
+    TypeLegalizationContext*    context,
+    IRValue*                    irValue,
+    LegalVal const&             legalVal)
+{
+    context->mapValToLegalVal.Add(irValue, legalVal);
+}
+
+
+static bool isResourceType(Type* type)
+{
+    while (auto arrayType = type->As<ArrayExpressionType>())
+    {
+        type = arrayType->baseType;
+    }
+
+    if (auto textureTypeBase = type->As<TextureTypeBase>())
+    {
+        return true;
+    }
+    else if (auto samplerType = type->As<SamplerStateType>())
+    {
+        return true;
+    }
+
+    // TODO: need more comprehensive coverage here
+
+    return false;
+}
+
+// Legalize a type, including any nested types
+// that it transitively contains.
+static LegalType legalizeType(
+    TypeLegalizationContext*    context,
+    Type*                       type)
+{
+    if (auto parameterBlockType = type->As<ParameterBlockType>())
+    {
+        // We basically legalize the `ParameterBlock<T>` type
+        // over to `T`. In order to represent this preoperly,
+        // we need to be careful to wrap it up in a way that
+        // tells us to eliminate downstream deferences...
+
+        auto legalElementType = legalizeType(context,
+            parameterBlockType->getElementType());
+        return LegalType::implicitDeref(legalElementType);
+    }
+    else if (isResourceType(type))
+    {
+        // We assume that any resource types not handled above
+        // are legal as-is.
+        return LegalType::simple(type);
+    }
+    else if (type->As<BasicExpressionType>())
+    {
+        return LegalType::simple(type);
+    }
+    else if (type->As<VectorExpressionType>())
+    {
+        return LegalType::simple(type);
+    }
+    else if (type->As<MatrixExpressionType>())
+    {
+        return LegalType::simple(type);
+    }
+    else if (auto declRefType = type->As<DeclRefType>())
+    {
+        auto declRef = declRefType->declRef;
+        if (auto aggTypeDeclRef = declRef.As<AggTypeDecl>())
+        {
+            // Look at the (non-static) fields, and
+            // see if anything needs to be cleaned up.
+
+            // We collect the legalized types for the fields,
+            // along with whether we've seen anything non-simple.
+            List<TupleType::Element> legalizedElements;
+            bool anyComplex = false;
+            bool anyResource = false;
+
+            for (auto ff : getMembersOfType<StructField>(aggTypeDeclRef))
+            {
+                if (ff.getDecl()->HasModifier<HLSLStaticModifier>())
+                    continue;
+
+                auto fieldType = GetType(ff);
+                if (isResourceType(fieldType))
+                {
+                    anyResource = true;
+                }
+
+                auto legalFieldType = legalizeType(context, fieldType);
+
+                TupleType::Element element;
+                element.fieldDeclRef = ff;
+                element.type = legalFieldType;
+                legalizedElements.Add(element);
+
+                switch (legalFieldType.flavor)
+                {
+                case LegalType::Flavor::simple:
+                    break;
+
+                default:
+                    anyComplex = true;
+                    break;
+                }
+            }
+
+            // If we didn't see anything that requires work,
+            // we can conceivably just use the type as-is
+            //
+            // TODO: this might be a good place to turn
+            // a reference to a generic `struct` type into
+            // a concrete non-generic type so that downstream
+            // codegen doesn't have to deal with generics...
+            //
+            // TODO: In fact, why not just fully replace
+            // all aggregate types here with some structural
+            // types defined in the IR?
+            if (!anyComplex && !anyResource)
+            {
+                return LegalType::simple(type);
+            }
+
+            // Okay, we are going to have to generate a
+            // "tuple" type.
+            //
+            // TODO: split out the "simple" fields into
+            // their own sub-type?
+
+            RefPtr<TupleType> tupleType = new TupleType();
+            tupleType->elements = legalizedElements;
+
+            return LegalType::tuple(tupleType);
+        }
+    }
+
+    return LegalType::simple(type);
+}
+
+// Legalize a type, and then expect it to
+// result in a simple type.
+static RefPtr<Type> legalizeSimpleType(
+    TypeLegalizationContext*    context,
+    Type*                       type)
+{
+    auto legalType = legalizeType(context, type);
+    switch (legalType.flavor)
+    {
+    case LegalType::Flavor::simple:
+        return legalType.getSimple();
+
+    default:
+        // TODO: need to issue a diagnostic here.
+        SLANG_UNEXPECTED("unexpected type case");
+        break;
+    }
+}
+
+// Take a value that is being used as an operand,
+// and turn it into the equivalent legalized value.
+static LegalVal legalizeOperand(
+    TypeLegalizationContext*    context,
+    IRValue*                    irValue)
+{
+    LegalVal legalVal;
+    if (context->mapValToLegalVal.TryGetValue(irValue, legalVal))
+        return legalVal;
+
+    // For now, assume that anything not covered
+    // by the mapping is legal as-is.
+
+    return LegalVal::simple(irValue);
+}
+
+static LegalVal legalizeLoad(
+    TypeLegalizationContext*    context,
+    LegalVal                    legalPtrVal)
+{
+    switch (legalPtrVal.flavor)
+    {
+    case LegalVal::Flavor::simple:
+        {
+            return LegalVal::simple(
+                context->builder->emitLoad(legalPtrVal.getSimple()));
+        }
+        break;
+
+    case LegalVal::Flavor::implicitDeref:
+        // We have turne a pointer(-like) type into its pointed-to (value)
+        // type, and so the operation of loading goes away; we just use
+        // the underlying value.
+        return legalPtrVal.getImplicitDeref();
+
+    case LegalVal::Flavor::tuple:
+        {
+            // We need to emit a load for each element of
+            // the tuple.
+            RefPtr<TupleVal> tupleVal = new TupleVal();
+            for (auto ee : legalPtrVal.getTuple()->elements)
+            {
+                TupleVal::Element element;
+                element.fieldDeclRef = ee.fieldDeclRef;
+                element.val = legalizeLoad(context, ee.val);
+
+
+                tupleVal->elements.Add(element);
+            }
+            return LegalVal::tuple(tupleVal);
+        }
+        break;
+
+    default:
+        SLANG_UNEXPECTED("unhandled case");
+        break;
+    }
+}
+
+static LegalVal legalizeFieldAddress(
+    TypeLegalizationContext*    context,
+    LegalType                   type,
+    LegalVal                    legalPtrOperand,
+    LegalVal                    legalFieldOperand)
+{
+    auto builder = context->builder;
+
+    // We don't expect any legalization to affect
+    // the "field" argument.
+    auto fieldOperand = legalFieldOperand.getSimple();
+    assert(fieldOperand->op == kIROp_decl_ref);
+    auto fieldDeclRef = ((IRDeclRef*)fieldOperand)->declRef;
+
+    switch (legalPtrOperand.flavor)
+    {
+    case LegalVal::Flavor::simple:
+        return LegalVal::simple(
+            builder->emitFieldAddress(
+                type.getSimple(),
+                legalPtrOperand.getSimple(),
+                fieldOperand));
+
+    case LegalVal::Flavor::tuple:
+        {
+            // The operand is a tuple of pointer-like
+            // values, we want to extract the element
+            // corresponding to a field. We will handle
+            // this by simply returning the corresponding
+            // element from the operand.
+            for (auto ee : legalPtrOperand.getTuple()->elements)
+            {
+                if (ee.fieldDeclRef.Equals(fieldDeclRef))
+                {
+                    return ee.val;
+                }
+            }
+            SLANG_UNEXPECTED("didn't find tuple element");
+            return LegalVal();
+        }
+
+    default:
+        SLANG_UNEXPECTED("unhandled");
+        return LegalVal();
+    }
+}
+
+static LegalVal legalizeInst(
+    TypeLegalizationContext*    context,
+    IRInst*                     inst,
+    LegalType                   type,
+    LegalVal const*             args)
+{
+    switch (inst->op)
+    {
+    case kIROp_Load:
+        return legalizeLoad(context, args[0]);
+
+    case kIROp_FieldAddress:
+        return legalizeFieldAddress(context, type, args[0], args[1]);
+
+    default:
+        // TODO: produce a user-visible diagnostic here
+        SLANG_UNEXPECTED("non-simple operand(s)!");
+        break;
+    }
+}
+
+static LegalVal legalizeInst(
+    TypeLegalizationContext*    context,
+    IRInst*                     inst)
+{
+    // Need to legalize all the operands.
+    auto argCount = inst->getArgCount();
+    List<LegalVal> legalArgs;
+    bool anyComplex = false;
+    for (UInt aa = 0; aa < argCount; ++aa)
+    {
+        auto oldArg = inst->getArg(aa);
+        auto legalArg = legalizeOperand(context, oldArg);
+        legalArgs.Add(legalArg);
+
+        if (legalArg.flavor != LegalVal::Flavor::simple)
+            anyComplex = true;
+    }
+
+    // Also legalize the type of the instruction
+    LegalType legalType = legalizeType(context, inst->type);
+
+    if (!anyComplex && legalType.flavor == LegalType::Flavor::simple)
+    {
+        // Nothing interesting happened to the operands,
+        // so we seem to be okay, right?
+
+        for (UInt aa = 0; aa < argCount; ++aa)
+        {
+            auto legalArg = legalArgs[aa];
+            inst->setArg(aa, legalArg.getSimple());
+        }
+
+        inst->type = legalType.getSimple();
+
+        return LegalVal::simple(inst);
+    }
+
+    // We have at least one "complex" operand, and we
+    // need to figure out what to do with it. The anwer
+    // will, in general, depend on what we are doing.
+
+    // We will set up the IR builder so that any new
+    // instructions generated will be placed after
+    // the location of the original instruct.
+    auto builder = context->builder;
+    builder->curBlock = inst->getParentBlock();
+    builder->insertBeforeInst = inst->getNextInst();
+
+    LegalVal legalVal = legalizeInst(
+        context,
+        inst,
+        legalType,
+        legalArgs.Buffer());
+
+    // After we are done, we will eliminate the
+    // original instruction by removing it from
+    // the IR.
+    //
+    // TODO: we need to add it to a list of
+    // instructions to be cleaned up...
+    inst->removeFromParent();
+
+    // The value to be used when referencing
+    // the original instruction will now be
+    // whatever value(s) we created to replace it.
+    return legalVal;
+}
+
+static void legalizeFunc(
+    TypeLegalizationContext*    context,
+    IRFunc*                     irFunc)
+{
+    // Overwrite the function's type with
+    // the result of legalization.
+    irFunc->type = legalizeSimpleType(context, irFunc->type);
+
+    // Go through the blocks of the function
+    for (auto bb = irFunc->getFirstBlock(); bb; bb = bb->getNextBlock())
+    {
+        // Legalize the parameters of the block, which may
+        // involve increasing the number of parameters
+        for (auto pp = bb->getFirstParam(); pp; pp = pp->getNextParam())
+        {
+            auto legalParamType = legalizeType(context, pp->getType());
+
+            switch (legalParamType.flavor)
+            {
+            case LegalType::Flavor::simple:
+                // The type is simple, so we can just rewrite it in place
+                pp->type = legalParamType.getSimple();
+                break;
+
+            default:
+                // We have something like a tuple, and will need
+                // to expand into multiple parameters now.
+                SLANG_UNEXPECTED("need to handle it!");
+                break;
+            }
+
+        }
+
+
+        // Now legalize the instructions inside the block
+        IRInst* nextInst = nullptr;
+        for (auto ii = bb->getFirstInst(); ii; ii = nextInst)
+        {
+            nextInst = ii->getNextInst();
+
+            LegalVal legalVal = legalizeInst(context, ii);
+
+            registerLegalizedValue(context, ii, legalVal);
+        }
+    }
+}
+
+// Represents the "chain" of declarations that
+// were followed to get to a variable that we
+// are now declaring as a leaf variable.
+struct LegalVarChain
+{
+    LegalVarChain*  next;
+    VarLayout*      varLayout;
+};
+
+static LegalVal declareSimpleVar(
+    TypeLegalizationContext*    context,
+    IROp                        op,
+    Type*                       type,
+    TypeLayout*                 typeLayout,
+    LegalVarChain*              varChain)
+{
+    RefPtr<VarLayout> varLayout;
+    if (typeLayout)
+    {
+        // We need to construct a layout for the new variable
+        // that reflects both the type we have given it, as
+        // well as all the offset information that has accumulated
+        // along the chain of parent variables.
+
+        varLayout = new VarLayout();
+        varLayout->typeLayout = typeLayout;
+
+        for (auto rr : typeLayout->resourceInfos)
+        {
+            auto resInfo = varLayout->findOrAddResourceInfo(rr.kind);
+
+            for (auto vv = varChain; vv; vv = vv->next)
+            {
+                if (auto parentResInfo = vv->varLayout->FindResourceInfo(rr.kind))
+                {
+                    resInfo->index += parentResInfo->index;
+                    resInfo->space += parentResInfo->space;
+                }
+            }
+        }
+
+        // Some of the parent variables might actually contain offsets
+        // to the `space` or `set` of the field, and we need to apply
+        // those to all the nested resource infos.
+        for (auto vv = varChain; vv; vv = vv->next)
+        {
+            auto parentSpaceInfo = vv->varLayout->findOrAddResourceInfo(LayoutResourceKind::ParameterBlock);
+            if (!parentSpaceInfo)
+                continue;
+
+            for (auto& rr : varLayout->resourceInfos)
+            {
+                if (rr.kind == LayoutResourceKind::ParameterBlock)
+                {
+                    rr.index += parentSpaceInfo->index;
+                }
+                else
+                {
+                    rr.space += parentSpaceInfo->index;
+                }
+            }
+        }
+    }
+
+    switch (op)
+    {
+    case kIROp_global_var:
+        {
+            IRBuilder* builder = context->builder;
+
+            auto globalVar = builder->createGlobalVar(type);
+            globalVar->removeFromParent();
+            globalVar->insertBefore(context->insertBeforeGlobal);
+
+            if (varLayout)
+            {
+                builder->addLayoutDecoration(globalVar, varLayout);
+            }
+
+            return LegalVal::simple(globalVar);
+        }
+        break;
+
+    default:
+        SLANG_UNEXPECTED("unexpected IR opcode");
+        break;
+    }
+}
+
+static RefPtr<TypeLayout> getDerefTypeLayout(
+    TypeLayout* typeLayout)
+{
+    if (!typeLayout)
+        return nullptr;
+
+    if (auto parameterGroupTypeLayout = dynamic_cast<ParameterGroupTypeLayout*>(typeLayout))
+    {
+        return parameterGroupTypeLayout->elementTypeLayout;
+    }
+
+    return typeLayout;
+}
+
+static RefPtr<VarLayout> getFieldLayout(
+    TypeLayout*             typeLayout,
+    DeclRef<VarDeclBase>    fieldDeclRef)
+{
+    if (!typeLayout)
+        return nullptr;
+
+    if (auto structTypeLayout = dynamic_cast<StructTypeLayout*>(typeLayout))
+    {
+        RefPtr<VarLayout> fieldLayout;
+        if (structTypeLayout->mapVarToLayout.TryGetValue(fieldDeclRef.getDecl(), fieldLayout))
+            return fieldLayout;
+    }
+
+    return nullptr;
+}
+
+static LegalVal declareVars(
+    TypeLegalizationContext*    context,
+    IROp                        op,
+    LegalType                   type,
+    TypeLayout*                 typeLayout,
+    LegalVarChain*              varChain)
+{
+    switch (type.flavor)
+    {
+    case LegalType::Flavor::simple:
+        return declareSimpleVar(context, op, type.getSimple(), typeLayout, varChain);
+        break;
+
+    case LegalType::Flavor::implicitDeref:
+        {
+            // Just declare a variable of the pointed-to type,
+            // since we are removing the indirection.
+
+            auto val = declareVars(
+                context,
+                op,
+                type.getImplicitDeref()->valueType,
+                getDerefTypeLayout(typeLayout),
+                varChain);
+            return LegalVal::implicitDeref(val);
+        }
+        break;
+
+    case LegalType::Flavor::tuple:
+        {
+            // Declare one variable for each element of the tuple
+            auto tupleType = type.getTuple();
+
+            RefPtr<TupleVal> tupleVal = new TupleVal();
+
+            for (auto ee : tupleType->elements)
+            {
+                auto fieldLayout = getFieldLayout(typeLayout, ee.fieldDeclRef);
+                RefPtr<TypeLayout> fieldTypeLayout = fieldLayout ? fieldLayout->typeLayout : nullptr;
+
+                // If we are processing layout information, then
+                // we need to create a new link in the chain
+                // of variables that will determine offsets
+                // for the eventual leaf fields...
+                LegalVarChain newVarChainStorage;
+                LegalVarChain* newVarChain = varChain;
+                if (fieldLayout)
+                {
+                    newVarChainStorage.next = varChain;
+                    newVarChainStorage.varLayout = fieldLayout;
+                    newVarChain = &newVarChainStorage;
+                }
+
+                TupleVal::Element element;
+                element.fieldDeclRef = ee.fieldDeclRef;
+                element.val = declareVars(
+                    context,
+                    op,
+                    ee.type,
+                    fieldTypeLayout,
+                    newVarChain);
+                tupleVal->elements.Add(element);
+            }
+
+            return LegalVal::tuple(tupleVal);
+        }
+        break;
+
+    default:
+        SLANG_UNEXPECTED("unhandled");
+        break;
+    }
+}
+
+RefPtr<VarLayout> findVarLayout(IRValue* value)
+{
+    if (auto layoutDecoration = value->findDecoration<IRLayoutDecoration>())
+        return layoutDecoration->layout.As<VarLayout>();
+    return nullptr;
+}
+
+static void legalizeGlobalVar(
+    TypeLegalizationContext*    context,
+    IRGlobalVar*                irGlobalVar)
+{
+    // Legalize the type for the variable's value
+    auto legalValueType = legalizeType(
+        context,
+        irGlobalVar->getType()->getValueType());
+
+    RefPtr<VarLayout> varLayout = findVarLayout(irGlobalVar);
+    RefPtr<TypeLayout> typeLayout = varLayout ? varLayout->typeLayout : nullptr;
+
+    // If we've decided to do implicit deref on the type,
+    // then go ahead and declare a value of the pointed-to type.
+    LegalType maybeSimpleType = legalValueType;
+    while (maybeSimpleType.flavor == LegalType::Flavor::implicitDeref)
+    {
+        maybeSimpleType = maybeSimpleType.getImplicitDeref()->valueType;
+    }
+
+    switch (maybeSimpleType.flavor)
+    {
+    case LegalType::Flavor::simple:
+        // Easy case: the type is usable as-is, and we
+        // should just do that.
+        irGlobalVar->type = context->session->getPtrType(
+            maybeSimpleType.getSimple());
+        break;
+
+    default:
+        {
+            context->insertBeforeGlobal = irGlobalVar->getNextValue();
+
+            LegalVarChain* varChain = nullptr;
+            LegalVarChain varChainStorage;
+            if (varLayout)
+            {
+                varChainStorage.next = nullptr;
+                varChainStorage.varLayout = varLayout;
+                varChain = &varChainStorage;
+            }
+
+            LegalVal newVal = declareVars(context, kIROp_global_var, legalValueType, typeLayout, varChain);
+
+            // Register the new value as the replacement for the old
+            registerLegalizedValue(context, irGlobalVar, newVal);
+
+            // Remove the old global from the module.
+            irGlobalVar->removeFromParent();
+            // TODO: actually clean up the global!
+        }
+        break;
+    }
+}
+
+static void legalizeGlobalValue(
+    TypeLegalizationContext*    context,
+    IRGlobalValue*              irValue)
+{
+    switch (irValue->op)
+    {
+    case kIROp_witness_table:
+        // Just skip these.
+        break;
+
+    case kIROp_Func:
+        legalizeFunc(context, (IRFunc*)irValue);
+        break;
+
+    case kIROp_global_var:
+        legalizeGlobalVar(context, (IRGlobalVar*)irValue);
+        break;
+
+    default:
+        SLANG_UNEXPECTED("unknown global value type");
+        break;
+    }
+}
+
+static void legalizeTypes(
+    TypeLegalizationContext*    context)
+{
+    auto module = context->module;
+    for (auto gv = module->getFirstGlobalValue(); gv; gv = gv->getNextValue())
+    {
+        legalizeGlobalValue(context, gv);
+    }
+}
+
+
+void legalizeTypes(
+    IRModule*   module)
+{
+    auto session = module->session;
+
+    SharedIRBuilder sharedBuilderStorage;
+    auto sharedBuilder = &sharedBuilderStorage;
+
+    sharedBuilder->session = session;
+    sharedBuilder->module = module;
+
+    IRBuilder builderStorage;
+    auto builder = &builderStorage;
+
+    builder->sharedBuilder = sharedBuilder;
+
+
+    TypeLegalizationContext contextStorage;
+    auto context = &contextStorage;
+
+    context->session = session;
+    context->module = module;
+    context->builder = builder;
+
+    legalizeTypes(context);
+
+}
+
+#if 0
+    typedef unsigned int TypeScalarizationFlags;
+    enum TypeScalarizationFlag
+    {
+        anyResource     = 0x1,
+        anyNonResource  = 0x2,
+        anyAggregate    = 0x4,
+    };
+
+    bool isResourceType(Type* type)
+    {
+        while (auto arrayType = type->As<ArrayExpressionType>())
+        {
+            type = arrayType->baseType;
+        }
+
+        if (auto textureTypeBase = type->As<TextureTypeBase>())
+        {
+            return true;
+        }
+        else if (auto samplerType = type->As<SamplerStateType>())
+        {
+            return true;
+        }
+
+        // TODO: need more comprehensive coverage here
+
+        return false;
+    }
+
+    TypeScalarizationFlags getTypeScalarizationFlags(
+        Session*    session,
+        Type*       type)
+    {
+        // TODO: we should probably cache flags once
+        // they are computed, to avoid O(N^2) sorts
+        // of behavior.
+
+        if (isResourceType(type))
+            return TypeScalarizationFlag::anyNonResource;
+
+        if(type->As<BasicExpressionType>())
+        {
+            return TypeScalarizationFlag::anyNonResource;
+        }
+        if(type->As<VectorExpressionType>())
+        {
+            return TypeScalarizationFlag::anyNonResource;
+        }
+        if(type->As<MatrixExpressionType>())
+        {
+            return TypeScalarizationFlag::anyNonResource;
+        }
+        else if (auto declRefType = type->As<DeclRefType>())
+        {
+            auto declRef = declRefType->declRef;
+            if (auto structDeclRef = declRef.As<StructDecl>())
+            {
+                TypeScalarizationFlags flags = TypeScalarizationFlag::anyAggregate;
+
+                // For structure types, the basic rule will be
+                // that if the type contains *any* resource-type
+                // fields, then it needs to be scalarized.
+                // If it contains any non-resource-type fields,
+                // then we should aggregate these into a single
+                // new `struct` type with just the non-resource
+                // fields.
+                for (auto fieldDeclRef : getMembersOfType<StructField>(structDeclRef))
+                {
+                    auto fieldType = GetType(fieldDeclRef);
+
+                    // TODO: we are making a recursive call here, so
+                    // this will break if/when we ever allowed a recursive type!
+                    auto fieldFlags = getTypeScalarizationFlags(session, fieldType);
+                    flags |= fieldFlags;
+
+                }
+
+                return flags;
+            }
+        }
+        else if (auto arrayType = type->As<ArrayExpressionType>())
+        {
+            return getTypeScalarizationFlags(
+                session,
+                arrayType->baseType);
+        }
+
+        // Default behavior: assume we have a non-resource type
+        return TypeScalarizationFlag::anyNonResource;
+    }
+
+    struct ArrayScalarizationInfo
+    {
+        ArrayScalarizationInfo* next;
+        RefPtr<IntVal>          elementCount;
+        RefPtr<ArrayTypeLayout> typeLayout;
+    };
+
+    struct SharedScalarizationContext
+    {
+
+    };
+
+    struct ScalarizationContext
+    {
+        SharedScalarizationContext* shared;
+
+        IRBuilder*              builder;
+        IRGlobalVar*            globalVar;
+        VarLayout*              globalVarLayout;
+
+        IRGlobalValue*          valueToInsertAfter;
+    };
+
+    IRValue* emitSimpleScalarizedField(
+        ScalarizationContext*   context,
+        Type*                   inType,
+        VarLayout*              fieldLayout,
+        TypeLayout*             inTypeLayout,
+        ArrayScalarizationInfo* arrayInfo)
+    {
+        auto builder = context->builder;
+        auto globalVar = context->globalVar;
+        auto globalVarLayout = context->globalVarLayout;
+        auto valueToInsertAfter = context->valueToInsertAfter;
+
+        RefPtr<Type> type = inType;
+        RefPtr<TypeLayout> typeLayout = inTypeLayout;
+
+        // If we are turning an array-of-structs into
+        // a struct-of-arrays, then we need to apply
+        // all the appropriate array dimensions here.
+        for (auto aa = arrayInfo; aa; aa = aa->next)
+        {
+            type = builder->getSession()->getArrayType(type, aa->elementCount);
+
+            if (typeLayout)
+            {
+                RefPtr<ArrayTypeLayout> arrayTypeLayout = new ArrayTypeLayout();
+                arrayTypeLayout->elementTypeLayout = typeLayout;
+
+                // TODO: fill in the other fields!
+
+                typeLayout = arrayTypeLayout;
+            }
+        }
+
+        RefPtr<VarLayout> newVarLayout;
+        if (typeLayout)
+        {
+            newVarLayout = new VarLayout();
+            newVarLayout->typeLayout = typeLayout;
+
+            if (fieldLayout)
+            {
+                for (auto fieldResourceInfo : fieldLayout->resourceInfos)
+                {
+                    auto newResourceInfo = newVarLayout->findOrAddResourceInfo(fieldResourceInfo.kind);
+
+                    if (globalVarLayout)
+                    {
+                        if (auto globalResourceInfo = globalVarLayout->FindResourceInfo(fieldResourceInfo.kind))
+                        {
+                            newResourceInfo->index += globalResourceInfo->index;
+                            newResourceInfo->space += globalResourceInfo->space;
+                        }
+                    }
+
+                    newResourceInfo->index += fieldResourceInfo.index;
+                    newResourceInfo->space += fieldResourceInfo.space;
+                }
+            }
+        }
+
+        auto newGlobalVar = addGlobalVariable(builder->getModule(), type);
+        builder->addLayoutDecoration(newGlobalVar, newVarLayout);
+
+        newGlobalVar->removeFromParent();
+        newGlobalVar->insertAfter(valueToInsertAfter);
+
+        context->valueToInsertAfter = newGlobalVar;
+
+        return newGlobalVar;
+    }
+
+    void scalarizeGlobalVariable(
+        ScalarizationContext*   context,
+        Type*                   valueType,
+        TypeLayout*             valueTypeLayout,
+        ArrayScalarizationInfo* arrayInfo)
+    {
+        if (auto arrayType = valueType->As<ArrayExpressionType>())
+        {
+            // Okay, we need to recurse down and scalarize the
+            // array element type, wrapping up each field in
+            // an array declarator as needed.
+
+            ArrayScalarizationInfo newArrayInfo;
+            newArrayInfo.next = arrayInfo;
+            newArrayInfo.elementCount = arrayType->ArrayLength;
+
+            RefPtr<TypeLayout> elementTypeLayout;
+            if (auto arrayTypeLayout = dynamic_cast<ArrayTypeLayout*>(valueTypeLayout))
+            {
+                newArrayInfo.typeLayout = arrayTypeLayout;
+                elementTypeLayout = arrayTypeLayout->elementTypeLayout;
+            }
+
+            scalarizeGlobalVariable(
+                context,
+                arrayType->baseType,
+                elementTypeLayout,
+                &newArrayInfo);
+
+            // Now we need to look at all uses of the variable,
+            // and properly rework element-index operations
+            // to instead index into the sub-arrays...
+        }
+        else if (auto declRefType = valueType->As<DeclRefType>())
+        {
+            auto declRef = declRefType->declRef;
+            if (auto aggTypeDeclRef = declRef.As<AggTypeDecl>())
+            {
+                RefPtr<StructTypeLayout> structTypeLayout = dynamic_cast<StructTypeLayout*>(valueTypeLayout);
+
+                // Okay, we need to look through the fields, and
+                // create a new variable for each of them.
+                Dictionary<Decl*, IRValue*> fieldMap;
+                UInt fieldCounter = 0;
+                for (auto fieldDeclRef : getMembersOfType<StructField>(aggTypeDeclRef))
+                {
+                    UInt fieldIndex = fieldCounter++;
+
+                    RefPtr<VarLayout> fieldLayout;
+                    RefPtr<TypeLayout> fieldTypeLayout;
+                    if (structTypeLayout)
+                    {
+                        fieldLayout = structTypeLayout->fields[fieldIndex];
+                        fieldTypeLayout = fieldLayout->typeLayout;
+                    }
+
+                    // Note: we do *not* try to deal with recursive
+                    // expansion of the fields here, and instead
+                    // prefer to handle those in further
+                    // simplification passes.
+
+                    auto fieldGlobalVar = emitSimpleScalarizedField(
+                        context,
+                        GetType(fieldDeclRef),
+                        fieldLayout,
+                        fieldTypeLayout,
+                        arrayInfo);
+
+                    fieldMap.Add(fieldDeclRef.getDecl(), fieldGlobalVar);
+                }
+
+                // Now we need to scan for uses of the original variable,
+                // and replace them with uses of the individual fields.
+                auto globalVar = context->globalVar;
+                IRUse* nextUse = nullptr;
+                for (IRUse* use = globalVar->firstUse; use; use = nextUse)
+                {
+                    nextUse = use->nextUse;
+
+                    IRUser* user = use->user;
+                    switch (user->op)
+                    {
+                    case kIROp_FieldAddress:
+                        {
+                            // This should be the easy case: we are taking
+                            // the address of a field inside this global
+                            // value, so we can just return the adress
+                            // of the global value that replaced that field.
+                            IRFieldAddress* fieldAddressInst = (IRFieldAddress*)user;
+
+                            IRValue* fieldOperand = fieldAddressInst->getField();
+                            assert(fieldOperand->op == kIROp_decl_ref);
+                            auto fieldDeclRef = ((IRDeclRef*)fieldOperand)->declRef;
+                            auto fieldDecl = fieldDeclRef.getDecl();
+
+                            IRValue* fieldVar = *fieldMap.TryGetValue(fieldDecl);
+
+                            fieldAddressInst->replaceUsesWith(fieldVar);
+                        }
+                        break;
+
+                    default:
+                        SLANG_UNEXPECTED("what to do?");
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                SLANG_UNEXPECTED("not handled");
+            }
+        }
+        else
+        {
+            SLANG_UNEXPECTED("not handled");
+        }
+    }
+
+    void scalarizeGlobalVariable(
+        SharedScalarizationContext* sharedContext,
+        IRBuilder*              builder,
+        IRGlobalVar*            globalVar,
+        VarLayout*              globalVarLayout,
+        Type*                   valueType,
+        TypeLayout*             valueTypeLayout)
+    {
+        ScalarizationContext contextStorage;
+        auto context = &contextStorage;
+
+        context->shared = sharedContext;
+        context->builder = builder;
+        context->globalVar = globalVar;
+        context->globalVarLayout = globalVarLayout;
+        context->valueToInsertAfter = globalVar;
+
+        scalarizeGlobalVariable(
+            context,
+            valueType,
+            valueTypeLayout,
+            nullptr);
+    }
+
+    RefPtr<VarLayout> findVarLayout(IRValue* value)
+    {
+        if (auto layoutDecoration = value->findDecoration<IRLayoutDecoration>())
+            return layoutDecoration->layout.As<VarLayout>();
+        return nullptr;
+    }
+
+    void scalarizeMixedResourceTypes(
+        Session*    session,
+        IRModule*   module)
+    {
+        SharedIRBuilder sharedBuilderStorage;
+        auto sharedBuilder = &sharedBuilderStorage;
+
+        sharedBuilder->session = session;
+        sharedBuilder->module = module;
+
+        IRBuilder builderStorage;
+        auto builder = &builderStorage;
+
+        builder->shared = sharedBuilder;
+
+        SharedScalarizationContext sharedContextStorage;
+        auto sharedContext = &sharedContextStorage;
+
+
+        List<IRValue*> workList;
+        for (auto gv = module->getFirstGlobalValue(); gv; gv = gv->getNextValue())
+        {
+            workList.Add(gv);
+        }
+
+        while (workList.Count())
+        {
+            IRValue* value = workList[0];
+            workList.FastRemoveAt(0);
+
+            switch (value->op)
+            {
+            case kIROp_Func:
+                {
+                    // TODO: need to iterate over parameters of
+                    // the function (and its blocks) to make
+                    // sure that any types that need scalarization
+                    // are properly handled.
+                }
+                break;
+
+            case kIROp_global_var:
+                {
+                    IRGlobalVar* globalVar = (IRGlobalVar*)value;
+                    auto valueType = globalVar->getType()->getValueType();
+
+                    auto flags = getTypeScalarizationFlags(session, valueType);
+                    if (!(flags & (TypeScalarizationFlag::anyNonResource | TypeScalarizationFlag::anyAggregate)))
+                        continue;
+
+                    auto varLayout = findVarLayout(globalVar);
+                    RefPtr<TypeLayout> typeLayout = varLayout ? varLayout->typeLayout : nullptr;
+
+                    // Okay, we have a variable of some composite type
+                    // that we need to scalarize. Since this is a global,
+                    // we also need to be careful to deal with any
+                    // layout information that has been attached.
+
+                    scalarizeGlobalVariable(
+                        sharedContext,
+                        builder,
+                        globalVar,
+                        varLayout,
+                        valueType,
+                        typeLayout);
+
+                    globalVar->removeFromParent();
+                    // TODO: need to destroy this global!
+                }
+                break;
+
+            default:
+                {
+                    // TODO: look at the type of the value,
+                    // and if it needs scalarization, replace
+                    // it with a tuple here.
+                }
+                break;
+            }
+        }
+    }
+
+
+#endif
+
+}