[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/docs/TargetLLVMIR.md

 -   function types used in arguments of another function type are wrapped in an
     LLVM dialect pointer type to comply with LLVM IR expectations;
 -   the structs corresponding to `memref` types, both ranked and unranked,
     appearing as function arguments are unbundled into individual function
     arguments to allow for specifying metadata such as aliasing information on
     individual pointers;
 -   the conversion of `memref`-typed arguments is subject to
     [calling conventions](TargetLLVMIR.md#calling-conventions).
+-   if a function type has boolean attribute `func.varargs` being set, the
+    converted LLVM function will be variadic.
 
 Examples:
 
 ```mlir
 // Zero-ary function type with no results:
 () -> ()
 // is converted to a zero-ary function with `void` result.
 !llvm.func<void ()>

 !llvm.func<struct<(ptr<f32>, ptr<f32>, i64, array<1xi64>, array<1xi64>)> ()>
 
 // If multiple memref-typed results are returned:
 () -> (memref<f32>, memref<f64>)
 // their descriptor structures are additionally packed into another structure,
 // potentially with other non-memref typed results.
 !llvm.func<struct<(struct<(ptr<f32>, ptr<f32>, i64)>,
                    struct<(ptr<double>, ptr<double>, i64)>)> ()>
+
+// If "func.varargs" attribute is set:
+(i32) -> () attributes { "func.varargs" = true }
+// the corresponding LLVM function will be variadic:
+!llvm.func<void (i32, ...)>
 ```
 
 Conversion patterns are available to convert built-in function operations and
 standard call operations targeting those functions using these conversion rules.
 
 #### Multi-dimensional Vector Types
 
 LLVM IR only supports *one-dimensional* vectors, unlike MLIR where vectors can

 stack exhaustion and/or concurrent access to the same address. Auxiliary
 interface function serves as an allocation scope in this case. Furthermore, when
 targeting accelerators with separate memory spaces such as GPUs, stack-allocated
 descriptors passed by pointer would have to be transferred to the device memory,
 which introduces significant overhead. In such situations, auxiliary interface
 functions are executed on host and only pass the values through device function
 invocation mechanism.
 
+Limitation: Right now we cannot generate C interface for variadic functions,
+regardless of being non-external or external. Because C functions are unable to
+"forward" variadic arguments like this:
+```c
+void bar(int, ...);
+
+void foo(int x, ...) {
+  // ERROR: no way to forward variadic arguments.
+  void bar(x, ...);
+}
+```
+
 ### Address Computation
 
 Accesses to a memref element are transformed into an access to an element of the
 buffer pointed to by the descriptor. The position of the element in the buffer
 is calculated by linearizing memref indices in row-major order (lexically first
 index is the slowest varying, similar to C, but accounting for strides). The
 computation of the linear address is emitted as arithmetic operation in the LLVM
 IR dialect. Strides are extracted from the memref descriptor.

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/Conversion/FuncToLLVM/FuncToLLVM.cpp

struct FuncOpConversion : public FuncOpConversionBase {
   matchAndRewrite(func::FuncOp funcOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto newFuncOp = convertFuncOpToLLVMFuncOp(funcOp, rewriter);
     if (!newFuncOp)
       return failure();
 
     if (getTypeConverter()->getOptions().emitCWrappers ||
         funcOp->getAttrOfType<UnitAttr>(kEmitIfaceAttrName)) {
+      if (newFuncOp.isVarArg())
+        return funcOp->emitError("C interface for variadic functions is not "
+                                 "supported yet.");
+
       if (newFuncOp.isExternal())
         wrapExternalFunction(rewriter, funcOp.getLoc(), *getTypeConverter(),
                              funcOp, newFuncOp);
       else
         wrapForExternalCallers(rewriter, funcOp.getLoc(), *getTypeConverter(),
                                funcOp, newFuncOp);
     }
 

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

 
 //===----------------------------------------------------------------------===//
 // Implementations for LLVM::LLVMFuncOp.
 //===----------------------------------------------------------------------===//
 
 // Add the entry block to the function.
 Block *LLVMFuncOp::addEntryBlock() {
   assert(empty() && "function already has an entry block");
-  assert(!isVarArg() && "unimplemented: non-external variadic functions");
 
   auto *entry = new Block;
   push_back(entry);
 
   // FIXME: Allow passing in proper locations for the entry arguments.
   LLVMFunctionType type = getFunctionType();
   for (unsigned i = 0, e = type.getNumParams(); i < e; ++i)
     entry->addArgument(type.getParamType(i), getLoc());
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/Conversion/FuncToLLVM/convert-funcs.mlir

 // CHECK-LABEL: llvm.func @indirect_call(%arg0: !llvm.ptr<func<i32 (f32)>>, %arg1: f32) -> i32 {
 func.func @indirect_call(%arg0: (f32) -> i32, %arg1: f32) -> i32 {
 // CHECK-NEXT:  %0 = llvm.call %arg0(%arg1) : (f32) -> i32
   %0 = call_indirect %arg0(%arg1) : (f32) -> i32
 // CHECK-NEXT:  llvm.return %0 : i32
   return %0 : i32
 }
 
+func.func @variadic_func(%arg0: i32) attributes { "func.varargs" = true } {
+  return
+}
+
 // -----
 
 func.func private @badllvmlinkage(i32) attributes { "llvm.linkage" = 3 : i64 } // expected-error {{Contains llvm.linkage attribute not of type LLVM::LinkageAttr}}
+
+// -----
+
+// expected-error@+1{{C interface for variadic functions is not supported yet.}}
+func.func @variadic_func(%arg0: i32) attributes { "func.varargs" = true, "llvm.emit_c_interface" } {
+  return
+}

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/lit.local.cfg

 import sys
 
 # FIXME: llvm orc does not support the COFF rtld.
 if sys.platform == 'win32':
     config.unsupported = True
 
 # MSAN does not work with JIT.
 if 'msan' in config.available_features:
   config.unsupported = True
 
 # Requires native execution.
 if 'native' not in config.available_features:
     config.unsupported = True
 
+config.available_features.add(
+        config.root.native_target.lower() + '-native-target')

mlir/test/mlir-cpu-runner/x86-varargs.mlir

+// RUN: mlir-cpu-runner %s -e caller --entry-point-result=i32 | FileCheck %s
+// Varaidic argument list (va_list) and the extraction logics are ABI-specific.
+// REQUIRES: x86-native-target
+
+// Check if variadic functions can be called and the correct variadic argument
+// can be extracted.
+
+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