Add tests for literal overloads of fmod, length, and normalize

lib/DXIL/DxilOperations.cpp

@@ -3566,9 +3566,18 @@ Function *OP::GetOpFunc(OpCode opCode, Type *pOverloadType) {
   DXASSERT(0 <= (unsigned)opCode && opCode < OpCode::NumOpCodes,
            "otherwise caller passed OOB OpCode");
   assert(0 <= (unsigned)opCode && opCode < OpCode::NumOpCodes);
-  DXASSERT(IsOverloadLegal(opCode, pOverloadType),
-           "otherwise the caller requested illegal operation overload (eg HLSL "
-           "function with unsupported types for mapped intrinsic function)");
+
+  // Remove this assert on illegal overload for now.
+  // Illegal overloads are generated and eliminated by DXIL op constant
+  // evaluation for a number of cases where a double overload of an HL intrinsic
+  // that otherwise does not support double is used for literal values, when
+  // there is no constant evaluation for the intrinsic in CodeGen.
+  // Illegal overloads of DXIL intrinsics may survive through to final DXIL,
+  // but these will be caught by the validator, and this is not a regression.
+  // DXASSERT(IsOverloadLegal(opCode, pOverloadType),
+  //      "otherwise the caller requested illegal operation overload (eg HLSL "
+  //      "function with unsupported types for mapped intrinsic function)");
+
   OpCodeClass opClass = m_OpCodeProps[(unsigned)opCode].opCodeClass;
   Function *&F =
       m_OpCodeClassCache[(unsigned)opClass].pOverloads[pOverloadType];

tools/clang/test/HLSLFileCheck/hlsl/intrinsics/basic/fmod_const_eval.hlsl

@@ -0,0 +1,55 @@
+// RUN: %dxc -T vs_6_0 %s -E main | %FileCheck %s
+// RUN: %dxc -T vs_6_0 %s -E main -DNO_FOLD | %FileCheck %s -check-prefixes=NO_FOLD
+
+// Ensure fmod is constant evaluated during codegen, or dxil const eval
+// TODO: handle fp specials properly!
+
+RWBuffer<float4> results : register(u0);
+
+[shader("vertex")]
+void main(bool b : B) {
+    uint i = 0;
+
+    // Literal float
+    // 2.5, -2.5, 2.5, -2.5
+    // CHECK: call void @dx.op.bufferStore.f32(i32 69, %dx.types.Handle %{{.+}}, i32 0, i32 undef, float 2.500000e+00, float -2.500000e+00, float 2.500000e+00, float -2.500000e+00, i8 15)
+    results[i++] = float4(fmod(5.5, 3.0),
+                          fmod(-5.5, 3.0),
+                          fmod(5.5, -3.0),
+                          fmod(-5.5, -3.0));
+
+    // Explicit float
+    // 2.5, -2.5, 2.5, -2.5
+    // CHECK: call void @dx.op.bufferStore.f32(i32 69, %dx.types.Handle %{{.+}}, i32 1, i32 undef, float 2.500000e+00, float -2.500000e+00, float 2.500000e+00, float -2.500000e+00, i8 15)
+    results[i++] = float4(fmod(5.5f, 3.0f),
+                          fmod(-5.5f, 3.0f),
+                          fmod(5.5f, -3.0f),
+                          fmod(-5.5f, -3.0f));
+
+#ifdef SPECIALS
+    // Literal float
+    // 0.0, -0.0, NaN, -NaN
+    results[i++] = float4(fmod(0.0, 1.0),
+                          fmod(-0.0, 1.0),
+                          fmod(5.5, 0.0),
+                          fmod(-5.5, 0.0));
+    // Explicit float
+    // 0.0, -0.0, NaN, -NaN
+    results[i++] = float4(fmod(0.0f, 1.0f),
+                          fmod(-0.0f, 1.0f),
+                          fmod(5.5f, 0.0f),
+                          fmod(-5.5f, 0.0f));
+#endif // SPECIALS
+
+#ifdef NO_FOLD
+    // Currently, we rely on constant folding of DXIL ops to get rid of illegal
+    // double overloads. If this doesn't happen, we expect a validation error.
+    // Ternary operator can return literal type, while not being foldable due
+    // non-constant condition.
+    // NO_FOLD: error: validation errors
+    // NO_FOLD: error: DXIL intrinsic overload must be valid.
+    // NO_FOLD: note: at '%{{.+}} = call double @dx.op.unary.f64(i32 22, double %{{.+}})' in block '#0' of function 'main'.
+    float result = fmod(-5.5, b ? 1.5 : 0.5);
+    results[i++] = float4(result, 0, 0, 0);
+#endif // NO_FOLD
+}

tools/clang/test/HLSLFileCheck/hlsl/intrinsics/basic/length_const_eval.hlsl

@@ -0,0 +1,38 @@
+// RUN: %dxc -T vs_6_0 %s -E main | %FileCheck %s
+// RUN: %dxc -T vs_6_0 %s -E main -DNO_FOLD | %FileCheck %s -check-prefixes=NO_FOLD
+
+// Ensure length is constant evaluated during codegen, or dxil const eval
+// TODO: handle fp specials properly!
+
+RWBuffer<float4> results : register(u0);
+
+[shader("vertex")]
+void main(bool b : B) {
+    uint i = 0;
+
+    // Literal float
+    // CHECK: call void @dx.op.bufferStore.f32(i32 69, %dx.types.Handle %{{.+}}, i32 0, i32 undef, float 0x3FE6A09E60000000, float 0x4004C8DC20000000, float 0.000000e+00, float 0.000000e+00, i8 15)
+    results[i++] = float4(length(0.5.xx),
+                          length(-1.5.xxx),
+                          length(0.0.xxxx),
+                          length(-0.0.xxxx));
+
+    // Explicit float
+    // CHECK: call void @dx.op.bufferStore.f32(i32 69, %dx.types.Handle %{{.+}}, i32 1, i32 undef, float 0x3FE6A09E60000000, float 0x4004C8DC20000000, float 0.000000e+00, float 0.000000e+00, i8 15)
+    results[i++] = float4(length(0.5F.xx),
+                          length(-1.5F.xxx),
+                          length(0.0F.xxxx),
+                          length(-0.0F.xxxx));
+
+#ifdef NO_FOLD
+    // Currently, we rely on constant folding of DXIL ops to get rid of illegal
+    // double overloads. If this doesn't happen, we expect a validation error.
+    // Ternary operator can return literal type, while not being foldable due
+    // non-constant condition.
+    // NO_FOLD: error: validation errors
+    // NO_FOLD: error: DXIL intrinsic overload must be valid.
+    // NO_FOLD: note: at '%{{.+}} = call double @dx.op.unary.f64(i32 24, double %{{.+}})' in block '#0' of function 'main'.
+    float result = length((b ? 1.5 : 0.5).xxx);
+    results[i++] = float4(result, 0, 0, 0);
+#endif // NO_FOLD
+}

tools/clang/test/HLSLFileCheck/hlsl/intrinsics/basic/normalize_const_eval.hlsl

@@ -0,0 +1,38 @@
+// RUN: %dxc -T vs_6_0 %s -E main | %FileCheck %s
+// RUN: %dxc -T vs_6_0 %s -E main -DNO_FOLD | %FileCheck %s -check-prefixes=NO_FOLD
+
+// Ensure normalize is constant evaluated during codegen, or dxil const eval
+// TODO: handle fp specials properly!
+
+RWBuffer<float4> results : register(u0);
+
+[shader("vertex")]
+void main(bool b : B) {
+    uint i = 0;
+
+    // Literal float
+    // CHECK: call void @dx.op.bufferStore.f32(i32 69, %dx.types.Handle %{{.+}}, i32 0, i32 undef, float 0x3FE6A09E60000000, float 0xBFE279A740000000, float 0x7FF8000000000000, float 0x7FF8000000000000, i8 15)
+    results[i++] = float4(normalize(0.5.xx).x,
+                          normalize(-1.5.xxx).x,
+                          normalize(0.0.xxxx).x,
+                          normalize(-0.0.xxxx).x);
+
+    // Explicit float
+    // CHECK: call void @dx.op.bufferStore.f32(i32 69, %dx.types.Handle %{{.+}}, i32 1, i32 undef, float 0x3FE6A09E60000000, float 0xBFE279A740000000, float 0x7FF8000000000000, float 0x7FF8000000000000, i8 15)
+    results[i++] = float4(normalize(0.5F.xx).x,
+                          normalize(-1.5F.xxx).x,
+                          normalize(0.0F.xxxx).x,
+                          normalize(-0.0F.xxxx).x);
+
+#ifdef NO_FOLD
+    // Currently, we rely on constant folding of DXIL ops to get rid of illegal
+    // double overloads. If this doesn't happen, we expect a validation error.
+    // Ternary operator can return literal type, while not being foldable due
+    // non-constant condition.
+    // NO_FOLD: error: validation errors
+    // NO_FOLD: error: DXIL intrinsic overload must be valid.
+    // NO_FOLD: note: at '%{{.+}} = call double @dx.op.dot3.f64(i32 55, double %{{.+}}, double %{{.+}}, double %{{.+}}, double %{{.+}}, double %{{.+}}, double %{{.+}})' in block '#0' of function 'main'.
+    float result = normalize((b ? 1.5 : 0.5).xxx).x;
+    results[i++] = float4(result, 0, 0, 0);
+#endif // NO_FOLD
+}