Use CopyLogical to further defer storage-to-logical translation when emitting SPIRV. (#8819)

In #8526, we implemented an
optimization that defers translation to end of access chains from
strorage type to logical type until a leaf logical value is needed.

Upon seeing:
```
mutablePtr : ptr<SomeStorageType> = ...
t = translateStorageToLogical(mutablePtr);
result = load(t)
```

We will create a local var to hold the result of the load, but defer the
conversion logic from storage type to logical type past the load, so we
translate the code into:

```
var tmp;
v = load(mutablePtr)
store(tmp, v);
result = translateStorageToLogicalDeref(tmp)
... 
```

So that after this translation, we can continue pushing the
`translateStorageToLogicalDeref` to the users of the `result`.

Unfortunately, this translation breaks a vulkan-spirv validation rule:
because `tmp` will have `SomeStorageType`, which is a type that has
explicit layout, it cannot be used to declare a local variable in the
`Function` address space.

Due to this, we rolled back this optimization and stop deferring
storage-to-logical conversion past the loads from mutable locations in
#8752.

In this PR, we re-enables the deferring logic, by translating into the
following code instead:

```
var tmp : Ptr<SomeStorageType_logical>;

// load from `mutablePtr`, convert it from SomeStorageType
// to SomeStorageType_logical, and write to `tmp`.
copyLogical(tmp, mutablePtr) 

result = translateStorageToLogicalDeref(tmp)
```

Where `SomeStorageType_logical` is a clone of `SomeStorageType` that is
the same in all aspects, except that `SomeStorageType_logical` does not
have a `PhysicalType` decoration and won't be emitted with explicit
layouts when emitting SPIRV. This means that `SomeStorageType_logical`
is still a "storage type" in Slang's terminology (since `bool` are
represented as `uint32_t`, `float4x4` is still represented in a
`_MatrixStorage_float_4x4` struct), but is a "logical" type in SPIRV
terminology because it does not have explicit offsets or array strides.

The `copyLogical` inst can be implemented by the `OpCopyLogical` in
SPIRV 1.4.
When emitting code for older SPIRV versions, we will run a dedicated
pass to convert the `copyLogical` into recursive
field-by-field/element-by-element copies.

Using SPIRV's `CopyLogical` allow us to generate cleaner code that has
higher chance of being optimized out by the driver.

Part of #8652.

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: csyonghe

source/slang/slang-emit-spirv.cpp

@@ -4196,6 +4196,9 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex
         case kIROp_BitCast:
             result = emitOpBitcast(parent, inst, inst->getDataType(), inst->getOperand(0));
             break;
+        case kIROp_CopyLogical:
+            result = emitCopyLogical(parent, as<IRCopyLogical>(inst));
+            break;
         case kIROp_BitfieldExtract:
             result = emitBitfieldExtract(parent, inst);
             break;
@@ -6739,6 +6742,11 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex
                         break;
                     case kIROp_Loop:
                         argStartIndex = 3;
+                        // The use from a loop inst is a true source of control flow
+                        // only if the use is the loopInst's target block operand.
+                        // A use from loop's continue block shouldn't count as an incoming block.
+                        if (use != as<IRLoop>(branchInst)->getTargetBlockUse())
+                            continue;
                         break;
                     default:
                         // A phi argument can only come from an unconditional branch inst.
@@ -7933,6 +7941,25 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex
             inst->getOperand(0));
     }
 
+    SpvInst* emitCopyLogical(SpvInstParent* parent, IRCopyLogical* inst)
+    {
+        IRBuilder builder(inst);
+        builder.setInsertBefore(inst);
+        auto dstValType = tryGetPointedToType(&builder, inst->getPtr()->getDataType());
+        auto srcValType = tryGetPointedToType(&builder, inst->getVal()->getDataType());
+        ShortList<IRInst*> attribs;
+        for (auto attrib : inst->getAllAttrs())
+        {
+            attribs.add(attrib);
+        }
+        auto slangIRLoad = as<IRLoad>(
+            builder.emitLoad(srcValType, inst->getVal(), attribs.getArrayView().arrayView));
+        auto srcVal = emitLoad(parent, slangIRLoad);
+        auto convertedVal =
+            emitInst(parent, nullptr, SpvOpCopyLogical, dstValType, kResultID, srcVal);
+        return emitOpStore(parent, nullptr, inst->getPtr(), convertedVal);
+    }
+
     SpvInst* emitBitfieldExtract(SpvInstParent* parent, IRInst* inst)
     {
         auto dataType = inst->getDataType();

source/slang/slang-ir-insts-stable-names.lua

@@ -223,7 +223,7 @@ return {
 	["field"] = 219,
 	["var"] = 220,
 	["load"] = 221,
-	["store"] = 222,
+	["StoreBase.store"] = 222,
 	["AtomicOperation.atomicLoad"] = 223,
 	["AtomicOperation.atomicStore"] = 224,
 	["AtomicOperation.atomicExchange"] = 225,
@@ -682,4 +682,6 @@ return {
 	["Attr.MemoryScope"] = 678,
 	["Undefined.LoadFromUninitializedMemory"] = 679,
 	["CUDA_LDG"] = 680,
+	["StoreBase.copyLogical"] = 681,
+	["MakeStorageTypeLoweringConfig"] = 682,
 }

source/slang/slang-ir-insts.h

@@ -1984,6 +1984,7 @@ struct IRUnconditionalBranch : IRTerminatorInst
     IRUse block;
 
     IRBlock* getTargetBlock() { return (IRBlock*)block.get(); }
+    IRUse* getTargetBlockUse() { return █ }
 
     UInt getArgCount();
     IRUse* getArgs();
@@ -2590,7 +2591,10 @@ struct IRCastStorageToLogicalBase : IRInst
 {
     FIDDLE(baseInst())
     IRInst* getVal() { return getOperand(0); }
-    IRInst* getBufferType() { return getOperand(1); }
+    IRMakeStorageTypeLoweringConfig* getLayoutConfig()
+    {
+        return as<IRMakeStorageTypeLoweringConfig>(getOperand(1));
+    }
 };
 
 FIDDLE()
@@ -3770,6 +3774,8 @@ struct IRBuilder
     IRInst* emitStore(IRInst* dstPtr, IRInst* srcVal, IRInst* align);
     IRInst* emitStore(IRInst* dstPtr, IRInst* srcVal, IRInst* align, IRInst* memoryScope);
 
+    IRInst* emitCopyLogical(IRInst* dest, IRInst* srcPtr, IRInst* instsToCopyLoadAttributesFrom);
+
     IRInst* emitAtomicStore(IRInst* dstPtr, IRInst* srcVal, IRInst* memoryOrder);
 
     IRInst* emitImageLoad(IRType* type, ShortList<IRInst*> params);
@@ -3977,8 +3983,18 @@ struct IRBuilder
     IRInst* emitCastPtrToInt(IRInst* val);
     IRInst* emitCastIntToPtr(IRType* ptrType, IRInst* val);
 
-    IRInst* emitCastStorageToLogical(IRType* type, IRInst* val, IRInst* bufferType);
-    IRInst* emitCastStorageToLogicalDeref(IRType* type, IRInst* val, IRInst* bufferType);
+    IRMakeStorageTypeLoweringConfig* emitMakeStorageTypeLoweringConfig(
+        AddressSpace addrspace,
+        IRTypeLayoutRuleName ruleName,
+        bool lowerToPhysicalType);
+    IRInst* emitCastStorageToLogical(
+        IRType* type,
+        IRInst* val,
+        IRMakeStorageTypeLoweringConfig* config);
+    IRInst* emitCastStorageToLogicalDeref(
+        IRType* type,
+        IRInst* val,
+        IRMakeStorageTypeLoweringConfig* config);
 
     IRGlobalConstant* emitGlobalConstant(IRType* type);
 

source/slang/slang-ir-insts.lua

@@ -938,8 +938,16 @@ local insts = {
 	{ field = { struct_name = "StructField", min_operands = 2 } },
 	{ var = {} },
 	{ load = { min_operands = 1 } },
-	{ store = { min_operands = 2 } },
+	{
+		StoreBase =
+		{
+			operands = {{"ptr"}, {"val"}},
+			{ store = {} },
+			{ copyLogical = {} },
+		},
+	},
 	{ CUDA_LDG = {min_operands = 1 } },
+
 	-- Atomic Operations
 	{
 		AtomicOperation = {
@@ -2335,8 +2343,10 @@ local insts = {
 	{ EnumCast = { operands = { { "value" } } } },
 	{ CastUInt2ToDescriptorHandle = { operands = { { "value" } } } },
 	{ CastDescriptorHandleToUInt2 = { operands = { { "value" } } } },
-	-- Represents a psuedo cast to convert between a logical type (user declared) and a storage Type
+	-- Represents a psuedo cast to convert between an original(user declared) type and a storage Type
 	-- (valid in buffer locations). The operand can either be a value or an address.
+	-- The first operand is a pointer to a storage type, the second operand must be a `MakeStorageTypeLoweringConfig` inst
+	-- that defines how the storage type is lowered from the original type.
 	{
 		CastStorageToLogicalBase = {
 			min_operands = 2,
@@ -2345,6 +2355,9 @@ local insts = {
 			{ CastStorageToLogicalDeref = { min_operands = 2, struct_name = "CastStorageToLogicalDeref" } },
 		},
 	},
+	-- IR encoding of a `TypeLoweringConfig` object that defines how a type is lowered to a storage type.
+	-- This is produced/consumed only in the lower-buffer-element-to-storage-type pass.
+	{ MakeStorageTypeLoweringConfig = { hoistable = true, operands = { { "addressSpace" }, { "layoutRule" }, { "lowerToPhysicalType" } } } },
 	{ CastUInt64ToDescriptorHandle = { operands = { { "value" } } } },
 	{ CastDescriptorHandleToUInt64 = { operands = { { "value" } } } },
 	-- Represents a no-op cast to convert a resource pointer to a resource on targets where the resource handles are