[mlir][llvm] Tighten LLVM dialect intrinsic type constraints.

[gysit]

Summary

The revision specifies more precise argument and result type
constraints for many of the llvm intrinsics. Additionally, add
tests to verify intrinsics with invalid arguments/result result
in a verification error.

[ftynse]

mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td

21

I suspect we want AnySignlessInteger here and below, MLIR integers can have signs and we don't want those in the LLVM intrinsics.

mlir/test/Target/LLVMIR/llvmir-invalid.mlir

138

Nit: FileCheck now supports @below instead of @+1 that reads better and works when combining errors and notes.

[gysit]

Address comments:

• use @below instead of @+1
• use AnySignlessInteger for all intrinsics

Rebase (after https://reviews.llvm.org/D136498):

• use qualified(type($ptr)) for arguments of type LLVM_AnyPointer
• adapt expected error messages

[gysit]

@dcaballe I changed the integer type constraints on the vector predicate intrinsics from AnyInteger to AnySignlessInteger as well. I hope this does not conflict with your changes.

[dcaballe]

In D136360#3882263, @gysit wrote:

@dcaballe I changed the integer type constraints on the vector predicate intrinsics from AnyInteger to AnySignlessInteger as well. I hope this does not conflict with your changes.

That should be fine! Thanks for pinging me :)

[nicolasvasilache]

mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td

310

Could you comment on why we need this vs just taking a fast math flags attr ?
This seems quite inconsistent with other places.

[gysit]

mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td

310

As far as I remember the reason for this was that vector reduction instructions only support allowReassoc (they do not have a fast math flag attribute attached). I would assume that is a limitation of the op itself and I didn't want to change the op semantics at the time. If LLVM IR actually supports the full fastmath attribute it could be added to the LLVM dialect operation as well.

[gysit]

mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td

310

It seems like the reassoc is the only thing that is supported on these intrinsics:

%unord = call reassoc float @llvm.vector.reduce.fmul.v4f32(float 1.0, <4 x float> %input) ; relaxed reduction

At least this is mentioned specifically in the language ref https://llvm.org/docs/LangRef.html#id826

mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td

 #ifndef LLVM_INTRINSIC_OPS
 #define LLVM_INTRINSIC_OPS
 
 include "mlir/IR/OpBase.td"
 include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 
 // Operations that correspond to LLVM intrinsics. With MLIR operation set being
 // extendable, there is no reason to introduce a hard boundary between "core"
 // operations and intrinsics. However, we systematically prefix them with
 // "intr." to avoid potential name clashes.
 
-class LLVM_UnaryIntrinsicOp<string func, list<Trait> traits = []> :
+class LLVM_UnaryIntrOpBase<string func, Type element,
+                           list<Trait> traits = []> :
     LLVM_OneResultIntrOp<func, [], [0],
            !listconcat([Pure, SameOperandsAndResultType], traits)> {
-  let arguments = (ins LLVM_Type:$in);
+  let arguments = (ins LLVM_ScalarOrVectorOf<element>:$in);
 }
 
-class LLVM_BinarySameArgsIntrinsicOp<string func, list<Trait> traits = []> :
+class LLVM_UnaryIntrOpI<string func, list<Trait> traits = []> :
+    LLVM_UnaryIntrOpBase<func, AnyInteger, traits>;
+
+class LLVM_UnaryIntrOpF<string func, list<Trait> traits = []> :
+    LLVM_UnaryIntrOpBase<func, LLVM_AnyFloat, traits>;
+
+class LLVM_BinarySameArgsIntrOpBase<string func, Type element,
+                                    list<Trait> traits = []> :
     LLVM_OneResultIntrOp<func, [], [0],
            !listconcat([Pure, SameOperandsAndResultType], traits)> {
-  let arguments = (ins LLVM_Type:$a, LLVM_Type:$b);
+  let arguments = (ins LLVM_ScalarOrVectorOf<element>:$a,
+                       LLVM_ScalarOrVectorOf<element>:$b);
 }
 
-class LLVM_BinaryIntrinsicOp<string func, list<Trait> traits = []> :
-    LLVM_OneResultIntrOp<func, [], [0,1],
-           !listconcat([Pure], traits)> {
-  let arguments = (ins LLVM_Type:$a, LLVM_Type:$b);
-}
+class LLVM_BinarySameArgsIntrOpI<string func, list<Trait> traits = []> :
+    LLVM_BinarySameArgsIntrOpBase<func, AnyInteger, traits>;
 
-class LLVM_TernarySameArgsIntrinsicOp<string func, list<Trait> traits = []> :
+class LLVM_BinarySameArgsIntrOpF<string func, list<Trait> traits = []> :
+    LLVM_BinarySameArgsIntrOpBase<func, LLVM_AnyFloat, traits>;
+
+class LLVM_TernarySameArgsIntrOpF<string func, list<Trait> traits = []> :
     LLVM_OneResultIntrOp<func, [], [0],
            !listconcat([Pure, SameOperandsAndResultType], traits)> {
-  let arguments = (ins LLVM_Type:$a, LLVM_Type:$b, LLVM_Type:$c);
+  let arguments = (ins LLVM_ScalarOrVectorOf<AnyFloat>:$a,
+                       LLVM_ScalarOrVectorOf<AnyFloat>:$b,
+                       LLVM_ScalarOrVectorOf<AnyFloat>:$c);
 }
 
-class LLVM_CountZerosIntrinsicOp<string func, list<Trait> traits = []> :
+class LLVM_CountZerosIntrOp<string func, list<Trait> traits = []> :
     LLVM_OneResultIntrOp<func, [], [0],
            !listconcat([Pure], traits)> {
-  let arguments = (ins LLVM_Type:$in, I1:$zero_undefined);
+  let arguments = (ins LLVM_ScalarOrVectorOf<AnyInteger>:$in,
+                   I1:$zero_undefined);
 }
 
 def LLVM_AbsOp : LLVM_OneResultIntrOp<"abs", [], [0], [Pure]> {
-  let arguments = (ins LLVM_Type:$in, I1:$is_int_min_poison);
+  let arguments = (ins LLVM_ScalarOrVectorOf<AnyInteger>:$in,
+                   I1:$is_int_min_poison);
 }
 
 def LLVM_IsFPClass : LLVM_OneResultIntrOp<"is.fpclass", [], [0], [Pure]> {
-  let arguments = (ins LLVM_Type:$in, I32:$bit);
+  let arguments = (ins LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$in, I32:$bit);
 }
 
-def LLVM_CopySignOp : LLVM_BinarySameArgsIntrinsicOp<"copysign">;
-def LLVM_CosOp : LLVM_UnaryIntrinsicOp<"cos">;
-def LLVM_ExpOp : LLVM_UnaryIntrinsicOp<"exp">;
-def LLVM_Exp2Op : LLVM_UnaryIntrinsicOp<"exp2">;
-def LLVM_FAbsOp : LLVM_UnaryIntrinsicOp<"fabs">;
-def LLVM_FCeilOp : LLVM_UnaryIntrinsicOp<"ceil">;
-def LLVM_FFloorOp : LLVM_UnaryIntrinsicOp<"floor">;
-def LLVM_FMAOp : LLVM_TernarySameArgsIntrinsicOp<"fma">;
-def LLVM_FMulAddOp : LLVM_TernarySameArgsIntrinsicOp<"fmuladd">;
-def LLVM_Log10Op : LLVM_UnaryIntrinsicOp<"log10">;
-def LLVM_Log2Op : LLVM_UnaryIntrinsicOp<"log2">;
-def LLVM_LogOp : LLVM_UnaryIntrinsicOp<"log">;
+def LLVM_CopySignOp : LLVM_BinarySameArgsIntrOpF<"copysign">;
+def LLVM_CosOp : LLVM_UnaryIntrOpF<"cos">;
+def LLVM_ExpOp : LLVM_UnaryIntrOpF<"exp">;
+def LLVM_Exp2Op : LLVM_UnaryIntrOpF<"exp2">;
+def LLVM_FAbsOp : LLVM_UnaryIntrOpF<"fabs">;
+def LLVM_FCeilOp : LLVM_UnaryIntrOpF<"ceil">;
+def LLVM_FFloorOp : LLVM_UnaryIntrOpF<"floor">;
+def LLVM_FMAOp : LLVM_TernarySameArgsIntrOpF<"fma">;
+def LLVM_FMulAddOp : LLVM_TernarySameArgsIntrOpF<"fmuladd">;
+def LLVM_Log10Op : LLVM_UnaryIntrOpF<"log10">;
+def LLVM_Log2Op : LLVM_UnaryIntrOpF<"log2">;
+def LLVM_LogOp : LLVM_UnaryIntrOpF<"log">;
 def LLVM_Prefetch : LLVM_ZeroResultIntrOp<"prefetch", [0]> {
-  let arguments = (ins LLVM_Type:$addr, LLVM_Type:$rw, LLVM_Type:$hint,
-                   LLVM_Type:$cache);
+  let arguments = (ins LLVM_AnyPointer:$addr, I32:$rw, I32:$hint, I32:$cache);
 }
-def LLVM_SinOp : LLVM_UnaryIntrinsicOp<"sin">;
-def LLVM_RoundEvenOp : LLVM_UnaryIntrinsicOp<"roundeven">;
-def LLVM_RoundOp : LLVM_UnaryIntrinsicOp<"round">;
-def LLVM_FTruncOp : LLVM_UnaryIntrinsicOp<"trunc">;
-def LLVM_SqrtOp : LLVM_UnaryIntrinsicOp<"sqrt">;
-def LLVM_PowOp : LLVM_BinarySameArgsIntrinsicOp<"pow">;
-def LLVM_PowIOp : LLVM_BinaryIntrinsicOp<"powi">;
-def LLVM_BitReverseOp : LLVM_UnaryIntrinsicOp<"bitreverse">;
-def LLVM_CountLeadingZerosOp : LLVM_CountZerosIntrinsicOp<"ctlz">;
-def LLVM_CountTrailingZerosOp : LLVM_CountZerosIntrinsicOp<"cttz">;
-def LLVM_CtPopOp : LLVM_UnaryIntrinsicOp<"ctpop">;
-def LLVM_MaxNumOp : LLVM_BinarySameArgsIntrinsicOp<"maxnum">;
-def LLVM_MinNumOp : LLVM_BinarySameArgsIntrinsicOp<"minnum">;
-def LLVM_MaximumOp : LLVM_BinarySameArgsIntrinsicOp<"maximum">;
-def LLVM_MinimumOp : LLVM_BinarySameArgsIntrinsicOp<"minimum">;
-def LLVM_SMaxOp : LLVM_BinarySameArgsIntrinsicOp<"smax">;
-def LLVM_SMinOp : LLVM_BinarySameArgsIntrinsicOp<"smin">;
-def LLVM_UMaxOp : LLVM_BinarySameArgsIntrinsicOp<"umax">;
-def LLVM_UMinOp : LLVM_BinarySameArgsIntrinsicOp<"umin">;
+def LLVM_SinOp : LLVM_UnaryIntrOpF<"sin">;
+def LLVM_RoundEvenOp : LLVM_UnaryIntrOpF<"roundeven">;
+def LLVM_RoundOp : LLVM_UnaryIntrOpF<"round">;
+def LLVM_FTruncOp : LLVM_UnaryIntrOpF<"trunc">;
+def LLVM_SqrtOp : LLVM_UnaryIntrOpF<"sqrt">;
+def LLVM_PowOp : LLVM_BinarySameArgsIntrOpF<"pow">;
+def LLVM_PowIOp : LLVM_OneResultIntrOp<"powi"> {
+  let arguments = (ins LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$val,
+                   AnyInteger:$power);
+}
+def LLVM_BitReverseOp : LLVM_UnaryIntrOpI<"bitreverse">;
+def LLVM_CountLeadingZerosOp : LLVM_CountZerosIntrOp<"ctlz">;
+def LLVM_CountTrailingZerosOp : LLVM_CountZerosIntrOp<"cttz">;
+def LLVM_CtPopOp : LLVM_UnaryIntrOpI<"ctpop">;
+def LLVM_MaxNumOp : LLVM_BinarySameArgsIntrOpF<"maxnum">;
+def LLVM_MinNumOp : LLVM_BinarySameArgsIntrOpF<"minnum">;
+def LLVM_MaximumOp : LLVM_BinarySameArgsIntrOpF<"maximum">;
+def LLVM_MinimumOp : LLVM_BinarySameArgsIntrOpF<"minimum">;
+def LLVM_SMaxOp : LLVM_BinarySameArgsIntrOpI<"smax">;
+def LLVM_SMinOp : LLVM_BinarySameArgsIntrOpI<"smin">;
+def LLVM_UMaxOp : LLVM_BinarySameArgsIntrOpI<"umax">;
+def LLVM_UMinOp : LLVM_BinarySameArgsIntrOpI<"umin">;
 
 def LLVM_MemcpyOp : LLVM_ZeroResultIntrOp<"memcpy", [0, 1, 2]> {
-  let arguments = (ins Arg<LLVM_Type,"",[MemWrite]>:$dst, Arg<LLVM_Type,"",[MemRead]>:$src, LLVM_Type:$len,
-                   LLVM_Type:$isVolatile);
+  let arguments = (ins Arg<LLVM_AnyPointer,"",[MemWrite]>:$dst,
+                       Arg<LLVM_AnyPointer,"",[MemRead]>:$src,
+                       AnyInteger:$len, I1:$isVolatile);
 }
 def LLVM_MemcpyInlineOp : LLVM_ZeroResultIntrOp<"memcpy.inline", [0, 1, 2]> {
-  let arguments = (ins Arg<LLVM_Type,"",[MemWrite]>:$dst, Arg<LLVM_Type,"",[MemRead]>:$src, LLVM_Type:$len,
-                   LLVM_Type:$isVolatile);
+  let arguments = (ins Arg<LLVM_AnyPointer,"",[MemWrite]>:$dst,
+                       Arg<LLVM_AnyPointer,"",[MemRead]>:$src,
+                       AnyInteger:$len, I1:$isVolatile);
 }
 def LLVM_MemmoveOp : LLVM_ZeroResultIntrOp<"memmove", [0, 1, 2]> {
-  let arguments = (ins Arg<LLVM_Type,"",[MemWrite]>:$dst, Arg<LLVM_Type,"",[MemRead]>:$src, LLVM_Type:$len,
-                   LLVM_Type:$isVolatile);
+  let arguments = (ins Arg<LLVM_AnyPointer,"",[MemWrite]>:$dst,
+                       Arg<LLVM_AnyPointer,"",[MemRead]>:$src,
+                       AnyInteger:$len, I1:$isVolatile);
 }
 
 def LLVM_MemsetOp : LLVM_ZeroResultIntrOp<"memset", [0, 2]> {
-  let arguments = (ins Arg<LLVM_Type,"",[MemWrite]>:$dst, LLVM_Type:$val, LLVM_Type:$len,
-                   LLVM_Type:$isVolatile);
+  let arguments = (ins Arg<LLVM_AnyPointer,"",[MemWrite]>:$dst,
+                       I8:$val, AnyInteger:$len, I1:$isVolatile);
 }
 
 //===----------------------------------------------------------------------===//
 // Lifetime Markers
 //===----------------------------------------------------------------------===//
 
 /// Base operation for lifetime markers. The LLVM intrinsics require the size
 /// operand to be an immediate. In MLIR it is encoded as an attribute.
def LLVM_LifetimeEndOp : LLVM_LifetimeBaseOp<"lifetime.end"> {
   string mlirBuilder = [{
     $_builder.create<LLVM::LifetimeEndOp>(
       $_location, $_int_attr($size), $ptr);
   }];
 }
 
 // Intrinsics with multiple returns.
 
-def LLVM_SAddWithOverflowOp
-    : LLVM_IntrOp<"sadd.with.overflow", [0], [], [], 2> {
-  let arguments = (ins LLVM_Type, LLVM_Type);
-}
-def LLVM_UAddWithOverflowOp
-    : LLVM_IntrOp<"uadd.with.overflow", [0], [], [], 2> {
-  let arguments = (ins LLVM_Type, LLVM_Type);
-}
-def LLVM_SSubWithOverflowOp
-    : LLVM_IntrOp<"ssub.with.overflow", [0], [], [], 2> {
-  let arguments = (ins LLVM_Type, LLVM_Type);
-}
-def LLVM_USubWithOverflowOp
-    : LLVM_IntrOp<"usub.with.overflow", [0], [], [], 2> {
-  let arguments = (ins LLVM_Type, LLVM_Type);
-}
-def LLVM_SMulWithOverflowOp
-    : LLVM_IntrOp<"smul.with.overflow", [0], [], [], 2> {
-  let arguments = (ins LLVM_Type, LLVM_Type);
-}
-def LLVM_UMulWithOverflowOp
-    : LLVM_IntrOp<"umul.with.overflow", [0], [], [], 2> {
-  let arguments = (ins LLVM_Type, LLVM_Type);
-}
-
-
-def LLVM_AssumeOp : LLVM_ZeroResultIntrOp<"assume", []> {
-  let arguments = (ins LLVM_Type:$cond);
-}
+class LLVM_ArithWithOverflowOp<string mnem>
+    : LLVM_IntrOp<mnem, [0], [], [SameOperandsElementType], 2>,
+      Arguments<(ins LLVM_ScalarOrVectorOf<AnyInteger>,
+                 LLVM_ScalarOrVectorOf<AnyInteger>)>;
+
+def LLVM_SAddWithOverflowOp : LLVM_ArithWithOverflowOp<"sadd.with.overflow">;
+def LLVM_UAddWithOverflowOp : LLVM_ArithWithOverflowOp<"uadd.with.overflow">;
+def LLVM_SSubWithOverflowOp : LLVM_ArithWithOverflowOp<"ssub.with.overflow">;
+def LLVM_USubWithOverflowOp : LLVM_ArithWithOverflowOp<"usub.with.overflow">;
+def LLVM_SMulWithOverflowOp : LLVM_ArithWithOverflowOp<"smul.with.overflow">;
+def LLVM_UMulWithOverflowOp : LLVM_ArithWithOverflowOp<"umul.with.overflow">;
 
+def LLVM_AssumeOp
+  : LLVM_ZeroResultIntrOp<"assume", []>, Arguments<(ins I1:$cond)>;
 
 //
 // Coroutine intrinsics.
 //
 
 def LLVM_CoroIdOp : LLVM_IntrOp<"coro.id", [], [], [], 1> {
   let arguments = (ins I32:$align,
                        LLVM_i8Ptr:$promise,
def LLVM_StackRestoreOp : LLVM_ZeroResultIntrOp<"stackrestore"> {
   let arguments = (ins LLVM_i8Ptr:$ptr);
   let assemblyFormat = "$ptr attr-dict";
 }
 
 //
 // Vector Reductions.
 //
 
-def LLVM_vector_reduce_add : LLVM_VectorReduction<"add">;
-def LLVM_vector_reduce_and : LLVM_VectorReduction<"and">;
-def LLVM_vector_reduce_mul : LLVM_VectorReduction<"mul">;
-def LLVM_vector_reduce_fmax : LLVM_VectorReduction<"fmax">;
-def LLVM_vector_reduce_fmin : LLVM_VectorReduction<"fmin">;
-def LLVM_vector_reduce_or : LLVM_VectorReduction<"or">;
-def LLVM_vector_reduce_smax : LLVM_VectorReduction<"smax">;
-def LLVM_vector_reduce_smin : LLVM_VectorReduction<"smin">;
-def LLVM_vector_reduce_umax : LLVM_VectorReduction<"umax">;
-def LLVM_vector_reduce_umin : LLVM_VectorReduction<"umin">;
-def LLVM_vector_reduce_xor : LLVM_VectorReduction<"xor">;
+// LLVM vector reduction over a single vector.
+class LLVM_VecReductionBase<string mnem, Type element>
+    : LLVM_OneResultIntrOp<"vector.reduce." # mnem, [], [0],
+                           [Pure, SameOperandsAndResultElementType]>,
+      Arguments<(ins LLVM_VectorOf<element>)>;
+
+class LLVM_VecReductionF<string mnem>
+    : LLVM_VecReductionBase<mnem, AnyFloat>;
+
+class LLVM_VecReductionI<string mnem>
+    : LLVM_VecReductionBase<mnem, AnyInteger>;
+
+// LLVM vector reduction over a single vector, with an initial value,
+// and with permission to reassociate the reduction operations.
+class LLVM_VecReductionAccBase<string mnem, Type element>
+    : LLVM_OneResultIntrOp<"vector.reduce." # mnem, [], [0],
+                           [Pure, SameOperandsAndResultElementType]>,
+      Arguments<(ins element:$start_value, LLVM_VectorOf<element>:$input,
+                 DefaultValuedAttr<BoolAttr, "false">:$reassoc)> {
+  let llvmBuilder = [{
+    llvm::Module *module = builder.GetInsertBlock()->getModule();
+    llvm::Function *fn = llvm::Intrinsic::getDeclaration(
+        module,
+        llvm::Intrinsic::vector_reduce_}] # mnem # [{,
+        { }] # !interleave(ListIntSubst<LLVM_IntrPatterns.operand, [1]>.lst,
+                           ", ") # [{
+        });
+    auto operands = moduleTranslation.lookupValues(opInst.getOperands());
+    llvm::FastMathFlags origFM = builder.getFastMathFlags();
+    llvm::FastMathFlags tempFM = origFM;
+    tempFM.setAllowReassoc($reassoc);
+    builder.setFastMathFlags(tempFM);  // set fastmath flag
+    $res = builder.CreateCall(fn, operands);
+    builder.setFastMathFlags(origFM);  // restore fastmath flag
+  }];
+  let mlirBuilder = [{
+    bool allowReassoc = inst->getFastMathFlags().allowReassoc();
+    $res = $_builder.create<$_qualCppClassName>($_location,
+      $_resultType, $start_value, $input, allowReassoc);
+  }];
+}
+
+class LLVM_VecReductionAccF<string mnem>
+    : LLVM_VecReductionAccBase<mnem, AnyFloat>;
+
+def LLVM_vector_reduce_add : LLVM_VecReductionI<"add">;
+def LLVM_vector_reduce_and : LLVM_VecReductionI<"and">;
+def LLVM_vector_reduce_mul : LLVM_VecReductionI<"mul">;
+def LLVM_vector_reduce_or : LLVM_VecReductionI<"or">;
+def LLVM_vector_reduce_smax : LLVM_VecReductionI<"smax">;
+def LLVM_vector_reduce_smin : LLVM_VecReductionI<"smin">;
+def LLVM_vector_reduce_umax : LLVM_VecReductionI<"umax">;
+def LLVM_vector_reduce_umin : LLVM_VecReductionI<"umin">;
+def LLVM_vector_reduce_xor : LLVM_VecReductionI<"xor">;
+
+def LLVM_vector_reduce_fmax : LLVM_VecReductionF<"fmax">;
+def LLVM_vector_reduce_fmin : LLVM_VecReductionF<"fmin">;
 
-def LLVM_vector_reduce_fadd : LLVM_VectorReductionAcc<"fadd">;
-def LLVM_vector_reduce_fmul : LLVM_VectorReductionAcc<"fmul">;
+def LLVM_vector_reduce_fadd : LLVM_VecReductionAccF<"fadd">;
+def LLVM_vector_reduce_fmul : LLVM_VecReductionAccF<"fmul">;
 
 //
 // LLVM Matrix operations.
 //
 
 /// Create a column major, strided 2-D matrix load, as specified in the LLVM
 /// MatrixBuilder.
 /// data       - Start address of the matrix read
 /// rows       - Number of rows in matrix (must be a constant)
 /// isVolatile - True if the load operation is marked as volatile.
 /// columns    - Number of columns in matrix (must be a constant)
 /// stride     - Space between columns
 def LLVM_MatrixColumnMajorLoadOp : LLVM_OneResultIntrOp<"matrix.column.major.load"> {
-  let arguments = (ins LLVM_Type:$data, LLVM_Type:$stride, I1Attr:$isVolatile,
+  let arguments = (ins LLVM_AnyPointer:$data, AnyInteger:$stride, I1Attr:$isVolatile,
                    I32Attr:$rows, I32Attr:$columns);
   let results = (outs LLVM_AnyVector:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$data `,` `<` `stride` `=` $stride `>` attr-dict"
     "`:` type($res) `from` type($data) `stride` type($stride)";
 
   string llvmBuilder = [{
     llvm::MatrixBuilder mb(builder);

 /// MatrixBuilder.
 /// matrix     - Matrix to store
 /// ptr        - Pointer to write back to
 /// isVolatile - True if the load operation is marked as volatile.
 /// rows       - Number of rows in matrix (must be a constant)
 /// columns    - Number of columns in matrix (must be a constant)
 /// stride     - Space between columns
 def LLVM_MatrixColumnMajorStoreOp : LLVM_ZeroResultIntrOp<"matrix.column.major.store"> {
-  let arguments = (ins LLVM_AnyVector:$matrix, LLVM_Type:$data,
-                   LLVM_Type:$stride, I1Attr:$isVolatile, I32Attr:$rows,
+  let arguments = (ins LLVM_AnyVector:$matrix, LLVM_AnyPointer:$data,
+                   AnyInteger:$stride, I1Attr:$isVolatile, I32Attr:$rows,
                    I32Attr:$columns);
   let builders = [LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder];
   let assemblyFormat = "$matrix `,` $data `,` `<` `stride` `=` $stride `>` "
     "attr-dict`:` type($matrix) `to` type($data) `stride` type($stride)";
 
   string llvmBuilder = [{
     llvm::MatrixBuilder mb(builder);
     const llvm::DataLayout &dl =
$_builder.create<LLVM::MatrixColumnMajorStoreOp>(
       $_location, $matrix, $data, $stride,
       $_int_attr($isVolatile), $_int_attr($rows), $_int_attr($columns));
   }];
 }
 
 /// Create a llvm.matrix.multiply call, multiplying 2-D matrices LHS and RHS, as
 /// specified in the LLVM MatrixBuilder.
 def LLVM_MatrixMultiplyOp : LLVM_OneResultIntrOp<"matrix.multiply"> {
-  let arguments = (ins LLVM_Type:$lhs, LLVM_Type:$rhs, I32Attr:$lhs_rows,
+  let arguments = (ins LLVM_AnyVector:$lhs, LLVM_AnyVector:$rhs, I32Attr:$lhs_rows,
                    I32Attr:$lhs_columns, I32Attr:$rhs_columns);
-  let results = (outs LLVM_Type:$res);
+  let results = (outs LLVM_AnyVector:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$lhs `,` $rhs attr-dict "
     "`:` `(` type($lhs) `,` type($rhs) `)` `->` type($res)";
 
   string llvmBuilder = [{
     llvm::MatrixBuilder mb(builder);
     $res = mb.CreateMatrixMultiply(
       $lhs, $rhs, $lhs_rows, $lhs_columns,
       $rhs_columns);
   }];
   string mlirBuilder = [{
     $res = $_builder.create<LLVM::MatrixMultiplyOp>(
       $_location, $_resultType, $lhs, $rhs,
       $_int_attr($lhs_rows), $_int_attr($lhs_columns), $_int_attr($rhs_columns));
   }];
 }
 
 /// Create a llvm.matrix.transpose call, transposing a `rows` x `columns` 2-D
 /// `matrix`, as specified in the LLVM MatrixBuilder.
 def LLVM_MatrixTransposeOp : LLVM_OneResultIntrOp<"matrix.transpose"> {
-  let arguments = (ins LLVM_Type:$matrix, I32Attr:$rows, I32Attr:$columns);
-  let results = (outs LLVM_Type:$res);
+  let arguments = (ins LLVM_AnyVector:$matrix, I32Attr:$rows, I32Attr:$columns);
+  let results = (outs LLVM_AnyVector:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$matrix attr-dict `:` type($matrix) `into` type($res)";
 
   string llvmBuilder = [{
     llvm::MatrixBuilder mb(builder);
     $res = mb.CreateMatrixTranspose(
       $matrix, $rows, $columns);
   }];
   string mlirBuilder = [{
     $res = $_builder.create<LLVM::MatrixTransposeOp>(
       $_location, $_resultType, $matrix,
       $_int_attr($rows), $_int_attr($columns));
   }];
 }
 
 //
 // LLVM masked operations.
 //
 
 /// Create a llvm.get.active.lane.mask to set a mask up to a given position.
 def LLVM_GetActiveLaneMaskOp
     : LLVM_OneResultIntrOp<"get.active.lane.mask", [0], [0], [Pure]> {
-  let arguments = (ins LLVM_Type:$base, LLVM_Type:$n);
+  let arguments = (ins AnyInteger:$base, AnyInteger:$n);
   let assemblyFormat = "$base `,` $n attr-dict `:` "
     "type($base) `,` type($n) `to` type($res)";
 }
 
 /// Create a call to Masked Load intrinsic.
 def LLVM_MaskedLoadOp : LLVM_OneResultIntrOp<"masked.load"> {
-  let arguments = (ins LLVM_Type:$data, LLVM_Type:$mask,
-                   Variadic<LLVM_Type>:$pass_thru, I32Attr:$alignment);
+  let arguments = (ins LLVM_AnyPointer:$data, LLVM_VectorOf<I1>:$mask,
+                   Variadic<LLVM_AnyVector>:$pass_thru, I32Attr:$alignment);
   let results = (outs LLVM_AnyVector:$res);
   let assemblyFormat =
     "operands attr-dict `:` functional-type(operands, results)";
 
   string llvmBuilder = [{
     $res = $pass_thru.empty() ? builder.CreateMaskedLoad(
         $_resultType, $data, llvm::Align($alignment), $mask) :
       builder.CreateMaskedLoad(
         $_resultType, $data, llvm::Align($alignment), $mask, $pass_thru[0]);
   }];
   string mlirBuilder = [{
     $res = $_builder.create<LLVM::MaskedLoadOp>($_location,
       $_resultType, $data, $mask, $pass_thru, $_int_attr($alignment));
   }];
   list<int> llvmArgIndices = [0, 2, 3, 1];
 }
 
 /// Create a call to Masked Store intrinsic.
 def LLVM_MaskedStoreOp : LLVM_ZeroResultIntrOp<"masked.store"> {
-  let arguments = (ins LLVM_Type:$value, LLVM_Type:$data, LLVM_Type:$mask,
-                   I32Attr:$alignment);
+  let arguments = (ins LLVM_AnyVector:$value, LLVM_AnyPointer:$data,
+                   LLVM_VectorOf<I1>:$mask, I32Attr:$alignment);
   let builders = [LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder];
   let assemblyFormat = "$value `,` $data `,` $mask attr-dict `:` "
     "type($value) `,` type($mask) `into` type($data)";
 
   string llvmBuilder = [{
     builder.CreateMaskedStore(
       $value, $data, llvm::Align($alignment), $mask);
   }];
   string mlirBuilder = [{
     $_builder.create<LLVM::MaskedStoreOp>($_location,
       $value, $data, $mask, $_int_attr($alignment));
   }];
   list<int> llvmArgIndices = [0, 1, 3, 2];
 }
 
 /// Create a call to Masked Gather intrinsic.
 def LLVM_masked_gather : LLVM_OneResultIntrOp<"masked.gather"> {
-  let arguments = (ins LLVM_AnyVector:$ptrs, LLVM_Type:$mask,
-                   Variadic<LLVM_Type>:$pass_thru, I32Attr:$alignment);
-  let results = (outs LLVM_Type:$res);
+  let arguments = (ins LLVM_VectorOf<LLVM_AnyPointer>:$ptrs,
+                   LLVM_VectorOf<I1>:$mask, Variadic<LLVM_AnyVector>:$pass_thru,
+                   I32Attr:$alignment);
+  let results = (outs LLVM_AnyVector:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat =
     "operands attr-dict `:` functional-type(operands, results)";
 
   string llvmBuilder = [{
     $res = $pass_thru.empty() ? builder.CreateMaskedGather(
         $_resultType, $ptrs, llvm::Align($alignment), $mask) :
       builder.CreateMaskedGather(
         $_resultType, $ptrs, llvm::Align($alignment), $mask, $pass_thru[0]);
   }];
   string mlirBuilder = [{
     $res = $_builder.create<LLVM::masked_gather>($_location,
       $_resultType, $ptrs, $mask, $pass_thru, $_int_attr($alignment));
   }];
   list<int> llvmArgIndices = [0, 2, 3, 1];
 }
 
 /// Create a call to Masked Scatter intrinsic.
 def LLVM_masked_scatter : LLVM_ZeroResultIntrOp<"masked.scatter"> {
-  let arguments = (ins LLVM_Type:$value, LLVM_Type:$ptrs, LLVM_Type:$mask,
-                   I32Attr:$alignment);
+  let arguments = (ins LLVM_AnyVector:$value, LLVM_VectorOf<LLVM_AnyPointer>:$ptrs,
+                   LLVM_VectorOf<I1>:$mask, I32Attr:$alignment);
   let builders = [LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder];
   let assemblyFormat = "$value `,` $ptrs `,` $mask attr-dict `:` "
     "type($value) `,` type($mask) `into` type($ptrs)";
 
   string llvmBuilder = [{
     builder.CreateMaskedScatter(
       $value, $ptrs, llvm::Align($alignment), $mask);
   }];
   string mlirBuilder = [{
     $_builder.create<LLVM::masked_scatter>($_location,
       $value, $ptrs, $mask, $_int_attr($alignment));
   }];
   list<int> llvmArgIndices = [0, 1, 3, 2];
 }
 
 /// Create a call to Masked Expand Load intrinsic.
 def LLVM_masked_expandload : LLVM_IntrOp<"masked.expandload", [0], [], [], 1> {
-  let arguments = (ins LLVM_Type, LLVM_Type, LLVM_Type);
+  let arguments = (ins LLVM_AnyPointer, LLVM_VectorOf<I1>, LLVM_AnyVector);
 }
 
 /// Create a call to Masked Compress Store intrinsic.
 def LLVM_masked_compressstore
     : LLVM_IntrOp<"masked.compressstore", [], [0], [], 0> {
-  let arguments = (ins LLVM_Type, LLVM_Type, LLVM_Type);
+  let arguments = (ins LLVM_AnyVector, LLVM_AnyPointer, LLVM_VectorOf<I1>);
 }
 
 /// Create a call to vscale intrinsic.
 def LLVM_vscale : LLVM_IntrOp<"vscale", [0], [], [], 1>;
 
 /// Create a call to stepvector intrinsic.
 def LLVM_StepVectorOp
     : LLVM_IntrOp<"experimental.stepvector", [0], [], [Pure], 1> {
   let arguments = (ins);
-  let results = (outs LLVM_Type:$res);
+  let results = (outs LLVM_VectorOf<AnyInteger>:$res);
   let assemblyFormat = "attr-dict `:` type($res)";
 }
 
 /// Create a call to vector.insert intrinsic
 def LLVM_vector_insert
     : LLVM_Op<"intr.vector.insert",
                  [Pure, AllTypesMatch<["dstvec", "res"]>,
                   PredOpTrait<"vectors are not bigger than 2^17 bits.", And<[

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

 // result, called "res". Additionally, the overloadedResults list should contain
 // "0" if the result must be used to resolve overloaded intrinsics, or remain
 // empty otherwise.
 class LLVM_OneResultIntrOp<string mnem, list<int> overloadedResults = [],
                            list<int> overloadedOperands = [],
                            list<Trait> traits = []>
     : LLVM_IntrOp<mnem, overloadedResults, overloadedOperands, traits, 1>;
 
-// LLVM vector reduction over a single vector.
-class LLVM_VectorReduction<string mnem>
-    : LLVM_OneResultIntrOp<"vector.reduce." # mnem,
-                           [], [0], [Pure]>,
-      Arguments<(ins LLVM_Type)>;
-
-// LLVM vector reduction over a single vector, with an initial value,
-// and with permission to reassociate the reduction operations.
-class LLVM_VectorReductionAcc<string mnem>
-    : LLVM_OneResultIntrOp<"vector.reduce." # mnem,
-                           [], [0], [Pure]>,
-      Arguments<(ins LLVM_Type:$start_value, LLVM_Type:$input,
-                 DefaultValuedAttr<BoolAttr, "false">:$reassoc)> {
-  let llvmBuilder = [{
-    llvm::Module *module = builder.GetInsertBlock()->getModule();
-    llvm::Function *fn = llvm::Intrinsic::getDeclaration(
-        module,
-        llvm::Intrinsic::vector_reduce_}] # mnem # [{,
-        { }] # !interleave(ListIntSubst<LLVM_IntrPatterns.operand, [1]>.lst,
-                           ", ") # [{
-        });
-    auto operands = moduleTranslation.lookupValues(opInst.getOperands());
-    llvm::FastMathFlags origFM = builder.getFastMathFlags();
-    llvm::FastMathFlags tempFM = origFM;
-    tempFM.setAllowReassoc($reassoc);
-    builder.setFastMathFlags(tempFM);  // set fastmath flag
-    $res = builder.CreateCall(fn, operands);
-    builder.setFastMathFlags(origFM);  // restore fastmath flag
-  }];
-  let mlirBuilder = [{
-    bool allowReassoc = inst->getFastMathFlags().allowReassoc();
-    $res = $_builder.create<$_qualCppClassName>($_location,
-      $_resultType, $start_value, $input, allowReassoc);
-  }];
-}
-
 def LLVM_OneResultOpBuilder :
   OpBuilder<(ins "Type":$resultType, "ValueRange":$operands,
     CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
   [{
     if (resultType) $_state.addTypes(resultType);
     $_state.addOperands(operands);
     for (auto namedAttr : attributes)
       $_state.addAttribute(namedAttr.getName(), namedAttr.getValue());

mlir/test/Target/LLVMIR/llvmir-invalid.mlir

 llvm.func @passthrough_wrong_type() attributes {passthrough = [42]}
 
 // -----
 
 // expected-error @+1 {{expected arrays within 'passthrough' to contain two strings}}
 llvm.func @passthrough_wrong_type() attributes {
   passthrough = [[ 42, 42 ]]
 }
+
+// -----
+
+llvm.func @unary_float_intr_wrong_type(%arg0 : i32) -> i32 {
+  // expected-error @+1 {{op operand #0 must be floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type}}
+  %0 = "llvm.intr.exp"(%arg0) : (i32) -> i32
+  llvm.return %0 : i32
+}
+
+// -----
+
+llvm.func @binary_float_intr_wrong_type(%arg0 : f32, %arg1 : i32) -> i32 {
+  // expected-error @+1 {{op operand #1 must be floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type}}
+  %0 = "llvm.intr.pow"(%arg0, %arg1) : (f32, i32) -> i32
+  llvm.return %0 : i32
+}
+
+// -----
+
+llvm.func @unary_int_intr_wrong_type(%arg0 : f32) -> f32 {
+  // expected-error @+1 {{op operand #0 must be integer or LLVM dialect-compatible vector of integer}}
+  %0 = "llvm.intr.ctpop"(%arg0) : (f32) -> f32
+  llvm.return %0 : f32
+}
+
+// -----
+
+llvm.func @binary_int_intr_wrong_type(%arg0 : i32, %arg1 : f32) -> f32 {
+  // expected-error @+1 {{op operand #1 must be integer or LLVM dialect-compatible vector of integer}}
+  %0 = "llvm.intr.smax"(%arg0, %arg1) : (i32, f32) -> f32
+  llvm.return %0 : f32
+}
+
+// -----
+
+llvm.func @ternary_float_intr_wrong_type(%arg0 : f32, %arg1 : f32, %arg2 : i32) -> f32 {
+  // expected-error @+1 {{op operand #2 must be floating-point or LLVM dialect-compatible vector of floating-point}}
+  %0 = "llvm.intr.fma"(%arg0, %arg1, %arg2) : (f32, f32, i32) -> f32
+  llvm.return %0 : f32
+}
+
+// -----
+
+llvm.func @powi_intr_wrong_type(%arg0 : f32, %arg1 : f32) -> f32 {
+  // expected-error @+1 {{op operand #1 must be integer, but got 'f32'}}
+  %0 = "llvm.intr.powi"(%arg0, %arg1) : (f32, f32) -> f32
+  llvm.return %0 : f32
+}
+
+// -----
+
+llvm.func @ctlz_intr_wrong_type(%arg0 : i32, %arg1 : i32) -> i32 {
+  // expected-error @+1 {{op operand #1 must be 1-bit signless integer, but got 'i32'}}
+  %0 = "llvm.intr.ctlz"(%arg0, %arg1) : (i32, i32) -> i32
+  llvm.return %0 : i32
+}
+
+// -----
+
+llvm.func @memcpy_intr_wrong_type(%src : i64, %dst : i64, %len : i64, %volatile : i1) {
+  // expected-error @+1 {{op operand #0 must be LLVM pointer type, but got 'i64'}}
+  "llvm.intr.memcpy"(%src, %dst, %len, %volatile) : (i64, i64, i64, i1) -> ()
+  llvm.return
+}
+
+// -----
+
+llvm.func @memcpy_inline_intr_wrong_type(%src : !llvm.ptr, %dst : !llvm.ptr, %len : i64, %volatile : i32) {
+  // expected-error @+1 {{op operand #3 must be 1-bit signless integer, but got 'i32'}}
+  "llvm.intr.memcpy.inline"(%src, %dst, %len, %volatile) : (!llvm.ptr, !llvm.ptr, i64, i32) -> ()
+  llvm.return
+}
+
+// -----
+
+llvm.func @memmove_intr_wrong_type(%src : !llvm.ptr, %dst : i64, %len : i64, %volatile : i1) {
+  // expected-error @+1 {{op operand #1 must be LLVM pointer type, but got 'i64'}}
+  "llvm.intr.memmove"(%src, %dst, %len, %volatile) : (!llvm.ptr, i64, i64, i1) -> ()
+  llvm.return
+}
+
+// -----
+
+llvm.func @memset_intr_wrong_type(%dst : !llvm.ptr, %val : i32, %len : i64, %volatile : i1) {
+  // expected-error @+1 {{op operand #1 must be 8-bit signless integer, but got 'i32'}}
+  "llvm.intr.memset"(%dst, %val, %len, %volatile) : (!llvm.ptr, i32, i64, i1) -> ()
+  llvm.return
+}
+
+// -----
+
+llvm.func @sadd_overflow_intr_wrong_type(%arg0 : i32, %arg1 : f32) -> !llvm.struct<(i32, i1)> {
+  // expected-error @+1 {{op operand #1 must be integer or LLVM dialect-compatible vector of integer, but got 'f32'}}
+  %0 = "llvm.intr.sadd.with.overflow"(%arg0, %arg1) : (i32, f32) -> !llvm.struct<(i32, i1)>
+  llvm.return %0 : !llvm.struct<(i32, i1)>
+}
+
+// -----
+
+llvm.func @assume_intr_wrong_type(%cond : i16) {
+  // expected-error @+1 {{op operand #0 must be 1-bit signless integer, but got 'i16'}}
+  "llvm.intr.assume"(%cond) : (i16) -> ()
+  llvm.return
+}
+
+// -----
+
+llvm.func @vec_reduce_add_intr_wrong_type(%arg0 : vector<4xi32>) -> f32 {
+  // expected-error @+1 {{op requires the same element type for all operands and results}}
+  %0 = "llvm.intr.vector.reduce.add"(%arg0) : (vector<4xi32>) -> f32
+  llvm.return %0 : f32
+}
+
+// -----
+
+llvm.func @vec_reduce_fmax_intr_wrong_type(%arg0 : vector<4xi32>) -> i32 {
+  // expected-error @+1 {{op operand #0 must be LLVM dialect-compatible vector of floating-point}}
+  %0 = "llvm.intr.vector.reduce.fmax"(%arg0) : (vector<4xi32>) -> i32
+  llvm.return %0 : i32
+}
+
+// -----
+
+llvm.func @matrix_load_intr_wrong_type(%ptr : !llvm.ptr, %stride : i32) -> f32 {
+  // expected-error @+1 {{op result #0 must be LLVM dialect-compatible vector type, but got 'f32'}}
+  %0 = llvm.intr.matrix.column.major.load %ptr, <stride=%stride>
+    { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} : f32 from !llvm.ptr stride i32
+  llvm.return %0 : f32
+}
+
+// -----
+
+llvm.func @matrix_store_intr_wrong_type(%matrix : vector<48xf32>, %ptr : i32, %stride : i32) {
+  // expected-error @+2 {{invalid kind of type specified}}
+  llvm.intr.matrix.column.major.store %E, %ptr, <stride=%stride>
+    { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} : vector<48xf32> to i32 stride i64
+  llvm.return
+}
+
+// -----
+
+llvm.func @matrix_multiply_intr_wrong_type(%arg0 : vector<64xf32>, %arg1 : f32) -> vector<12xf32> {
+  // expected-error @+1 {{op operand #1 must be LLVM dialect-compatible vector type, but got 'f32'}}
+  %0 = llvm.intr.matrix.multiply %arg0, %arg1
+    { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32} : (vector<64xf32>, f32) -> vector<12xf32>
+  llvm.return %0 : vector<12xf32>
+}
+
+// -----
+
+llvm.func @matrix_transpose_intr_wrong_type(%matrix : f32) -> vector<48xf32> {
+  // expected-error @+1 {{op operand #0 must be LLVM dialect-compatible vector type, but got 'f32'}}
+  %0 = llvm.intr.matrix.transpose %matrix {rows = 3: i32, columns = 16: i32} : f32 into vector<48xf32>
+  llvm.return %0 : vector<48xf32>
+}
+
+// -----
+
+llvm.func @active_lane_intr_wrong_type(%base : i64, %n : vector<7xi64>) -> vector<7xi1> {
+  // expected-error @+1 {{invalid kind of type specified}}
+  %0 = llvm.intr.get.active.lane.mask %base, %n : i64, vector<7xi64> to vector<7xi1>
+  llvm.return %0 : vector<7xi1>
+}
+
+// -----
+
+llvm.func @masked_load_intr_wrong_type(%ptr : i64, %mask : vector<7xi1>) -> vector<7xf32> {
+  // expected-error @+1 {{op operand #0 must be LLVM pointer type, but got 'i64'}}
+  %0 = llvm.intr.masked.load %ptr, %mask { alignment = 1: i32} : (i64, vector<7xi1>) -> vector<7xf32>
+  llvm.return %0 : vector<7xf32>
+}
+
+// -----
+
+llvm.func @masked_store_intr_wrong_type(%vec : vector<7xf32>, %ptr : !llvm.ptr, %mask : vector<7xi32>) {
+  // expected-error @+1 {{op operand #2 must be LLVM dialect-compatible vector of 1-bit signless integer, but got 'vector<7xi32>}}
+  llvm.intr.masked.store %vec, %ptr, %mask { alignment = 1: i32} : vector<7xf32>, vector<7xi32> into !llvm.ptr
+  llvm.return
+}
+
+// -----
+
+llvm.func @masked_gather_intr_wrong_type(%ptrs : vector<7xf32>, %mask : vector<7xi1>) -> vector<7xf32> {
+  // expected-error @+1 {{op operand #0 must be LLVM dialect-compatible vector of LLVM pointer type, but got 'vector<7xf32>'}}
+  %0 = llvm.intr.masked.gather %ptrs, %mask { alignment = 1: i32} : (vector<7xf32>, vector<7xi1>) -> vector<7xf32>
+  llvm.return %0 : vector<7xf32>
+}
+
+// -----
+
+llvm.func @masked_scatter_intr_wrong_type(%vec : f32, %ptrs : !llvm.vec<7xptr<f32>>, %mask : vector<7xi1>) {
+  // expected-error @+1 {{op operand #0 must be LLVM dialect-compatible vector type, but got 'f32'}}
+  llvm.intr.masked.scatter %vec, %ptrs, %mask { alignment = 1: i32} : f32, vector<7xi1> into !llvm.vec<7xptr<f32>>
+  llvm.return
+}
+
+// -----
+
+llvm.func @stepvector_intr_wrong_type() -> vector<7xf32> {
+  // expected-error @+1 {{op result #0 must be LLVM dialect-compatible vector of integer, but got 'vector<7xf32>'}}
+  %0 = llvm.intr.experimental.stepvector : vector<7xf32>
+  llvm.return %0 : vector<7xf32>
+}