[mlir][LLVMIR] Add support for va_start/copy/end intrinsics

[myhsu]

Summary

This patch adds three new LLVM intrinsic operations: llvm.intr.vastart/copy/end. And its translation from LLVM IR.

This effectively removes a restriction, imposed by 0126dcf1f0a1, where non-external functions in LLVM dialect cannot be variadic. At that time it was not clear how LLVM intrinsics are going to be modeled, which indirectly affects va_start/copy/end, the core intrinsics used in variadic functions. But since we have LLVM intrinsics as normal MLIR operations, it's not a problem anymore.

[ftynse]

I don't see how these connect to actual functions with variadic signatures. The change only drops the verifier, but there is no test for a variadic function with a body that uses the arguments. Ideally, we would also want an "integration" test with the mlir-cpu-runner to check that it does run + documentation in "LLVM IR Target" (speaking about which, maybe also check how this behaves with llvm.emit_c_interface).

[myhsu]

In D127540#3577151, @ftynse wrote:

I don't see how these connect to actual functions with variadic signatures. The change only drops the verifier, but there is no test for a variadic function with a body that uses the arguments.

Sorry I don't quite follow. My original thought was that the incoming LLVM IR should place the variadic-related intrinsics in the right place (we always assume input LLVM IR to be well-formed) so as a translator, we just need to make sure those intrinsics are properly translated to the corresponding operations. Plus, these intrinsics actually don't take the variadic arguments in the function signature as input (the i8 pointer argument is pointer to an allocated storage). That said, I'm happy to add a test with varadic function with body.

Ideally, we would also want an "integration" test with the mlir-cpu-runner to check that it does run + documentation in "LLVM IR Target" (speaking about which, maybe also check how this behaves with llvm.emit_c_interface).

Fair enough, I forgot to take care of the other direction (translating from LLVM dialect to LLVM IR). Will do.

[myhsu]

Add tests of variadic functions that use va_start/copy/end intrinsics. Including importer, roundtrip, convert-to-llvm, and mlir-cpu-runner tests. Note that the mlir-cpu-runner test case is X86-specific.

[myhsu]

In D127540#3577151, @ftynse wrote:

documentation in "LLVM IR Target" (speaking about which, maybe also check how this behaves with llvm.emit_c_interface).

FYI: I don't see any line in the LLVM IR Target documentation page that needs to be updated. Regarding llvm.emit_c_interface, I think you're asking about parameter packing and IIUC we only take care of such attribute on func.func rather than llvm.func, plus, I think func.func doesn't support variadic arguments either.

[ftynse]

In D127540#3593648, @myhsu wrote:

In D127540#3577151, @ftynse wrote:

documentation in "LLVM IR Target" (speaking about which, maybe also check how this behaves with llvm.emit_c_interface).

FYI: I don't see any line in the LLVM IR Target documentation page that needs to be updated. Regarding llvm.emit_c_interface, I think you're asking about parameter packing and IIUC we only take care of such attribute on func.func rather than llvm.func, plus, I think func.func doesn't support variadic arguments either.

func.func does support variadic arguments in external functions through the func.varargs attribute. This is arguably a hack. The documentation doesn't say anything because the feature has been largely unsupported. Now that it is, it makes sense to describe what exactly is supported (translation between the LLVM dialect and the LLVM IR, but not the conversion from higher levels).

One last request: please do not rename the X86Vector directory, its name is derived from the dialect of the same name. You can either prefix the new test with x86-, or create a new directory.

[myhsu]

• Move test/mlir-cpu-runner/X86/vararg.mlir to test/mlir-cpu-runner/x86-varargs.mlir and restore the X86Vector folder.
• Add documentations about converting from functions with variadic arguments.
• Disallow generating C-compatible interfaces for variadic functions.

[myhsu]

In D127540#3595838, @ftynse wrote:

In D127540#3593648, @myhsu wrote:

In D127540#3577151, @ftynse wrote:

documentation in "LLVM IR Target" (speaking about which, maybe also check how this behaves with llvm.emit_c_interface).

FYI: I don't see any line in the LLVM IR Target documentation page that needs to be updated. Regarding llvm.emit_c_interface, I think you're asking about parameter packing and IIUC we only take care of such attribute on func.func rather than llvm.func, plus, I think func.func doesn't support variadic arguments either.

func.func does support variadic arguments in external functions through the func.varargs attribute. This is arguably a hack. The documentation doesn't say anything because the feature has been largely unsupported. Now that it is, it makes sense to describe what exactly is supported (translation between the LLVM dialect and the LLVM IR, but not the conversion from higher levels).

Ideally, a dialect (that uses func.func) can support non-external variadic functions by generating llvm.intr.vastart and friends during their conversion of the function body. Thus, I don't think we should forbid variadic function conversion from higher levels.

Somewhat related: I found that it's really difficult if not impossible to generate C interfaces for variadic function (both non-external and external) because we can't forward variadic arguments easily. I also put this in TargetLLVMIR.md.

One last request: please do not rename the X86Vector directory, its name is derived from the dialect of the same name. You can either prefix the new test with x86-, or create a new directory.

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

 }
 
 def LLVM_CoroResumeOp : LLVM_IntrOp<"coro.resume", [], [], [], 0> {
   let arguments = (ins LLVM_i8Ptr:$handle);
   let assemblyFormat = "$handle attr-dict";
 }
 
 //
+// Variadic function intrinsics.
+//
+
+def LLVM_VaStartOp : LLVM_ZeroResultIntrOp<"vastart">,
+                     Arguments<(ins LLVM_i8Ptr:$arg_list)> {
+  let assemblyFormat = "$arg_list attr-dict";
+  let summary = "Initializes `arg_list` for subsequent variadic argument extractions.";
+}
+
+def LLVM_VaCopyOp : LLVM_ZeroResultIntrOp<"vacopy">,
+                    Arguments<(ins LLVM_i8Ptr:$dest_list, LLVM_i8Ptr:$src_list)> {
+  let assemblyFormat = "$src_list `to` $dest_list attr-dict";
+  let summary = "Copies the current argument position from `src_list` to `dest_list`.";
+}
+
+def LLVM_VaEndOp : LLVM_ZeroResultIntrOp<"vaend">,
+                   Arguments<(ins LLVM_i8Ptr:$arg_list)> {
+  let assemblyFormat = "$arg_list attr-dict";
+  let summary = "Destroys `arg_list`, which has been initialized by `intr.vastart` or `intr.vacopy`.";
+}
+
+//
 // Exception handling intrinsics.
 //
 
 def LLVM_EhTypeidForOp : LLVM_OneResultIntrOp<"eh.typeid.for"> {
     let arguments = (ins LLVM_i8Ptr:$type_info);
     let assemblyFormat = "$type_info attr-dict `:` type($res)";
 }
 

 def LLVM_VPFPToSIOp : LLVM_VPCastF<"fptosi">;
 
 def LLVM_VPUIToFPOp : LLVM_VPCastI<"uitofp">;
 def LLVM_VPSIToFPOp : LLVM_VPCastI<"sitofp">;
 
 def LLVM_VPPtrToIntOp : LLVM_VPCastPtr<"ptrtoint">;
 def LLVM_VPIntToPtrOp : LLVM_VPCastI<"inttoptr">;
 
-#endif // LLVM_INTRINSIC_OPS
+#endif // LLVM_INTRINSIC_OPS
 

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

if (getLinkage() != LLVM::Linkage::External &&
       return emitOpError() << "external functions must have '"
                            << stringifyLinkage(LLVM::Linkage::External)
                            << "' or '"
                            << stringifyLinkage(LLVM::Linkage::ExternWeak)
                            << "' linkage";
     return success();
   }
 
-  if (isVarArg())
-    return emitOpError("only external functions can be variadic");
-
   return success();
 }
 
 /// Verifies LLVM- and implementation-specific properties of the LLVM func Op:
 /// - entry block arguments are of LLVM types.
 LogicalResult LLVMFuncOp::verifyRegions() {
   if (isExternal())
     return success();

mlir/test/Dialect/LLVMIR/func.mlir

module {
   llvm.func weak ccc @cconv2() {
     llvm.return
   }
 
   // CHECK: llvm.func weak fastcc @cconv3
   llvm.func weak fastcc @cconv3() {
     llvm.return
   }
+
+  // CHECK-LABEL: llvm.func @variadic_def
+  llvm.func @variadic_def(...) {
+    llvm.return
+  }
 }
 
 // -----
 
 module {
   // expected-error@+1 {{requires one region}}
   "llvm.func"() {function_type = !llvm.func<void ()>, sym_name = "no_region"} : () -> ()
 }

 module {
   // expected-error@+1 {{failed to construct function type: expected zero or one function result}}
   llvm.func @foo() -> (i64, i64)
 }
 
 // -----
 
 module {
-  // expected-error@+1 {{only external functions can be variadic}}
-  llvm.func @variadic_def(...) {
-    llvm.return
-  }
-}
-
-// -----
-
-module {
   // expected-error@+1 {{cannot attach result attributes to functions with a void return}}
   llvm.func @variadic_def() -> (!llvm.void {llvm.noalias})
 }
 
 // -----
 
 module {
   // expected-error@+1 {{variadic arguments must be in the end of the argument list}}

mlir/test/Dialect/LLVMIR/roundtrip.mlir

module {
   }
   // CHECK: llvm.metadata @metadata attributes {test_attribute} {
   llvm.metadata @metadata attributes {test_attribute} {
     // CHECK: llvm.access_group @group1
     llvm.access_group @group1
     llvm.return
   }
 }
+
+// CHECK-LABEL: llvm.func @vararg_func
+llvm.func @vararg_func(%arg0: i32, ...) {
+  // CHECK: %{{.*}} = llvm.mlir.constant(1 : i32) : i32
+  // CHECK: %{{.*}} = llvm.mlir.constant(1 : i32) : i32
+  %0 = llvm.mlir.constant(1 : i32) : i32
+  %1 = llvm.mlir.constant(1 : i32) : i32
+  // CHECK: %[[ALLOCA0:.+]] = llvm.alloca %{{.*}} x !llvm.struct<"struct.va_list", (ptr<i8>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>>
+  // CHECK: %[[CAST0:.+]] = llvm.bitcast %[[ALLOCA0]] : !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>> to !llvm.ptr<i8>
+  %2 = llvm.alloca %1 x !llvm.struct<"struct.va_list", (ptr<i8>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>>
+  %3 = llvm.bitcast %2 : !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>> to !llvm.ptr<i8>
+  // CHECK: llvm.intr.vastart %[[CAST0]]
+  llvm.intr.vastart %3
+  // CHECK: %[[ALLOCA1:.+]] = llvm.alloca %{{.*}} x !llvm.ptr<i8> {alignment = 8 : i64} : (i32) -> !llvm.ptr<ptr<i8>>
+  // CHECK: %[[CAST1:.+]] = llvm.bitcast %[[ALLOCA1]] : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
+  %4 = llvm.alloca %0 x !llvm.ptr<i8> {alignment = 8 : i64} : (i32) -> !llvm.ptr<ptr<i8>>
+  %5 = llvm.bitcast %4 : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
+  // CHECK: llvm.intr.vacopy %[[CAST0]] to %[[CAST1]]
+  llvm.intr.vacopy %3 to %5
+  // CHECK: llvm.intr.vaend %[[CAST1]]
+  // CHECK: llvm.intr.vaend %[[CAST0]]
+  llvm.intr.vaend %5
+  llvm.intr.vaend %3
+  // CHECK: llvm.return
+  llvm.return
+}

mlir/test/Target/LLVMIR/Import/basic.ll

 }
 
 ; Unreachable
 ; CHECK-LABEL: llvm.func @unreachable_inst
 define void @unreachable_inst() {
   ; CHECK: llvm.unreachable
   unreachable
 }
+
+; Varadic function definition
+%struct.va_list = type { i8* }
+
+declare void @llvm.va_start(i8*)
+declare void @llvm.va_copy(i8*, i8*)
+declare void @llvm.va_end(i8*)
+
+; CHECK-LABEL: llvm.func @variadic_function
+define void @variadic_function(i32 %X, ...) {
+  ; CHECK: %[[ALLOCA0:.+]] = llvm.alloca %{{.*}} x !llvm.struct<"struct.va_list", (ptr<i8>)> {{.*}} : (i32) -> !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>>
+  %ap = alloca %struct.va_list
+  ; CHECK: %[[CAST0:.+]] = llvm.bitcast %[[ALLOCA0]] : !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>> to !llvm.ptr<i8>
+  %ap2 = bitcast %struct.va_list* %ap to i8*
+  ; CHECK: llvm.intr.vastart %[[CAST0]]
+  call void @llvm.va_start(i8* %ap2)
+
+  ; CHECK: %[[ALLOCA1:.+]] = llvm.alloca %{{.*}} x !llvm.ptr<i8> {{.*}} : (i32) -> !llvm.ptr<ptr<i8>>
+  %aq = alloca i8*
+  ; CHECK: %[[CAST1:.+]] = llvm.bitcast %[[ALLOCA1]] : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
+  %aq2 = bitcast i8** %aq to i8*
+  ; CHECK: llvm.intr.vacopy %[[CAST0]] to %[[CAST1]]
+  call void @llvm.va_copy(i8* %aq2, i8* %ap2)
+  ; CHECK: llvm.intr.vaend %[[CAST1]]
+  call void @llvm.va_end(i8* %aq2)
+
+  ; CHECK: llvm.intr.vaend %[[CAST0]]
+  call void @llvm.va_end(i8* %ap2)
+  ; CHECK: llvm.return
+  ret void
+}

mlir/test/Target/LLVMIR/Import/intrinsic.ll

 define void @umul_with_overflow_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {
   ; CHECK: "llvm.intr.umul.with.overflow"(%{{.*}}, %{{.*}}) : (i32, i32) -> !llvm.struct<(i32, i1)>
   %5 = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %0, i32 %1)
   ; CHECK: "llvm.intr.umul.with.overflow"(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>
   %6 = call { <8 x i32>, <8 x i1> } @llvm.umul.with.overflow.v8i32(<8 x i32> %2, <8 x i32> %3)
   ret void
 }
 
+; CHECK-LABEL: llvm.func @va_intrinsics_test
+define void @va_intrinsics_test(i8* %0, i8* %1) {
+; CHECK: llvm.intr.vastart %{{.*}}
+  call void @llvm.va_start(i8* %0)
+; CHECK: llvm.intr.vacopy %{{.*}} to %{{.*}}
+  call void @llvm.va_copy(i8* %1, i8* %0)
+; CHECK: llvm.intr.vaend %{{.*}}
+  call void @llvm.va_end(i8* %0)
+  ret void
+}
+
 ; CHECK-LABEL:  llvm.func @coro_id
 define void @coro_id(i32 %0, i8* %1) {
   ; CHECK: llvm.intr.coro.id %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : !llvm.token
   %3 = call token @llvm.coro.id(i32 %0, i8* %1, i8* %1, i8* null)
   ret void
 }
 
 ; CHECK-LABEL:  llvm.func @coro_begin

 declare token @llvm.coro.save(i8*)
 declare i8 @llvm.coro.suspend(token, i1)
 declare i1 @llvm.coro.end(i8*, i1)
 declare i8* @llvm.coro.free(token, i8* nocapture readonly)
 declare void @llvm.coro.resume(i8*)
 declare i32 @llvm.eh.typeid.for(i8*)
 declare i8* @llvm.stacksave()
 declare void @llvm.stackrestore(i8*)
+declare void @llvm.va_start(i8*)
+declare void @llvm.va_copy(i8*, i8*)
+declare void @llvm.va_end(i8*)
 declare <8 x i32> @llvm.vp.add.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
 declare <8 x i32> @llvm.vp.sub.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
 declare <8 x i32> @llvm.vp.mul.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
 declare <8 x i32> @llvm.vp.sdiv.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
 declare <8 x i32> @llvm.vp.udiv.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
 declare <8 x i32> @llvm.vp.srem.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
 declare <8 x i32> @llvm.vp.urem.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
 declare <8 x i32> @llvm.vp.ashr.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)

mlir/test/Target/LLVMIR/llvmir.mlir

 ^bb3(%arg4: f32):
   llvm.call @qux(%arg4) : (f32) -> ()
   llvm.return
 }
 
 llvm.func @bar(f32)
 llvm.func @baz()
 llvm.func @qux(f32)
+
+// -----
+
+// Varaidic function definition
+
+// CHECK: %struct.va_list = type { ptr }
+
+// CHECK: define void @vararg_function(i32 %{{.*}}, ...)
+llvm.func @vararg_function(%arg0: i32, ...) {
+  %0 = llvm.mlir.constant(1 : i32) : i32
+  %1 = llvm.mlir.constant(1 : i32) : i32
+  // CHECK: %[[ALLOCA0:.+]] = alloca %struct.va_list, align 8
+  %2 = llvm.alloca %1 x !llvm.struct<"struct.va_list", (ptr<i8>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>>
+  %3 = llvm.bitcast %2 : !llvm.ptr<struct<"struct.va_list", (ptr<i8>)>> to !llvm.ptr<i8>
+  // CHECK: call void @llvm.va_start(ptr %[[ALLOCA0]])
+  llvm.intr.vastart %3
+  // CHECK: %[[ALLOCA1:.+]] = alloca ptr, align 8
+  %4 = llvm.alloca %0 x !llvm.ptr<i8> {alignment = 8 : i64} : (i32) -> !llvm.ptr<ptr<i8>>
+  %5 = llvm.bitcast %4 : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
+  // CHECK: call void @llvm.va_copy(ptr %[[ALLOCA1]], ptr %[[ALLOCA0]])
+  llvm.intr.vacopy %3 to %5
+  // CHECK: call void @llvm.va_end(ptr %[[ALLOCA1]])
+  // CHECK: call void @llvm.va_end(ptr %[[ALLOCA0]])
+  llvm.intr.vaend %5
+  llvm.intr.vaend %3
+  // CHECK: ret void
+  llvm.return
+}

mlir/test/mlir-cpu-runner/X86/lit.local.cfg

+if config.root.native_target != 'X86':
+    config.unsupported = True
+
+# X86Vector tests must be enabled via build flag.
+if config.mlir_run_x86vector_tests:
+    config.available_features.add('x86vector-tests-enabled')

mlir/test/mlir-cpu-runner/X86/math-polynomial-approx-avx2.mlir

 // RUN:   mlir-opt %s -test-math-polynomial-approximation="enable-avx2"        \
 // RUN:               -convert-arith-to-llvm                                   \
 // RUN:               -convert-vector-to-llvm="enable-x86vector"               \
 // RUN:               -convert-math-to-llvm                                    \
 // RUN:               -convert-func-to-llvm                                     \
 // RUN:               -reconcile-unrealized-casts                              \
 // RUN: | mlir-cpu-runner                                                      \
 // RUN:     -e main -entry-point-result=void -O0                               \
 // RUN:     -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext  \
 // RUN:     -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext    \
 // RUN: | FileCheck %s
+// REQUIRES: x86vector-tests-enabled
 
 // -------------------------------------------------------------------------- //
 // rsqrt.
 // -------------------------------------------------------------------------- //
 
 func.func @rsqrt() {
   // Sanity-check that the scalar rsqrt still works OK.
   // CHECK: inf

mlir/test/mlir-cpu-runner/X86/vararg.mlir

+// RUN: mlir-cpu-runner %s -e caller --entry-point-result=i32 | FileCheck %s
+
+// Check if variadic functions can be called and the correct variadic argument
+// can be extracted.
+// Note that varaidic argument list (va_list) and the extraction logics are ABI-
+// specific.
+
+llvm.func @caller() -> i32 {
+  %0 = llvm.mlir.constant(3 : i32) : i32
+  %1 = llvm.mlir.constant(2 : i32) : i32
+  %2 = llvm.mlir.constant(1 : i32) : i32
+  %3 = llvm.call @foo(%2, %1, %0) : (i32, i32, i32) -> i32
+  llvm.return %3 : i32
+}
+
+// Equivalent C code:
+// int foo(int X, ...) {
+//  va_list args;
+//  va_start(args, X);
+//  int num = va_arg(args, int);
+//  va_end(args);
+//  return num;
+//}
+llvm.func @foo(%arg0: i32, ...) -> i32 {
+  %0 = llvm.mlir.constant(8 : i64) : i64
+  %1 = llvm.mlir.constant(2 : i32) : i32
+  %2 = llvm.mlir.constant(0 : i64) : i64
+  %3 = llvm.mlir.constant(0 : i64) : i64
+  %4 = llvm.mlir.constant(8 : i32) : i32
+  %5 = llvm.mlir.constant(3 : i32) : i32
+  %6 = llvm.mlir.constant(0 : i64) : i64
+  %7 = llvm.mlir.constant(0 : i64) : i64
+  %8 = llvm.mlir.constant(41 : i32) : i32
+  %9 = llvm.mlir.constant(0 : i32) : i32
+  %10 = llvm.mlir.constant(0 : i64) : i64
+  %11 = llvm.mlir.constant(0 : i64) : i64
+  %12 = llvm.mlir.constant(1 : i32) : i32
+  %13 = llvm.alloca %12 x !llvm.array<1 x struct<"struct.va_list", (i32, i32, ptr<i8>, ptr<i8>)>> {alignment = 8 : i64} : (i32) -> !llvm.ptr<array<1 x struct<"struct.va_list", (i32, i32, ptr<i8>, ptr<i8>)>>>
+  %14 = llvm.bitcast %13 : !llvm.ptr<array<1 x struct<"struct.va_list", (i32, i32, ptr<i8>, ptr<i8>)>>> to !llvm.ptr<i8>
+  llvm.intr.vastart %14
+  %15 = llvm.getelementptr %13[%11, %10, 0] : (!llvm.ptr<array<1 x struct<"struct.va_list", (i32, i32, ptr<i8>, ptr<i8>)>>>, i64, i64) -> !llvm.ptr<i32>
+  %16 = llvm.load %15 : !llvm.ptr<i32>
+  %17 = llvm.icmp "ult" %16, %8 : i32
+  llvm.cond_br %17, ^bb1, ^bb2
+^bb1:  // pred: ^bb0
+  %18 = llvm.getelementptr %13[%7, %6, 3] : (!llvm.ptr<array<1 x struct<"struct.va_list", (i32, i32, ptr<i8>, ptr<i8>)>>>, i64, i64) -> !llvm.ptr<ptr<i8>>
+  %19 = llvm.load %18 : !llvm.ptr<ptr<i8>>
+  %20 = llvm.zext %16 : i32 to i64
+  %21 = llvm.getelementptr %19[%20] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
+  %22 = llvm.add %16, %4  : i32
+  llvm.store %22, %15 : !llvm.ptr<i32>
+  llvm.br ^bb3(%21 : !llvm.ptr<i8>)
+^bb2:  // pred: ^bb0
+  %23 = llvm.getelementptr %13[%3, %2, 2] : (!llvm.ptr<array<1 x struct<"struct.va_list", (i32, i32, ptr<i8>, ptr<i8>)>>>, i64, i64) -> !llvm.ptr<ptr<i8>>
+  %24 = llvm.load %23 : !llvm.ptr<ptr<i8>>
+  %25 = llvm.getelementptr %24[%0] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
+  llvm.store %25, %23 : !llvm.ptr<ptr<i8>>
+  llvm.br ^bb3(%24 : !llvm.ptr<i8>)
+^bb3(%26: !llvm.ptr<i8>):  // 2 preds: ^bb1, ^bb2
+  %27 = llvm.bitcast %26 : !llvm.ptr<i8> to !llvm.ptr<i32>
+  %28 = llvm.load %27 : !llvm.ptr<i32>
+  llvm.intr.vaend %14
+  llvm.return %28 : i32
+}
+
+// CHECK: 2

mlir/test/mlir-cpu-runner/X86Vector/lit.local.cfg

-import sys
-
-# X86Vector tests must be enabled via build flag.
-if not config.mlir_run_x86vector_tests:
-    config.unsupported = True