diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/disabledesugarer/DesugaredLibraryDisableDesugarer.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/disabledesugarer/DesugaredLibraryDisableDesugarer.java
index bd4b771..5c956aa 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/disabledesugarer/DesugaredLibraryDisableDesugarer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/disabledesugarer/DesugaredLibraryDisableDesugarer.java
@@ -62,6 +62,7 @@
     return rewriteInstruction(instruction, context) != null;
   }
 
+  // TODO(b/261024278): Share this code.
   private CfInstruction rewriteInstruction(CfInstruction instruction, ProgramMethod context) {
     if (!appView.dexItemFactory().multiDexTypes.contains(context.getHolderType())) {
       return null;
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/varhandle/VarHandleDesugaringMethods.java b/src/main/java/com/android/tools/r8/ir/desugar/varhandle/VarHandleDesugaringMethods.java
index d463636..ae46d63 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/varhandle/VarHandleDesugaringMethods.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/varhandle/VarHandleDesugaringMethods.java
@@ -18,8 +18,10 @@
 import com.android.tools.r8.cf.code.CfInvoke;
 import com.android.tools.r8.cf.code.CfLabel;
 import com.android.tools.r8.cf.code.CfLoad;
+import com.android.tools.r8.cf.code.CfNew;
 import com.android.tools.r8.cf.code.CfReturn;
 import com.android.tools.r8.cf.code.CfReturnVoid;
+import com.android.tools.r8.cf.code.CfStackInstruction;
 import com.android.tools.r8.cf.code.CfStore;
 import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.graph.CfCode;
@@ -222,6 +224,45 @@
                 .build()));
   }
 
+  public static void generateDesugarMethodHandlesLookupClass(
+      SyntheticProgramClassBuilder builder, DexItemFactory factory) {
+    builder.setInstanceFields(ImmutableList.of());
+    DexMethod findVarHandle =
+        factory.createMethod(
+            builder.getType(),
+            factory.createProto(
+                factory.createType(factory.createString("Lcom/android/tools/r8/DesugarVarHandle;")),
+                factory.createType(factory.createString("Ljava/lang/Class;")),
+                factory.createType(factory.createString("Ljava/lang/String;")),
+                factory.createType(factory.createString("Ljava/lang/Class;"))),
+            factory.createString("findVarHandle"));
+    DexMethod constructor_0 =
+        factory.createMethod(
+            builder.getType(),
+            factory.createProto(factory.voidType),
+            factory.createString("<init>"));
+    builder.setDirectMethods(
+        ImmutableList.of(
+            DexEncodedMethod.syntheticBuilder()
+                .setMethod(constructor_0)
+                .setAccessFlags(
+                    MethodAccessFlags.fromSharedAccessFlags(
+                        Constants.ACC_PUBLIC | Constants.ACC_SYNTHETIC, true))
+                .setCode(DesugarMethodHandlesLookup_constructor_0(factory, constructor_0))
+                .disableAndroidApiLevelCheck()
+                .build()));
+    builder.setVirtualMethods(
+        ImmutableList.of(
+            DexEncodedMethod.syntheticBuilder()
+                .setMethod(findVarHandle)
+                .setAccessFlags(
+                    MethodAccessFlags.fromSharedAccessFlags(
+                        Constants.ACC_PUBLIC | Constants.ACC_SYNTHETIC, false))
+                .setCode(DesugarMethodHandlesLookup_findVarHandle(factory, findVarHandle))
+                .disableAndroidApiLevelCheck()
+                .build()));
+  }
+
   public static CfCode DesugarVarHandle_constructor_3(DexItemFactory factory, DexMethod method) {
     CfLabel label0 = new CfLabel();
     CfLabel label1 = new CfLabel();
@@ -472,4 +513,57 @@
         ImmutableList.of(),
         ImmutableList.of());
   }
+
+  public static CfCode DesugarMethodHandlesLookup_constructor_0(
+      DexItemFactory factory, DexMethod method) {
+    CfLabel label0 = new CfLabel();
+    CfLabel label1 = new CfLabel();
+    return new CfCode(
+        method.holder,
+        1,
+        1,
+        ImmutableList.of(
+            label0,
+            new CfLoad(ValueType.OBJECT, 0),
+            new CfInvoke(
+                183,
+                factory.createMethod(
+                    factory.objectType,
+                    factory.createProto(factory.voidType),
+                    factory.createString("<init>")),
+                false),
+            new CfReturnVoid(),
+            label1),
+        ImmutableList.of(),
+        ImmutableList.of());
+  }
+
+  public static CfCode DesugarMethodHandlesLookup_findVarHandle(
+      DexItemFactory factory, DexMethod method) {
+    CfLabel label0 = new CfLabel();
+    CfLabel label1 = new CfLabel();
+    return new CfCode(
+        method.holder,
+        5,
+        4,
+        ImmutableList.of(
+            label0,
+            new CfNew(factory.createType("Lcom/android/tools/r8/DesugarVarHandle;")),
+            new CfStackInstruction(CfStackInstruction.Opcode.Dup),
+            new CfLoad(ValueType.OBJECT, 1),
+            new CfLoad(ValueType.OBJECT, 2),
+            new CfLoad(ValueType.OBJECT, 3),
+            new CfInvoke(
+                183,
+                factory.createMethod(
+                    factory.createType("Lcom/android/tools/r8/DesugarVarHandle;"),
+                    factory.createProto(
+                        factory.voidType, factory.classType, factory.stringType, factory.classType),
+                    factory.createString("<init>")),
+                false),
+            new CfReturn(ValueType.OBJECT),
+            label1),
+        ImmutableList.of(),
+        ImmutableList.of());
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/ir/desugar/varhandle/DesugarMethodHandlesLookup.java b/src/test/java/com/android/tools/r8/ir/desugar/varhandle/DesugarMethodHandlesLookup.java
new file mode 100644
index 0000000..d700033
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/desugar/varhandle/DesugarMethodHandlesLookup.java
@@ -0,0 +1,126 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.desugar.varhandle;
+
+public final class DesugarMethodHandlesLookup {
+  public DesugarVarHandle findVarHandle(Class<?> recv, String name, Class<?> type)
+      throws NoSuchFieldException, IllegalAccessException {
+    return new DesugarVarHandle(recv, name, type);
+  }
+
+  /*
+   * Remaining methods on MethodHandles.Lookup.
+   *
+   * These could be implemented by forwarding to the runtime MethodHandles.Lookup if present at
+   * runtime.
+   *
+
+  public Class<?>	accessClass(Class<?> targetClass) throws IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandle bind(Object receiver, String name, MethodType type) throws NoSuchMethodException,
+      IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public Class<?> defineClass(byte[] bytes) throws IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandles.Lookup dropLookupMode(int modeToDrop) {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public Class<?> findClass(String targetName) throws ClassNotFoundException, IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandle findConstructor(Class<?> refc, MethodType type) throws NoSuchMethodException, IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandle findGetter(Class<?> refc, String name, Class<?> type) throws NoSuchMethodException, IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandle findSetter(Class<?> refc, String name, Class<?> type) throws NoSuchFieldException, IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandle findSpecial(Class<?> refc, String name, MethodType type, Class<?> specialCaller) throws NoSuchFieldException, IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandle findStatic(Class<?> refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandle findStaticGetter(Class<?> refc, String name, Class<?> type) throws NoSuchMethodException, IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandle findStaticSetter(Class<?> refc, String name, Class<?> type) throws NoSuchMethodException, IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public DesugarVarHandle findStaticVarHandle(Class<?> decl, String name, Class<?> type) throws Exception throws NoSuchFieldException, IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandle findVirtual(Class<?> refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public boolean hasPrivateAccess() {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandles.Lookup in(Class<?> requestedLookupClass) {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public Class<?> lookupClass() {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public int lookupModes() {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandleInfo revealDirect(MethodHandle target) {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public String toString() {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandle unreflect(Method m) throws IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandle unreflectConstructor(Constructor<?> c) throws IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandle unreflectGetter(Field f) throws IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandle unreflectSetter(Field f) throws IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  public MethodHandle unreflectSpecial(Method m, Class<?> specialCaller) {
+    throw new RuntimeException("Unsupported");
+  }
+
+  DesugarVarHandle unreflectVarHandle(Field f) throws IllegalAccessException {
+    throw new RuntimeException("Unsupported");
+  }
+
+  */
+}
diff --git a/src/test/java/com/android/tools/r8/ir/desugar/varhandle/DesugarVarHandle.java b/src/test/java/com/android/tools/r8/ir/desugar/varhandle/DesugarVarHandle.java
index 2a19a45..7e88943 100644
--- a/src/test/java/com/android/tools/r8/ir/desugar/varhandle/DesugarVarHandle.java
+++ b/src/test/java/com/android/tools/r8/ir/desugar/varhandle/DesugarVarHandle.java
@@ -22,7 +22,8 @@
   private final Class<?> type;
   private final long offset;
 
-  DesugarVarHandle(Class<?> recv, String name, Class<?> type) throws Exception {
+  DesugarVarHandle(Class<?> recv, String name, Class<?> type)
+      throws NoSuchFieldException, IllegalAccessException {
     Field theUnsafe = UnsafeStub.class.getDeclaredField("theUnsafe");
     theUnsafe.setAccessible(true);
     U = (UnsafeStub) theUnsafe.get(null);
diff --git a/src/test/java/com/android/tools/r8/ir/desugar/varhandle/GenerateVarHandleMethods.java b/src/test/java/com/android/tools/r8/ir/desugar/varhandle/GenerateVarHandleMethods.java
index b15131b..a8527a0 100644
--- a/src/test/java/com/android/tools/r8/ir/desugar/varhandle/GenerateVarHandleMethods.java
+++ b/src/test/java/com/android/tools/r8/ir/desugar/varhandle/GenerateVarHandleMethods.java
@@ -10,22 +10,25 @@
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.TestRuntime.CfVm;
 import com.android.tools.r8.cf.code.CfFieldInstruction;
+import com.android.tools.r8.cf.code.CfFrame;
 import com.android.tools.r8.cf.code.CfInstruction;
 import com.android.tools.r8.cf.code.CfInvoke;
+import com.android.tools.r8.cf.code.CfTypeInstruction;
 import com.android.tools.r8.cfmethodgeneration.MethodGenerationBase;
 import com.android.tools.r8.graph.CfCode;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProto;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.utils.FileUtils;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -37,7 +40,8 @@
 
   private final DexType GENERATED_TYPE =
       factory.createType("Lcom/android/tools/r8/ir/desugar/varhandle/VarHandleDesugaringMethods;");
-  private final List<Class<?>> METHOD_TEMPLATE_CLASSES = ImmutableList.of(DesugarVarHandle.class);
+  private final List<Class<?>> METHOD_TEMPLATE_CLASSES =
+      ImmutableList.of(DesugarVarHandle.class, DesugarMethodHandlesLookup.class);
 
   protected final TestParameters parameters;
 
@@ -62,7 +66,7 @@
 
   @Override
   protected List<Class<?>> getClassesToGenerate() {
-    return ImmutableList.of(DesugarVarHandle.class);
+    return ImmutableList.of(DesugarVarHandle.class, DesugarMethodHandlesLookup.class);
   }
 
   @Override
@@ -76,63 +80,6 @@
     return 2022;
   }
 
-  private static CfInstruction rewriteToUnsafe(DexItemFactory factory, CfInstruction instruction) {
-    DexType unsafe = factory.unsafeType;
-    DexType unsafeStub =
-        factory.createType(
-            "L" + DesugarVarHandle.class.getTypeName().replace('.', '/') + "$UnsafeStub;");
-    // Rewrite references to UnsafeStub to sun.misc.Unsafe
-    if (instruction.isTypeInstruction()
-        && instruction.asTypeInstruction().getType() == unsafeStub) {
-      return instruction.asTypeInstruction().withType(unsafe);
-    }
-    if (instruction.isFieldInstruction()) {
-      CfFieldInstruction fieldInstruction = instruction.asFieldInstruction();
-      if (fieldInstruction.getField().getType() == unsafeStub) {
-        return fieldInstruction.createWithField(
-            factory.createField(
-                fieldInstruction.getField().getHolderType(),
-                unsafe,
-                fieldInstruction.getField().name));
-      }
-    }
-    if (instruction.isInvoke()) {
-      CfInvoke invoke = instruction.asInvoke();
-      DexMethod method = invoke.getMethod();
-      String name = method.getName().toString();
-      if (invoke.getMethod().getHolderType() == unsafeStub) {
-        return new CfInvoke(
-            invoke.getOpcode(),
-            factory.createMethod(unsafe, invoke.getMethod().getProto(), factory.createString(name)),
-            invoke.isInterface());
-      }
-    }
-    if (instruction.isFrame()) {
-      return instruction.asFrame().mapReferenceTypes(type -> (type == unsafeStub) ? unsafe : type);
-    }
-    return instruction;
-  }
-
-  private static CfInstruction rewriteDesugarVarHandle(
-      DexItemFactory factory, CfInstruction instruction) {
-    // Rewrite references to com.android.tools.r8.ir.desugar.varhandle.DesugarVarHandle to
-    // com.android.tools.r8.DesugarVarHandle.
-    DexType desugarVarHandle = factory.desugarVarHandleType;
-    DexType desugarVarHandleStub =
-        factory.createType("L" + DesugarVarHandle.class.getTypeName().replace('.', '/') + ";");
-    if (instruction.isFieldInstruction()) {
-      CfFieldInstruction fieldInstruction = instruction.asFieldInstruction();
-      if (fieldInstruction.getField().getHolderType() == desugarVarHandleStub) {
-        return fieldInstruction.createWithField(
-            factory.createField(
-                desugarVarHandle,
-                fieldInstruction.getField().getType(),
-                fieldInstruction.getField().name));
-      }
-    }
-    return instruction;
-  }
-
   @Override
   protected DexEncodedField getField(DexEncodedField field) {
     if (field.getType().getTypeName().endsWith("$UnsafeStub")) {
@@ -146,19 +93,95 @@
     return field;
   }
 
+  // TODO(b/261024278): Share this code.
+  private class InstructionTypeMapper {
+    private final Map<DexType, DexType> typeMap;
+
+    InstructionTypeMapper(Map<DexType, DexType> typeMap) {
+      this.typeMap = typeMap;
+    }
+
+    private CfInstruction rewriteInstruction(CfInstruction instruction) {
+      if (instruction.isTypeInstruction()) {
+        CfInstruction rewritten = rewriteTypeInstruction(instruction.asTypeInstruction());
+        return rewritten == null ? instruction : rewritten;
+      }
+      if (instruction.isFieldInstruction()) {
+        return rewriteFieldInstruction(instruction.asFieldInstruction());
+      }
+      if (instruction.isInvoke()) {
+        return rewriteInvokeInstruction(instruction.asInvoke());
+      }
+      if (instruction.isFrame()) {
+        return rewriteFrameInstruction(instruction.asFrame());
+      }
+      return instruction;
+    }
+
+    private CfInstruction rewriteInvokeInstruction(CfInvoke instruction) {
+      CfInvoke invoke = instruction.asInvoke();
+      DexMethod method = invoke.getMethod();
+      String name = method.getName().toString();
+      DexType holderType = invoke.getMethod().getHolderType();
+      DexType rewrittenType = typeMap.getOrDefault(holderType, holderType);
+      if (rewrittenType != holderType) {
+        // TODO(b/261024278): If sharing this code also rewrite signature.
+        return new CfInvoke(
+            invoke.getOpcode(),
+            factory.createMethod(
+                rewrittenType, invoke.getMethod().getProto(), factory.createString(name)),
+            invoke.isInterface());
+      }
+      return instruction;
+    }
+
+    private CfFieldInstruction rewriteFieldInstruction(CfFieldInstruction instruction) {
+      DexType holderType = instruction.getField().getHolderType();
+      DexType rewrittenHolderType = typeMap.getOrDefault(holderType, holderType);
+      DexType fieldType = instruction.getField().getType();
+      DexType rewrittenType = typeMap.getOrDefault(fieldType, fieldType);
+      if (rewrittenHolderType != holderType || rewrittenType != fieldType) {
+        return instruction.createWithField(
+            factory.createField(rewrittenHolderType, rewrittenType, instruction.getField().name));
+      }
+      return instruction;
+    }
+
+    private CfInstruction rewriteTypeInstruction(CfTypeInstruction instruction) {
+      DexType rewrittenType = typeMap.getOrDefault(instruction.getType(), instruction.getType());
+      return rewrittenType != instruction.getType() ? instruction.withType(rewrittenType) : null;
+    }
+
+    private CfInstruction rewriteFrameInstruction(CfFrame instruction) {
+      return instruction.asFrame().mapReferenceTypes(type -> typeMap.getOrDefault(type, type));
+    }
+  }
+
   @Override
   protected CfCode getCode(String holderName, String methodName, CfCode code) {
     if (methodName.endsWith("Stub")) {
       // Don't include stubs targeted only for rewriting in the generated code.
       return null;
     }
-    if (!holderName.equals("DesugarVarHandle")) {
-      throw new RuntimeException("Unexpected");
+    if (!holderName.equals("DesugarVarHandle")
+        && !holderName.equals("DesugarMethodHandlesLookup")) {
+      throw new RuntimeException("Unexpected: " + holderName);
     }
+    // Rewrite references to com.android.tools.r8.ir.desugar.varhandle.DesugarVarHandle to
+    // com.android.tools.r8.DesugarVarHandle and rewrite references to UnsafeStub to
+    // sun.misc.Unsafe.
+    InstructionTypeMapper instructionTypeMapper =
+        new InstructionTypeMapper(
+            ImmutableMap.of(
+                factory.createType(
+                    "L" + DesugarVarHandle.class.getTypeName().replace('.', '/') + ";"),
+                factory.desugarVarHandleType,
+                factory.createType(
+                    "L" + DesugarVarHandle.class.getTypeName().replace('.', '/') + "$UnsafeStub;"),
+                factory.unsafeType));
     code.setInstructions(
         code.getInstructions().stream()
-            .map(instruction -> rewriteToUnsafe(factory, instruction))
-            .map(instruction -> rewriteDesugarVarHandle(factory, instruction))
+            .map(instructionTypeMapper::rewriteInstruction)
             .collect(Collectors.toList()));
     return code;
   }