From 60a47cb071f48a44e95c3b4a6defcf477738db0d Mon Sep 17 00:00:00 2001
From: Jorn Vernee <jvernee@openjdk.org>
Date: Thu, 22 Sep 2022 22:25:48 +0000
Subject: [PATCH] 8292047: Consider ways to add linkage parameters to downcall
 handles

Reviewed-by: mcimadamore
---
 doc/panama_ffi.md                             |  3 +-
 .../java/lang/foreign/FunctionDescriptor.java | 21 +----
 .../classes/java/lang/foreign/Linker.java     | 48 +++++++---
 .../java/lang/foreign/SegmentAllocator.java   |  2 +-
 .../java/lang/foreign/SymbolLookup.java       |  2 +-
 .../classes/java/lang/foreign/VaList.java     |  2 +-
 .../java/lang/foreign/package-info.java       |  4 +-
 .../foreign/FunctionDescriptorImpl.java       | 87 ++-----------------
 .../internal/foreign/abi/AbstractLinker.java  | 16 ++--
 .../internal/foreign/abi/LinkerOptions.java   | 80 +++++++++++++++++
 .../jdk/internal/foreign/abi/SharedUtils.java |  5 --
 .../foreign/abi/aarch64/CallArranger.java     | 11 ++-
 .../abi/aarch64/linux/LinuxAArch64Linker.java |  5 +-
 .../abi/aarch64/macos/MacOsAArch64Linker.java |  5 +-
 .../foreign/abi/x64/sysv/SysVx64Linker.java   |  3 +-
 .../foreign/abi/x64/windows/CallArranger.java | 11 ++-
 .../abi/x64/windows/Windowsx64Linker.java     |  5 +-
 test/jdk/java/foreign/NativeTestHelper.java   |  1 -
 test/jdk/java/foreign/StdLibTest.java         |  4 +-
 .../java/foreign/TestFunctionDescriptor.java  |  4 -
 test/jdk/java/foreign/TestIntrinsics.java     |  6 +-
 test/jdk/java/foreign/TestLinker.java         | 50 +++++++++++
 test/jdk/java/foreign/TestVarArgs.java        |  7 +-
 .../callarranger/TestAarch64CallArranger.java | 11 ++-
 .../callarranger/TestWindowsCallArranger.java |  7 +-
 test/jdk/java/foreign/valist/VaListTest.java  |  4 -
 .../java/lang/foreign/PointerInvoke.java      |  2 -
 .../bench/java/lang/foreign/VaList.java       |  3 +-
 28 files changed, 239 insertions(+), 170 deletions(-)
 create mode 100644 src/java.base/share/classes/jdk/internal/foreign/abi/LinkerOptions.java
 create mode 100644 test/jdk/java/foreign/TestLinker.java

diff --git a/doc/panama_ffi.md b/doc/panama_ffi.md
index 1bae70a817e..731d715fe06 100644
--- a/doc/panama_ffi.md
+++ b/doc/panama_ffi.md
@@ -416,7 +416,8 @@ public class Examples {
     public static void printf() throws Throwable {
         MethodHandle printf = LINKER.downcallHandle(
                 STDLIB.lookup("printf").get(),
-                FunctionDescriptor.of(JAVA_INT, ADDRESS).asVariadic(JAVA_INT, JAVA_INT, JAVA_INT)
+                FunctionDescriptor.of(JAVA_INT, ADDRESS, JAVA_INT, JAVA_INT, JAVA_INT),
+                Linker.Option.firstVariadicArg(1) // first int is variadic
         );
         try (MemorySession session = MemorySession.openConfined()) {
             MemorySegment s = session.allocateUtf8String("%d plus %d equals %d\n");
diff --git a/src/java.base/share/classes/java/lang/foreign/FunctionDescriptor.java b/src/java.base/share/classes/java/lang/foreign/FunctionDescriptor.java
index e631a42fc0c..ddb4491be13 100644
--- a/src/java.base/share/classes/java/lang/foreign/FunctionDescriptor.java
+++ b/src/java.base/share/classes/java/lang/foreign/FunctionDescriptor.java
@@ -36,7 +36,7 @@
 /**
  * A function descriptor is made up of zero or more argument layouts and zero or one return layout. A function descriptor
  * is used to model the signature of foreign functions when creating
- * {@linkplain Linker#downcallHandle(MemorySegment, FunctionDescriptor) downcall method handles} or
+ * {@linkplain Linker#downcallHandle(MemorySegment, FunctionDescriptor, Linker.Option...) downcall method handles} or
  * {@linkplain Linker#upcallStub(MethodHandle, FunctionDescriptor, MemorySession) upcall stubs}.
  *
  * @implSpec
@@ -58,13 +58,6 @@ public sealed interface FunctionDescriptor permits FunctionDescriptorImpl {
      */
     List<MemoryLayout> argumentLayouts();
 
-    /**
-     * The index of the first variadic argument layout (where defined).
-     * @return The index of the first variadic argument layout, or {@code -1} if this is not a
-     * {@linkplain #asVariadic(MemoryLayout...) variadic} layout.
-     */
-    int firstVariadicArgumentIndex();
-
     /**
      * Returns a function descriptor with the given argument layouts appended to the argument layout array
      * of this function descriptor.
@@ -113,17 +106,6 @@ public sealed interface FunctionDescriptor permits FunctionDescriptorImpl {
      */
     MethodType toMethodType();
 
-    /**
-     * Creates a specialized variadic function descriptor, by appending given variadic layouts to this
-     * function descriptor argument layouts. The resulting function descriptor can report the position
-     * of the {@linkplain #firstVariadicArgumentIndex() first variadic argument}, and cannot be altered
-     * in any way: for instance, calling {@link #changeReturnLayout(MemoryLayout)} on the resulting descriptor
-     * will throw an {@link UnsupportedOperationException}.
-     * @param variadicLayouts the variadic argument layouts to be appended to this descriptor argument layouts.
-     * @return a variadic function descriptor, or this descriptor if {@code variadicLayouts.length == 0}.
-     */
-    FunctionDescriptor asVariadic(MemoryLayout... variadicLayouts);
-
     /**
      * Creates a function descriptor with the given return and argument layouts.
      * @param resLayout the return layout.
@@ -145,5 +127,4 @@ static FunctionDescriptor ofVoid(MemoryLayout... argLayouts) {
         // Null checks are implicit in List.of(argLayouts)
         return FunctionDescriptorImpl.ofVoid(List.of(argLayouts));
     }
-
 }
diff --git a/src/java.base/share/classes/java/lang/foreign/Linker.java b/src/java.base/share/classes/java/lang/foreign/Linker.java
index b572cb7b0fd..6d347554124 100644
--- a/src/java.base/share/classes/java/lang/foreign/Linker.java
+++ b/src/java.base/share/classes/java/lang/foreign/Linker.java
@@ -26,6 +26,7 @@
 package java.lang.foreign;
 
 import jdk.internal.foreign.abi.AbstractLinker;
+import jdk.internal.foreign.abi.LinkerOptions;
 import jdk.internal.foreign.abi.SharedUtils;
 import jdk.internal.javac.PreviewFeature;
 import jdk.internal.reflect.CallerSensitive;
@@ -46,7 +47,7 @@
  * in the JVM and foreign functions in the library. In particular:
  * <ul>
  * <li>A linker allows Java code to link against foreign functions, via
- * {@linkplain #downcallHandle(MemorySegment, FunctionDescriptor) downcall method handles}; and</li>
+ * {@linkplain #downcallHandle(MemorySegment, FunctionDescriptor, Option...) downcall method handles}; and</li>
  * <li>A linker allows foreign functions to call Java method handles,
  * via the generation of {@linkplain #upcallStub(MethodHandle, FunctionDescriptor, MemorySession) upcall stubs}.</li>
  * </ul>
@@ -61,7 +62,7 @@
  *
  * <h2 id="downcall-method-handles">Downcall method handles</h2>
  *
- * {@linkplain #downcallHandle(FunctionDescriptor) Linking a foreign function} is a process which requires a function descriptor,
+ * {@linkplain #downcallHandle(FunctionDescriptor, Option...) Linking a foreign function} is a process which requires a function descriptor,
  * a set of memory layouts which, together, specify the signature of the foreign function to be linked, and returns,
  * when complete, a downcall method handle, that is, a method handle that can be used to invoke the target foreign function.
  * <p>
@@ -77,7 +78,7 @@
  * The downcall method handle type, derived as above, might be decorated by additional leading parameters,
  * in the given order if both are present:
  * <ul>
- * <li>If the downcall method handle is created {@linkplain #downcallHandle(FunctionDescriptor) without specifying a target address},
+ * <li>If the downcall method handle is created {@linkplain #downcallHandle(FunctionDescriptor, Option...) without specifying a target address},
  * the downcall method handle type features a leading parameter of type {@link MemorySegment}, from which the
  * address of the target foreign function can be derived.</li>
  * <li>If the function descriptor's return layout is a group layout, the resulting downcall method handle accepts
@@ -166,15 +167,15 @@ public sealed interface Linker permits AbstractLinker {
      * <p>
      * Any layout not listed above is <em>unsupported</em>; function descriptors containing unsupported layouts
      * will cause an {@link IllegalArgumentException} to be thrown, when used to create a
-     * {@link #downcallHandle(MemorySegment, FunctionDescriptor) downcall method handle} or an
+     * {@link #downcallHandle(MemorySegment, FunctionDescriptor, Option...) downcall method handle} or an
      * {@linkplain #upcallStub(MethodHandle, FunctionDescriptor, MemorySession) upcall stub}.
      * <p>
      * Variadic functions (e.g. a C function declared with a trailing ellipses {@code ...} at the end of the formal parameter
      * list or with an empty formal parameter list) are not supported directly. However, it is possible to link a
-     * variadic function by using a {@linkplain FunctionDescriptor#asVariadic(MemoryLayout...) <em>variadic</em>}
-     * function descriptor, in which the specialized signature of a given variable arity callsite is described in full.
-     * Alternatively, where the foreign library allows it, clients might be able to interact with variadic functions by
-     * passing a trailing parameter of type {@link VaList} (e.g. as in {@code vsprintf}).
+     * variadic function by using {@linkplain Linker.Option#firstVariadicArg(int) a linker option} to indicate
+     * the start of the list of variadic arguments, together with a specialized function descriptor describing a
+     * given variable arity callsite. Alternatively, where the foreign library allows it, clients might be able to
+     * interact with variadic functions by passing a trailing parameter of type {@link VaList} (e.g. as in {@code vsprintf}).
      * <p>
      * This method is <a href="package-summary.html#restricted"><em>restricted</em></a>.
      * Restricted methods are unsafe, and, if used incorrectly, their use might crash
@@ -210,15 +211,17 @@ static Linker nativeLinker() {
      * linker.downcallHandle(function).bindTo(symbol);
      * }
      *
-     * @param symbol the address of the target function.
+     * @param symbol   the address of the target function.
      * @param function the function descriptor of the target function.
+     * @param options  any linker options.
      * @return a downcall method handle. The method handle type is <a href="Linker.html#downcall-method-handles"><em>inferred</em></a>
      * @throws IllegalArgumentException if the provided function descriptor is not supported by this linker.
-     * or if the symbol is {@link MemorySegment#NULL}
+     *                                  or if the symbol is {@link MemorySegment#NULL}
+     * @throws IllegalArgumentException if an invalid combination of linker options is given.
      */
-    default MethodHandle downcallHandle(MemorySegment symbol, FunctionDescriptor function) {
+    default MethodHandle downcallHandle(MemorySegment symbol, FunctionDescriptor function, Option... options) {
         SharedUtils.checkSymbol(symbol);
-        return downcallHandle(function).bindTo(symbol);
+        return downcallHandle(function, options).bindTo(symbol);
     }
 
     /**
@@ -235,11 +238,13 @@ default MethodHandle downcallHandle(MemorySegment symbol, FunctionDescriptor fun
      * associated with the {@link MemorySegment#NULL} address, or a {@link NullPointerException} if that parameter is {@code null}.
      *
      * @param function the function descriptor of the target function.
+     * @param options  any linker options.
      * @return a downcall method handle. The method handle type is <a href="Linker.html#downcall-method-handles"><em>inferred</em></a>
      * from the provided function descriptor.
      * @throws IllegalArgumentException if the provided function descriptor is not supported by this linker.
+     * @throws IllegalArgumentException if an invalid combination of linker options is given.
      */
-    MethodHandle downcallHandle(FunctionDescriptor function);
+    MethodHandle downcallHandle(FunctionDescriptor function, Option... options);
 
     /**
      * Creates a stub which can be passed to other foreign functions as a function pointer, with the given
@@ -282,4 +287,21 @@ default MethodHandle downcallHandle(MemorySegment symbol, FunctionDescriptor fun
      * @return a symbol lookup for symbols in a set of commonly used libraries.
      */
     SymbolLookup defaultLookup();
+
+    /**
+     * A linker option that can be used to indicate additional linking requirements to the linker,
+     * besides what is described by a function descriptor.
+     */
+    sealed interface Option
+            permits LinkerOptions.FirstVariadicArg {
+
+        /**
+         * {@return A linker option used to denote the index of the first variadic argument layout in a
+         *          foreign function call}
+         * @param index the index of the first variadic argument in a downcall handle linkage request.
+         */
+        static Option firstVariadicArg(int index) {
+            return new LinkerOptions.FirstVariadicArg(index);
+        }
+    }
 }
diff --git a/src/java.base/share/classes/java/lang/foreign/SegmentAllocator.java b/src/java.base/share/classes/java/lang/foreign/SegmentAllocator.java
index f8f8d6377ad..b74564e8bff 100644
--- a/src/java.base/share/classes/java/lang/foreign/SegmentAllocator.java
+++ b/src/java.base/share/classes/java/lang/foreign/SegmentAllocator.java
@@ -55,7 +55,7 @@
  * <p>
  * Passing a segment allocator to an API can be especially useful in circumstances where a client wants to communicate <em>where</em>
  * the results of a certain operation (performed by the API) should be stored, as a memory segment. For instance,
- * {@linkplain Linker#downcallHandle(FunctionDescriptor) downcall method handles} can accept an additional
+ * {@linkplain Linker#downcallHandle(FunctionDescriptor, Linker.Option...) downcall method handles} can accept an additional
  * {@link SegmentAllocator} parameter if the underlying foreign function is known to return a struct by-value. Effectively,
  * the allocator parameter tells the linker runtime where to store the return value of the foreign function.
  */
diff --git a/src/java.base/share/classes/java/lang/foreign/SymbolLookup.java b/src/java.base/share/classes/java/lang/foreign/SymbolLookup.java
index 79fa99841cc..240b9f4559a 100644
--- a/src/java.base/share/classes/java/lang/foreign/SymbolLookup.java
+++ b/src/java.base/share/classes/java/lang/foreign/SymbolLookup.java
@@ -51,7 +51,7 @@
  * The address of a symbol is modelled as a zero-length {@linkplain MemorySegment memory segment}. The segment can be used in different ways:
  * <ul>
  *     <li>It can be passed to a {@link Linker} to create a downcall method handle, which can then be used to call the foreign function at the segment's base address.</li>
- *     <li>It can be passed to an existing {@linkplain Linker#downcallHandle(FunctionDescriptor) downcall method handle}, as an argument to the underlying foreign function.</li>
+ *     <li>It can be passed to an existing {@linkplain Linker#downcallHandle(FunctionDescriptor, Linker.Option...) downcall method handle}, as an argument to the underlying foreign function.</li>
  *     <li>It can be {@linkplain MemorySegment#set(ValueLayout.OfAddress, long, MemorySegment) stored} inside another memory segment.</li>
  *     <li>It can be used to dereference memory associated with a global variable (this might require
  *     {@link MemorySegment#ofAddress(long, long, MemorySession) resizing} the segment first).</li>
diff --git a/src/java.base/share/classes/java/lang/foreign/VaList.java b/src/java.base/share/classes/java/lang/foreign/VaList.java
index 9c0ff19fa50..bb3b65bfab7 100644
--- a/src/java.base/share/classes/java/lang/foreign/VaList.java
+++ b/src/java.base/share/classes/java/lang/foreign/VaList.java
@@ -48,7 +48,7 @@
  *                                           .addVarg(C_DOUBLE, 3.8d));
  *}
  * Once created, clients can obtain the platform-dependent {@linkplain #segment() memory segment} associated a variable
- * argument list, which can then be passed to {@linkplain Linker#downcallHandle(FunctionDescriptor) downcall method handles}
+ * argument list, which can then be passed to {@linkplain Linker#downcallHandle(FunctionDescriptor, Linker.Option...) downcall method handles}
  * targeting native functions using the C {@code va_list} type.
  * <p>
  * The contents of a foreign memory segment modelling a variable argument list can be accessed by <em>unsafely</em> creating
diff --git a/src/java.base/share/classes/java/lang/foreign/package-info.java b/src/java.base/share/classes/java/lang/foreign/package-info.java
index ce8d26f62e6..114aa3aac24 100644
--- a/src/java.base/share/classes/java/lang/foreign/package-info.java
+++ b/src/java.base/share/classes/java/lang/foreign/package-info.java
@@ -128,7 +128,7 @@
  * Here, we obtain a {@linkplain java.lang.foreign.Linker#nativeLinker() native linker} and we use it
  * to {@linkplain java.lang.foreign.SymbolLookup#find(java.lang.String) look up} the {@code strlen} symbol in the
  * standard C library; a <em>downcall method handle</em> targeting said symbol is subsequently
- * {@linkplain java.lang.foreign.Linker#downcallHandle(java.lang.foreign.FunctionDescriptor) obtained}.
+ * {@linkplain java.lang.foreign.Linker#downcallHandle(FunctionDescriptor, Linker.Option...) obtained}.
  * To complete the linking successfully, we must provide a {@link java.lang.foreign.FunctionDescriptor} instance,
  * describing the signature of the {@code strlen} function.
  * From this information, the linker will uniquely determine the sequence of steps which will turn
@@ -225,7 +225,7 @@
  *}
  *
  * The {@link java.lang.foreign.FunctionDescriptor} instance created in the previous step is then used to
- * {@linkplain java.lang.foreign.Linker#upcallStub(java.lang.invoke.MethodHandle, java.lang.foreign.FunctionDescriptor, java.lang.foreign.MemorySession) create}
+ * {@linkplain java.lang.foreign.Linker#upcallStub(java.lang.invoke.MethodHandle, FunctionDescriptor, MemorySession) create}
  * a new upcall stub; the layouts in the function descriptors allow the linker to determine the sequence of steps which
  * allow foreign code to call the stub for {@code intCompareHandle} according to the rules specified by the ABI of the
  * underlying platform.
diff --git a/src/java.base/share/classes/jdk/internal/foreign/FunctionDescriptorImpl.java b/src/java.base/share/classes/jdk/internal/foreign/FunctionDescriptorImpl.java
index 88d8e4f260f..4b492a4c38a 100644
--- a/src/java.base/share/classes/jdk/internal/foreign/FunctionDescriptorImpl.java
+++ b/src/java.base/share/classes/jdk/internal/foreign/FunctionDescriptorImpl.java
@@ -25,27 +25,23 @@
 package jdk.internal.foreign;
 
 import java.lang.foreign.FunctionDescriptor;
+import java.lang.foreign.GroupLayout;
 import java.lang.foreign.MemoryLayout;
 import java.lang.foreign.MemorySegment;
-import java.lang.foreign.GroupLayout;
 import java.lang.foreign.ValueLayout;
 import java.lang.invoke.MethodType;
-
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-import java.util.stream.Stream;
 
 import static java.util.Objects.requireNonNull;
 
 /**
  * @implSpec This class and its subclasses are immutable, thread-safe and <a href="{@docRoot}/java.base/java/lang/doc-files/ValueBased.html">value-based</a>.
  */
-public sealed class FunctionDescriptorImpl implements FunctionDescriptor {
+public final class FunctionDescriptorImpl implements FunctionDescriptor {
 
     private final MemoryLayout resLayout; // Nullable
     private final List<MemoryLayout> argLayouts;
@@ -69,31 +65,6 @@ public final List<MemoryLayout> argumentLayouts() {
         return argLayouts;
     }
 
-    /**
-     * Creates a specialized variadic function descriptor, by appending given variadic layouts to this
-     * function descriptor argument layouts. The resulting function descriptor can report the position
-     * of the {@linkplain #firstVariadicArgumentIndex() first variadic argument}, and cannot be altered
-     * in any way: for instance, calling {@link #changeReturnLayout(MemoryLayout)} on the resulting descriptor
-     * will throw an {@link UnsupportedOperationException}.
-     *
-     * @param variadicLayouts the variadic argument layouts to be appended to this descriptor argument layouts.
-     * @return a variadic function descriptor, or this descriptor if {@code variadicLayouts.length == 0}.
-     */
-    public final FunctionDescriptorImpl asVariadic(MemoryLayout... variadicLayouts) {
-        // Null checks are implicit in the constructor of VariadicFunction
-        return variadicLayouts.length == 0 ? this : new VariadicFunctionDescriptor(this, variadicLayouts);
-    }
-
-    /**
-     * The index of the first variadic argument layout (where defined).
-     *
-     * @return The index of the first variadic argument layout, or {@code -1} if this is not a
-     * {@linkplain #asVariadic(MemoryLayout...) variadic} layout.
-     */
-    public int firstVariadicArgumentIndex() {
-        return -1;
-    }
-
     /**
      * Returns a function descriptor with the given argument layouts appended to the argument layout array
      * of this function descriptor.
@@ -172,9 +143,7 @@ public MethodType toMethodType() {
     @Override
     public final String toString() {
         return String.format("(%s)%s",
-                IntStream.range(0, argLayouts.size())
-                        .mapToObj(i -> (i == firstVariadicArgumentIndex() ?
-                                "..." : "") + argLayouts.get(i))
+                argLayouts.stream().map(Object::toString)
                         .collect(Collectors.joining()),
                 returnLayout()
                         .map(Object::toString)
@@ -187,7 +156,6 @@ public final String toString() {
      * <ul>
      *     <li>the two function descriptors have equals return layouts (see {@link MemoryLayout#equals(Object)}), or both have no return layout;</li>
      *     <li>the two function descriptors have argument layouts that are pair-wise {@linkplain MemoryLayout#equals(Object) equal}; and</li>
-     *     <li>the two function descriptors have the same leading {@linkplain #firstVariadicArgumentIndex() variadic argument index}</li>
      * </ul>
      *
      * @param other the object to be compared for equality with this function descriptor.
@@ -197,8 +165,7 @@ public final String toString() {
     public final boolean equals(Object other) {
         return other instanceof FunctionDescriptorImpl f &&
                 Objects.equals(resLayout, f.resLayout) &&
-                Objects.equals(argLayouts, f.argLayouts) &&
-                firstVariadicArgumentIndex() == f.firstVariadicArgumentIndex();
+                Objects.equals(argLayouts, f.argLayouts);
     }
 
     /**
@@ -206,7 +173,7 @@ public final boolean equals(Object other) {
      */
     @Override
     public final int hashCode() {
-        return Objects.hash(argLayouts, resLayout, firstVariadicArgumentIndex());
+        return Objects.hash(argLayouts, resLayout);
     }
 
     public static FunctionDescriptor of(MemoryLayout resLayout, List<MemoryLayout> argLayouts) {
@@ -216,48 +183,4 @@ public static FunctionDescriptor of(MemoryLayout resLayout, List<MemoryLayout> a
     public static FunctionDescriptor ofVoid(List<MemoryLayout> argLayouts) {
         return new FunctionDescriptorImpl(null, argLayouts);
     }
-
-    static final class VariadicFunctionDescriptor extends FunctionDescriptorImpl {
-
-        private final int firstVariadicIndex;
-
-        /**
-         * Constructor.
-         *
-         * @param descriptor the original functional descriptor
-         * @param argLayouts the memory layouts to apply
-         * @throws NullPointerException if any of the provided parameters or array elements are {@code null}
-         */
-        VariadicFunctionDescriptor(FunctionDescriptorImpl descriptor, MemoryLayout... argLayouts) {
-            super(descriptor.returnLayout().orElse(null),
-                    Stream.concat(descriptor.argumentLayouts().stream(), Arrays.stream(argLayouts)
-                            .map(Objects::requireNonNull))
-                            .toList());
-            this.firstVariadicIndex = descriptor.argumentLayouts().size();
-        }
-
-        @Override
-        public int firstVariadicArgumentIndex() {
-            return firstVariadicIndex;
-        }
-
-        @Override
-        public FunctionDescriptorImpl insertArgumentLayouts(int index, MemoryLayout... addedLayouts) {
-            throw newUnsupportedOperationException();
-        }
-
-        @Override
-        public FunctionDescriptorImpl changeReturnLayout(MemoryLayout newReturn) {
-            throw newUnsupportedOperationException();
-        }
-
-        @Override
-        public FunctionDescriptorImpl dropReturnLayout() {
-            throw newUnsupportedOperationException();
-        }
-
-        private UnsupportedOperationException newUnsupportedOperationException() {
-            return new UnsupportedOperationException("Method not supported by " + VariadicFunctionDescriptor.class.getSimpleName());
-        }
-    }
 }
diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/AbstractLinker.java b/src/java.base/share/classes/jdk/internal/foreign/abi/AbstractLinker.java
index 41e73223631..ab71f81b075 100644
--- a/src/java.base/share/classes/jdk/internal/foreign/abi/AbstractLinker.java
+++ b/src/java.base/share/classes/jdk/internal/foreign/abi/AbstractLinker.java
@@ -37,9 +37,7 @@
 import java.lang.foreign.FunctionDescriptor;
 import java.lang.foreign.Linker;
 import java.lang.foreign.MemorySegment;
-import java.lang.foreign.PaddingLayout;
 import java.lang.foreign.SequenceLayout;
-import java.lang.foreign.ValueLayout;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodType;
 import java.util.Objects;
@@ -47,21 +45,25 @@
 public abstract sealed class AbstractLinker implements Linker permits LinuxAArch64Linker, MacOsAArch64Linker,
                                                                       SysVx64Linker, Windowsx64Linker {
 
-    private final SoftReferenceCache<FunctionDescriptor, MethodHandle> DOWNCALL_CACHE = new SoftReferenceCache<>();
+    private record LinkRequest(FunctionDescriptor descriptor, LinkerOptions options) {}
+    private final SoftReferenceCache<LinkRequest, MethodHandle> DOWNCALL_CACHE = new SoftReferenceCache<>();
 
     @Override
-    public MethodHandle downcallHandle(FunctionDescriptor function) {
+    public MethodHandle downcallHandle(FunctionDescriptor function, Option... options) {
         Objects.requireNonNull(function);
+        Objects.requireNonNull(options);
         checkHasNaturalAlignment(function);
+        LinkerOptions optionSet = LinkerOptions.of(options);
 
-        return DOWNCALL_CACHE.get(function, fd -> {
+        return DOWNCALL_CACHE.get(new LinkRequest(function, optionSet), linkRequest ->  {
+            FunctionDescriptor fd = linkRequest.descriptor();
             MethodType type = fd.toMethodType();
-            MethodHandle handle = arrangeDowncall(type, fd);
+            MethodHandle handle = arrangeDowncall(type, fd, linkRequest.options());
             handle = SharedUtils.maybeInsertAllocator(fd, handle);
             return handle;
         });
     }
-    protected abstract MethodHandle arrangeDowncall(MethodType inferredMethodType, FunctionDescriptor function);
+    protected abstract MethodHandle arrangeDowncall(MethodType inferredMethodType, FunctionDescriptor function, LinkerOptions options);
 
     @Override
     public MemorySegment upcallStub(MethodHandle target, FunctionDescriptor function, MemorySession scope) {
diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/LinkerOptions.java b/src/java.base/share/classes/jdk/internal/foreign/abi/LinkerOptions.java
new file mode 100644
index 00000000000..9b0d08c1257
--- /dev/null
+++ b/src/java.base/share/classes/jdk/internal/foreign/abi/LinkerOptions.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi;
+
+import java.lang.foreign.Linker;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+public class LinkerOptions {
+
+    private static final LinkerOptions EMPTY = LinkerOptions.of();
+    private final Map<Class<?>, Linker.Option> optionsMap;
+
+    private LinkerOptions(Map<Class<?>, Linker.Option> optionsMap) {
+        this.optionsMap = optionsMap;
+    }
+
+    public static LinkerOptions of(Linker.Option... options) {
+        Map<Class<?>, Linker.Option> optionMap = new HashMap<>();
+
+        for (Linker.Option option : options) {
+            if (optionMap.containsKey(option.getClass())) {
+                throw new IllegalArgumentException("Duplicate option: " + option);
+            }
+            optionMap.put(option.getClass(), option);
+        }
+
+        return new LinkerOptions(optionMap);
+    }
+
+    public static LinkerOptions empty() {
+        return EMPTY;
+    }
+
+    private <T extends Linker.Option> T getOption(Class<T> type) {
+        return type.cast(optionsMap.get(type));
+    }
+
+    public boolean isVarargsIndex(int argIndex) {
+        FirstVariadicArg fva = getOption(FirstVariadicArg.class);
+        return fva != null && argIndex >= fva.index();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        return o instanceof LinkerOptions that
+                && Objects.equals(optionsMap, that.optionsMap);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(optionsMap);
+    }
+
+    public record FirstVariadicArg(int index) implements Linker.Option { }
+}
diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/SharedUtils.java b/src/java.base/share/classes/jdk/internal/foreign/abi/SharedUtils.java
index 5f6b256f66c..b5a1884e645 100644
--- a/src/java.base/share/classes/jdk/internal/foreign/abi/SharedUtils.java
+++ b/src/java.base/share/classes/jdk/internal/foreign/abi/SharedUtils.java
@@ -316,11 +316,6 @@ static void checkType(Class<?> actualType, Class<?> expectedType) {
         }
     }
 
-    public static boolean isVarargsIndex(FunctionDescriptor descriptor, int argIndex) {
-        int firstPos = descriptor.firstVariadicArgumentIndex();
-        return firstPos != -1 && argIndex >= firstPos;
-    }
-
     public static NoSuchElementException newVaListNSEE(MemoryLayout layout) {
         return new NoSuchElementException("No such element: " + layout);
     }
diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java b/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
index 98d655b4075..aaa9c588f37 100644
--- a/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
+++ b/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
@@ -34,6 +34,7 @@
 import jdk.internal.foreign.abi.CallingSequence;
 import jdk.internal.foreign.abi.CallingSequenceBuilder;
 import jdk.internal.foreign.abi.DowncallLinker;
+import jdk.internal.foreign.abi.LinkerOptions;
 import jdk.internal.foreign.abi.UpcallLinker;
 import jdk.internal.foreign.abi.SharedUtils;
 import jdk.internal.foreign.abi.VMStorage;
@@ -115,6 +116,10 @@ public record Bindings(CallingSequence callingSequence,
     protected CallArranger() {}
 
     public Bindings getBindings(MethodType mt, FunctionDescriptor cDesc, boolean forUpcall) {
+        return getBindings(mt, cDesc, forUpcall, LinkerOptions.empty());
+    }
+
+    public Bindings getBindings(MethodType mt, FunctionDescriptor cDesc, boolean forUpcall, LinkerOptions options) {
         CallingSequenceBuilder csb = new CallingSequenceBuilder(C, forUpcall);
 
         BindingCalculator argCalc = forUpcall ? new BoxBindingCalculator(true) : new UnboxBindingCalculator(true);
@@ -133,7 +138,7 @@ public Bindings getBindings(MethodType mt, FunctionDescriptor cDesc, boolean for
         for (int i = 0; i < mt.parameterCount(); i++) {
             Class<?> carrier = mt.parameterType(i);
             MemoryLayout layout = cDesc.argumentLayouts().get(i);
-            if (varArgsOnStack() && SharedUtils.isVarargsIndex(cDesc, i)) {
+            if (varArgsOnStack() && options.isVarargsIndex(i)) {
                 argCalc.storageCalculator.adjustForVarArgs();
             }
             csb.addArgumentBindings(carrier, layout, argCalc.getBindings(carrier, layout));
@@ -142,8 +147,8 @@ public Bindings getBindings(MethodType mt, FunctionDescriptor cDesc, boolean for
         return new Bindings(csb.build(), returnInMemory);
     }
 
-    public MethodHandle arrangeDowncall(MethodType mt, FunctionDescriptor cDesc) {
-        Bindings bindings = getBindings(mt, cDesc, false);
+    public MethodHandle arrangeDowncall(MethodType mt, FunctionDescriptor cDesc, LinkerOptions options) {
+        Bindings bindings = getBindings(mt, cDesc, false, options);
 
         MethodHandle handle = new DowncallLinker(C, bindings.callingSequence).getBoundMethodHandle();
 
diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/linux/LinuxAArch64Linker.java b/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/linux/LinuxAArch64Linker.java
index de1f80c39f7..f8d01a87a01 100644
--- a/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/linux/LinuxAArch64Linker.java
+++ b/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/linux/LinuxAArch64Linker.java
@@ -26,6 +26,7 @@
 package jdk.internal.foreign.abi.aarch64.linux;
 
 import jdk.internal.foreign.abi.AbstractLinker;
+import jdk.internal.foreign.abi.LinkerOptions;
 import jdk.internal.foreign.abi.aarch64.CallArranger;
 
 import java.lang.foreign.MemorySession;
@@ -55,8 +56,8 @@ private LinuxAArch64Linker() {
     }
 
     @Override
-    protected MethodHandle arrangeDowncall(MethodType inferredMethodType, FunctionDescriptor function) {
-        return CallArranger.LINUX.arrangeDowncall(inferredMethodType, function);
+    protected MethodHandle arrangeDowncall(MethodType inferredMethodType, FunctionDescriptor function, LinkerOptions options) {
+        return CallArranger.LINUX.arrangeDowncall(inferredMethodType, function, options);
     }
 
     @Override
diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/macos/MacOsAArch64Linker.java b/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/macos/MacOsAArch64Linker.java
index d4fcc8fbc40..d324ee5a3fb 100644
--- a/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/macos/MacOsAArch64Linker.java
+++ b/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/macos/MacOsAArch64Linker.java
@@ -26,6 +26,7 @@
 package jdk.internal.foreign.abi.aarch64.macos;
 
 import jdk.internal.foreign.abi.AbstractLinker;
+import jdk.internal.foreign.abi.LinkerOptions;
 import jdk.internal.foreign.abi.aarch64.CallArranger;
 
 import java.lang.foreign.FunctionDescriptor;
@@ -55,8 +56,8 @@ private MacOsAArch64Linker() {
     }
 
     @Override
-    protected MethodHandle arrangeDowncall(MethodType inferredMethodType, FunctionDescriptor function) {
-        return CallArranger.MACOS.arrangeDowncall(inferredMethodType, function);
+    protected MethodHandle arrangeDowncall(MethodType inferredMethodType, FunctionDescriptor function, LinkerOptions options) {
+        return CallArranger.MACOS.arrangeDowncall(inferredMethodType, function, options);
     }
 
     @Override
diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVx64Linker.java b/src/java.base/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVx64Linker.java
index 0a576b8b490..13dc5a0d5d1 100644
--- a/src/java.base/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVx64Linker.java
+++ b/src/java.base/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVx64Linker.java
@@ -26,6 +26,7 @@
 
 
 import jdk.internal.foreign.abi.AbstractLinker;
+import jdk.internal.foreign.abi.LinkerOptions;
 
 import java.lang.foreign.MemorySession;
 import java.lang.foreign.FunctionDescriptor;
@@ -52,7 +53,7 @@ private SysVx64Linker() {
         // Ensure there is only one instance
     }
     @Override
-    protected MethodHandle arrangeDowncall(MethodType inferredMethodType, FunctionDescriptor function) {
+    protected MethodHandle arrangeDowncall(MethodType inferredMethodType, FunctionDescriptor function, LinkerOptions options) {
         return CallArranger.arrangeDowncall(inferredMethodType, function);
     }
 
diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java b/src/java.base/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java
index bdf36cdafb4..b04d08eb7f6 100644
--- a/src/java.base/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java
+++ b/src/java.base/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java
@@ -30,6 +30,7 @@
 import jdk.internal.foreign.abi.CallingSequence;
 import jdk.internal.foreign.abi.CallingSequenceBuilder;
 import jdk.internal.foreign.abi.DowncallLinker;
+import jdk.internal.foreign.abi.LinkerOptions;
 import jdk.internal.foreign.abi.SharedUtils;
 import jdk.internal.foreign.abi.UpcallLinker;
 import jdk.internal.foreign.abi.VMStorage;
@@ -79,6 +80,10 @@ public record Bindings(
     }
 
     public static Bindings getBindings(MethodType mt, FunctionDescriptor cDesc, boolean forUpcall) {
+        return getBindings(mt, cDesc, forUpcall, LinkerOptions.empty());
+    }
+
+    public static Bindings getBindings(MethodType mt, FunctionDescriptor cDesc, boolean forUpcall, LinkerOptions options) {
         class CallingSequenceBuilderHelper {
             final CallingSequenceBuilder csb = new CallingSequenceBuilder(CWindows, forUpcall);
             final BindingCalculator argCalc =
@@ -109,14 +114,14 @@ void setReturnBindings(Class<?> carrier, MemoryLayout layout) {
         }
 
         for (int i = 0; i < mt.parameterCount(); i++) {
-            csb.addArgumentBindings(mt.parameterType(i), cDesc.argumentLayouts().get(i), SharedUtils.isVarargsIndex(cDesc, i));
+            csb.addArgumentBindings(mt.parameterType(i), cDesc.argumentLayouts().get(i), options.isVarargsIndex(i));
         }
 
         return new Bindings(csb.csb.build(), returnInMemory);
     }
 
-    public static MethodHandle arrangeDowncall(MethodType mt, FunctionDescriptor cDesc) {
-        Bindings bindings = getBindings(mt, cDesc, false);
+    public static MethodHandle arrangeDowncall(MethodType mt, FunctionDescriptor cDesc, LinkerOptions options) {
+        Bindings bindings = getBindings(mt, cDesc, false, options);
 
         MethodHandle handle = new DowncallLinker(CWindows, bindings.callingSequence).getBoundMethodHandle();
 
diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/x64/windows/Windowsx64Linker.java b/src/java.base/share/classes/jdk/internal/foreign/abi/x64/windows/Windowsx64Linker.java
index 4eea91cbf4a..10af1385a96 100644
--- a/src/java.base/share/classes/jdk/internal/foreign/abi/x64/windows/Windowsx64Linker.java
+++ b/src/java.base/share/classes/jdk/internal/foreign/abi/x64/windows/Windowsx64Linker.java
@@ -25,6 +25,7 @@
 package jdk.internal.foreign.abi.x64.windows;
 
 import jdk.internal.foreign.abi.AbstractLinker;
+import jdk.internal.foreign.abi.LinkerOptions;
 
 import java.lang.foreign.FunctionDescriptor;
 import java.lang.foreign.MemorySegment;
@@ -52,8 +53,8 @@ private Windowsx64Linker() {
     }
 
     @Override
-    protected MethodHandle arrangeDowncall(MethodType inferredMethodType, FunctionDescriptor function) {
-        return CallArranger.arrangeDowncall(inferredMethodType, function);
+    protected MethodHandle arrangeDowncall(MethodType inferredMethodType, FunctionDescriptor function, LinkerOptions options) {
+        return CallArranger.arrangeDowncall(inferredMethodType, function, options);
     }
 
     @Override
diff --git a/test/jdk/java/foreign/NativeTestHelper.java b/test/jdk/java/foreign/NativeTestHelper.java
index 1165a35eb51..a3bd0d087df 100644
--- a/test/jdk/java/foreign/NativeTestHelper.java
+++ b/test/jdk/java/foreign/NativeTestHelper.java
@@ -26,7 +26,6 @@
 import java.lang.foreign.Linker;
 import java.lang.foreign.MemoryLayout;
 import java.lang.foreign.MemorySegment;
-import java.lang.foreign.SegmentAllocator;
 import java.lang.foreign.SymbolLookup;
 import java.lang.foreign.ValueLayout;
 
diff --git a/test/jdk/java/foreign/StdLibTest.java b/test/jdk/java/foreign/StdLibTest.java
index 7c1729e1463..dd2890d3ad1 100644
--- a/test/jdk/java/foreign/StdLibTest.java
+++ b/test/jdk/java/foreign/StdLibTest.java
@@ -322,8 +322,10 @@ private MethodHandle specializedPrintf(List<PrintfArg> args) {
                 mt = mt.appendParameterTypes(arg.carrier);
                 variadicLayouts.add(arg.layout);
             }
+            Linker.Option varargIndex = Linker.Option.firstVariadicArg(fd.argumentLayouts().size());
             MethodHandle mh = abi.downcallHandle(printfAddr,
-                    fd.asVariadic(variadicLayouts.toArray(new MemoryLayout[args.size()])));
+                    fd.appendArgumentLayouts(variadicLayouts.toArray(new MemoryLayout[args.size()])),
+                    varargIndex);
             return mh.asSpreader(1, Object[].class, args.size());
         }
     }
diff --git a/test/jdk/java/foreign/TestFunctionDescriptor.java b/test/jdk/java/foreign/TestFunctionDescriptor.java
index 046267d8820..915c97ad507 100644
--- a/test/jdk/java/foreign/TestFunctionDescriptor.java
+++ b/test/jdk/java/foreign/TestFunctionDescriptor.java
@@ -100,11 +100,7 @@ public void testDropReturnLayout() {
     @Test
     public void testEquals() {
         FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_INT, C_INT);
-        FunctionDescriptor fd_va1 = FunctionDescriptor.of(C_INT).asVariadic(C_INT, C_INT);
-        FunctionDescriptor fd_va2 = FunctionDescriptor.of(C_INT, C_INT).asVariadic(C_INT);
         assertEquals(fd, fd);
-        assertNotEquals(fd, fd_va1);
-        assertNotEquals(fd, fd_va2);
     }
 
     @Test
diff --git a/test/jdk/java/foreign/TestIntrinsics.java b/test/jdk/java/foreign/TestIntrinsics.java
index 984d92f4536..38c742015bb 100644
--- a/test/jdk/java/foreign/TestIntrinsics.java
+++ b/test/jdk/java/foreign/TestIntrinsics.java
@@ -43,6 +43,7 @@
 import java.lang.foreign.MemoryLayout;
 import org.testng.annotations.*;
 
+import static java.lang.foreign.Linker.Option.firstVariadicArg;
 import static java.lang.invoke.MethodType.methodType;
 import static java.lang.foreign.ValueLayout.JAVA_CHAR;
 import static org.testng.Assert.assertEquals;
@@ -106,8 +107,9 @@ interface AddIdentity {
 
         { // identity_va
             MemorySegment ma = findNativeOrThrow("identity_va");
-            FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_INT).asVariadic(C_DOUBLE, C_INT, C_FLOAT, C_LONG_LONG);
-            tests.add(abi.downcallHandle(ma, fd), 1, 1, 10D, 2, 3F, 4L);
+            FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_INT,
+                                                                 C_DOUBLE, C_INT, C_FLOAT, C_LONG_LONG);
+            tests.add(abi.downcallHandle(ma, fd, firstVariadicArg(1)), 1, 1, 10D, 2, 3F, 4L);
         }
 
         { // high_arity
diff --git a/test/jdk/java/foreign/TestLinker.java b/test/jdk/java/foreign/TestLinker.java
new file mode 100644
index 00000000000..8077e3ef841
--- /dev/null
+++ b/test/jdk/java/foreign/TestLinker.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @enablePreview
+ * @run testng TestLinker
+ */
+
+import org.testng.annotations.Test;
+
+import java.lang.foreign.FunctionDescriptor;
+import java.lang.foreign.Linker;
+import java.lang.invoke.MethodHandle;
+
+import static org.testng.Assert.assertNotSame;
+
+public class TestLinker extends NativeTestHelper {
+
+    @Test
+    public void testLinkerOptionsCache() {
+        Linker linker = Linker.nativeLinker();
+        FunctionDescriptor descriptor = FunctionDescriptor.ofVoid(C_INT, C_INT);
+        MethodHandle mh1 = linker.downcallHandle(descriptor);
+        MethodHandle mh2 = linker.downcallHandle(descriptor, Linker.Option.firstVariadicArg(1));
+        // assert that these are 2 distinct link request. No caching allowed
+        assertNotSame(mh1, mh2);
+    }
+
+}
diff --git a/test/jdk/java/foreign/TestVarArgs.java b/test/jdk/java/foreign/TestVarArgs.java
index 1d00883f445..3fe23733d45 100644
--- a/test/jdk/java/foreign/TestVarArgs.java
+++ b/test/jdk/java/foreign/TestVarArgs.java
@@ -89,10 +89,11 @@ public void testVarArgs(int count, String fName, Ret ret, // ignore this stuff
             argLayouts.add(C_POINTER); // call info
             argLayouts.add(C_INT); // size
 
-            FunctionDescriptor desc = FunctionDescriptor.ofVoid(argLayouts.toArray(MemoryLayout[]::new))
-                    .asVariadic(args.stream().map(a -> a.layout).toArray(MemoryLayout[]::new));
+            FunctionDescriptor baseDesc = FunctionDescriptor.ofVoid(argLayouts.toArray(MemoryLayout[]::new));
+            Linker.Option varargIndex = Linker.Option.firstVariadicArg(baseDesc.argumentLayouts().size());
+            FunctionDescriptor desc = baseDesc.appendArgumentLayouts(args.stream().map(a -> a.layout).toArray(MemoryLayout[]::new));
 
-            MethodHandle downcallHandle = LINKER.downcallHandle(VARARGS_ADDR, desc);
+            MethodHandle downcallHandle = LINKER.downcallHandle(VARARGS_ADDR, desc, varargIndex);
 
             List<Object> argValues = new ArrayList<>();
             argValues.add(callInfoPtr); // call info
diff --git a/test/jdk/java/foreign/callarranger/TestAarch64CallArranger.java b/test/jdk/java/foreign/callarranger/TestAarch64CallArranger.java
index e9d6f1b91bf..d58727070f2 100644
--- a/test/jdk/java/foreign/callarranger/TestAarch64CallArranger.java
+++ b/test/jdk/java/foreign/callarranger/TestAarch64CallArranger.java
@@ -33,16 +33,19 @@
  */
 
 import java.lang.foreign.FunctionDescriptor;
+import java.lang.foreign.Linker;
 import java.lang.foreign.MemoryLayout;
 import java.lang.foreign.MemorySegment;
 import jdk.internal.foreign.abi.Binding;
 import jdk.internal.foreign.abi.CallingSequence;
+import jdk.internal.foreign.abi.LinkerOptions;
 import jdk.internal.foreign.abi.aarch64.CallArranger;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
 import java.lang.invoke.MethodType;
 
+import static java.lang.foreign.Linker.Option.firstVariadicArg;
 import static java.lang.foreign.ValueLayout.ADDRESS;
 import static jdk.internal.foreign.PlatformLayouts.AArch64.*;
 import static jdk.internal.foreign.abi.Binding.*;
@@ -399,9 +402,9 @@ public void testStructStackSpill() {
     @Test
     public void testVarArgsInRegs() {
         MethodType mt = MethodType.methodType(void.class, int.class, int.class, float.class);
-        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_INT).asVariadic(C_INT, C_FLOAT);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_INT, C_INT, C_FLOAT);
         FunctionDescriptor fdExpected = FunctionDescriptor.ofVoid(ADDRESS, C_INT, C_INT, C_FLOAT);
-        CallArranger.Bindings bindings = CallArranger.LINUX.getBindings(mt, fd, false);
+        CallArranger.Bindings bindings = CallArranger.LINUX.getBindings(mt, fd, false, LinkerOptions.of(firstVariadicArg(1)));
 
         assertFalse(bindings.isInMemoryReturn());
         CallingSequence callingSequence = bindings.callingSequence();
@@ -422,9 +425,9 @@ public void testVarArgsInRegs() {
     @Test
     public void testVarArgsOnStack() {
         MethodType mt = MethodType.methodType(void.class, int.class, int.class, float.class);
-        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_INT).asVariadic(C_INT, C_FLOAT);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_INT, C_INT, C_FLOAT);
         FunctionDescriptor fdExpected = FunctionDescriptor.ofVoid(ADDRESS, C_INT, C_INT, C_FLOAT);
-        CallArranger.Bindings bindings = CallArranger.MACOS.getBindings(mt, fd, false);
+        CallArranger.Bindings bindings = CallArranger.MACOS.getBindings(mt, fd, false, LinkerOptions.of(firstVariadicArg(1)));
 
         assertFalse(bindings.isInMemoryReturn());
         CallingSequence callingSequence = bindings.callingSequence();
diff --git a/test/jdk/java/foreign/callarranger/TestWindowsCallArranger.java b/test/jdk/java/foreign/callarranger/TestWindowsCallArranger.java
index 398c4f13ce0..64c502509ea 100644
--- a/test/jdk/java/foreign/callarranger/TestWindowsCallArranger.java
+++ b/test/jdk/java/foreign/callarranger/TestWindowsCallArranger.java
@@ -34,15 +34,18 @@
  */
 
 import java.lang.foreign.FunctionDescriptor;
+import java.lang.foreign.Linker;
 import java.lang.foreign.MemoryLayout;
 import java.lang.foreign.MemorySegment;
 import jdk.internal.foreign.abi.Binding;
 import jdk.internal.foreign.abi.CallingSequence;
+import jdk.internal.foreign.abi.LinkerOptions;
 import jdk.internal.foreign.abi.x64.windows.CallArranger;
 import org.testng.annotations.Test;
 
 import java.lang.invoke.MethodType;
 
+import static java.lang.foreign.Linker.Option.firstVariadicArg;
 import static java.lang.foreign.ValueLayout.ADDRESS;
 import static jdk.internal.foreign.PlatformLayouts.Win64.*;
 import static jdk.internal.foreign.abi.Binding.*;
@@ -187,10 +190,10 @@ public void testAbiExampleVarargs() {
         MethodType mt = MethodType.methodType(void.class,
                 int.class, double.class, int.class, double.class, double.class);
         FunctionDescriptor fd = FunctionDescriptor.ofVoid(
-                C_INT, C_DOUBLE).asVariadic(C_INT, C_DOUBLE, C_DOUBLE);
+                C_INT, C_DOUBLE, C_INT, C_DOUBLE, C_DOUBLE);
         FunctionDescriptor fdExpected = FunctionDescriptor.ofVoid(
                 ADDRESS, C_INT, C_DOUBLE, C_INT, C_DOUBLE, C_DOUBLE);
-        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false, LinkerOptions.of(firstVariadicArg(2)));
 
         assertFalse(bindings.isInMemoryReturn());
         CallingSequence callingSequence = bindings.callingSequence();
diff --git a/test/jdk/java/foreign/valist/VaListTest.java b/test/jdk/java/foreign/valist/VaListTest.java
index a5dedb26f99..9593096c241 100644
--- a/test/jdk/java/foreign/valist/VaListTest.java
+++ b/test/jdk/java/foreign/valist/VaListTest.java
@@ -63,13 +63,9 @@
 
 import static java.lang.foreign.MemoryLayout.PathElement.groupElement;
 import static java.lang.foreign.ValueLayout.ADDRESS;
-import static java.lang.foreign.ValueLayout.JAVA_BYTE;
-import static java.lang.foreign.ValueLayout.JAVA_CHAR;
 import static java.lang.foreign.ValueLayout.JAVA_DOUBLE;
-import static java.lang.foreign.ValueLayout.JAVA_FLOAT;
 import static java.lang.foreign.ValueLayout.JAVA_INT;
 import static java.lang.foreign.ValueLayout.JAVA_LONG;
-import static java.lang.foreign.ValueLayout.JAVA_SHORT;
 import static jdk.internal.foreign.PlatformLayouts.*;
 import static org.testng.Assert.*;
 
diff --git a/test/micro/org/openjdk/bench/java/lang/foreign/PointerInvoke.java b/test/micro/org/openjdk/bench/java/lang/foreign/PointerInvoke.java
index 0dfd55ac4b1..2e2b570fce2 100644
--- a/test/micro/org/openjdk/bench/java/lang/foreign/PointerInvoke.java
+++ b/test/micro/org/openjdk/bench/java/lang/foreign/PointerInvoke.java
@@ -32,8 +32,6 @@
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Fork;
-import org.openjdk.jmh.annotations.Setup;
-import org.openjdk.jmh.annotations.Param;
 import org.openjdk.jmh.annotations.TearDown;
 import org.openjdk.jmh.annotations.Measurement;
 import org.openjdk.jmh.annotations.Mode;
diff --git a/test/micro/org/openjdk/bench/java/lang/foreign/VaList.java b/test/micro/org/openjdk/bench/java/lang/foreign/VaList.java
index ebc5c9d869c..388438df3e9 100644
--- a/test/micro/org/openjdk/bench/java/lang/foreign/VaList.java
+++ b/test/micro/org/openjdk/bench/java/lang/foreign/VaList.java
@@ -58,7 +58,8 @@ public class VaList extends CLayouts {
     static {
         SymbolLookup loaderLibs = SymbolLookup.loaderLookup();
         MH_ellipsis = linker.downcallHandle(loaderLibs.find("ellipsis").get(),
-                FunctionDescriptor.ofVoid(C_INT).asVariadic(C_INT, C_DOUBLE, C_LONG_LONG));
+                FunctionDescriptor.ofVoid(C_INT, C_INT, C_DOUBLE, C_LONG_LONG),
+                Linker.Option.firstVariadicArg(1));
         MH_vaList = linker.downcallHandle(loaderLibs.find("vaList").get(),
                 FunctionDescriptor.ofVoid(C_INT, C_POINTER));
     }