diff --git a/jcl/src/java.base/share/classes/java/lang/PinnedThreadPrinter.java b/jcl/src/java.base/share/classes/java/lang/PinnedThreadPrinter.java
index a9f6e4c6746..6253fa3f329 100644
--- a/jcl/src/java.base/share/classes/java/lang/PinnedThreadPrinter.java
+++ b/jcl/src/java.base/share/classes/java/lang/PinnedThreadPrinter.java
@@ -26,26 +26,20 @@
 import java.lang.StackWalker.StackFrame;
 import java.lang.StackWalker.StackFrameImpl;
 import java.util.List;
-import java.util.Set;
 import java.util.stream.Collectors;
-import static java.lang.StackWalker.Option.*;
 
 /**
- * Prints the stack trace of Pinned Thread that is attempting to yield.
+ * Prints the stack trace of a pinned thread that is attempting to yield.
  */
 final class PinnedThreadPrinter {
-	private static final StackWalker STACKWALKER;
 
-	static {
-		STACKWALKER = StackWalker.getInstance(Set.of(SHOW_REFLECT_FRAMES, RETAIN_CLASS_REFERENCE));
-		STACKWALKER.setGetMonitorsFlag();
-	}
+	private static final StackWalker STACKWALKER = StackWalker.newInstanceWithMonitors();
 
 	static void printStackTrace(PrintStream out, boolean printAll) {
 		out.println(Thread.currentThread());
 		List<StackFrame> stackFrames = STACKWALKER.walk(s -> s.collect(Collectors.toList()));
 		for (int i = 0; i < stackFrames.size(); i++) {
-			StackFrameImpl sti = (StackFrameImpl)stackFrames.get(i);
+			StackFrameImpl sti = (StackFrameImpl) stackFrames.get(i);
 			Object[] monitors = sti.getMonitors();
 
 			if (monitors != null) {
diff --git a/jcl/src/java.base/share/classes/java/lang/StackWalker.java b/jcl/src/java.base/share/classes/java/lang/StackWalker.java
index d0085389ed3..32a7c4d4adf 100644
--- a/jcl/src/java.base/share/classes/java/lang/StackWalker.java
+++ b/jcl/src/java.base/share/classes/java/lang/StackWalker.java
@@ -22,7 +22,6 @@
  *******************************************************************************/
 package java.lang;
 
-import java.lang.StackWalker.StackFrameImpl;
 /*[IF JAVA_SPEC_VERSION >= 10]*/
 import java.lang.invoke.MethodType;
 /*[ENDIF] JAVA_SPEC_VERSION >= 10 */
@@ -30,7 +29,6 @@
 import java.lang.module.ModuleDescriptor.Version;
 import java.security.Permission;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
@@ -57,81 +55,119 @@ public final class StackWalker {
 	private static final int DEFAULT_BUFFER_SIZE = 1;
 
 	/* Java StackWalker flag constants cloned from java_lang_StackWalker.cpp. */
-	private static final int J9_RETAIN_CLASS_REFERENCE = 0x1;
-	private static final int J9_SHOW_REFLECT_FRAMES = 0x2;
-	private static final int J9_SHOW_HIDDEN_FRAMES = 0x4;
-	/* 0x8 flag used by VM constant J9_FRAME_VALID */
+	private static final int J9_RETAIN_CLASS_REFERENCE = 0x01;
+	private static final int J9_SHOW_REFLECT_FRAMES    = 0x02;
+	private static final int J9_SHOW_HIDDEN_FRAMES     = 0x04;
 	/*[IF JAVA_SPEC_VERSION >= 21]*/
-	/* Internal flag for retrieving monitor info for stack frames. */
-	private static final int J9_GET_MONITORS = 0x10;
+	private static final int J9_GET_MONITORS           = 0x08;
 	/*[ENDIF] JAVA_SPEC_VERSION >= 21 */
+	/*[IF JAVA_SPEC_VERSION >= 22]*/
+	private static final int J9_DROP_METHOD_INFO       = 0x10;
+	/*[ENDIF] JAVA_SPEC_VERSION >= 22 */
 
-	final Set<Option> walkerOptions;
+	/* Map the given options to the corresponding set of flags. */
+	private static int flagsFor(Set<Option> options) {
+		int flags = 0;
+
+		if (options.contains(Option.RETAIN_CLASS_REFERENCE)) {
+			flags |= J9_RETAIN_CLASS_REFERENCE;
+		}
+
+		if (options.contains(Option.SHOW_REFLECT_FRAMES)) {
+			flags |= J9_SHOW_REFLECT_FRAMES;
+		}
+
+		if (options.contains(Option.SHOW_HIDDEN_FRAMES)) {
+			flags |= J9_SHOW_HIDDEN_FRAMES;
+		}
+
+		/* There is no option corresponding to J9_GET_MONITORS. */
+
+		/*[IF JAVA_SPEC_VERSION >= 22]*/
+		if (options.contains(Option.DROP_METHOD_INFO)) {
+			flags |= J9_DROP_METHOD_INFO;
+		}
+		/*[ENDIF] JAVA_SPEC_VERSION >= 22 */
+
+		return flags;
+	}
 
 	private final int bufferSize;
-	private int flags;
+	private final int flags;
+
+	/*[IF JAVA_SPEC_VERSION >= 19]*/
+	private StackWalker(int flags, int estimatedDepth) {
+		this(flags, null, null, null, estimatedDepth);
+	}
+	/*[ENDIF] JAVA_SPEC_VERSION >= 19 */
 
-	private StackWalker(Set<Option> options, int estimatedDepth) {
+	private StackWalker(
+			int flags,
+			/*[IF JAVA_SPEC_VERSION >= 19]*/
+			ExtendedOption extendedOption,
+			ContinuationScope contScope,
+			Continuation continuation,
+			/*[ENDIF] JAVA_SPEC_VERSION >= 19 */
+			int estimatedDepth) {
 		super();
-		/* Caller is responsible for copying the client set (if any) */
-		walkerOptions = options; 
-		bufferSize = estimatedDepth;
+		this.flags = flags;
+		/*[IF JAVA_SPEC_VERSION >= 19]*/
+		this.extendedOption = extendedOption;
+		this.scope = contScope;
+		this.cont = continuation;
+		/*[ENDIF] JAVA_SPEC_VERSION >= 19 */
+		this.bufferSize = estimatedDepth;
+
 		if (estimatedDepth <= 0) {
 			/*[MSG "K0641", "estimatedDepth must be greater than 0"]*/
 			throw new IllegalArgumentException(com.ibm.oti.util.Msg.getString("K0641")); //$NON-NLS-1$
 		}
-		if (options.contains(Option.RETAIN_CLASS_REFERENCE)) {
+
+		if ((flags & J9_RETAIN_CLASS_REFERENCE) != 0) {
 			@SuppressWarnings("removal")
 			SecurityManager securityMgr = System.getSecurityManager();
 			if (null != securityMgr) {
 				securityMgr.checkPermission(PermissionSingleton.perm);
 			}
-		}
-		flags = 0;
-		if (walkerOptions.contains(Option.RETAIN_CLASS_REFERENCE)) {
-			flags |= J9_RETAIN_CLASS_REFERENCE;
-		/*[IF JAVA_SPEC_VERSION >= 19]*/
-			retainClassRef = true;
+			/*[IF JAVA_SPEC_VERSION >= 19]*/
+			this.retainClassRef = true;
 		} else {
-			retainClassRef = false;
-		/*[ENDIF] JAVA_SPEC_VERSION >= 19 */
-		}
-		if (walkerOptions.contains(Option.SHOW_REFLECT_FRAMES)) {
-			flags |= J9_SHOW_REFLECT_FRAMES;
-		}
-		if (walkerOptions.contains(Option.SHOW_HIDDEN_FRAMES)) {
-			flags |= J9_SHOW_HIDDEN_FRAMES;
+			this.retainClassRef = false;
+			/*[ENDIF] JAVA_SPEC_VERSION >= 19 */
 		}
 	}
 
 	/*[IF JAVA_SPEC_VERSION >= 21]*/
 	/**
-	 * Set the J9_GET_MONITORS flag.
+	 * Return a new StackWalker suitable for use by PinnedThreadPrinter
+	 * with appropriate flags set (including J9_GET_MONITORS).
 	 */
-	void setGetMonitorsFlag() {
-		flags |= J9_GET_MONITORS;
+	static StackWalker newInstanceWithMonitors() {
+		int flags = J9_GET_MONITORS | J9_SHOW_REFLECT_FRAMES | J9_RETAIN_CLASS_REFERENCE;
+
+		return new StackWalker(flags, DEFAULT_BUFFER_SIZE);
 	}
 	/*[ENDIF] JAVA_SPEC_VERSION >= 21 */
 
 	/**
 	 * Factory method to create a StackWalker instance with no options set.
-	 * 
+	 *
 	 * @return StackWalker StackWalker object
 	 */
 	public static StackWalker getInstance() {
-		return getInstance(Collections.emptySet(), DEFAULT_BUFFER_SIZE);
+		return new StackWalker(0, DEFAULT_BUFFER_SIZE);
 	}
 
 	/**
 	 * Factory method to create a StackWalker with one option. This is provided
 	 * for the case where only a single option is required.
-	 * 
+	 *
 	 * @param option
 	 *            select the type of information to include
 	 * @return StackWalker instance configured with the value of option
 	 * @throws SecurityException
 	 *             if option is RETAIN_CLASS_REFERENCE and the security manager
-	 *             check fails.
+	 *             check fails
 	 */
 	public static StackWalker getInstance(Option option) {
 		Objects.requireNonNull(option);
@@ -140,33 +176,34 @@ public static StackWalker getInstance(Option option) {
 
 	/**
 	 * Factory method to create a StackWalker with any number of options.
-	 * 
+	 *
 	 * @param options
-	 *            select the types of information to include.
+	 *            select the types of information to include
 	 * @return StackWalker instance configured with the given options
 	 * @throws SecurityException
 	 *             if RETAIN_CLASS_REFERENCE is requested and not permitted by
 	 *             the security manager
 	 */
 	public static StackWalker getInstance(Set<Option> options) {
-		return getInstance(new HashSet<>(options), DEFAULT_BUFFER_SIZE);
+		return getInstance(options, DEFAULT_BUFFER_SIZE);
 	}
 
 	/**
 	 * Factory method to create a StackWalker.
-	 * 
+	 *
 	 * @param options
-	 *            select the types of information to include.
+	 *            select the types of information to include
 	 * @param estimatedDepth
-	 *            Hint for the size of buffer to use. Must be 1 or greater.
+	 *            hint for the size of buffer to use. Must be 1 or greater
 	 * @return StackWalker instance with the given options specifying the stack
-	 *         frame information it can access.
+	 *         frame information it can access
 	 * @throws SecurityException
 	 *             if RETAIN_CLASS_REFERENCE is requested and not permitted by
 	 *             the security manager
 	 */
 	public static StackWalker getInstance(Set<Option> options, int estimatedDepth) {
-		return new StackWalker(new HashSet<>(options), estimatedDepth);
+		Objects.requireNonNull(options);
+		return new StackWalker(flagsFor(options), estimatedDepth);
 	}
 
 	/**
@@ -185,16 +222,16 @@ public void forEach(Consumer<? super StackFrame> action) {
 	/**
 	 * Get the caller of the caller of this function, eliding any reflection or
 	 * hidden frames.
-	 * 
+	 *
 	 * @return Class object for the method calling the current method.
 	 * @throws UnsupportedOperationException
 	 *             if the StackWalker was not created with
 	 *             {@link Option#RETAIN_CLASS_REFERENCE}
 	 * @throws IllegalStateException
-	 *             if the caller is at the bottom of the stack.
+	 *             if the caller is at the bottom of the stack
 	 */
 	public Class<?> getCallerClass() {
-		if (!walkerOptions.contains(Option.RETAIN_CLASS_REFERENCE)) {
+		if ((flags & J9_RETAIN_CLASS_REFERENCE) == 0) {
 			/*[MSG "K0639", "Stack walker not configured with RETAIN_CLASS_REFERENCE"]*/
 			throw new UnsupportedOperationException(com.ibm.oti.util.Msg.getString("K0639")); //$NON-NLS-1$
 		}
@@ -223,11 +260,11 @@ private static native <T> T walkWrapperImpl(int flags, String walkerMethod,
 	/**
 	 * Traverse the calling thread's stack at the time this method is called and
 	 * apply {@code function} to each stack frame.
-	 * 
-	 * @param <T> the type of the return value from applying function to the stream 
+	 *
+	 * @param <T> the type of the return value from applying function to the stream
 	 * @param function operation to apply to the stream
 	 * @param walkState Pointer to a J9StackWalkState struct
-	 * @return the value returned by {@code function}.
+	 * @return the value returned by {@code function}
 	 */
 	private static <T> T walkImpl(Function<? super Stream<StackFrame>, ? extends T> function, long walkState) {
 		T result;
@@ -242,10 +279,10 @@ private static <T> T walkImpl(Function<? super Stream<StackFrame>, ? extends T>
 	/**
 	 * Traverse the calling thread's stack at the time this method is called and
 	 * apply {@code function} to each stack frame.
-	 * 
-	 * @param <T> the type of the return value from applying function to the stream 
+	 *
+	 * @param <T> the type of the return value from applying function to the stream
 	 * @param function operation to apply to the stream
-	 * @return the value returned by {@code function}.
+	 * @return the value returned by {@code function}
 	 */
 	public <T> T walk(Function<? super Stream<StackFrame>, ? extends T> function) {
 		/*[IF JAVA_SPEC_VERSION >= 19]*/
@@ -267,9 +304,9 @@ public <T> T walk(Function<? super Stream<StackFrame>, ? extends T> function) {
 	/*[IF JAVA_SPEC_VERSION >= 19]*/
 	final boolean retainClassRef;
 
-	private ExtendedOption extendedOption;
-	private ContinuationScope scope;
-	private Continuation cont;
+	private final ExtendedOption extendedOption;
+	private final ContinuationScope scope;
+	private final Continuation cont;
 
 	private static native <T> T walkContinuationImpl(int flags, Function<? super Stream<StackFrame>, ? extends T> function, Continuation cont);
 
@@ -280,13 +317,10 @@ static StackWalker newInstance(Set<Option> options, ExtendedOption extendedOptio
 	static StackWalker newInstance(Set<Option> options, ExtendedOption extendedOption, ContinuationScope contScope) {
 		return newInstance(options, extendedOption, contScope, null);
 	}
-	static StackWalker newInstance(Set<Option> options, ExtendedOption extendedOption, ContinuationScope contScope, Continuation continuation) {
-		StackWalker result = getInstance(options);
-		result.extendedOption = extendedOption;
-		result.scope = contScope;
-		result.cont = continuation;
 
-		return result;
+	static StackWalker newInstance(Set<Option> options, ExtendedOption extendedOption, ContinuationScope contScope, Continuation continuation) {
+		Objects.requireNonNull(options);
+		return new StackWalker(flagsFor(options), extendedOption, contScope, continuation, DEFAULT_BUFFER_SIZE);
 	}
 
 	enum ExtendedOption {
@@ -296,10 +330,16 @@ enum ExtendedOption {
 
 	/**
 	 * Selects what type of stack and method information is provided by the
-	 * StackWalker
-	 *
+	 * StackWalker.
 	 */
 	public static enum Option {
+		/*[IF JAVA_SPEC_VERSION >= 22]*/
+		/**
+		 * A client may use this option to signal that method information is not
+		 * required (OpenJ9 ignores this option collects that information anyway).
+		 */
+		DROP_METHOD_INFO,
+		/*[ENDIF] JAVA_SPEC_VERSION >= 22 */
 		/**
 		 * Allow clients to obtain a method's Class object.
 		 */
@@ -322,19 +362,19 @@ public static interface StackFrame {
 
 		/**
 		 * @return the offset of the current bytecode in the method represented
-		 *         by this frame.
+		 *         by this frame
 		 */
 		int getByteCodeIndex();
 
 		/**
 		 * @return the binary name of the declaring class of this frame's
-		 *         method.
+		 *         method
 		 */
 		String getClassName();
 
 		/**
 		 * @return the Class object of the declaring class of this frame's
-		 *         method.
+		 *         method
 		 * @throws UnsupportedOperationException
 		 *             if the StackWalker was not created with
 		 *             Option.RETAIN_CLASS_REFERENCE
@@ -342,15 +382,15 @@ public static interface StackFrame {
 		Class<?> getDeclaringClass();
 
 		/**
-		 * @return File name of the class containing the current method. May be
-		 *         null.
+		 * @return file name of the class containing the current method (may be
+		 *         null)
 		 */
 		String getFileName();
 
 		/**
-		 * @return Location of the current point of execution in the source
+		 * @return location of the current point of execution in the source
 		 *         file, or a negative number if this information is unavailable
-		 *         or the method is native.
+		 *         or the method is native
 		 */
 		int getLineNumber();
 
@@ -367,7 +407,7 @@ public static interface StackFrame {
 
 		/**
 		 * Converts this StackFrame into a StackTraceElement.
-		 * 
+		 *
 		 * @return StackTraceElement
 		 */
 		StackTraceElement toStackTraceElement();
@@ -375,7 +415,7 @@ public static interface StackFrame {
 		/*[IF JAVA_SPEC_VERSION >= 10]*/
 		/**
 		 * @throws UnsupportedOperationException if this method is not overridden
-		 * @return MethodType containing the parameter and return types for the associated method.
+		 * @return MethodType containing the parameter and return types for the associated method
 		 * @since 10
 		 */
 		default MethodType getMethodType() {
@@ -384,14 +424,13 @@ default MethodType getMethodType() {
 
 		/**
 		 * @throws UnsupportedOperationException if this method is not overridden or the StackWalker
-		 * instance is not configured with RETAIN_CLASS_REFERENCE.
-		 * @return method descriptor string representing the type of this frame's method.
+		 * instance is not configured with RETAIN_CLASS_REFERENCE
+		 * @return method descriptor string representing the type of this frame's method
 		 * @since 10
 		 */
 		default String getDescriptor() {
 			throw new UnsupportedOperationException();
 		}
-
 		/*[ENDIF] JAVA_SPEC_VERSION >= 10 */
 	}
 
@@ -409,7 +448,7 @@ static final class StackFrameImpl implements StackFrame {
 		/*[IF JAVA_SPEC_VERSION >= 21]*/
 		private Object[] monitors;
 		/*[ENDIF] JAVA_SPEC_VERSION >= 21 */
-		boolean callerSensitive;
+		private boolean callerSensitive;
 
 		@Override
 		public int getByteCodeIndex() {
@@ -464,7 +503,8 @@ public StackTraceElement toStackTraceElement() {
 				}
 			}
 
-			StackTraceElement element = new StackTraceElement(classLoaderName, moduleName, moduleVersion, className, methodName, fileName,
+			StackTraceElement element = new StackTraceElement(classLoaderName,
+					moduleName, moduleVersion, className, methodName, fileName,
 					lineNumber);
 
 			/**
@@ -477,7 +517,7 @@ public StackTraceElement toStackTraceElement() {
 
 			return element;
 		}
-		
+
 		@Override
 		public String toString() {
 			StackTraceElement stackTraceElement = toStackTraceElement();
@@ -506,19 +546,19 @@ public MethodType getMethodType() {
 		 * @since 10
 		 */
 		@Override
-		public java.lang.String getDescriptor() {
+		public String getDescriptor() {
 			return methodSignature;
 		}
 		/*[ENDIF] JAVA_SPEC_VERSION >= 10 */
 
 		/*[IF JAVA_SPEC_VERSION >= 21]*/
-		protected Object[] getMonitors() {
+		Object[] getMonitors() {
 			return monitors;
 		}
 		/*[ENDIF] JAVA_SPEC_VERSION >= 21 */
 	}
 
-	static class PermissionSingleton {
+	static final class PermissionSingleton {
 		static final Permission perm =
 				new RuntimePermission("getStackWalkerWithClassReference"); //$NON-NLS-1$
 	}
diff --git a/runtime/j9vm/exports.cmake b/runtime/j9vm/exports.cmake
index b915ff7e6f3..21fee7fca06 100644
--- a/runtime/j9vm/exports.cmake
+++ b/runtime/j9vm/exports.cmake
@@ -438,6 +438,12 @@ if(NOT JAVA_SPEC_VERSION LESS 21)
 	)
 endif()
 
+if(NOT JAVA_SPEC_VERSION LESS 22)
+	jvm_add_exports(jvm
+		JVM_ExpandStackFrameInfo
+	)
+endif()
+
 if(J9VM_OPT_JITSERVER)
 	jvm_add_exports(jvm
 		JITServer_CreateServer
diff --git a/runtime/j9vm/j9vmnatives.xml b/runtime/j9vm/j9vmnatives.xml
index 0410edafc19..6ddce903c23 100644
--- a/runtime/j9vm/j9vmnatives.xml
+++ b/runtime/j9vm/j9vmnatives.xml
@@ -446,4 +446,9 @@ SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-ex
 		<export name="JVM_VirtualThreadStart"/>
 		<export name="JVM_VirtualThreadUnmount"/>
 	</exports>
+
+	<exports group="jdk22">
+		<!-- Additions for Java 22 (General) -->
+		<export name="JVM_ExpandStackFrameInfo"/>
+	</exports>
 </exportlists>
diff --git a/runtime/j9vm/java11vmi.c b/runtime/j9vm/java11vmi.c
index b0f064c29a3..d2bb9a03c73 100644
--- a/runtime/j9vm/java11vmi.c
+++ b/runtime/j9vm/java11vmi.c
@@ -1333,7 +1333,11 @@ JVM_ConstantPoolGetNameAndTypeRefIndexAt(JNIEnv *env, jobject arg1, jobject arg2
 }
 
 jint JNICALL
+#if JAVA_SPEC_VERSION >= 22
+JVM_MoreStackWalk(JNIEnv *env, jobject arg1, jint arg2, jlong arg3, jint arg4, jint arg5, jobjectArray arg6, jobjectArray arg7)
+#else /* JAVA_SPEC_VERSION >= 22 */
 JVM_MoreStackWalk(JNIEnv *env, jobject arg1, jlong arg2, jlong arg3, jint arg4, jint arg5, jobjectArray arg6, jobjectArray arg7)
+#endif /* JAVA_SPEC_VERSION >= 22 */
 {
 	assert(!"JVM_MoreStackWalk unimplemented"); /* Jazz 108925: Revive J9JCL raw pConfig build */
 	return -1;
@@ -1417,7 +1421,11 @@ JVM_ConstantPoolGetTagAt(JNIEnv *env, jobject arg1, jobject arg2, jint arg3)
 }
 
 jobject JNICALL
+#if JAVA_SPEC_VERSION >= 22
+JVM_CallStackWalk(JNIEnv *env, jobject arg1, jint arg2, jint arg3, jint arg4, jint arg5, jobjectArray arg6, jobjectArray arg7)
+#else /* JAVA_SPEC_VERSION >= 22 */
 JVM_CallStackWalk(JNIEnv *env, jobject arg1, jlong arg2, jint arg3, jint arg4, jint arg5, jobjectArray arg6, jobjectArray arg7)
+#endif /* JAVA_SPEC_VERSION >= 22 */
 {
 	assert(!"JVM_CallStackWalk unimplemented"); /* Jazz 108925: Revive J9JCL raw pConfig build */
 	return NULL;
diff --git a/runtime/j9vm/javanextvmi.cpp b/runtime/j9vm/javanextvmi.cpp
index b06eb62f633..b575e4a5e3b 100644
--- a/runtime/j9vm/javanextvmi.cpp
+++ b/runtime/j9vm/javanextvmi.cpp
@@ -19,6 +19,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0 OR GPL-2.0-only WITH OpenJDK-assembly-exception-1.0
  *******************************************************************************/
+
+#include <assert.h>
 #include <jni.h>
 
 #include "bcverify_api.h"
@@ -676,4 +678,12 @@ JVM_IsValhallaEnabled()
 }
 #endif /* defined(J9VM_OPT_VALHALLA_VALUE_TYPES) */
 
+#if JAVA_SPEC_VERSION >= 22
+JNIEXPORT void JNICALL
+JVM_ExpandStackFrameInfo(JNIEnv *env, jobject object)
+{
+	assert(!"JVM_ExpandStackFrameInfo unimplemented");
+}
+#endif /* JAVA_SPEC_VERSION >= 22 */
+
 } /* extern "C" */
diff --git a/runtime/j9vm/module.xml b/runtime/j9vm/module.xml
index 813cdbd488d..2d3d5946796 100644
--- a/runtime/j9vm/module.xml
+++ b/runtime/j9vm/module.xml
@@ -82,6 +82,9 @@ SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-ex
 			<group name="jdk21">
 				<include-if condition="spec.java21"/>
 			</group>
+			<group name="jdk22">
+				<include-if condition="spec.java22"/>
+			</group>
 		</exports>
 		<includes>
 			<include path="j9include"/>
diff --git a/runtime/jcl/common/java_lang_StackWalker.cpp b/runtime/jcl/common/java_lang_StackWalker.cpp
index 5b65e44f8e6..1f5ce77617c 100644
--- a/runtime/jcl/common/java_lang_StackWalker.cpp
+++ b/runtime/jcl/common/java_lang_StackWalker.cpp
@@ -32,24 +32,35 @@
 
 extern "C" {
 /* Internal flag constants, equivalent Java flags defined in StackWalker class. */
-#define J9_RETAIN_CLASS_REFERENCE 0x1
-#define J9_SHOW_REFLECT_FRAMES 0x2
-#define J9_SHOW_HIDDEN_FRAMES 0x4
-#define J9_FRAME_VALID 0x8
+#define J9_RETAIN_CLASS_REFERENCE 0x01
+#define J9_SHOW_REFLECT_FRAMES    0x02
+#define J9_SHOW_HIDDEN_FRAMES     0x04
 #if JAVA_SPEC_VERSION >= 21
-#define J9_GET_MONITORS 0x10
-#define J9_FRAME_FILTER_MASK (J9_RETAIN_CLASS_REFERENCE | J9_SHOW_REFLECT_FRAMES | J9_SHOW_HIDDEN_FRAMES | J9_GET_MONITORS)
-#else /* JAVA_SPEC_VERSION >= 21 */
-#define J9_FRAME_FILTER_MASK (J9_RETAIN_CLASS_REFERENCE | J9_SHOW_REFLECT_FRAMES | J9_SHOW_HIDDEN_FRAMES)
+#define J9_GET_MONITORS           0x08
 #endif /* JAVA_SPEC_VERSION >= 21 */
+#if JAVA_SPEC_VERSION >= 22
+#define J9_DROP_METHOD_INFO       0x10
+#endif /* JAVA_SPEC_VERSION >= 22 */
+
+#define J9_FRAME_VALID            0x80
+
+#define J9_FRAME_COMMON_MASK (J9_RETAIN_CLASS_REFERENCE | J9_SHOW_REFLECT_FRAMES | J9_SHOW_HIDDEN_FRAMES)
+
+#if JAVA_SPEC_VERSION >= 22
+#define J9_FRAME_FILTER_MASK (J9_FRAME_COMMON_MASK | J9_GET_MONITORS | J9_DROP_METHOD_INFO)
+#elif JAVA_SPEC_VERSION >= 21 /* JAVA_SPEC_VERSION >= 22 */
+#define J9_FRAME_FILTER_MASK (J9_FRAME_COMMON_MASK | J9_GET_MONITORS)
+#else /* JAVA_SPEC_VERSION >= 21 */
+#define J9_FRAME_FILTER_MASK (J9_FRAME_COMMON_MASK)
+#endif /* JAVA_SPEC_VERSION >= 22 */
 
-static UDATA stackFrameFilter(J9VMThread * currentThread, J9StackWalkState * walkState);
+static UDATA stackFrameFilter(J9VMThread *currentThread, J9StackWalkState *walkState);
 
 static UDATA
-stackFrameFilter(J9VMThread * currentThread, J9StackWalkState * walkState)
+stackFrameFilter(J9VMThread *currentThread, J9StackWalkState *walkState)
 {
 	/*
-	 * userData1 contains filtering flags, i.e. show hidden, show reflect.
+	 * userData1 contains filtering flags, i.e. show hidden, show reflect
 	 * userData2 contains stackWalkerMethod, the method name to search for
 	 */
 	UDATA result = J9_STACKWALK_STOP_ITERATING;
@@ -59,17 +70,17 @@ stackFrameFilter(J9VMThread * currentThread, J9StackWalkState * walkState)
 		J9ROMClass *romClass = J9_CLASS_FROM_METHOD(walkState->method)->romClass;
 
 		J9UTF8 *utf = J9ROMMETHOD_NAME(romMethod);
-		const char  *stackWalkerMethod = (const char  *) walkState->userData2;
+		const char *stackWalkerMethod = (const char *)walkState->userData2;
 		result = J9_STACKWALK_KEEP_ITERATING;
 
-		if (compareUTF8Length(J9UTF8_DATA(utf), J9UTF8_LENGTH(utf), (void *) stackWalkerMethod, strlen(stackWalkerMethod)) == 0) {
+		if (0 == compareUTF8Length(J9UTF8_DATA(utf), J9UTF8_LENGTH(utf), (void *)stackWalkerMethod, strlen(stackWalkerMethod))) {
 			utf = J9ROMCLASS_CLASSNAME(romClass);
 			if (J9UTF8_LITERAL_EQUALS(J9UTF8_DATA(utf), J9UTF8_LENGTH(utf), "java/lang/StackWalker")) {
 				walkState->userData2 = NULL; /* Iteration will skip hidden frames and stop at the true caller of stackWalkerMethod. */
 			}
 		}
-	} else if (J9_ARE_NO_BITS_SET((UDATA) (walkState->userData1), J9_SHOW_REFLECT_FRAMES | J9_SHOW_HIDDEN_FRAMES)
-			&&	VM_VMHelpers::isReflectionMethod(currentThread, walkState->method)
+	} else if (J9_ARE_NO_BITS_SET((UDATA)(walkState->userData1), J9_SHOW_REFLECT_FRAMES | J9_SHOW_HIDDEN_FRAMES)
+			&& VM_VMHelpers::isReflectionMethod(currentThread, walkState->method)
 	) {
 		/* skip reflection/MethodHandleInvoke frames */
 		result = J9_STACKWALK_KEEP_ITERATING;
@@ -83,7 +94,7 @@ stackFrameFilter(J9VMThread * currentThread, J9StackWalkState * walkState)
 jobject JNICALL
 Java_java_lang_StackWalker_walkWrapperImpl(JNIEnv *env, jclass clazz, jint flags, jstring stackWalkerMethod, jobject function)
 {
-	J9VMThread *vmThread = (J9VMThread *) env;
+	J9VMThread *vmThread = (J9VMThread *)env;
 	J9JavaVM *vm = vmThread->javaVM;
 
 	J9StackWalkState newWalkState;
@@ -95,8 +106,10 @@ Java_java_lang_StackWalker_walkWrapperImpl(JNIEnv *env, jclass clazz, jint flags
 	vmThread->stackWalkState = &newWalkState;
 	walkState->walkThread = vmThread;
 	walkState->flags = J9_STACKWALK_ITERATE_FRAMES | J9_STACKWALK_WALK_TRANSLATE_PC
-			|  J9_STACKWALK_INCLUDE_NATIVES | J9_STACKWALK_VISIBLE_ONLY;
-	/* If -XX:+ShowHiddenFrames and StackWalker.SHOW_HIDDEN_FRAMES option has not been set, skip hidden method frames */
+			| J9_STACKWALK_INCLUDE_NATIVES | J9_STACKWALK_VISIBLE_ONLY;
+	/* Unless -XX:+ShowHiddenFrames or StackWalker.Option.SHOW_HIDDEN_FRAMES
+	 * has been specified, skip hidden method frames.
+	 */
 	if (J9_ARE_NO_BITS_SET(vm->runtimeFlags, J9_RUNTIME_SHOW_HIDDEN_FRAMES)
 	&& J9_ARE_NO_BITS_SET((UDATA)flags, J9_SHOW_HIDDEN_FRAMES)
 	) {
@@ -126,24 +139,24 @@ Java_java_lang_StackWalker_walkWrapperImpl(JNIEnv *env, jclass clazz, jint flags
 #endif /* JAVA_SPEC_VERSION >= 21 */
 
 	walkState->frameWalkFunction = stackFrameFilter;
-	const char * walkerMethodChars = env->GetStringUTFChars(stackWalkerMethod, NULL);
+	const char *walkerMethodChars = env->GetStringUTFChars(stackWalkerMethod, NULL);
 	if (NULL == walkerMethodChars) { /* native out of memory exception pending */
 		return NULL;
 	}
-	walkState->userData2 = (void *) walkerMethodChars;
+	walkState->userData2 = (void *)walkerMethodChars;
 	UDATA walkStateResult = vm->walkStackFrames(vmThread, walkState);
 	Assert_JCL_true(walkStateResult == J9_STACKWALK_RC_NONE);
 	walkState->flags |= J9_STACKWALK_RESUME;
 	walkState->userData1 = (void *)(UDATA)flags;
 	if (J9SF_FRAME_TYPE_END_OF_STACK != walkState->pc) {
 		/* indicate the we have the topmost client method's frame */
-		walkState->userData1 = (void *)((UDATA) walkState->userData1 | J9_FRAME_VALID);
+		walkState->userData1 = (void *)((UDATA)walkState->userData1 | J9_FRAME_VALID);
 	}
 
 	jmethodID walkImplMID = JCL_CACHE_GET(env, MID_java_lang_StackWalker_walkImpl);
 	if (NULL == walkImplMID) {
 		walkImplMID = env->GetStaticMethodID( clazz, "walkImpl", "(Ljava/util/function/Function;J)Ljava/lang/Object;");
-		Assert_JCL_notNull (walkImplMID);
+		Assert_JCL_notNull(walkImplMID);
 		JCL_CACHE_SET(env, MID_java_lang_StackWalker_walkImpl, walkImplMID);
 	}
 	jobject result = env->CallStaticObjectMethod(clazz, walkImplMID, function, (jlong)(UDATA)walkState);
@@ -167,7 +180,7 @@ Java_java_lang_StackWalker_walkWrapperImpl(JNIEnv *env, jclass clazz, jint flags
 jobject JNICALL
 Java_java_lang_StackWalker_walkContinuationImpl(JNIEnv *env, jclass clazz, jint flags, jobject function, jobject cont)
 {
-	J9VMThread *vmThread = (J9VMThread *) env;
+	J9VMThread *vmThread = (J9VMThread *)env;
 	J9JavaVM *vm = vmThread->javaVM;
 
 	J9StackWalkState walkState = {0};
@@ -182,8 +195,10 @@ Java_java_lang_StackWalker_walkContinuationImpl(JNIEnv *env, jclass clazz, jint
 
 	walkState.walkThread = &stackThread;
 	walkState.flags = J9_STACKWALK_ITERATE_FRAMES | J9_STACKWALK_WALK_TRANSLATE_PC
-			|  J9_STACKWALK_INCLUDE_NATIVES | J9_STACKWALK_VISIBLE_ONLY;
-	/* If -XX:+ShowHiddenFrames and StackWalker.SHOW_HIDDEN_FRAMES option has not been set, skip hidden method frames */
+			| J9_STACKWALK_INCLUDE_NATIVES | J9_STACKWALK_VISIBLE_ONLY;
+	/* Unless -XX:+ShowHiddenFrames or StackWalker.Option.SHOW_HIDDEN_FRAMES
+	 * has been specified, skip hidden method frames.
+	 */
 	if (J9_ARE_NO_BITS_SET(vm->runtimeFlags, J9_RUNTIME_SHOW_HIDDEN_FRAMES)
 	&& J9_ARE_NO_BITS_SET((UDATA)flags, J9_SHOW_HIDDEN_FRAMES)
 	) {
@@ -199,7 +214,7 @@ Java_java_lang_StackWalker_walkContinuationImpl(JNIEnv *env, jclass clazz, jint
 	walkState.userData1 = (void *)(UDATA)flags;
 	if (J9SF_FRAME_TYPE_END_OF_STACK != walkState.pc) {
 		/* indicate the we have the topmost client method's frame */
-		walkState.userData1 = (void *)((UDATA) walkState.userData1 | J9_FRAME_VALID);
+		walkState.userData1 = (void *)((UDATA)walkState.userData1 | J9_FRAME_VALID);
 	}
 
 	jmethodID walkImplMID = JCL_CACHE_GET(env, MID_java_lang_StackWalker_walkImpl);
@@ -217,28 +232,28 @@ Java_java_lang_StackWalker_walkContinuationImpl(JNIEnv *env, jclass clazz, jint
 jobject JNICALL
 Java_java_lang_StackWalker_getImpl(JNIEnv *env, jobject clazz, jlong walkStateP)
 {
-	J9VMThread *vmThread = (J9VMThread *) env;
+	J9VMThread *vmThread = (J9VMThread *)env;
 	J9JavaVM *vm = vmThread->javaVM;
 	J9InternalVMFunctions const * const vmFuncs = vm->internalVMFunctions;
 	J9MemoryManagerFunctions const * const mmFuncs = vm->memoryManagerFunctions;
-	J9StackWalkState *walkState = (J9StackWalkState *) ((UDATA) walkStateP);
+	J9StackWalkState *walkState = (J9StackWalkState *)(UDATA)walkStateP;
 	jobject result = NULL;
 
 	enterVMFromJNI(vmThread);
 
-	if (J9_ARE_NO_BITS_SET((UDATA) (walkState->userData1), J9_FRAME_VALID)) {
+	if (J9_ARE_NO_BITS_SET((UDATA)(walkState->userData1), J9_FRAME_VALID)) {
 		/* skip over the current frame */
-		walkState->userData1 = (void *) ((UDATA)walkState->userData1 & J9_FRAME_FILTER_MASK);
+		walkState->userData1 = (void *)((UDATA)walkState->userData1 & J9_FRAME_FILTER_MASK);
 		if (J9_STACKWALK_RC_NONE != vm->walkStackFrames(vmThread, walkState)) {
 			vmFuncs->setNativeOutOfMemoryError(vmThread, 0, 0);
 			goto _done;
 		}
 	}
 	/* clear the valid bit */
-	walkState->userData1 = (void *) (((UDATA) walkState->userData1 & J9_FRAME_FILTER_MASK));
+	walkState->userData1 = (void *)((UDATA)walkState->userData1 & J9_FRAME_FILTER_MASK);
 
 	if (J9SF_FRAME_TYPE_END_OF_STACK != walkState->pc) {
-		J9Class * frameClass = J9VMJAVALANGSTACKWALKERSTACKFRAMEIMPL_OR_NULL(vm);
+		J9Class *frameClass = J9VMJAVALANGSTACKWALKERSTACKFRAMEIMPL_OR_NULL(vm);
 		j9object_t frame = mmFuncs->J9AllocateObject(vmThread, frameClass, J9_GC_ALLOCATE_OBJECT_NON_INSTRUMENTABLE);
 		if (NULL == frame) {
 			vmFuncs->setHeapOutOfMemoryError(vmThread);
@@ -246,30 +261,30 @@ Java_java_lang_StackWalker_getImpl(JNIEnv *env, jobject clazz, jlong walkStateP)
 			J9ROMMethod *romMethod = getOriginalROMMethod(walkState->method);
 			J9Class *ramClass = J9_CLASS_FROM_METHOD(walkState->method);
 			J9ROMClass *romClass = ramClass->romClass;
-			J9ClassLoader* classLoader = ramClass->classLoader;
+			J9ClassLoader *classLoader = ramClass->classLoader;
 
 			result = vmFuncs->j9jni_createLocalRef(env, frame);
-			UDATA bytecodeOffset = walkState->bytecodePCOffset;  /* need this for StackFrame */
+			UDATA bytecodeOffset = walkState->bytecodePCOffset; /* need this for StackFrame */
 			UDATA lineNumber = getLineNumberForROMClassFromROMMethod(vm, romMethod, romClass, classLoader, bytecodeOffset);
 			PUSH_OBJECT_IN_SPECIAL_FRAME(vmThread, frame);
 
 			/* set the class object if requested */
-			if (J9_ARE_ANY_BITS_SET((UDATA) walkState->userData1, J9_RETAIN_CLASS_REFERENCE)) {
+			if (J9_ARE_ANY_BITS_SET((UDATA)walkState->userData1, J9_RETAIN_CLASS_REFERENCE)) {
 				j9object_t classObject = J9VM_J9CLASS_TO_HEAPCLASS(ramClass);
 				J9VMJAVALANGSTACKWALKERSTACKFRAMEIMPL_SET_DECLARINGCLASS(vmThread, frame, classObject);
 			}
 
 			/* set bytecode index */
-			J9VMJAVALANGSTACKWALKERSTACKFRAMEIMPL_SET_BYTECODEINDEX(vmThread, frame, (U_32) bytecodeOffset);
+			J9VMJAVALANGSTACKWALKERSTACKFRAMEIMPL_SET_BYTECODEINDEX(vmThread, frame, (U_32)bytecodeOffset);
 
-			/* Fill in line number - Java wants -2 for natives, -1 for no line number (which will be 0 coming in from the iterator) */
+			/* Fill in line number - Java wants -2 for natives, -1 for no line number (which will be 0 coming in from the iterator). */
 
 			if (J9_ARE_ANY_BITS_SET(romMethod->modifiers, J9AccNative)) {
 				lineNumber = -2;
 			} else if (lineNumber == 0) {
 				lineNumber = -1;
 			}
-			J9VMJAVALANGSTACKWALKERSTACKFRAMEIMPL_SET_LINENUMBER(vmThread, frame, (I_32) lineNumber);
+			J9VMJAVALANGSTACKWALKERSTACKFRAMEIMPL_SET_LINENUMBER(vmThread, frame, (I_32)lineNumber);
 
 			j9object_t stringObject = J9VMJAVALANGCLASSLOADER_CLASSLOADERNAME(vmThread, classLoader->classLoaderObject);
 			J9VMJAVALANGSTACKWALKERSTACKFRAMEIMPL_SET_CLASSLOADERNAME(vmThread, frame, stringObject);
diff --git a/runtime/redirector/forwarders.m4 b/runtime/redirector/forwarders.m4
index 230cf13dfd3..cc5048722c7 100644
--- a/runtime/redirector/forwarders.m4
+++ b/runtime/redirector/forwarders.m4
@@ -316,8 +316,10 @@ _IF([JAVA_SPEC_VERSION >= 11],
 	[_X(JVM_SetMethodInfo,JNICALL,false,void,JNIEnv *env, jobject arg1)])
 _IF([JAVA_SPEC_VERSION >= 11],
 	[_X(JVM_ConstantPoolGetNameAndTypeRefIndexAt,JNICALL,false,jint,JNIEnv *env, jobject arg1, jobject arg2, jint arg3)])
-_IF([JAVA_SPEC_VERSION >= 11],
+_IF([(11 <= JAVA_SPEC_VERSION) && (JAVA_SPEC_VERSION < 22)],
 	[_X(JVM_MoreStackWalk,JNICALL,false,jint,JNIEnv *env, jobject arg1, jlong arg2, jlong arg3, jint arg4, jint arg5, jobjectArray arg6, jobjectArray arg7)])
+_IF([JAVA_SPEC_VERSION >= 22],
+	[_X(JVM_MoreStackWalk,JNICALL,false,jint,JNIEnv *env, jobject arg1, jint arg2, jlong arg3, jint arg4, jint arg5, jobjectArray arg6, jobjectArray arg7)])
 _IF([JAVA_SPEC_VERSION >= 11],
 	[_X(JVM_ConstantPoolGetClassRefIndexAt,JNICALL,false,jint,JNIEnv *env, jobject arg1, jlong arg2, jint arg3)])
 _IF([JAVA_SPEC_VERSION >= 11],
@@ -330,8 +332,10 @@ _IF([JAVA_SPEC_VERSION >= 11],
 	[_X(JVM_ConstantPoolGetNameAndTypeRefInfoAt,JNICALL,false,jobjectArray,JNIEnv *env, jobject arg1, jobject arg2, jint arg3)])
 _IF([JAVA_SPEC_VERSION >= 11],
 	[_X(JVM_ConstantPoolGetTagAt,JNICALL,false,jbyte,JNIEnv *env, jobject arg1, jobject arg2, jint arg3)])
-_IF([JAVA_SPEC_VERSION >= 11],
+_IF([(11 <= JAVA_SPEC_VERSION) && (JAVA_SPEC_VERSION < 22)],
 	[_X(JVM_CallStackWalk,JNICALL,false,jobject,JNIEnv *env, jobject arg1, jlong arg2, jint arg3, jint arg4, jint arg5, jobjectArray arg6, jobjectArray arg7)])
+_IF([JAVA_SPEC_VERSION >= 22],
+	[_X(JVM_CallStackWalk,JNICALL,false,jobject,JNIEnv *env, jobject arg1, jint arg2, jint arg3, jint arg4, jint arg5, jobjectArray arg6, jobjectArray arg7)])
 _IF([JAVA_SPEC_VERSION >= 11],
 	[_X(JVM_SetBootLoaderUnnamedModule,JNICALL,false,void,JNIEnv *env, jobject arg1)])
 _IF([JAVA_SPEC_VERSION >= 11],
@@ -423,3 +427,5 @@ _IF([JAVA_SPEC_VERSION >= 21],
 	[_X(JVM_VirtualThreadUnmount, JNICALL, false, void, JNIEnv *env, jobject vthread, jboolean hide)])
 _IF([defined(J9VM_OPT_VALHALLA_VALUE_TYPES)],
 	[_X(JVM_IsValhallaEnabled, JNICALL, false, jboolean, void)])
+_IF([JAVA_SPEC_VERSION >= 22],
+	[_X(JVM_ExpandStackFrameInfo, JNICALL, false, void, JNIEnv *env, jobject object)])
diff --git a/runtime/redirector/module.xml b/runtime/redirector/module.xml
index 6b861ae7526..7d28eaa6c9a 100644
--- a/runtime/redirector/module.xml
+++ b/runtime/redirector/module.xml
@@ -83,6 +83,9 @@ SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-ex
 			<group name="jdk21">
 				<include-if condition="spec.java21"/>
 			</group>
+			<group name="jdk22">
+				<include-if condition="spec.java22"/>
+			</group>
 		</exports>
 		<includes>
 			<include path="j9include"/>