[mlir][spirv] Do not truncate i/f64 -> i/f32 in SPIRVConversion

This truncation can be unexpected and break program behavior.
Dedicated emulation passes should be used instead.

Also rename pass options to "emulate-lt-32-bit-scalar-types".

Fixes: #57917

Reviewed By: antiagainst

Differential Revision: https://reviews.llvm.org/D137115

Author: kuhar

mlir/include/mlir/Conversion/Passes.td

@@ -118,10 +118,10 @@ def ConvertArithToSPIRV : Pass<"convert-arith-to-spirv"> {
   let constructor = "mlir::arith::createConvertArithToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
   let options = [
-    Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
+    Option<"emulateLT32BitScalarTypes", "emulate-lt-32-bit-scalar-types",
            "bool", /*default=*/"true",
-           "Emulate non-32-bit scalar types with 32-bit ones if "
-           "missing native support">,
+           "Emulate narrower scalar types with 32-bit ones if not supported by "
+           "the target">,
     Option<"enableFastMath", "enable-fast-math",
            "bool", /*default=*/"false",
            "Enable fast math mode (assuming no NaN and infinity for floating "
@@ -259,10 +259,10 @@ def ConvertControlFlowToSPIRV : Pass<"convert-cf-to-spirv"> {
   let constructor = "mlir::createConvertControlFlowToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
   let options = [
-    Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
+    Option<"emulateLT32BitScalarTypes", "emulate-lt-32-bit-scalar-types",
            "bool", /*default=*/"true",
-           "Emulate non-32-bit scalar types with 32-bit ones if "
-           "missing native support">
+           "Emulate narrower scalar types with 32-bit ones if not supported by"
+           " the target">
   ];
 }
 
@@ -320,10 +320,10 @@ def ConvertFuncToSPIRV : Pass<"convert-func-to-spirv"> {
   let constructor = "mlir::createConvertFuncToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
   let options = [
-    Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
+    Option<"emulateLT32BitScalarTypes", "emulate-lt-32-bit-scalar-types",
            "bool", /*default=*/"true",
-           "Emulate non-32-bit scalar types with 32-bit ones if "
-           "missing native support">
+           "Emulate narrower scalar types with 32-bit ones if not supported by"
+           " the target">
   ];
 }
 
@@ -815,10 +815,10 @@ def ConvertTensorToSPIRV : Pass<"convert-tensor-to-spirv"> {
   let constructor = "mlir::createConvertTensorToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
   let options = [
-    Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
+    Option<"emulateLT32BitScalarTypes", "emulate-lt-32-bit-scalar-types",
            "bool", /*default=*/"true",
-           "Emulate non-32-bit scalar types with 32-bit ones if "
-           "missing native support">
+           "Emulate narrower scalar types with 32-bit ones if not supported by"
+           " the target">
   ];
 }
 

mlir/include/mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h

@@ -30,21 +30,21 @@ struct SPIRVConversionOptions {
   /// The number of bits to store a boolean value.
   unsigned boolNumBits{8};
 
-  /// Whether to emulate non-32-bit scalar types with 32-bit scalar types if
-  /// no native support.
+  /// Whether to emulate narrower scalar types with 32-bit scalar types if not
+  /// supported by the target.
   ///
   /// Non-32-bit scalar types require special hardware support that may not
   /// exist on all GPUs. This is reflected in SPIR-V as that non-32-bit scalar
   /// types require special capabilities or extensions. This option controls
-  /// whether to use 32-bit types to emulate, if a scalar type of a certain
-  /// bitwidth is not supported in the target environment. This requires the
-  /// runtime to also feed in data with a matched bitwidth and layout for
-  /// interface types. The runtime can do that by inspecting the SPIR-V
-  /// module.
+  /// whether to use 32-bit types to emulate < 32-bits-wide scalars, if a scalar
+  /// type of a certain bitwidth is not supported in the target environment.
+  /// This requires the runtime to also feed in data with a matched bitwidth and
+  /// layout for interface types. The runtime can do that by inspecting the
+  /// SPIR-V module.
   ///
   /// If the original scalar type has less than 32-bit, a multiple of its
   /// values will be packed into one 32-bit value to be memory efficient.
-  bool emulateNon32BitScalarTypes{true};
+  bool emulateLT32BitScalarTypes{true};
 
   /// Use 64-bit integers to convert index types.
   bool use64bitIndex{false};

mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp

@@ -1031,7 +1031,7 @@ struct ConvertArithToSPIRVPass
     auto target = SPIRVConversionTarget::get(targetAttr);
 
     SPIRVConversionOptions options;
-    options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes;
+    options.emulateLT32BitScalarTypes = this->emulateLT32BitScalarTypes;
     options.enableFastMathMode = this->enableFastMath;
     SPIRVTypeConverter typeConverter(targetAttr, options);
 

mlir/lib/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRVPass.cpp

@@ -41,7 +41,7 @@ void ConvertControlFlowToSPIRVPass::runOnOperation() {
       SPIRVConversionTarget::get(targetAttr);
 
   SPIRVConversionOptions options;
-  options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes;
+  options.emulateLT32BitScalarTypes = this->emulateLT32BitScalarTypes;
   SPIRVTypeConverter typeConverter(targetAttr, options);
 
   RewritePatternSet patterns(context);

mlir/lib/Conversion/FuncToSPIRV/FuncToSPIRVPass.cpp

@@ -40,7 +40,7 @@ void ConvertFuncToSPIRVPass::runOnOperation() {
       SPIRVConversionTarget::get(targetAttr);
 
   SPIRVConversionOptions options;
-  options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes;
+  options.emulateLT32BitScalarTypes = this->emulateLT32BitScalarTypes;
   SPIRVTypeConverter typeConverter(targetAttr, options);
 
   RewritePatternSet patterns(context);

mlir/lib/Conversion/TensorToSPIRV/TensorToSPIRVPass.cpp

@@ -38,7 +38,7 @@ class ConvertTensorToSPIRVPass
         SPIRVConversionTarget::get(targetAttr);
 
     SPIRVConversionOptions options;
-    options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes;
+    options.emulateLT32BitScalarTypes = this->emulateLT32BitScalarTypes;
     SPIRVTypeConverter typeConverter(targetAttr, options);
 
     RewritePatternSet patterns(context);

mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp

@@ -220,9 +220,16 @@ static Type convertScalarType(const spirv::TargetEnv &targetEnv,
 
   // Otherwise we need to adjust the type, which really means adjusting the
   // bitwidth given this is a scalar type.
+  if (!options.emulateLT32BitScalarTypes)
+    return nullptr;
 
-  if (!options.emulateNon32BitScalarTypes)
+  // We only emulate narrower scalar types here and do not truncate results.
+  if (type.getIntOrFloatBitWidth() > 32) {
+    LLVM_DEBUG(llvm::dbgs()
+               << type
+               << " not converted to 32-bit for SPIR-V to avoid truncation\n");
     return nullptr;
+  }
 
   if (auto floatType = type.dyn_cast<FloatType>()) {
     LLVM_DEBUG(llvm::dbgs() << type << " converted to 32-bit for SPIR-V\n");

mlir/test/Conversion/ArithToSPIRV/arith-to-spirv-unsupported.mlir

@@ -49,24 +49,84 @@ func.func @int_vector4_invalid(%arg0: vector<2xi16>) {
 
 // -----
 
-func.func @unsupported_constant_0() {
+func.func @unsupported_constant_i64_0() {
+  // expected-error @+1 {{failed to legalize operation 'arith.constant'}}
+  %0 = arith.constant 0 : i64
+  return
+}
+
+// -----
+
+func.func @unsupported_constant_i64_1() {
   // expected-error @+1 {{failed to legalize operation 'arith.constant'}}
   %0 = arith.constant 4294967296 : i64 // 2^32
   return
 }
 
 // -----
 
-func.func @unsupported_constant_1() {
+func.func @unsupported_constant_vector_2xi64_0() {
+  // expected-error @+1 {{failed to legalize operation 'arith.constant'}}
+  %1 = arith.constant dense<0> : vector<2xi64>
+  return
+}
+
+// -----
+
+func.func @unsupported_constant_f64_0() {
   // expected-error @+1 {{failed to legalize operation 'arith.constant'}}
-  %1 = arith.constant -2147483649 : i64 // -2^31 - 1
+  %1 = arith.constant 0.0 : f64
   return
 }
 
 // -----
 
-func.func @unsupported_constant_2() {
+func.func @unsupported_constant_vector_2xf64_0() {
   // expected-error @+1 {{failed to legalize operation 'arith.constant'}}
-  %2 = arith.constant -2147483649 : i64 // -2^31 - 1
+  %1 = arith.constant dense<0.0> : vector<2xf64>
   return
 }
+
+// -----
+
+func.func @unsupported_constant_tensor_2xf64_0() {
+  // expected-error @+1 {{failed to legalize operation 'arith.constant'}}
+  %1 = arith.constant dense<0.0> : tensor<2xf64>
+  return
+}
+
+///===----------------------------------------------------------------------===//
+// Type emulation
+//===----------------------------------------------------------------------===//
+
+// -----
+
+module attributes {
+  spirv.target_env = #spirv.target_env<
+    #spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
+} {
+
+// Check that we do not emualte i64 by truncating to i32.
+func.func @unsupported_i64(%arg0: i64) {
+  // expected-error@+1 {{failed to legalize operation 'arith.addi'}}
+  %2 = arith.addi %arg0, %arg0: i64
+  return
+}
+
+} // end module
+
+// -----
+
+module attributes {
+  spirv.target_env = #spirv.target_env<
+    #spirv.vce<v1.0, [], []>, #spirv.resource_limits<>>
+} {
+
+// Check that we do not emualte f64 by truncating to i32.
+func.func @unsupported_f64(%arg0: f64) {
+  // expected-error@+1 {{failed to legalize operation 'arith.addf'}}
+  %2 = arith.addf %arg0, %arg0: f64
+  return
+}
+
+} // end module