diff a/src/java.base/share/classes/java/lang/invoke/AbstractValidatingLambdaMetafactory.java b/src/java.base/share/classes/java/lang/invoke/AbstractValidatingLambdaMetafactory.java
--- a/src/java.base/share/classes/java/lang/invoke/AbstractValidatingLambdaMetafactory.java
+++ b/src/java.base/share/classes/java/lang/invoke/AbstractValidatingLambdaMetafactory.java
@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2012, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024, 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
@@ -67,11 +67,13 @@
     final Class<?> implClass;                 // Class for referencing the implementation method "class CC"
     final MethodType dynamicMethodType;       // Dynamically checked method type "(Integer)Object"
     final boolean isSerializable;             // Should the returned instance be serializable
     final Class<?>[] altInterfaces;           // Additional interfaces to be implemented
     final MethodType[] altMethods;            // Signatures of additional methods to bridge
-
+    final MethodHandle quotableOpGetter;       // A getter method handle that is used to retrieve the
+                                              // the quotable lambda's associated intermediate representation (can be null).
+    final MethodHandleInfo quotableOpGetterInfo;  // Info about the quotable getter method handle (can be null).
 
     /**
      * Meta-factory constructor.
      *
      * @param caller Stacked automatically by VM; represents a lookup context
@@ -103,10 +105,13 @@
      *                       types must extend {@code Serializable}.
      * @param altInterfaces Additional interfaces which the lambda object
      *                      should implement.
      * @param altMethods Method types for additional signatures to be
      *                   implemented by invoking the implementation method
+     * @param reflectiveField a {@linkplain MethodHandles.Lookup#findGetter(Class, String, Class) getter}
+     *                   method handle that is used to retrieve the string representation of the
+     *                   quotable lambda's associated intermediate representation.
      * @throws LambdaConversionException If any of the meta-factory protocol
      *         invariants are violated
      * @throws SecurityException If a security manager is present, and it
      *         <a href="MethodHandles.Lookup.html#secmgr">denies access</a>
      *         from {@code caller} to the package of {@code implementation}.
@@ -117,11 +122,12 @@
                                         MethodType interfaceMethodType,
                                         MethodHandle implementation,
                                         MethodType dynamicMethodType,
                                         boolean isSerializable,
                                         Class<?>[] altInterfaces,
-                                        MethodType[] altMethods)
+                                        MethodType[] altMethods,
+                                        MethodHandle reflectiveField)
             throws LambdaConversionException {
         if (!caller.hasFullPrivilegeAccess()) {
             throw new LambdaConversionException(String.format(
                     "Invalid caller: %s",
                     caller.lookupClass().getName()));
@@ -178,10 +184,11 @@
 
         this.dynamicMethodType = dynamicMethodType;
         this.isSerializable = isSerializable;
         this.altInterfaces = altInterfaces;
         this.altMethods = altMethods;
+        this.quotableOpGetter = reflectiveField;
 
         if (interfaceMethodName.isEmpty() ||
                 interfaceMethodName.indexOf('.') >= 0 ||
                 interfaceMethodName.indexOf(';') >= 0 ||
                 interfaceMethodName.indexOf('[') >= 0 ||
@@ -204,10 +211,23 @@
                 throw new LambdaConversionException(String.format(
                         "%s is not an interface",
                         c.getName()));
             }
         }
+
+        if (reflectiveField != null) {
+            try {
+                quotableOpGetterInfo = caller.revealDirect(reflectiveField); // may throw SecurityException
+            } catch (IllegalArgumentException e) {
+                throw new LambdaConversionException(implementation + " is not direct or cannot be cracked");
+            }
+            if (quotableOpGetterInfo.getReferenceKind() != REF_invokeStatic) {
+                throw new LambdaConversionException(String.format("Unsupported MethodHandle kind: %s", quotableOpGetterInfo));
+            }
+        } else {
+            quotableOpGetterInfo = null;
+        }
     }
 
     /**
      * Build the CallSite.
      *
