[mlir][arith] Mark unknown types legal in WIE

[kuhar]

Summary

Allow unknown types to pass through without being marked as illegal.

[kuhar]

Drop an accidental include.

[kuhar]

Fix test function name

[antiagainst]

mlir/lib/Dialect/Arith/Transforms/EmulateWideInt.cpp

644

Should we actually add addConversion([](Type type) -> Optional<Type> { return type; }); at L629 to let all other types pass through? There can exist dialect types we don't know about at all.

[kuhar]

mlir/lib/Dialect/Arith/Transforms/EmulateWideInt.cpp

644

Originally, I thought that out-of-tree passes would be able to add custom conversions to this type converter to support whatever types they need.
I looked at how the type converter works and it attempts conversions one by one in reverse order, so adding the Type -> Type as a base conversion should also work. Custom conversions added outside of this constructors should be picked up first.

Thanks for the suggestion!

[kuhar]

Allow all unknown types to pass through.

mlir/lib/Dialect/Arith/Transforms/EmulateWideInt.cpp

 //===- EmulateWideInt.cpp - Wide integer operation emulation ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Arith/Transforms/Passes.h"
 
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/Arith/Transforms/WideIntEmulationConverter.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Func/Transforms/FuncConversions.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
+#include "mlir/IR/BuiltinTypes.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/Support/MathExtras.h"
 #include <cassert>
 
 namespace mlir::arith {
 #define GEN_PASS_DEF_ARITHEMULATEWIDEINT
 #include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
 } // namespace mlir::arith
addConversion([this](IntegerType ty) -> Optional<Type> {
 
     // i2N --> vector<2xiN>
     if (width == 2 * maxIntWidth)
       return VectorType::get(2, IntegerType::get(ty.getContext(), maxIntWidth));
 
     return None;
   });
 
+  // IndexType is not sized, do not emulate.
+  addConversion([](IndexType ty) -> Optional<Type> { return ty; });
+  // FlatType is not an integer type, do not emulate.
+  addConversion([](FloatType ty) -> Optional<Type> { return ty; });
+
   // Vector case.
   addConversion([this](VectorType ty) -> Optional<Type> {
     auto intTy = ty.getElementType().dyn_cast<IntegerType>();
     if (!intTy)
       return ty;
 
     unsigned width = intTy.getWidth();
     if (width <= maxIntWidth)

mlir/test/Dialect/Arith/emulate-wide-int.mlir

 // RUN: mlir-opt --arith-emulate-wide-int="widest-int-supported=32" %s | FileCheck %s
 
 // Expect no conversions, i32 is supported.
 // CHECK-LABEL: func @addi_same_i32
 // CHECK-SAME:    ([[ARG:%.+]]: i32) -> i32
 // CHECK-NEXT:    [[X:%.+]] = arith.addi [[ARG]], [[ARG]] : i32
 // CHECK-NEXT:    return [[X]] : i32
 func.func @addi_same_i32(%a : i32) -> i32 {
     %x = arith.addi %a, %a : i32
     return %x : i32
 }
 
+// Expect no conversions, index is not sized.
+// CHECK-LABEL: func @addi_same_index
+// CHECK-SAME:    ([[ARG:%.+]]: index) -> index
+// CHECK-NEXT:    [[X:%.+]] = arith.addi [[ARG]], [[ARG]] : index
+// CHECK-NEXT:    return [[X]] : index
+func.func @addi_same_index(%a : index) -> index {
+    %x = arith.addi %a, %a : index
+    return %x : index
+}
+
+// Expect no conversions, f64 is not an integer type.
+// CHECK-LABEL: func @addi_same_f64
+// CHECK-SAME:    ([[ARG:%.+]]: f64) -> f64
+// CHECK-NEXT:    return [[ARG]] : f64
+func.func @addi_same_f64(%a : f64) -> f64 {
+    return %a : f64
+}
+
 // Expect no conversions, i32 is supported.
 // CHECK-LABEL: func @addi_same_vector_i32
 // CHECK-SAME:    ([[ARG:%.+]]: vector<2xi32>) -> vector<2xi32>
 // CHECK-NEXT:    [[X:%.+]] = arith.addi [[ARG]], [[ARG]] : vector<2xi32>
 // CHECK-NEXT:    return [[X]] : vector<2xi32>
 func.func @addi_same_vector_i32(%a : vector<2xi32>) -> vector<2xi32> {
     %x = arith.addi %a, %a : vector<2xi32>
     return %x : vector<2xi32>