[mlir] Add unsigned version of index_cast

[ThomasRaoux]

Summary

This is required to be able to cast integer type to a potential larger index using zero-extend cast.

There is a larger change under discussion to move index ops in a separate dialect: https://discourse.llvm.org/t/rfc-index-dialect/65540/
Based on timing of this work this patch can be included as part of this effort but as a short term solution we may want to add this op to arithmetic dialect for now in order to fill the gap.

[stellaraccident]

I'm personally ok with this patch. If we decide to go forward with the index dialect, it will come with a transition plan for index-in-arith, and it doesn't seem like this makes that harder. If anything, it makes it easier to specify what the transition path is for the existing index cast ops.

Marking as accepted to note my agreement. Please wait for consensus to land.

mlir/include/mlir/Dialect/Arith/IR/ArithOps.td

let description = [{
     integer, the value is truncated.
   }];
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
+// IndexCastUIOp
+//===----------------------------------------------------------------------===//
+
+def Arith_IndexCastUIOp
+  : Arith_CastOp<"index_castui", IndexCastTypeConstraint, IndexCastTypeConstraint,
+                 [DeclareOpInterfaceMethods<InferIntRangeInterface>]> {
+  let summary = "unsigned cast between index and integer types";
+  let description = [{
+    Casts between scalar or vector integers and corresponding 'index' scalar or
+    vectors. Index is an integer of platform-specific bit width. If casting to
+    a wider integer, the value is zero-extended. If casting to a narrower
+    integer, the value is truncated.
+  }];
+
+  let hasFolder = 1;
+  let hasCanonicalizer = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // BitcastOp
 //===----------------------------------------------------------------------===//
 
 // Bitcast can convert between memrefs of signless integers, indices, and
 // floats too.
 def BitcastTypeConstraint : TypeConstraint<Or<[
         SignlessIntegerOrFloatLike.predicate,
         MemRefOf<[AnySignlessInteger, Index, AnyFloat]>.predicate]>,

mlir/lib/Conversion/ArithToLLVM/ArithToLLVM.cpp

struct ConstantOpLowering : public ConvertOpToLLVMPattern<arith::ConstantOp> {
   matchAndRewrite(arith::ConstantOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// The lowering of index_cast becomes an integer conversion since index
 /// becomes an integer.  If the bit width of the source and target integer
 /// types is the same, just erase the cast.  If the target type is wider,
 /// sign-extend the value, otherwise truncate it.
-struct IndexCastOpLowering : public ConvertOpToLLVMPattern<arith::IndexCastOp> {
-  using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern;
+template <typename OpTy, typename ExtCastTy>
+struct IndexCastOpLowering : public ConvertOpToLLVMPattern<OpTy> {
+  using ConvertOpToLLVMPattern<OpTy>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(arith::IndexCastOp op, OpAdaptor adaptor,
+  matchAndRewrite(OpTy op, typename OpTy::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
+using IndexCastOpSILowering =
+    IndexCastOpLowering<arith::IndexCastOp, LLVM::SExtOp>;
+using IndexCastOpUILowering =
+    IndexCastOpLowering<arith::IndexCastUIOp, LLVM::ZExtOp>;
+
 struct AddUICarryOpLowering
     : public ConvertOpToLLVMPattern<arith::AddUICarryOp> {
   using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(arith::AddUICarryOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
return LLVM::detail::oneToOneRewrite(op, LLVM::ConstantOp::getOperationName(),
                                        adaptor.getOperands(),
                                        *getTypeConverter(), rewriter);
 }
 
 //===----------------------------------------------------------------------===//
 // IndexCastOpLowering
 //===----------------------------------------------------------------------===//
 
-LogicalResult IndexCastOpLowering::matchAndRewrite(
-    arith::IndexCastOp op, OpAdaptor adaptor,
+template <typename OpTy, typename ExtCastTy>
+LogicalResult IndexCastOpLowering<OpTy, ExtCastTy>::matchAndRewrite(
+    OpTy op, typename OpTy::Adaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   Type resultType = op.getResult().getType();
   Type targetElementType =
-      typeConverter->convertType(getElementTypeOrSelf(resultType));
+      this->typeConverter->convertType(getElementTypeOrSelf(resultType));
   Type sourceElementType =
-      typeConverter->convertType(getElementTypeOrSelf(op.getIn()));
+      this->typeConverter->convertType(getElementTypeOrSelf(op.getIn()));
   unsigned targetBits = targetElementType.getIntOrFloatBitWidth();
   unsigned sourceBits = sourceElementType.getIntOrFloatBitWidth();
 
   if (targetBits == sourceBits) {
     rewriter.replaceOp(op, adaptor.getIn());
     return success();
   }
 
   // Handle the scalar and 1D vector cases.
   Type operandType = adaptor.getIn().getType();
   if (!operandType.isa<LLVM::LLVMArrayType>()) {
-    Type targetType = typeConverter->convertType(resultType);
+    Type targetType = this->typeConverter->convertType(resultType);
     if (targetBits < sourceBits)
       rewriter.replaceOpWithNewOp<LLVM::TruncOp>(op, targetType,
                                                  adaptor.getIn());
     else
-      rewriter.replaceOpWithNewOp<LLVM::SExtOp>(op, targetType,
-                                                adaptor.getIn());
+      rewriter.replaceOpWithNewOp<ExtCastTy>(op, targetType, adaptor.getIn());
     return success();
   }
 
   if (!resultType.isa<VectorType>())
     return rewriter.notifyMatchFailure(op, "expected vector result type");
 
   return LLVM::detail::handleMultidimensionalVectors(
-      op.getOperation(), adaptor.getOperands(), *getTypeConverter(),
+      op.getOperation(), adaptor.getOperands(), *(this->getTypeConverter()),
       [&](Type llvm1DVectorTy, ValueRange operands) -> Value {
-        OpAdaptor adaptor(operands);
+        typename OpTy::Adaptor adaptor(operands);
         if (targetBits < sourceBits) {
           return rewriter.create<LLVM::TruncOp>(op.getLoc(), llvm1DVectorTy,
                                                 adaptor.getIn());
         }
-        return rewriter.create<LLVM::SExtOp>(op.getLoc(), llvm1DVectorTy,
-                                             adaptor.getIn());
+        return rewriter.create<ExtCastTy>(op.getLoc(), llvm1DVectorTy,
       },
       rewriter);
 }
 
 //===----------------------------------------------------------------------===//
 // AddUICarryOpLowering
 //===----------------------------------------------------------------------===//
 
patterns.add<
     DivFOpLowering,
     DivSIOpLowering,
     DivUIOpLowering,
     ExtFOpLowering,
     ExtSIOpLowering,
     ExtUIOpLowering,
     FPToSIOpLowering,
     FPToUIOpLowering,
-    IndexCastOpLowering,
+    IndexCastOpSILowering,
+    IndexCastOpUILowering,
     MaxFOpLowering,
     MaxSIOpLowering,
     MaxUIOpLowering,
     MinFOpLowering,
     MinSIOpLowering,
     MinUIOpLowering,
     MulFOpLowering,
     MulIOpLowering,

mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp

patterns.add<
     TypeCastingOpPattern<arith::ExtSIOp, spirv::SConvertOp>,
     TypeCastingOpPattern<arith::ExtFOp, spirv::FConvertOp>,
     TypeCastingOpPattern<arith::TruncIOp, spirv::SConvertOp>, TruncII1Pattern,
     TypeCastingOpPattern<arith::TruncFOp, spirv::FConvertOp>,
     TypeCastingOpPattern<arith::UIToFPOp, spirv::ConvertUToFOp>, UIToFPI1Pattern,
     TypeCastingOpPattern<arith::SIToFPOp, spirv::ConvertSToFOp>,
     TypeCastingOpPattern<arith::FPToSIOp, spirv::ConvertFToSOp>,
     TypeCastingOpPattern<arith::IndexCastOp, spirv::SConvertOp>,
+    TypeCastingOpPattern<arith::IndexCastUIOp, spirv::UConvertOp>,
     TypeCastingOpPattern<arith::BitcastOp, spirv::BitcastOp>,
     CmpIOpBooleanPattern, CmpIOpPattern,
     CmpFOpNanNonePattern, CmpFOpPattern,
     AddICarryOpPattern, SelectOpPattern,
 
     MinMaxFOpPattern<arith::MaxFOp, spirv::GLFMaxOp>,
     MinMaxFOpPattern<arith::MinFOp, spirv::GLFMinOp>,
     spirv::ElementwiseOpPattern<arith::MaxSIOp, spirv::GLSMaxOp>,

mlir/lib/Dialect/Arith/IR/ArithCanonicalization.td

Pat<(Arith_IndexCastOp:$res (Arith_IndexCastOp $x)),
         (replaceWithValue $x),
         [(Constraint<CPred<"$0.getType() == $1.getType()">> $res, $x)]>;
 
 // index_cast(extsi(x)) -> index_cast(x)
 def IndexCastOfExtSI :
     Pat<(Arith_IndexCastOp (Arith_ExtSIOp $x)), (Arith_IndexCastOp $x)>;
 
 //===----------------------------------------------------------------------===//
+// IndexCastUIOp
+//===----------------------------------------------------------------------===//
+
+// index_castui(index_castui(x)) -> x, if dstType == srcType.
+def IndexCastUIOfIndexCastUI :
+    Pat<(Arith_IndexCastUIOp:$res (Arith_IndexCastUIOp $x)),
+        (replaceWithValue $x),
+        [(Constraint<CPred<"$0.getType() == $1.getType()">> $res, $x)]>;
+
+// index_castui(extui(x)) -> index_castui(x)
+def IndexCastUIOfExtUI :
+    Pat<(Arith_IndexCastUIOp (Arith_ExtUIOp $x)), (Arith_IndexCastUIOp $x)>;
+
+
+//===----------------------------------------------------------------------===//
 // BitcastOp
 //===----------------------------------------------------------------------===//
 
 // bitcast(bitcast(x)) -> x
 def BitcastOfBitcast :
     Pat<(Arith_BitcastOp (Arith_BitcastOp $x)), (replaceWithValue $x)>;
 
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/Arith/IR/ArithOps.cpp

return constFoldCastOp<FloatAttr, IntegerAttr>(
         return api;
       });
 }
 
 //===----------------------------------------------------------------------===//
 // IndexCastOp
 //===----------------------------------------------------------------------===//
 
-bool arith::IndexCastOp::areCastCompatible(TypeRange inputs,
-                                           TypeRange outputs) {
+static bool areIndexCastCompatible(TypeRange inputs, TypeRange outputs) {
   if (!areValidCastInputsAndOutputs(inputs, outputs))
     return false;
 
   auto srcType = getTypeIfLikeOrMemRef<IntegerType, IndexType>(inputs.front());
   auto dstType = getTypeIfLikeOrMemRef<IntegerType, IndexType>(outputs.front());
   if (!srcType || !dstType)
     return false;
 
   return (srcType.isIndex() && dstType.isSignlessInteger()) ||
          (srcType.isSignlessInteger() && dstType.isIndex());
 }
 
+bool arith::IndexCastOp::areCastCompatible(TypeRange inputs,
+                                           TypeRange outputs) {
+  return areIndexCastCompatible(inputs, outputs);
+}
+
 OpFoldResult arith::IndexCastOp::fold(ArrayRef<Attribute> operands) {
   // index_cast(constant) -> constant
   // A little hack because we go through int. Otherwise, the size of the
   // constant might need to change.
   if (auto value = operands[0].dyn_cast_or_null<IntegerAttr>())
     return IntegerAttr::get(getType(), value.getInt());
 
   return {};
 }
 
 void arith::IndexCastOp::getCanonicalizationPatterns(
     RewritePatternSet &patterns, MLIRContext *context) {
   patterns.add<IndexCastOfIndexCast, IndexCastOfExtSI>(context);
 }
 
 //===----------------------------------------------------------------------===//
+// IndexCastUIOp
+//===----------------------------------------------------------------------===//
+
+bool arith::IndexCastUIOp::areCastCompatible(TypeRange inputs,
+                                             TypeRange outputs) {
+  return areIndexCastCompatible(inputs, outputs);
+}
+
+OpFoldResult arith::IndexCastUIOp::fold(ArrayRef<Attribute> operands) {
+  // index_castui(constant) -> constant
+  // A little hack because we go through int. Otherwise, the size of the
+  // constant might need to change.
+  if (auto value = operands[0].dyn_cast_or_null<IntegerAttr>())
+    return IntegerAttr::get(getType(), value.getUInt());
+
+  return {};
+}
+
+void arith::IndexCastUIOp::getCanonicalizationPatterns(
+    RewritePatternSet &patterns, MLIRContext *context) {
+  patterns.add<IndexCastUIOfIndexCastUI, IndexCastUIOfExtUI>(context);
+}
+
+//===----------------------------------------------------------------------===//
 // BitcastOp
 //===----------------------------------------------------------------------===//
 
 bool arith::BitcastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   if (!areValidCastInputsAndOutputs(inputs, outputs))
     return false;
 
   auto srcType =

mlir/lib/Dialect/Arith/IR/InferIntRangeInterfaceImpls.cpp

void arith::MinUIOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
   const APInt &umax = lhs.umax().ult(rhs.umax()) ? lhs.umax() : rhs.umax();
   setResultRange(getResult(), ConstantIntRanges::fromUnsigned(umin, umax));
 }
 
 //===----------------------------------------------------------------------===//
 // ExtUIOp
 //===----------------------------------------------------------------------===//
 
+static ConstantIntRanges extUIRange(const ConstantIntRanges &range,
+                                    Type destType) {
+  unsigned destWidth = ConstantIntRanges::getStorageBitwidth(destType);
+  APInt smin = range.umin().zext(destWidth);
+  APInt smax = range.umax().zext(destWidth);
+  return ConstantIntRanges::fromSigned(smin, smax);
+}
+
 void arith::ExtUIOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
                                        SetIntRangeFn setResultRange) {
   Type destType = getResult().getType();
-  unsigned destWidth = ConstantIntRanges::getStorageBitwidth(destType);
-  APInt umin = argRanges[0].umin().zext(destWidth);
-  APInt umax = argRanges[0].umax().zext(destWidth);
-  setResultRange(getResult(), ConstantIntRanges::fromUnsigned(umin, umax));
+  setResultRange(getResult(), extUIRange(argRanges[0], destType));
 }
 
 //===----------------------------------------------------------------------===//
 // ExtSIOp
 //===----------------------------------------------------------------------===//
 
 static ConstantIntRanges extSIRange(const ConstantIntRanges &range,
                                     Type destType) {
if (srcWidth < destWidth)
     setResultRange(getResult(), extSIRange(argRanges[0], destType));
   else if (srcWidth > destWidth)
     setResultRange(getResult(), truncIRange(argRanges[0], destType));
   else
     setResultRange(getResult(), argRanges[0]);
 }
 
 //===----------------------------------------------------------------------===//
+// IndexCastUIOp
+//===----------------------------------------------------------------------===//
+
+void arith::IndexCastUIOp::inferResultRanges(
+    ArrayRef<ConstantIntRanges> argRanges, SetIntRangeFn setResultRange) {
+  Type sourceType = getOperand().getType();
+  Type destType = getResult().getType();
+  unsigned srcWidth = ConstantIntRanges::getStorageBitwidth(sourceType);
+  unsigned destWidth = ConstantIntRanges::getStorageBitwidth(destType);
+
+  if (srcWidth < destWidth)
+    setResultRange(getResult(), extUIRange(argRanges[0], destType));
+  else if (srcWidth > destWidth)
+    setResultRange(getResult(), truncIRange(argRanges[0], destType));
+  else
+    setResultRange(getResult(), argRanges[0]);
+}
+
+//===----------------------------------------------------------------------===//
 // CmpIOp
 //===----------------------------------------------------------------------===//
 
 bool isStaticallyTrue(arith::CmpIPredicate pred, const ConstantIntRanges &lhs,
                       const ConstantIntRanges &rhs) {
   switch (pred) {
   case arith::CmpIPredicate::sle:
   case arith::CmpIPredicate::slt:

mlir/test/Conversion/ArithToLLVM/arith-to-llvm.mlir

 func.func @vector_index_cast(%arg0: vector<2xindex>, %arg1: vector<2xi1>) {
 // CHECK: = llvm.trunc %{{.*}} : vector<2xi{{.*}}> to vector<2xi1>
   %0 = arith.index_cast %arg0: vector<2xindex> to vector<2xi1>
 // CHECK-NEXT: = llvm.sext %{{.*}} : vector<2xi1> to vector<2xi{{.*}}>
   %1 = arith.index_cast %arg1: vector<2xi1> to vector<2xindex>
   return
 }
 
+func.func @index_castui(%arg0: index, %arg1: i1) {
+// CHECK: = llvm.trunc %0 : i{{.*}} to i1
+  %0 = arith.index_castui %arg0: index to i1
+// CHECK-NEXT: = llvm.zext %arg1 : i1 to i{{.*}}
+  %1 = arith.index_castui %arg1: i1 to index
+  return
+}
+
+// CHECK-LABEL: @vector_index_castui
+func.func @vector_index_castui(%arg0: vector<2xindex>, %arg1: vector<2xi1>) {
+// CHECK: = llvm.trunc %{{.*}} : vector<2xi{{.*}}> to vector<2xi1>
+  %0 = arith.index_castui %arg0: vector<2xindex> to vector<2xi1>
+// CHECK-NEXT: = llvm.zext %{{.*}} : vector<2xi1> to vector<2xi{{.*}}>
+  %1 = arith.index_castui %arg1: vector<2xi1> to vector<2xindex>
+  return
+}
+
 // Checking conversion of signed integer types to floating point.
 // CHECK-LABEL: @sitofp
 func.func @sitofp(%arg0 : i32, %arg1 : i64) {
 // CHECK-NEXT: = llvm.sitofp {{.*}} : i32 to f32
   %0 = arith.sitofp %arg0: i32 to f32
 // CHECK-NEXT: = llvm.sitofp {{.*}} : i32 to f64
   %1 = arith.sitofp %arg0: i32 to f64
 // CHECK-NEXT: = llvm.sitofp {{.*}} : i64 to f32

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

 func.func @index_cast3(%arg0: i32) {
   // CHECK-NOT: spirv.SConvert
   %0 = arith.index_cast %arg0 : i32 to index
   return
 }
 
 // CHECK-LABEL: index_cast4
 func.func @index_cast4(%arg0: index) {
-  // CHECK-NOT: spirv.SConvert
+  // CHECK-NOT: spirv.UConvert
+  %0 = arith.index_cast %arg0 : index to i32
+  return
+}
+
+// CHECK-LABEL: index_castui1
+func.func @index_castui1(%arg0: i16) {
+  // CHECK: spirv.UConvert %{{.+}} : i16 to i32
+  %0 = arith.index_castui %arg0 : i16 to index
+  return
+}
+
+// CHECK-LABEL: index_castui2
+func.func @index_castui2(%arg0: index) {
+  // CHECK: spirv.UConvert %{{.+}} : i32 to i16
+  %0 = arith.index_castui %arg0 : index to i16
+  return
+}
+
+// CHECK-LABEL: index_castui3
+func.func @index_castui3(%arg0: i32) {
+  // CHECK-NOT: spirv.UConvert
+  %0 = arith.index_castui %arg0 : i32 to index
+  return
+}
+
+// CHECK-LABEL: index_castui4
+func.func @index_castui4(%arg0: index) {
+  // CHECK-NOT: spirv.UConvert
   %0 = arith.index_cast %arg0 : index to i32
   return
 }
 
 // CHECK-LABEL: @bit_cast
 func.func @bit_cast(%arg0: vector<2xf32>, %arg1: i64) {
   // CHECK: spirv.Bitcast %{{.+}} : vector<2xf32> to vector<2xi32>
   %0 = arith.bitcast %arg0 : vector<2xf32> to vector<2xi32>

mlir/test/Dialect/Arith/canonicalize.mlir

 //       CHECK:   %[[res:.+]] = arith.index_cast %arg0 : i8 to index
 //       CHECK:   return %[[res]]
 func.func @indexCastOfSignExtend(%arg0: i8) -> index {
   %ext = arith.extsi %arg0 : i8 to i16
   %idx = arith.index_cast %ext : i16 to index
   return %idx : index
 }
 
+// CHECK-LABEL: @indexCastUIOfUnsignedExtend
+//       CHECK:   %[[res:.+]] = arith.index_castui %arg0 : i8 to index
+//       CHECK:   return %[[res]]
+func.func @indexCastUIOfUnsignedExtend(%arg0: i8) -> index {
+  %ext = arith.extui %arg0 : i8 to i16
+  %idx = arith.index_castui %ext : i16 to index
+  return %idx : index
+}
+
 // CHECK-LABEL: @signExtendConstant
 //       CHECK:   %[[cres:.+]] = arith.constant -2 : i16
 //       CHECK:   return %[[cres]]
 func.func @signExtendConstant() -> i16 {
   %c-2 = arith.constant -2 : i8
   %ext = arith.extsi %c-2 : i8 to i16
   return %ext : i16
 }

mlir/test/Dialect/Arith/ops.mlir

 }
 
 // CHECK-LABEL: test_index_cast_scalable_vector1
 func.func @test_index_cast_scalable_vector1(%arg0 : vector<[8]xindex>) -> vector<[8]xi64> {
   %0 = arith.index_cast %arg0 : vector<[8]xindex> to vector<[8]xi64>
   return %0 : vector<[8]xi64>
 }
 
+
+// CHECK-LABEL: test_index_castui0
+func.func @test_index_castui0(%arg0 : i32) -> index {
+  %0 = arith.index_castui %arg0 : i32 to index
+  return %0 : index
+}
+
+// CHECK-LABEL: test_index_castui_tensor0
+func.func @test_index_castui_tensor0(%arg0 : tensor<8x8xi32>) -> tensor<8x8xindex> {
+  %0 = arith.index_castui %arg0 : tensor<8x8xi32> to tensor<8x8xindex>
+  return %0 : tensor<8x8xindex>
+}
+
+// CHECK-LABEL: test_index_castui_vector0
+func.func @test_index_castui_vector0(%arg0 : vector<8xi32>) -> vector<8xindex> {
+  %0 = arith.index_castui %arg0 : vector<8xi32> to vector<8xindex>
+  return %0 : vector<8xindex>
+}
+
+// CHECK-LABEL: test_index_castui_scalable_vector0
+func.func @test_index_castui_scalable_vector0(%arg0 : vector<[8]xi32>) -> vector<[8]xindex> {
+  %0 = arith.index_castui %arg0 : vector<[8]xi32> to vector<[8]xindex>
+  return %0 : vector<[8]xindex>
+}
+
+// CHECK-LABEL: test_indexui_cast1
+func.func @test_indexui_cast1(%arg0 : index) -> i64 {
+  %0 = arith.index_castui %arg0 : index to i64
+  return %0 : i64
+}
+
+// CHECK-LABEL: test_index_castui_tensor1
+func.func @test_index_castui_tensor1(%arg0 : tensor<8x8xindex>) -> tensor<8x8xi64> {
+  %0 = arith.index_castui %arg0 : tensor<8x8xindex> to tensor<8x8xi64>
+  return %0 : tensor<8x8xi64>
+}
+
+// CHECK-LABEL: test_index_castui_vector1
+func.func @test_index_castui_vector1(%arg0 : vector<8xindex>) -> vector<8xi64> {
+  %0 = arith.index_castui %arg0 : vector<8xindex> to vector<8xi64>
+  return %0 : vector<8xi64>
+}
+
+// CHECK-LABEL: test_index_castui_scalable_vector1
+func.func @test_index_castui_scalable_vector1(%arg0 : vector<[8]xindex>) -> vector<[8]xi64> {
+  %0 = arith.index_castui %arg0 : vector<[8]xindex> to vector<[8]xi64>
+  return %0 : vector<[8]xi64>
+}
+
 // CHECK-LABEL: test_bitcast0
 func.func @test_bitcast0(%arg0 : i64) -> f64 {
   %0 = arith.bitcast %arg0 : i64 to f64
   return %0 : f64
 }
 
 // CHECK-LABEL: test_bitcast_tensor0
 func.func @test_bitcast_tensor0(%arg0 : tensor<8x8xi64>) -> tensor<8x8xf64> {