Use and() and or() functions for logical-AND and OR

With this commit, Slang will emit function calls to `and()` and `or()`
for the logical-AND and logical-OR when the operands are non-scalar and
the target profile is SM6.0 and above. This is required change from
SM6.0.

For WGSL, there is no operator overloadings of `&&` and `||` when the
operands are non-scalar. Unlike HLSL, WGSL also don't have `and()` nor
`or()`. Alternatively, we can use `select()`.

Author: jkwak-work

lock

@@ -821,6 +821,36 @@ bool HLSLSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inOu
             }
             break;
         }
+    case kIROp_And:
+    case kIROp_Or:
+        {
+            // SM6.0 requires to use `and()` and `or()` functions for the logical-AND and
+            // logical-OR, respectively, with non-scalar operands.
+            auto targetProfile = getTargetProgram()->getOptionSet().getProfile();
+            if (targetProfile.getVersion() < ProfileVersion::DX_6_0)
+                return false;
+
+            if (as<IRBasicType>(inst->getDataType()))
+                return false;
+
+            const auto emitOp = getEmitOpForOp(inst->getOp());
+            const auto info = getInfo(emitOp);
+
+            if (inst->getOp() == kIROp_And)
+            {
+                m_writer->emit(" and(");
+            }
+            else
+            {
+                m_writer->emit(" or(");
+            }
+            emitOperand(inst->getOperand(0), getInfo(EmitOp::General));
+            m_writer->emit(", ");
+            emitOperand(inst->getOperand(1), getInfo(EmitOp::General));
+            m_writer->emit(")");
+            return true;
+        }
+
     case kIROp_BitCast:
         {
             // For simplicity, we will handle all bit-cast operations

source/slang/slang-emit-hlsl.cpp

@@ -1312,6 +1312,40 @@ bool WGSLSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inOu
         }
         break;
 
+    case kIROp_And:
+    case kIROp_Or:
+        {
+            // WGSL doesn't have operator overloadings for `&&` and `||` when the operands are
+            // non-scalar. Unlike HLSL, WGSL doesn't have `and()` and `or()`.
+            if (as<IRBasicType>(inst->getDataType()))
+                return false;
+
+            const auto emitOp = getEmitOpForOp(inst->getOp());
+            const auto info = getInfo(emitOp);
+
+            if (inst->getOp() == kIROp_And)
+            {
+                m_writer->emit(" select(");
+                emitType(inst->getDataType());
+                m_writer->emit("(false),");
+                emitOperand(inst->getOperand(0), getInfo(EmitOp::General));
+                m_writer->emit(", ");
+                emitOperand(inst->getOperand(1), getInfo(EmitOp::General));
+                m_writer->emit(")");
+            }
+            else
+            {
+                m_writer->emit(" select(");
+                emitOperand(inst->getOperand(0), getInfo(EmitOp::General));
+                m_writer->emit(", ");
+                emitType(inst->getDataType());
+                m_writer->emit("(true), ");
+                emitOperand(inst->getOperand(1), getInfo(EmitOp::General));
+                m_writer->emit(")");
+            }
+            return true;
+        }
+
     case kIROp_BitCast:
         {
             // In WGSL there is a built-in bitcast function!

source/slang/slang-emit-wgsl.cpp

@@ -0,0 +1,40 @@
+//TEST(compute):SIMPLE(filecheck=SM5):-target hlsl -profile cs_5_1 -entry computeMain
+//TEST(compute):SIMPLE(filecheck=SM6):-target hlsl -profile cs_6_0 -entry computeMain
+//TEST(compute):SIMPLE(filecheck=WGSL):-target wgsl -stage compute -entry computeMain
+//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHK):-slang -compute -shaderobj
+//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHK):-vk -compute  -shaderobj
+//TEST(compute):COMPARE_COMPUTE_EX(filecheck-buffer=CHK):-cuda -compute -shaderobj
+//TEST(compute):COMPARE_COMPUTE_EX(filecheck-buffer=CHK):-cpu -compute -shaderobj
+
+// SM6.0 and above require to use `and()` and `or()` when the operands are non-scalar.
+// And SM below SM6.0 doesn't have the functions, `and()` and `or()`.
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+static int result = 0;
+
+bool2 assignFunc(int index)
+{
+    result++;
+    return bool2(true);
+}
+
+[numthreads(4, 1, 1)]
+void computeMain(int3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int index = dispatchThreadID.x;
+
+    //SM5:!all({{.*}}&&
+    //SM6:!all({{ *}}and(
+    //WGSL:!all( select(vec2<bool>(false),
+    if (!all(bool2(index < 2) && assignFunc(index)))
+    {
+        result++;
+    }
+
+    outputBuffer[index] = result;
+
+    //CHK-COUNT-2: 1
+    //CHK-COUNT-2: 2
+}

tests/compute/logic-no-short-circuit-evaluation.slang

@@ -1,8 +1,8 @@
-//TEST(compute):COMPARE_COMPUTE:-dx12 -compute -shaderobj 
-//TEST(compute):COMPARE_COMPUTE:-vk -compute  -shaderobj
-//TEST(compute):COMPARE_COMPUTE_EX:-cuda -compute -shaderobj
-//TEST(compute):COMPARE_COMPUTE_EX:-cpu -compute -compile-arg -O3 -shaderobj
-//TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHK):-dx12 -compute -shaderobj
+//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHK):-vk -compute  -shaderobj
+//TEST(compute):COMPARE_COMPUTE_EX(filecheck-buffer=CHK):-cuda -compute -shaderobj
+//TEST(compute):COMPARE_COMPUTE_EX(filecheck-buffer=CHK):-cpu -compute -compile-arg -O3 -shaderobj
+//TEST(compute):COMPARE_COMPUTE_EX(filecheck-buffer=CHK):-slang -compute -shaderobj
 
 // Test doing vector comparisons 
 
@@ -25,4 +25,8 @@ void computeMain(int3 dispatchThreadID : SV_DispatchThreadID)
 
     // Only the last 4 elements will be 1.
     (index < 12) || assignFunc(index);
+
+    //CHK-COUNT-4: 1
+    //CHK-COUNT-8: 0
+    //CHK-COUNT-4: 1
 }