diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index 4e2f94e..00f2da3 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -438,6 +438,7 @@
   public final DexType classArrayType = createStaticallyKnownType(classArrayDescriptor);
   public final DexType enumType = createStaticallyKnownType(enumDescriptor);
   public final DexType annotationType = createStaticallyKnownType(annotationDescriptor);
+  public final DexType arraysType = createStaticallyKnownType(arraysDescriptor);
   public final DexType objectsType = createStaticallyKnownType(objectsDescriptor);
   public final DexType collectionsType = createStaticallyKnownType(collectionsDescriptor);
   public final DexType iterableType = createStaticallyKnownType(iterableDescriptor);
@@ -1407,6 +1408,8 @@
   public class JavaUtilArraysMethods {
 
     public final DexMethod asList;
+    public final DexMethod hashCode =
+        createMethod(arraysType, createProto(intType, objectArrayType), "hashCode");
     public final DexMethod equalsObjectArray;
 
     private JavaUtilArraysMethods() {
@@ -1794,6 +1797,8 @@
 
     public final DexMethod equals =
         createMethod(objectsType, createProto(booleanType, objectType, objectType), "equals");
+    public final DexMethod hash =
+        createMethod(objectsType, createProto(intType, objectArrayType), "hash");
     public final DexMethod hashCode =
         createMethod(objectsType, createProto(intType, objectType), "hashCode");
     public final DexMethod isNull =
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyScheduler.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyScheduler.java
index 45a4545..9e1a36e 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyScheduler.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/PolicyScheduler.java
@@ -66,8 +66,7 @@
 public class PolicyScheduler {
 
   public static List<Policy> getPolicies(
-      AppView<?> appView,
-      RuntimeTypeCheckInfo runtimeTypeCheckInfo) {
+      AppView<?> appView, RuntimeTypeCheckInfo runtimeTypeCheckInfo) {
     if (appView.hasClassHierarchy()) {
       return getPoliciesForR8(appView.withClassHierarchy(), runtimeTypeCheckInfo);
     } else {
diff --git a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
index dbb9d1a..1eb69e7 100644
--- a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
@@ -179,7 +179,7 @@
   public InstructionListIterator addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
       IRCode code,
       BasicBlockIterator blockIterator,
-      Collection<Instruction> instructionsToAdd,
+      Collection<? extends Instruction> instructionsToAdd,
       InternalOptions options) {
     // Assert that we are not inserting after the final jump, and also store peekNext() for later.
     Instruction origNext = null;
@@ -196,14 +196,14 @@
       BasicBlockInstructionListIterator dstIterator,
       IRCode code,
       BasicBlockIterator blockIterator,
-      Collection<Instruction> instructionsToAdd,
+      Collection<? extends Instruction> instructionsToAdd,
       InternalOptions options) {
     if (!dstIterator.block.hasCatchHandlers() || instructionsToAdd.isEmpty()) {
       dstIterator.addAll(instructionsToAdd);
       return dstIterator;
     }
 
-    Iterator<Instruction> srcIterator = instructionsToAdd.iterator();
+    Iterator<? extends Instruction> srcIterator = instructionsToAdd.iterator();
 
     // If the throwing instruction is before the cursor, then we must split the block first.
     // If there is one afterwards, we can add instructions and when we split, the throwing one
diff --git a/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java
index 0b2be34..6b33cca 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IRCodeInstructionListIterator.java
@@ -238,7 +238,7 @@
   public InstructionListIterator addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
       IRCode code,
       BasicBlockIterator blockIterator,
-      Collection<Instruction> instructionsToAdd,
+      Collection<? extends Instruction> instructionsToAdd,
       InternalOptions options) {
     return instructionIterator.addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
         code, blockIterator, instructionsToAdd, options);
diff --git a/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
index e612141..19c675b 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InstructionListIterator.java
@@ -36,13 +36,13 @@
     }
   }
 
-  default void addAll(Collection<Instruction> instructions) {
+  default void addAll(Collection<? extends Instruction> instructions) {
     for (Instruction instruction : instructions) {
       add(instruction);
     }
   }
 
-  default boolean addUntilThrowing(Iterator<Instruction> srcIterator) {
+  default boolean addUntilThrowing(Iterator<? extends Instruction> srcIterator) {
     while (srcIterator.hasNext()) {
       // Add all non-throwing instructions up until the first throwing instruction.
       Instruction instruction = srcIterator.next();
@@ -57,7 +57,7 @@
   InstructionListIterator addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
       IRCode code,
       BasicBlockIterator blockIterator,
-      Collection<Instruction> instructionsToAdd,
+      Collection<? extends Instruction> instructionsToAdd,
       InternalOptions options);
 
   default InstructionListIterator addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
diff --git a/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java
index 0bb697e..e3ac085 100644
--- a/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/LinearFlowInstructionListIterator.java
@@ -199,7 +199,7 @@
   public InstructionListIterator addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
       IRCode code,
       BasicBlockIterator blockIterator,
-      Collection<Instruction> instructionsToAdd,
+      Collection<? extends Instruction> instructionsToAdd,
       InternalOptions options) {
     return currentBlockIterator.addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
         code, blockIterator, instructionsToAdd, options);
diff --git a/src/main/java/com/android/tools/r8/ir/code/NewArrayFilled.java b/src/main/java/com/android/tools/r8/ir/code/NewArrayFilled.java
index 11dce59..c5d6c05 100644
--- a/src/main/java/com/android/tools/r8/ir/code/NewArrayFilled.java
+++ b/src/main/java/com/android/tools/r8/ir/code/NewArrayFilled.java
@@ -38,6 +38,10 @@
     this.type = type;
   }
 
+  public static Builder builder() {
+    return new Builder();
+  }
+
   @Override
   public int opcode() {
     return Opcodes.NEW_ARRAY_FILLED;
@@ -241,4 +245,30 @@
   public void buildLir(LirBuilder<Value, ?> builder) {
     builder.addNewArrayFilled(getArrayType(), arguments());
   }
+
+  public static class Builder extends BuilderBase<Builder, NewArrayFilled> {
+
+    private List<Value> elements;
+    private DexType type;
+
+    public Builder setElements(List<Value> elements) {
+      this.elements = elements;
+      return this;
+    }
+
+    public Builder setType(DexType type) {
+      this.type = type;
+      return this;
+    }
+
+    @Override
+    public NewArrayFilled build() {
+      return amend(new NewArrayFilled(type, outValue, elements));
+    }
+
+    @Override
+    public Builder self() {
+      return this;
+    }
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/backports/ObjectsMethodRewrites.java b/src/main/java/com/android/tools/r8/ir/desugar/backports/ObjectsMethodRewrites.java
index 20998db..96be152 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/backports/ObjectsMethodRewrites.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/backports/ObjectsMethodRewrites.java
@@ -9,7 +9,6 @@
 import com.android.tools.r8.cf.code.CfStackInstruction;
 import com.android.tools.r8.cf.code.CfStackInstruction.Opcode;
 import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.desugar.BackportedMethodRewriter.FullMethodInvokeRewriter;
 import com.android.tools.r8.ir.desugar.BackportedMethodRewriter.MethodInvokeRewriter;
 import com.android.tools.r8.ir.desugar.LocalStackAllocator;
@@ -20,13 +19,8 @@
 public final class ObjectsMethodRewrites {
 
   public static MethodInvokeRewriter rewriteToArraysHashCode() {
-    return (invoke, factory) -> {
-      DexType arraysType = factory.createType(factory.arraysDescriptor);
-      return new CfInvoke(
-          Opcodes.INVOKESTATIC,
-          factory.createMethod(arraysType, invoke.getMethod().proto, "hashCode"),
-          false);
-    };
+    return (invoke, factory) ->
+        new CfInvoke(Opcodes.INVOKESTATIC, factory.javaUtilArraysMethods.hashCode, false);
   }
 
   public static MethodInvokeRewriter rewriteRequireNonNull() {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerImpl.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerImpl.java
index 3470908..4734657 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerImpl.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerImpl.java
@@ -1268,16 +1268,17 @@
       assert false;
       return Reason.INVALID_INVOKE_NEW_ARRAY;
     }
-    if (enumClass.type.isNotIdenticalTo(arrayBaseType.getClassType())) {
+    if (enumClass.getType().isIdenticalTo(arrayBaseType.getClassType())) {
+      if (Iterables.all(
+          newArrayFilled.arguments(), argument -> isAssignableToArray(argument, arrayBaseType))) {
+        return Reason.ELIGIBLE;
+      }
       return Reason.INVALID_INVOKE_NEW_ARRAY;
     }
-
-    for (Value value : newArrayFilled.inValues()) {
-      if (!isAssignableToArray(value, arrayBaseType)) {
-        return Reason.INVALID_INVOKE_NEW_ARRAY;
-      }
+    if (EnumUnboxerUtils.isArrayUsedOnlyForHashCode(newArrayFilled, factory)) {
+      return Reason.ELIGIBLE;
     }
-    return Reason.ELIGIBLE;
+    return Reason.INVALID_INVOKE_NEW_ARRAY;
   }
 
   private Reason analyzeCheckCastUser(CheckCast checkCast) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerUtils.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerUtils.java
new file mode 100644
index 0000000..77d819f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxerUtils.java
@@ -0,0 +1,28 @@
+// Copyright (c) 2024, 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.optimize.enums;
+
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.ir.code.InvokeStatic;
+import com.android.tools.r8.ir.code.NewArrayFilled;
+import com.android.tools.r8.ir.code.Value;
+
+public class EnumUnboxerUtils {
+
+  public static boolean isArrayUsedOnlyForHashCode(
+      NewArrayFilled newArrayFilled, DexItemFactory factory) {
+    Value array = newArrayFilled.outValue();
+    if (!array.hasSingleUniqueUser() || array.hasPhiUsers()) {
+      return false;
+    }
+    InvokeStatic invoke = array.singleUniqueUser().asInvokeStatic();
+    if (invoke == null) {
+      return false;
+    }
+    DexMethod invokedMethod = invoke.getInvokedMethod();
+    return invokedMethod.isIdenticalTo(factory.javaUtilArraysMethods.hashCode)
+        || invokedMethod.isIdenticalTo(factory.objectsMethods.hash);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCfMethods.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCfMethods.java
index 53e7b32..f5eeee2 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCfMethods.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCfMethods.java
@@ -11,6 +11,7 @@
 import com.android.tools.r8.cf.code.CfArithmeticBinop;
 import com.android.tools.r8.cf.code.CfArrayLength;
 import com.android.tools.r8.cf.code.CfArrayStore;
+import com.android.tools.r8.cf.code.CfConstNull;
 import com.android.tools.r8.cf.code.CfConstNumber;
 import com.android.tools.r8.cf.code.CfFrame;
 import com.android.tools.r8.cf.code.CfGoto;
@@ -43,9 +44,52 @@
 public final class EnumUnboxingCfMethods {
 
   public static void registerSynthesizedCodeReferences(DexItemFactory factory) {
+    factory.createSynthesizedType("Ljava/lang/Integer;");
     factory.createSynthesizedType("Ljava/lang/NullPointerException;");
   }
 
+  public static CfCode EnumUnboxingMethods_boxedOrdinalOrNull(
+      DexItemFactory factory, DexMethod method) {
+    CfLabel label0 = new CfLabel();
+    CfLabel label1 = new CfLabel();
+    CfLabel label2 = new CfLabel();
+    CfLabel label3 = new CfLabel();
+    return new CfCode(
+        method.holder,
+        2,
+        1,
+        ImmutableList.of(
+            label0,
+            new CfLoad(ValueType.INT, 0),
+            new CfIf(IfType.NE, ValueType.INT, label1),
+            new CfConstNull(),
+            new CfGoto(label2),
+            label1,
+            new CfFrame(
+                new Int2ObjectAVLTreeMap<>(new int[] {0}, new FrameType[] {FrameType.intType()})),
+            new CfLoad(ValueType.INT, 0),
+            new CfConstNumber(1, ValueType.INT),
+            new CfArithmeticBinop(CfArithmeticBinop.Opcode.Sub, NumericType.INT),
+            new CfInvoke(
+                184,
+                factory.createMethod(
+                    factory.createType("Ljava/lang/Integer;"),
+                    factory.createProto(factory.createType("Ljava/lang/Integer;"), factory.intType),
+                    factory.createString("valueOf")),
+                false),
+            label2,
+            new CfFrame(
+                new Int2ObjectAVLTreeMap<>(new int[] {0}, new FrameType[] {FrameType.intType()}),
+                new ArrayDeque<>(
+                    Arrays.asList(
+                        FrameType.initializedNonNullReference(
+                            factory.createType("Ljava/lang/Integer;"))))),
+            new CfReturn(ValueType.OBJECT),
+            label3),
+        ImmutableList.of(),
+        ImmutableList.of());
+  }
+
   public static CfCode EnumUnboxingMethods_compareTo(DexItemFactory factory, DexMethod method) {
     CfLabel label0 = new CfLabel();
     CfLabel label1 = new CfLabel();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
index da575cd..aabff86 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
@@ -6,6 +6,7 @@
 
 import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
 import static com.android.tools.r8.ir.analysis.type.Nullability.maybeNull;
+import static com.android.tools.r8.ir.optimize.enums.EnumUnboxerUtils.isArrayUsedOnlyForHashCode;
 
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClassAndMethod;
@@ -40,6 +41,7 @@
 import com.android.tools.r8.ir.code.NewArrayFilled;
 import com.android.tools.r8.ir.code.NewUnboxedEnumInstance;
 import com.android.tools.r8.ir.code.Phi;
+import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.StaticGet;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.conversion.MethodProcessor;
@@ -56,6 +58,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.IdentityHashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -232,11 +235,61 @@
         }
       }
     }
+    if (code.metadata().mayHaveNewArrayFilled()) {
+      fixupPrimitiveElementsOfNonPrimitiveNewArrayFilled(code, convertedEnums, eventConsumer);
+    }
     code.removeRedundantBlocks();
     assert code.isConsistentSSABeforeTypesAreCorrect(appView);
     return affectedPhis;
   }
 
+  private void fixupPrimitiveElementsOfNonPrimitiveNewArrayFilled(
+      IRCode code,
+      Map<Instruction, DexType> convertedEnums,
+      EnumUnboxerMethodProcessorEventConsumer eventConsumer) {
+    BasicBlockIterator blocks = code.listIterator();
+    while (blocks.hasNext()) {
+      BasicBlock block = blocks.next();
+      InstructionListIterator instructionIterator = block.listIterator(code);
+      NewArrayFilled newArrayFilled;
+      while ((newArrayFilled = instructionIterator.nextUntil(Instruction::isNewArrayFilled))
+          != null) {
+        if (isArrayUsedOnlyForHashCode(newArrayFilled, factory)) {
+          // Insert a box operation.
+          Map<Value, InvokeStatic> argumentsToBox = new LinkedHashMap<>();
+          for (int argumentIndex = 0;
+              argumentIndex < newArrayFilled.arguments().size();
+              argumentIndex++) {
+            Value argument = newArrayFilled.getArgument(argumentIndex);
+            Position position = newArrayFilled.getPosition();
+            if (getEnumClassTypeOrNull(argument, convertedEnums) != null) {
+              InvokeStatic boxInstruction =
+                  argumentsToBox.computeIfAbsent(
+                      argument,
+                      a ->
+                          InvokeStatic.builder()
+                              .setFreshOutValue(code, factory.boxedIntType.toTypeElement(appView))
+                              .setSingleArgument(a)
+                              .setMethod(
+                                  getSharedUtilityClass()
+                                      .ensureBoxedOrdinalOrNullMethod(
+                                          appView, code.context(), eventConsumer))
+                              .setPosition(position)
+                              .build());
+              newArrayFilled.replaceValue(argumentIndex, boxInstruction.outValue());
+            }
+          }
+          if (!argumentsToBox.isEmpty()) {
+            instructionIterator.previous();
+            instructionIterator =
+                instructionIterator.addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
+                    code, blocks, argumentsToBox.values(), options);
+          }
+        }
+      }
+    }
+  }
+
   private void rewriteArrayAccess(
       IRCode code,
       Set<Phi> affectedPhis,
@@ -498,6 +551,19 @@
       Map<Instruction, DexType> convertedEnums,
       InstructionListIterator instructionIterator) {
     DexType arrayBaseType = newArrayFilled.getArrayType().toBaseType(factory);
+    if (isArrayUsedOnlyForHashCode(newArrayFilled, factory)) {
+      DexType rewrittenArrayType =
+          newArrayFilled.getArrayType().replaceBaseType(factory.objectType, factory);
+      NewArrayFilled rewrittenNewArrayFilled =
+          NewArrayFilled.builder()
+              .setElements(newArrayFilled.arguments())
+              .setFreshOutValue(
+                  code, rewrittenArrayType.toTypeElement(appView, definitelyNotNull()))
+              .setType(rewrittenArrayType)
+              .build();
+      instructionIterator.replaceCurrentInstruction(rewrittenNewArrayFilled);
+      return;
+    }
     if (!unboxedEnumsData.isUnboxedEnum(arrayBaseType)) {
       return;
     }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/SharedEnumUnboxingUtilityClass.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/SharedEnumUnboxingUtilityClass.java
index 37c814d..07dfc5e 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/SharedEnumUnboxingUtilityClass.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/SharedEnumUnboxingUtilityClass.java
@@ -74,6 +74,7 @@
     ensureEqualsMethod(appView);
     ensureObjectsEqualsMethod(appView);
     ensureOrdinalMethod(appView);
+    ensureBoxedOrdinalOrNullMethod(appView);
   }
 
   public ProgramMethod ensureCheckNotZeroMethod(
@@ -189,6 +190,25 @@
         method -> EnumUnboxingCfMethods.EnumUnboxingMethods_ordinal(dexItemFactory, method));
   }
 
+  public ProgramMethod ensureBoxedOrdinalOrNullMethod(
+      AppView<AppInfoWithLiveness> appView,
+      ProgramMethod context,
+      EnumUnboxerMethodProcessorEventConsumer eventConsumer) {
+    ProgramMethod method = ensureBoxedOrdinalOrNullMethod(appView);
+    eventConsumer.acceptEnumUnboxerSharedUtilityClassMethodContext(method, context);
+    return method;
+  }
+
+  private ProgramMethod ensureBoxedOrdinalOrNullMethod(AppView<AppInfoWithLiveness> appView) {
+    DexItemFactory dexItemFactory = appView.dexItemFactory();
+    return internalEnsureMethod(
+        appView,
+        dexItemFactory.createString("boxedOrdinalOrNull"),
+        dexItemFactory.createProto(dexItemFactory.boxedIntType, dexItemFactory.intType),
+        method ->
+            EnumUnboxingCfMethods.EnumUnboxingMethods_boxedOrdinalOrNull(dexItemFactory, method));
+  }
+
   private ProgramMethod internalEnsureMethod(
       AppView<AppInfoWithLiveness> appView,
       DexString methodName,
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumObjectsHashCodeTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumObjectsHashCodeTest.java
new file mode 100644
index 0000000..ebca151
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumObjectsHashCodeTest.java
@@ -0,0 +1,122 @@
+// Copyright (c) 2024, 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.enumunboxing;
+
+import com.android.tools.r8.KeepConstantArguments;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.util.Objects;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class EnumObjectsHashCodeTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(MyEnum.class))
+        .enableConstantArgumentAnnotations()
+        .enableInliningAnnotations()
+        .setMinApi(parameters)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("31", "70154", "31", "null", "31", "31", "31", "961");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      testFromGetter();
+      testMixed();
+      testNull(MyEnum.getNull());
+      testNullUnboxed();
+      testParam(MyEnum.getA());
+      testPhi();
+      testRepeated();
+    }
+
+    @NeverInline
+    static void testFromGetter() {
+      System.out.println(Objects.hash(MyEnum.getA()));
+    }
+
+    @NeverInline
+    static void testMixed() {
+      System.out.println(Objects.hash(new A(), MyEnum.A, MyEnum.B));
+    }
+
+    @NeverInline
+    static void testNull(MyEnum e) {
+      System.out.println(Objects.hash(e));
+    }
+
+    @NeverInline
+    static void testNullUnboxed() {
+      MyEnum e = null;
+      MyEnum.print(e);
+      System.out.println(Objects.hash(e));
+    }
+
+    @NeverInline
+    static void testParam(MyEnum e) {
+      System.out.println(Objects.hash(e));
+    }
+
+    @NeverInline
+    static void testPhi() {
+      MyEnum e = System.currentTimeMillis() > 0 ? MyEnum.A : MyEnum.B;
+      System.out.println(Objects.hash(e));
+    }
+
+    @NeverInline
+    static void testRepeated() {
+      System.out.println(Objects.hash(MyEnum.A, MyEnum.A));
+    }
+  }
+
+  static class A {
+
+    @Override
+    public int hashCode() {
+      return 42;
+    }
+  }
+
+  enum MyEnum {
+    A,
+    B;
+
+    @NeverInline
+    static MyEnum getA() {
+      return System.currentTimeMillis() > 0 ? A : B;
+    }
+
+    @NeverInline
+    static MyEnum getNull() {
+      return System.currentTimeMillis() > 0 ? null : A;
+    }
+
+    @KeepConstantArguments
+    @NeverInline
+    static void print(MyEnum e) {
+      System.out.println(e != null ? e.name() : "null");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingMethods.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingMethods.java
index 48818ec..c56421a 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingMethods.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingMethods.java
@@ -9,6 +9,10 @@
 // are different on each Enum implementation.
 public class EnumUnboxingMethods {
 
+  public static Integer boxedOrdinalOrNull(int unboxedEnum) {
+    return unboxedEnum == 0 ? null : unboxedEnum - 1;
+  }
+
   // An enum is unboxed to ordinal + 1.
   // For example, enum E {A,B}, is unboxed to null -> 0, A -> 1, B-> 2.
   // Computing the ordinal of an unboxed enum throws a null pointer exception on 0,
diff --git a/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java b/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java
index 02dc773..9dc6503 100644
--- a/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/regalloc/RegisterMoveSchedulerTest.java
@@ -205,7 +205,7 @@
     public InstructionListIterator addPossiblyThrowingInstructionsToPossiblyThrowingBlock(
         IRCode code,
         BasicBlockIterator blockIterator,
-        Collection<Instruction> instructionsToAdd,
+        Collection<? extends Instruction> instructionsToAdd,
         InternalOptions options) {
       throw new Unimplemented();
     }