[spirv] Limit firstbithigh/low to 32-bit args

Becuase the underlying GLSL.std.450 instructions FindSMsb, FindUMsb and
FindILsB are currently limited to 32-bit width components, we should
emit an explicit error messages when these instructions would be
generated incorrectly in the SPIR-V backend.

Closes microsoft#4702

Author: sudonatalie

tools/clang/lib/SPIRV/SpirvEmitter.cpp

@@ -8287,25 +8287,6 @@ SpirvEmitter::processIntrinsicCallExpr(const CallExpr *callExpr) {
                                            srcLoc, srcRange);                  \
   } break
 
-#define INTRINSIC_OP_CASE_SINT_UINT(intrinsicOp, glslSintOp, glslUintOp,       \
-                                    doEachVec)                                 \
-  case hlsl::IntrinsicOp::IOP_##intrinsicOp: {                                 \
-    glslOpcode = isSintType ? GLSLstd450::GLSLstd450##glslSintOp               \
-                            : GLSLstd450::GLSLstd450##glslUintOp;              \
-    retVal = processIntrinsicUsingGLSLInst(callExpr, glslOpcode, doEachVec,    \
-                                           srcLoc, srcRange);                  \
-  } break
-
-#define INTRINSIC_OP_CASE_SINT_UINT_FLOAT(intrinsicOp, glslSintOp, glslUintOp, \
-                                          glslFloatOp, doEachVec)              \
-  case hlsl::IntrinsicOp::IOP_##intrinsicOp: {                                 \
-    glslOpcode = isFloatType  ? GLSLstd450::GLSLstd450##glslFloatOp            \
-                 : isSintType ? GLSLstd450::GLSLstd450##glslSintOp             \
-                              : GLSLstd450::GLSLstd450##glslUintOp;            \
-    retVal = processIntrinsicUsingGLSLInst(callExpr, glslOpcode, doEachVec,    \
-                                           srcLoc, srcRange);                  \
-  } break
-
   switch (const auto hlslOpcode = static_cast<hlsl::IntrinsicOp>(opcode)) {
   case hlsl::IntrinsicOp::IOP_InterlockedAdd:
   case hlsl::IntrinsicOp::IOP_InterlockedAnd:
@@ -8713,6 +8694,35 @@ SpirvEmitter::processIntrinsicCallExpr(const CallExpr *callExpr) {
                                            srcRange);
     break;
   }
+  case hlsl::IntrinsicOp::IOP_ufirstbithigh:
+  case hlsl::IntrinsicOp::IOP_firstbithigh: {
+    const QualType argType = callExpr->getArg(0)->getType();
+    if (astContext.getTypeSize(argType) == 64) {
+      emitError("%0 is currently limited to 32-bit width components when "
+                "targetting SPIR-V",
+                srcLoc)
+          << getFunctionOrOperatorName(callee, true);
+      return 0;
+    }
+
+    glslOpcode = isSintType ? GLSLstd450::GLSLstd450FindSMsb
+                            : GLSLstd450::GLSLstd450FindUMsb;
+    retVal = processIntrinsicUsingGLSLInst(callExpr, glslOpcode, false, srcLoc,
+                                           srcRange);
+  } break;
+  case hlsl::IntrinsicOp::IOP_firstbitlow: {
+    const QualType argType = callExpr->getArg(0)->getType();
+    if (astContext.getTypeSize(argType) == 64) {
+      emitError("%0 is currently limited to 32-bit width components when "
+                "targetting SPIR-V",
+                srcLoc)
+          << getFunctionOrOperatorName(callee, true);
+      return 0;
+    }
+    glslOpcode = GLSLstd450::GLSLstd450FindILsb;
+    retVal = processIntrinsicUsingGLSLInst(callExpr, glslOpcode, false, srcLoc,
+                                           srcRange);
+  } break;
     INTRINSIC_SPIRV_OP_CASE(ddx, DPdx, true);
     INTRINSIC_SPIRV_OP_CASE(ddx_coarse, DPdxCoarse, false);
     INTRINSIC_SPIRV_OP_CASE(ddx_fine, DPdxFine, false);
@@ -8743,10 +8753,7 @@ SpirvEmitter::processIntrinsicCallExpr(const CallExpr *callExpr) {
     INTRINSIC_OP_CASE(determinant, Determinant, false);
     INTRINSIC_OP_CASE(exp, Exp, true);
     INTRINSIC_OP_CASE(exp2, Exp2, true);
-    INTRINSIC_OP_CASE_SINT_UINT(firstbithigh, FindSMsb, FindUMsb, false);
-    INTRINSIC_OP_CASE_SINT_UINT(ufirstbithigh, FindSMsb, FindUMsb, false);
     INTRINSIC_OP_CASE(faceforward, FaceForward, false);
-    INTRINSIC_OP_CASE(firstbitlow, FindILsb, false);
     INTRINSIC_OP_CASE(floor, Floor, true);
     INTRINSIC_OP_CASE(fma, Fma, true);
     INTRINSIC_OP_CASE(frac, Fract, true);

tools/clang/test/CodeGenSPIRV/intrinsics.firstbithigh.64bit.hlsl

@@ -0,0 +1,8 @@
+// RUN: %dxc -T ps_6_0 -E main
+
+void main() {
+  uint64_t   uint_1;
+  uint64_t fbh = firstbithigh(uint_1);
+}
+
+// CHECK: error: firstbithigh is currently limited to 32-bit width components when targetting SPIR-V

tools/clang/test/CodeGenSPIRV/intrinsics.firstbitlow.64bit.hlsl

@@ -0,0 +1,8 @@
+// RUN: %dxc -T ps_6_0 -E main
+
+void main() {
+  uint64_t   uint_1;
+  uint64_t fbl = firstbitlow(uint_1);
+}
+
+// CHECK: error: firstbitlow is currently limited to 32-bit width components when targetting SPIR-V

tools/clang/unittests/SPIRV/CodeGenSpirvTest.cpp

@@ -1274,9 +1274,15 @@ TEST_F(FileTest, IntrinsicsFaceForward) {
 TEST_F(FileTest, IntrinsicsFirstBitHigh) {
   runFileTest("intrinsics.firstbithigh.hlsl");
 }
+TEST_F(FileTest, IntrinsicsFirstBitHigh64bit) {
+  runFileTest("intrinsics.firstbithigh.64bit.hlsl", Expect::Failure);
+}
 TEST_F(FileTest, IntrinsicsFirstBitLow) {
   runFileTest("intrinsics.firstbitlow.hlsl");
 }
+TEST_F(FileTest, IntrinsicsFirstBitLow64bit) {
+  runFileTest("intrinsics.firstbitlow.64bit.hlsl", Expect::Failure);
+}
 TEST_F(FileTest, IntrinsicsPrintf) { runFileTest("intrinsics.printf.hlsl"); }
 TEST_F(FileTest, IntrinsicsFloor) { runFileTest("intrinsics.floor.hlsl"); }
 TEST_F(FileTest, IntrinsicsFmod) { runFileTest("intrinsics.fmod.hlsl"); }