diff --git a/src/main/java/com/android/tools/r8/ir/desugar/records/RecordCfToCfRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/records/RecordCfToCfRewriter.java
new file mode 100644
index 0000000..76c468a6
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/records/RecordCfToCfRewriter.java
@@ -0,0 +1,106 @@
+// Copyright (c) 2021, 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.records;
+
+import static com.android.tools.r8.ir.desugar.records.RecordRewriterHelper.isInvokeDynamicOnRecord;
+import static com.android.tools.r8.ir.desugar.records.RecordRewriterHelper.parseInvokeDynamicOnRecord;
+
+import com.android.tools.r8.cf.code.CfInvokeDynamic;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethodHandle;
+import com.android.tools.r8.graph.DexMethodHandle.MethodHandleType;
+import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.graph.DexValue;
+import com.android.tools.r8.graph.DexValue.DexValueMethodHandle;
+import com.android.tools.r8.graph.DexValue.DexValueString;
+import com.android.tools.r8.graph.DexValue.DexValueType;
+import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.desugar.records.RecordRewriterHelper.RecordInvokeDynamic;
+import com.android.tools.r8.naming.NamingLens;
+import java.util.ArrayList;
+
+/** Used to shrink records in Cf to Cf compilations */
+public class RecordCfToCfRewriter {
+
+  private final AppView<?> appView;
+
+  public static RecordCfToCfRewriter create(AppView<?> appView) {
+    if (appView.enableWholeProgramOptimizations()
+        && appView.options().isGeneratingClassFiles()
+        && appView.options().testing.enableRecordModeling) {
+      return new RecordCfToCfRewriter(appView);
+    }
+    return null;
+  }
+
+  private RecordCfToCfRewriter(AppView<?> appView) {
+    this.appView = appView;
+  }
+
+  // Called after final tree shaking, prune and minify field names and field values.
+  public CfInvokeDynamic rewriteRecordInvokeDynamic(
+      CfInvokeDynamic invokeDynamic, ProgramMethod context, NamingLens namingLens) {
+    if (!isInvokeDynamicOnRecord(invokeDynamic, appView, context)) {
+      return invokeDynamic;
+    }
+    RecordInvokeDynamic recordInvokeDynamic =
+        parseInvokeDynamicOnRecord(invokeDynamic, appView, context);
+    DexString newFieldNames =
+        recordInvokeDynamic
+            .computeRecordFieldNamesComputationInfo()
+            .internalComputeNameFor(
+                recordInvokeDynamic.getRecordClass().type,
+                appView,
+                appView.graphLens(),
+                namingLens);
+    DexField[] newFields = computePresentFields(appView.graphLens(), recordInvokeDynamic);
+    return writeRecordInvokeDynamic(
+        recordInvokeDynamic.withFieldNamesAndFields(newFieldNames, newFields));
+  }
+
+  private DexField[] computePresentFields(
+      GraphLens graphLens, RecordInvokeDynamic recordInvokeDynamic) {
+    ArrayList<DexField> finalFields = new ArrayList<>();
+    for (DexField field : recordInvokeDynamic.getFields()) {
+      DexEncodedField dexEncodedField =
+          recordInvokeDynamic
+              .getRecordClass()
+              .lookupInstanceField(graphLens.getRenamedFieldSignature(field));
+      if (dexEncodedField != null) {
+        finalFields.add(field);
+      }
+    }
+    DexField[] newFields = new DexField[finalFields.size()];
+    for (int i = 0; i < finalFields.size(); i++) {
+      newFields[i] = finalFields.get(i);
+    }
+    return newFields;
+  }
+
+  private CfInvokeDynamic writeRecordInvokeDynamic(RecordInvokeDynamic recordInvokeDynamic) {
+    DexItemFactory factory = appView.dexItemFactory();
+    DexMethodHandle bootstrapMethod =
+        new DexMethodHandle(
+            MethodHandleType.INVOKE_STATIC, factory.objectMethodsMembers.bootstrap, false, null);
+    ArrayList<DexValue> bootstrapArgs = new ArrayList<>();
+    bootstrapArgs.add(new DexValueType(recordInvokeDynamic.getRecordClass().type));
+    bootstrapArgs.add(new DexValueString(recordInvokeDynamic.getFieldNames()));
+    for (DexField field : recordInvokeDynamic.getFields()) {
+      bootstrapArgs.add(
+          new DexValueMethodHandle(
+              new DexMethodHandle(MethodHandleType.INSTANCE_GET, field, false, null)));
+    }
+    return new CfInvokeDynamic(
+        factory.createCallSite(
+            recordInvokeDynamic.getMethodName(),
+            recordInvokeDynamic.getMethodProto(),
+            bootstrapMethod,
+            bootstrapArgs));
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/records/RecordDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/records/RecordDesugaring.java
index 0c1ee6e..3829aa0 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/records/RecordDesugaring.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/records/RecordDesugaring.java
@@ -6,9 +6,12 @@
 
 import static com.android.tools.r8.cf.code.CfStackInstruction.Opcode.Dup;
 import static com.android.tools.r8.cf.code.CfStackInstruction.Opcode.Swap;
+import static com.android.tools.r8.ir.desugar.records.RecordRewriterHelper.isInvokeDynamicOnRecord;
+import static com.android.tools.r8.ir.desugar.records.RecordRewriterHelper.parseInvokeDynamicOnRecord;
 
 import com.android.tools.r8.cf.code.CfConstClass;
 import com.android.tools.r8.cf.code.CfConstString;
+import com.android.tools.r8.cf.code.CfDexItemBasedConstString;
 import com.android.tools.r8.cf.code.CfFieldInstruction;
 import com.android.tools.r8.cf.code.CfInstruction;
 import com.android.tools.r8.cf.code.CfInvoke;
@@ -21,20 +24,14 @@
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.CfCode;
-import com.android.tools.r8.graph.DexCallSite;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexMethodHandle;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexProto;
-import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexValue.DexValueMethodHandle;
-import com.android.tools.r8.graph.DexValue.DexValueString;
-import com.android.tools.r8.graph.DexValue.DexValueType;
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.ir.desugar.CfClassSynthesizerDesugaring;
@@ -48,6 +45,7 @@
 import com.android.tools.r8.ir.desugar.LocalStackAllocator;
 import com.android.tools.r8.ir.desugar.ProgramAdditions;
 import com.android.tools.r8.ir.desugar.records.RecordDesugaringEventConsumer.RecordInstructionDesugaringEventConsumer;
+import com.android.tools.r8.ir.desugar.records.RecordRewriterHelper.RecordInvokeDynamic;
 import com.android.tools.r8.ir.synthetic.CallObjectInitCfCodeProvider;
 import com.android.tools.r8.ir.synthetic.RecordCfCodeProvider.RecordEqualsCfCodeProvider;
 import com.android.tools.r8.ir.synthetic.RecordCfCodeProvider.RecordGetFieldsAsObjectsCfCodeProvider;
@@ -100,14 +98,15 @@
     CfCode cfCode = method.getDefinition().getCode().asCfCode();
     for (CfInstruction instruction : cfCode.getInstructions()) {
       if (instruction.isInvokeDynamic() && needsDesugaring(instruction, method)) {
-        prepareInvokeDynamicOnRecord(instruction.asInvokeDynamic(), method, programAdditions);
+        prepareInvokeDynamicOnRecord(instruction.asInvokeDynamic(), programAdditions, method);
       }
     }
   }
 
   private void prepareInvokeDynamicOnRecord(
-      CfInvokeDynamic invokeDynamic, ProgramMethod context, ProgramAdditions programAdditions) {
-    RecordInvokeDynamic recordInvokeDynamic = parseInvokeDynamicOnRecord(invokeDynamic, context);
+      CfInvokeDynamic invokeDynamic, ProgramAdditions programAdditions, ProgramMethod context) {
+    RecordInvokeDynamic recordInvokeDynamic =
+        parseInvokeDynamicOnRecord(invokeDynamic, appView, context);
     if (recordInvokeDynamic.getMethodName() == factory.toStringMethodName
         || recordInvokeDynamic.getMethodName() == factory.hashCodeMethodName) {
       ensureGetFieldsAsObjects(recordInvokeDynamic, programAdditions);
@@ -178,8 +177,8 @@
       return desugarInvokeDynamicOnRecord(
           instruction.asInvokeDynamic(),
           localStackAllocator,
-          context,
           eventConsumer,
+          context,
           methodProcessingContext);
     }
     assert instruction.isInvoke();
@@ -191,71 +190,17 @@
         new CfInvoke(cfInvoke.getOpcode(), newMethod, cfInvoke.isInterface()));
   }
 
-  static class RecordInvokeDynamic {
-
-    private final DexString methodName;
-    private final DexString fieldNames;
-    private final DexField[] fields;
-    private final DexProgramClass recordClass;
-
-    private RecordInvokeDynamic(
-        DexString methodName,
-        DexString fieldNames,
-        DexField[] fields,
-        DexProgramClass recordClass) {
-      this.methodName = methodName;
-      this.fieldNames = fieldNames;
-      this.fields = fields;
-      this.recordClass = recordClass;
-    }
-
-    DexField[] getFields() {
-      return fields;
-    }
-
-    DexProgramClass getRecordClass() {
-      return recordClass;
-    }
-
-    DexString getFieldNames() {
-      return fieldNames;
-    }
-
-    DexString getMethodName() {
-      return methodName;
-    }
-  }
-
-  private RecordInvokeDynamic parseInvokeDynamicOnRecord(
-      CfInvokeDynamic invokeDynamic, ProgramMethod context) {
-    assert needsDesugaring(invokeDynamic, context);
-    DexCallSite callSite = invokeDynamic.getCallSite();
-    DexValueType recordValueType = callSite.bootstrapArgs.get(0).asDexValueType();
-    DexValueString valueString = callSite.bootstrapArgs.get(1).asDexValueString();
-    DexString fieldNames = valueString.getValue();
-    DexField[] fields = new DexField[callSite.bootstrapArgs.size() - 2];
-    for (int i = 2; i < callSite.bootstrapArgs.size(); i++) {
-      DexValueMethodHandle handle = callSite.bootstrapArgs.get(i).asDexValueMethodHandle();
-      fields[i - 2] = handle.value.member.asDexField();
-    }
-    DexProgramClass recordClass =
-        appView.definitionFor(recordValueType.getValue()).asProgramClass();
-    return new RecordInvokeDynamic(callSite.methodName, fieldNames, fields, recordClass);
-  }
-
   private List<CfInstruction> desugarInvokeDynamicOnRecord(
       CfInvokeDynamic invokeDynamic,
       LocalStackAllocator localStackAllocator,
-      ProgramMethod context,
       CfInstructionDesugaringEventConsumer eventConsumer,
+      ProgramMethod context,
       MethodProcessingContext methodProcessingContext) {
-    RecordInvokeDynamic recordInvokeDynamic = parseInvokeDynamicOnRecord(invokeDynamic, context);
+    RecordInvokeDynamic recordInvokeDynamic =
+        parseInvokeDynamicOnRecord(invokeDynamic, appView, context);
     if (recordInvokeDynamic.getMethodName() == factory.toStringMethodName) {
       return desugarInvokeRecordToString(
-          recordInvokeDynamic,
-          localStackAllocator,
-          eventConsumer,
-          methodProcessingContext);
+          recordInvokeDynamic, localStackAllocator, eventConsumer, methodProcessingContext);
     }
     if (recordInvokeDynamic.getMethodName() == factory.hashCodeMethodName) {
       return desugarInvokeRecordHashCode(
@@ -392,7 +337,15 @@
     ArrayList<CfInstruction> instructions = new ArrayList<>();
     instructions.add(new CfInvoke(Opcodes.INVOKESPECIAL, getFieldsAsObjects, false));
     instructions.add(new CfConstClass(recordInvokeDynamic.getRecordClass().type, true));
-    instructions.add(new CfConstString(recordInvokeDynamic.getFieldNames()));
+    if (appView.options().testing.enableRecordModeling
+        && appView.enableWholeProgramOptimizations()) {
+      instructions.add(
+          new CfDexItemBasedConstString(
+              recordInvokeDynamic.getRecordClass().type,
+              recordInvokeDynamic.computeRecordFieldNamesComputationInfo()));
+    } else {
+      instructions.add(new CfConstString(recordInvokeDynamic.getFieldNames()));
+    }
     ProgramMethod programMethod =
         synthesizeRecordHelper(
             recordToStringHelperProto,
@@ -426,9 +379,7 @@
             appView,
             builder -> {
               DexEncodedMethod init = synthesizeRecordInitMethod();
-              builder
-                  .setAbstract()
-                  .setDirectMethods(ImmutableList.of(init));
+              builder.setAbstract().setDirectMethods(ImmutableList.of(init));
             },
             eventConsumer::acceptRecordClass);
   }
@@ -484,75 +435,7 @@
   }
 
   private boolean needsDesugaring(CfInvokeDynamic invokeDynamic, ProgramMethod context) {
-    DexCallSite callSite = invokeDynamic.getCallSite();
-    // 1. Validates this is an invoke-static to ObjectMethods#bootstrap.
-    DexMethodHandle bootstrapMethod = callSite.bootstrapMethod;
-    if (!bootstrapMethod.type.isInvokeStatic()) {
-      return false;
-    }
-    if (bootstrapMethod.member != factory.objectMethodsMembers.bootstrap) {
-      return false;
-    }
-    // From there on we assume in the assertions that the invoke to the library method is
-    // well-formed. If the invoke is not well formed assertions will fail but the execution is
-    // correct.
-    if (bootstrapMethod.isInterface) {
-      assert false
-          : "Invoke-dynamic invoking non interface method ObjectMethods#bootstrap as an interface"
-              + " method.";
-      return false;
-    }
-    // 2. Validate the bootstrapArgs include the record type, the instance field names and
-    // the corresponding instance getters.
-    if (callSite.bootstrapArgs.size() < 2) {
-      assert false
-          : "Invoke-dynamic invoking method ObjectMethods#bootstrap with less than 2 parameters.";
-      return false;
-    }
-    DexValueType recordType = callSite.bootstrapArgs.get(0).asDexValueType();
-    if (recordType == null) {
-      assert false : "Invoke-dynamic invoking method ObjectMethods#bootstrap with an invalid type.";
-      return false;
-    }
-    DexClass recordClass = appView.definitionFor(recordType.getValue());
-    if (recordClass == null || recordClass.isNotProgramClass()) {
-      return false;
-    }
-    DexValueString valueString = callSite.bootstrapArgs.get(1).asDexValueString();
-    if (valueString == null) {
-      assert false
-          : "Invoke-dynamic invoking method ObjectMethods#bootstrap with invalid field names.";
-      return false;
-    }
-    DexString fieldNames = valueString.getValue();
-    assert fieldNames.toString().isEmpty()
-        || (fieldNames.toString().split(";").length == callSite.bootstrapArgs.size() - 2);
-    assert recordClass.instanceFields().size() == callSite.bootstrapArgs.size() - 2;
-    for (int i = 2; i < callSite.bootstrapArgs.size(); i++) {
-      DexValueMethodHandle handle = callSite.bootstrapArgs.get(i).asDexValueMethodHandle();
-      if (handle == null
-          || !handle.value.type.isInstanceGet()
-          || !handle.value.member.isDexField()) {
-        assert false
-            : "Invoke-dynamic invoking method ObjectMethods#bootstrap with invalid getters.";
-        return false;
-      }
-    }
-    // 3. Create the invoke-record instruction.
-    if (callSite.methodName == factory.toStringMethodName) {
-      assert callSite.methodProto == factory.createProto(factory.stringType, recordClass.getType());
-      return true;
-    }
-    if (callSite.methodName == factory.hashCodeMethodName) {
-      assert callSite.methodProto == factory.createProto(factory.intType, recordClass.getType());
-      return true;
-    }
-    if (callSite.methodName == factory.equalsMethodName) {
-      assert callSite.methodProto
-          == factory.createProto(factory.booleanType, recordClass.getType(), factory.objectType);
-      return true;
-    }
-    return false;
+    return isInvokeDynamicOnRecord(invokeDynamic, appView, context);
   }
 
   @SuppressWarnings("ConstantConditions")
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/records/RecordRewriterHelper.java b/src/main/java/com/android/tools/r8/ir/desugar/records/RecordRewriterHelper.java
new file mode 100644
index 0000000..dc589e2
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/records/RecordRewriterHelper.java
@@ -0,0 +1,166 @@
+// Copyright (c) 2021, 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.records;
+
+import com.android.tools.r8.cf.code.CfInvokeDynamic;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexCallSite;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethodHandle;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexProto;
+import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.graph.DexValue.DexValueMethodHandle;
+import com.android.tools.r8.graph.DexValue.DexValueString;
+import com.android.tools.r8.graph.DexValue.DexValueType;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.naming.dexitembasedstring.RecordFieldNamesComputationInfo;
+
+public class RecordRewriterHelper {
+
+  public static boolean isInvokeDynamicOnRecord(
+      CfInvokeDynamic invokeDynamic, AppView<?> appView, ProgramMethod context) {
+    DexItemFactory factory = appView.dexItemFactory();
+    DexCallSite callSite = invokeDynamic.getCallSite();
+    // 1. Validates this is an invoke-static to ObjectMethods#bootstrap.
+    DexMethodHandle bootstrapMethod = callSite.bootstrapMethod;
+    if (!bootstrapMethod.type.isInvokeStatic()) {
+      return false;
+    }
+    if (bootstrapMethod.member != factory.objectMethodsMembers.bootstrap) {
+      return false;
+    }
+    // From there on we assume in the assertions that the invoke to the library method is
+    // well-formed. If the invoke is not well formed assertions will fail but the execution is
+    // correct.
+    if (bootstrapMethod.isInterface) {
+      assert false
+          : "Invoke-dynamic invoking non interface method ObjectMethods#bootstrap as an interface"
+              + " method.";
+      return false;
+    }
+    // 2. Validate the bootstrapArgs include the record type, the instance field names and
+    // the corresponding instance getters.
+    if (callSite.bootstrapArgs.size() < 2) {
+      assert false
+          : "Invoke-dynamic invoking method ObjectMethods#bootstrap with less than 2 parameters.";
+      return false;
+    }
+    DexValueType recordType = callSite.bootstrapArgs.get(0).asDexValueType();
+    if (recordType == null) {
+      assert false : "Invoke-dynamic invoking method ObjectMethods#bootstrap with an invalid type.";
+      return false;
+    }
+    DexClass recordClass = appView.definitionFor(recordType.getValue(), context);
+    if (recordClass == null || recordClass.isNotProgramClass()) {
+      return false;
+    }
+    DexValueString valueString = callSite.bootstrapArgs.get(1).asDexValueString();
+    if (valueString == null) {
+      assert false
+          : "Invoke-dynamic invoking method ObjectMethods#bootstrap with invalid field names.";
+      return false;
+    }
+    DexString fieldNames = valueString.getValue();
+    assert fieldNames.toString().isEmpty()
+        || (fieldNames.toString().split(";").length == callSite.bootstrapArgs.size() - 2);
+    assert recordClass.instanceFields().size() == callSite.bootstrapArgs.size() - 2;
+    for (int i = 2; i < callSite.bootstrapArgs.size(); i++) {
+      DexValueMethodHandle handle = callSite.bootstrapArgs.get(i).asDexValueMethodHandle();
+      if (handle == null
+          || !handle.value.type.isInstanceGet()
+          || !handle.value.member.isDexField()) {
+        assert false
+            : "Invoke-dynamic invoking method ObjectMethods#bootstrap with invalid getters.";
+        return false;
+      }
+    }
+    // 3. Check it matches one of the 3 invokeDynamicOnRecord instruction.
+    if (callSite.methodName == factory.toStringMethodName) {
+      assert callSite.methodProto == factory.createProto(factory.stringType, recordClass.getType());
+      return true;
+    }
+    if (callSite.methodName == factory.hashCodeMethodName) {
+      assert callSite.methodProto == factory.createProto(factory.intType, recordClass.getType());
+      return true;
+    }
+    if (callSite.methodName == factory.equalsMethodName) {
+      assert callSite.methodProto
+          == factory.createProto(factory.booleanType, recordClass.getType(), factory.objectType);
+      return true;
+    }
+    return false;
+  }
+
+  public static RecordInvokeDynamic parseInvokeDynamicOnRecord(
+      CfInvokeDynamic invokeDynamic, AppView<?> appView, ProgramMethod context) {
+    assert isInvokeDynamicOnRecord(invokeDynamic, appView, context);
+    DexCallSite callSite = invokeDynamic.getCallSite();
+    DexValueType recordValueType = callSite.bootstrapArgs.get(0).asDexValueType();
+    DexValueString valueString = callSite.bootstrapArgs.get(1).asDexValueString();
+    DexString fieldNames = valueString.getValue();
+    DexField[] fields = new DexField[callSite.bootstrapArgs.size() - 2];
+    for (int i = 2; i < callSite.bootstrapArgs.size(); i++) {
+      DexValueMethodHandle handle = callSite.bootstrapArgs.get(i).asDexValueMethodHandle();
+      fields[i - 2] = handle.value.member.asDexField();
+    }
+    DexProgramClass recordClass =
+        appView.definitionFor(recordValueType.getValue()).asProgramClass();
+    return new RecordInvokeDynamic(
+        callSite.methodName, callSite.methodProto, fieldNames, fields, recordClass);
+  }
+
+  static class RecordInvokeDynamic {
+
+    private final DexString methodName;
+    private final DexProto methodProto;
+    private final DexString fieldNames;
+    private final DexField[] fields;
+    private final DexProgramClass recordClass;
+
+    private RecordInvokeDynamic(
+        DexString methodName,
+        DexProto methodProto,
+        DexString fieldNames,
+        DexField[] fields,
+        DexProgramClass recordClass) {
+      this.methodName = methodName;
+      this.methodProto = methodProto;
+      this.fieldNames = fieldNames;
+      this.fields = fields;
+      this.recordClass = recordClass;
+    }
+
+    RecordInvokeDynamic withFieldNamesAndFields(DexString fieldNames, DexField[] fields) {
+      return new RecordInvokeDynamic(methodName, methodProto, fieldNames, fields, recordClass);
+    }
+
+    DexField[] getFields() {
+      return fields;
+    }
+
+    DexProgramClass getRecordClass() {
+      return recordClass;
+    }
+
+    DexString getFieldNames() {
+      return fieldNames;
+    }
+
+    DexString getMethodName() {
+      return methodName;
+    }
+
+    DexProto getMethodProto() {
+      return methodProto;
+    }
+
+    RecordFieldNamesComputationInfo computeRecordFieldNamesComputationInfo() {
+      return RecordFieldNamesComputationInfo.forFieldNamesAndFields(getFieldNames(), getFields());
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/naming/IdentifierMinifier.java b/src/main/java/com/android/tools/r8/naming/IdentifierMinifier.java
index a775a72..a22a766 100644
--- a/src/main/java/com/android/tools/r8/naming/IdentifierMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/IdentifierMinifier.java
@@ -19,10 +19,12 @@
 import com.android.tools.r8.graph.DexValue;
 import com.android.tools.r8.graph.DexValue.DexItemBasedValueString;
 import com.android.tools.r8.graph.DexValue.DexValueString;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.desugar.records.RecordCfToCfRewriter;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.ProguardClassFilter;
+import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.ThreadUtils;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
@@ -35,11 +37,13 @@
 
   private final AppView<AppInfoWithLiveness> appView;
   private final ProguardClassFilter adaptClassStrings;
+  private final RecordCfToCfRewriter recordCfToCfRewriter;
   private final NamingLens lens;
 
   IdentifierMinifier(AppView<AppInfoWithLiveness> appView, NamingLens lens) {
     this.appView = appView;
     this.adaptClassStrings = appView.options().getProguardConfiguration().getAdaptClassStrings();
+    this.recordCfToCfRewriter = RecordCfToCfRewriter.create(appView);
     this.lens = lens;
   }
 
@@ -117,12 +121,10 @@
           for (DexEncodedField field : clazz.staticFields()) {
             replaceDexItemBasedConstStringInStaticField(field);
           }
-          clazz
-              .methods(DexEncodedMethod::hasCode)
-              .forEach(this::replaceDexItemBasedConstStringInMethod);
+          clazz.forEachProgramMethodMatching(
+              DexEncodedMethod::hasCode, this::replaceDexItemBasedConstStringInMethod);
         },
-        executorService
-    );
+        executorService);
   }
 
   private void replaceDexItemBasedConstStringInStaticField(DexEncodedField encodedField) {
@@ -137,8 +139,8 @@
     }
   }
 
-  private void replaceDexItemBasedConstStringInMethod(DexEncodedMethod encodedMethod) {
-    Code code = encodedMethod.getCode();
+  private void replaceDexItemBasedConstStringInMethod(ProgramMethod programMethod) {
+    Code code = programMethod.getDefinition().getCode();
     assert code != null;
     if (code.isDexCode()) {
       Instruction[] instructions = code.asDexCode().instructions;
@@ -157,23 +159,23 @@
     } else {
       assert code.isCfCode();
       List<CfInstruction> instructions = code.asCfCode().getInstructions();
-      List<CfInstruction> newInstructions = null;
-      for (int i = 0; i < instructions.size(); ++i) {
-        CfInstruction instruction = instructions.get(i);
-        if (instruction.isDexItemBasedConstString()) {
-          CfDexItemBasedConstString cnst = instruction.asDexItemBasedConstString();
-          DexString replacement =
-              cnst.getNameComputationInfo()
-                  .computeNameFor(cnst.getItem(), appView, appView.graphLens(), lens);
-          if (newInstructions == null) {
-            newInstructions = new ArrayList<>(instructions);
-          }
-          newInstructions.set(i, new CfConstString(replacement));
-        }
-      }
-      if (newInstructions != null) {
-        code.asCfCode().setInstructions(newInstructions);
-      }
+      List<CfInstruction> newInstructions =
+          ListUtils.mapOrElse(
+              instructions,
+              (int i, CfInstruction instruction) -> {
+                if (instruction.isDexItemBasedConstString()) {
+                  CfDexItemBasedConstString cnst = instruction.asDexItemBasedConstString();
+                  return new CfConstString(
+                      cnst.getNameComputationInfo()
+                          .computeNameFor(cnst.getItem(), appView, appView.graphLens(), lens));
+                } else if (recordCfToCfRewriter != null && instruction.isInvokeDynamic()) {
+                  return recordCfToCfRewriter.rewriteRecordInvokeDynamic(
+                      instruction.asInvokeDynamic(), programMethod, lens);
+                }
+                return instruction;
+              },
+              instructions);
+      code.asCfCode().setInstructions(newInstructions);
     }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/naming/dexitembasedstring/NameComputationInfo.java b/src/main/java/com/android/tools/r8/naming/dexitembasedstring/NameComputationInfo.java
index 67e574c..8a16fb0 100644
--- a/src/main/java/com/android/tools/r8/naming/dexitembasedstring/NameComputationInfo.java
+++ b/src/main/java/com/android/tools/r8/naming/dexitembasedstring/NameComputationInfo.java
@@ -27,6 +27,10 @@
         return asClassNameComputationInfo()
             .internalComputeNameFor(rewritten.asDexType(), definitions, namingLens);
       }
+      if (isRecordFieldNamesComputationInfo()) {
+        return asRecordFieldNamesComputationInfo()
+            .internalComputeNameFor(rewritten.asDexType(), definitions, graphLens, namingLens);
+      }
     }
     return namingLens.lookupName(rewritten, definitions.dexItemFactory());
   }
@@ -53,4 +57,12 @@
   public ClassNameComputationInfo asClassNameComputationInfo() {
     return null;
   }
+
+  public boolean isRecordFieldNamesComputationInfo() {
+    return false;
+  }
+
+  public RecordFieldNamesComputationInfo asRecordFieldNamesComputationInfo() {
+    return null;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/naming/dexitembasedstring/RecordFieldNamesComputationInfo.java b/src/main/java/com/android/tools/r8/naming/dexitembasedstring/RecordFieldNamesComputationInfo.java
new file mode 100644
index 0000000..17ac83a
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/naming/dexitembasedstring/RecordFieldNamesComputationInfo.java
@@ -0,0 +1,168 @@
+// Copyright (c) 2021, 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.naming.dexitembasedstring;
+
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexDefinitionSupplier;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.GraphLens;
+import com.android.tools.r8.naming.NamingLens;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.IntFunction;
+
+/**
+ * Specific subclass for Record field names. Record field names are specific DexString instances
+ * used at the Java class file level for Records which encode the record field names in a single
+ * String separated by semi-colon. The computation is able to minify and prune such names.
+ *
+ * <p>Example: record Person(String name, int age) {} The string is: name;age
+ *
+ * <p>The JVM normally generates the Record field names string such as it includes each field name
+ * in the string. However, bytecode manipulation tools may rewrite the field name and not the
+ * string. For this reason we have two subclasses. - MatchingRecordFieldNamesComputationInfo is used
+ * when the name in the string matches the field names, and the R8 compilation is able to minify and
+ * prune the string based on the fields. - MissMatchingRecordFieldNamesComputationInfo is used when
+ * the name in the string does not match the field names, and the R8 compilation is then only able
+ * to prune the fields while maintaining the non-matching field names.
+ */
+public abstract class RecordFieldNamesComputationInfo extends NameComputationInfo<DexType> {
+
+  final DexField[] fields;
+
+  protected RecordFieldNamesComputationInfo(DexField[] fields) {
+    this.fields = fields;
+  }
+
+  private static class MissMatchingRecordFieldNamesComputationInfo
+      extends RecordFieldNamesComputationInfo {
+
+    private final String[] fieldNames;
+
+    private MissMatchingRecordFieldNamesComputationInfo(String[] fieldNames, DexField[] fields) {
+      super(fields);
+      this.fieldNames = fieldNames;
+    }
+
+    @Override
+    public DexString internalComputeNameFor(
+        DexType type,
+        DexDefinitionSupplier definitions,
+        GraphLens graphLens,
+        NamingLens namingLens) {
+      return internalComputeNameFor(type, definitions, graphLens, i -> fieldNames[i]);
+    }
+  }
+
+  private static class MatchingRecordFieldNamesComputationInfo
+      extends RecordFieldNamesComputationInfo {
+
+    public MatchingRecordFieldNamesComputationInfo(DexField[] fields) {
+      super(fields);
+    }
+
+    @Override
+    public DexString internalComputeNameFor(
+        DexType type,
+        DexDefinitionSupplier definitions,
+        GraphLens graphLens,
+        NamingLens namingLens) {
+      return internalComputeNameFor(
+          type,
+          definitions,
+          graphLens,
+          i ->
+              namingLens
+                  .lookupField(
+                      graphLens.getRenamedFieldSignature(fields[i]), definitions.dexItemFactory())
+                  .name
+                  .toString());
+    }
+  }
+
+  static DexString dexStringFromFieldNames(List<String> fieldNames, DexItemFactory factory) {
+    return factory.createString(StringUtils.join(";", fieldNames));
+  }
+
+  public static RecordFieldNamesComputationInfo forFieldNamesAndFields(
+      DexString fieldNames, DexField[] fields) {
+    String fieldNamesString = fieldNames.toString();
+    String[] fieldNamesSplit =
+        fieldNamesString.isEmpty() ? new String[0] : fieldNamesString.split(";");
+    assert fieldNamesSplit.length == fields.length;
+    if (fieldsMatchNames(fieldNamesSplit, fields)) {
+      return new MatchingRecordFieldNamesComputationInfo(fields);
+    }
+    return new MissMatchingRecordFieldNamesComputationInfo(fieldNamesSplit, fields);
+  }
+
+  private static boolean fieldsMatchNames(String[] fieldNames, DexField[] fields) {
+    for (int i = 0; i < fieldNames.length; i++) {
+      if (!(fields[i].name.toString().equals(fieldNames[i]))) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  public DexString internalComputeNameFor(
+      DexType type,
+      DexDefinitionSupplier definitions,
+      GraphLens graphLens,
+      IntFunction<String> nameSupplier) {
+    assert Arrays.stream(fields).allMatch(f -> f.holder == type);
+    DexClass recordClass = definitions.contextIndependentDefinitionFor(type);
+    assert recordClass != null;
+    List<String> names = new ArrayList<>(fields.length);
+    for (int i = 0; i < fields.length; i++) {
+      DexEncodedField recordField =
+          recordClass.lookupInstanceField(graphLens.getRenamedFieldSignature(fields[i]));
+      if (recordField != null) {
+        names.add(nameSupplier.apply(i));
+      } else {
+        // TODO(b/201277582): Temporarily work-around as long as the field values are not also
+        //  shrunk in dex.
+        names.add("<pruned>");
+      }
+    }
+    return dexStringFromFieldNames(names, definitions.dexItemFactory());
+  }
+
+  @Override
+  DexString internalComputeNameFor(
+      DexType reference, DexDefinitionSupplier definitions, NamingLens namingLens) {
+    throw new Unreachable();
+  }
+
+  public abstract DexString internalComputeNameFor(
+      DexType type, DexDefinitionSupplier definitions, GraphLens graphLens, NamingLens namingLens);
+
+  @Override
+  public boolean needsToComputeName() {
+    return true;
+  }
+
+  @Override
+  public boolean needsToRegisterReference() {
+    return false;
+  }
+
+  @Override
+  public boolean isRecordFieldNamesComputationInfo() {
+    return true;
+  }
+
+  @Override
+  public RecordFieldNamesComputationInfo asRecordFieldNamesComputationInfo() {
+    return this;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index ff3878e..24e9259 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -1590,6 +1590,10 @@
     public boolean testEnableTestAssertions = false;
     public boolean keepMetadataInR8IfNotRewritten = true;
 
+    // If set, pruned record fields are not used in hashCode/equals/toString and toString prints
+    // minified field names instead of original field names.
+    public boolean enableRecordModeling = false;
+
     public boolean allowConflictingSyntheticTypes = false;
 
     // Flag to allow processing of resources in D8. A data resource consumer still needs to be
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordShrinkFieldTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordShrinkFieldTest.java
index 7b653ed..df6be44 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/RecordShrinkFieldTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordShrinkFieldTest.java
@@ -29,6 +29,13 @@
   private static final String EXPECTED_RESULT_D8 =
       String.format(EXPECTED_RESULT, "Person", "Person");
   private static final String EXPECTED_RESULT_R8 = String.format(EXPECTED_RESULT, "a", "a");
+  // TODO(b/201277582): These results are temporary while we transition into pruned minified record
+  //  fields.
+  private static final String EXPECTED_RESULT_R8_ADVANCED_DEX =
+      StringUtils.lines(
+          "a[a=Jane Doe, <pruned>=42, <pruned>=-1]", "a[a=Bob, <pruned>=42, <pruned>=-1]");
+  private static final String EXPECTED_RESULT_R8_ADVANCED_CF =
+      StringUtils.lines("a[a=Jane Doe, b=42, c=-1]", "a[a=Bob, b=42, c=-1]");
 
   private final TestParameters parameters;
 
@@ -83,6 +90,43 @@
   }
 
   @Test
+  public void testR8AdvancedShrinking() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClassFileData(PROGRAM_DATA)
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(MAIN_TYPE)
+        .addOptionsModification(opt -> opt.testing.enableRecordModeling = true)
+        .addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
+        .compile()
+        .inspect(this::assertSingleField)
+        .run(parameters.getRuntime(), MAIN_TYPE)
+        .assertSuccessWithOutput(EXPECTED_RESULT_R8_ADVANCED_DEX);
+  }
+
+  @Test
+  public void testR8CfThenDexAdvancedShrinking() throws Exception {
+    Path desugared =
+        testForR8(Backend.CF)
+            .addProgramClassFileData(PROGRAM_DATA)
+            .setMinApi(parameters.getApiLevel())
+            .addKeepMainRule(MAIN_TYPE)
+            .addLibraryFiles(RecordTestUtils.getJdk15LibraryFiles(temp))
+            .addOptionsModification(opt -> opt.testing.enableRecordModeling = true)
+            .addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
+            .compile()
+            .writeToZip();
+    testForR8(parameters.getBackend())
+        .addProgramFiles(desugared)
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(MAIN_TYPE)
+        .addOptionsModification(TestingOptions::allowExperimentClassFileVersion)
+        .compile()
+        .inspect(this::assertSingleField)
+        .run(parameters.getRuntime(), MAIN_TYPE)
+        .assertSuccessWithOutput(EXPECTED_RESULT_R8_ADVANCED_CF);
+  }
+
+  @Test
   public void testR8CfThenDex() throws Exception {
     Path desugared =
         testForR8(Backend.CF)