diff a/test/hotspot/jtreg/compiler/codegen/TestRedundantLea.java b/test/hotspot/jtreg/compiler/codegen/TestRedundantLea.java
--- a/test/hotspot/jtreg/compiler/codegen/TestRedundantLea.java
+++ b/test/hotspot/jtreg/compiler/codegen/TestRedundantLea.java
@@ -79,10 +79,20 @@
  * @modules jdk.compiler/com.sun.tools.javac.util
  * @library /test/lib /
  * @run driver compiler.codegen.TestRedundantLea StoreNParallel
  */
 
+/*
+ * @test id=Spill
+ * @bug 8020282
+ * @summary Test that we do not generate redundant leas and remove related spills on x86.
+ * @requires os.simpleArch == "x64"
+ * @modules jdk.compiler/com.sun.tools.javac.util
+ * @library /test/lib /
+ * @run driver compiler.codegen.TestRedundantLea Spill
+ */
+
 
 package compiler.codegen;
 
 import java.util.concurrent.atomic.*;
 import java.util.regex.Matcher;
@@ -127,10 +137,13 @@
             }
             case "StoreNParallel" -> {
                 framework = new TestFramework(StoreNTest.class);
                 framework.addFlags("-XX:+UseParallelGC");
             }
+            case "Spill" -> {
+                framework = new TestFramework(SpillTest.class);
+            }
             default -> {
                 throw new IllegalArgumentException("Unknown test name \"" + testName +"\"");
             }
         }
 
@@ -272,25 +285,21 @@
     }
 }
 
 // The matcher generates leaP* rules for storing an object in an array of objects
 // at a constant offset, but only when using the Serial or Parallel GC.
-// Here, we can also manipulate the offset such that we get a leaP32Narrow rule
-// and we can demonstrate that the peephole also removes simple cases of unneeded
-// spills.
+// Here, we can also manipulate the offset such that we get a leaP32Narrow rule.
 class StoreNTest {
     private static final int SOME_SIZE = 42;
     private static final int OFFSET8BIT_IDX = 3;
     private static final int OFFSET32BIT_IDX = 33;
 
     private static final Object CURRENT = new Object();
     private static final Object OTHER = new Object();
 
     private StoreNTestHelper[] classArr8bit = new StoreNTestHelper[SOME_SIZE];
     private StoreNTestHelper[] classArr32bit = new StoreNTestHelper[SOME_SIZE];
-    private Object[] objArr8bit = new Object[SOME_SIZE];
-    private Object[] objArr32bit = new Object[SOME_SIZE];
 
     @Test
     @IR(counts = {IRNode.LEA_P, "=2"},
         phase = {CompilePhase.FINAL_CODE},
         applyIfPlatform = {"mac", "false"})
@@ -300,17 +309,10 @@
         applyIf = {"OptoPeephole", "false"})
     // Test that the peephole worked for leaPCompressedOopOffset
     @IR(failOn = {IRNode.DECODE_HEAP_OOP_NOT_NULL},
         phase = {CompilePhase.FINAL_CODE},
         applyIf = {"OptoPeephole", "true"})
-    // Test that the peephole removes a spill.
-    @IR(counts = {IRNode.MEM_TO_REG_SPILL_COPY, "=4"},
-        phase = {CompilePhase.FINAL_CODE},
-        applyIfAnd ={"OptoPeephole", "false", "UseCompactObjectHeaders", "false"})
-    @IR(counts = {IRNode.MEM_TO_REG_SPILL_COPY, "=3"},
-        phase = {CompilePhase.FINAL_CODE},
-        applyIfAnd ={"OptoPeephole", "true", "UseCompactObjectHeaders", "false"})
     public void testRemoveSpill() {
         this.classArr8bit[OFFSET8BIT_IDX] = new StoreNTestHelper(CURRENT, OTHER);
         this.classArr32bit[OFFSET32BIT_IDX] = new StoreNTestHelper(OTHER, CURRENT);
     }
 
@@ -329,50 +331,67 @@
         applyIf = {"OptoPeephole", "true"})
     public void testPhiSpill() {
         this.classArr8bit[OFFSET8BIT_IDX] = new StoreNTestHelper(CURRENT, OTHER);
         this.classArr8bit[OFFSET32BIT_IDX] = new StoreNTestHelper(CURRENT, OTHER);
     }
+}
+
+class StoreNTestHelper {
+    Object o1;
+    Object o2;
+
+    public StoreNTestHelper(Object o1, Object o2) {
+        this.o1 = o1;
+        this.o2 = o2;
+    }
+}
+
+// This test validates that the peephole removes simple spills.
+// The code for the test originates from compiler/escapeAnalysis/Test6775880.java.
+class SpillTest {
+    int cnt;
+    int b[];
+    String s;
+
+    @Run(test = "test")
+    public static void run() {
+        SpillTest t = new SpillTest();
+        t.cnt = 3;
+        t.b = new int[3];
+        t.b[0] = 0;
+        t.b[1] = 1;
+        t.b[2] = 2;
+        int j = 0;
+        t.s = "";
+        t.test();
+    }
 
     @Test
+    // TODO: Make tests more precise
     @IR(counts = {IRNode.LEA_P, "=2"},
         phase = {CompilePhase.FINAL_CODE},
         applyIfPlatform = {"mac", "false"})
     // Negative test
-    @IR(counts = {IRNode.DECODE_HEAP_OOP_NOT_NULL, "=2"},
+    @IR(counts = {IRNode.DECODE_HEAP_OOP_NOT_NULL, ">=2"},
         phase = {CompilePhase.FINAL_CODE},
         applyIf = {"OptoPeephole", "false"})
-    // Test that the peephole worked for leaPCompressedOopOffset
-    @IR(failOn = {IRNode.DECODE_HEAP_OOP_NOT_NULL},
+    @IR(counts = {IRNode.DECODE_HEAP_OOP_NOT_NULL, "<=2"},
         phase = {CompilePhase.FINAL_CODE},
         applyIf = {"OptoPeephole", "true"})
-    public void testNoAlloc() {
-        this.objArr8bit[OFFSET8BIT_IDX] = CURRENT;
-        this.objArr32bit[OFFSET32BIT_IDX] = OTHER;
-    }
-
-    @Test
-    @IR(counts = {IRNode.LEA_P, "=2"},
-        phase = {CompilePhase.FINAL_CODE},
-        applyIfPlatform = {"mac", "false"})
-    // Negative test
-    @IR(counts = {IRNode.DECODE_HEAP_OOP_NOT_NULL, "=1"},
+    // Test that the peephole removes a spill.
+    @IR(counts = {IRNode.MEM_TO_REG_SPILL_COPY, ">=18"},
         phase = {CompilePhase.FINAL_CODE},
         applyIf = {"OptoPeephole", "false"})
-    // Test that the peephole worked for leaPCompressedOopOffset
-    @IR(failOn = {IRNode.DECODE_HEAP_OOP_NOT_NULL},
+    @IR(counts = {IRNode.MEM_TO_REG_SPILL_COPY, ">=16"},
         phase = {CompilePhase.FINAL_CODE},
         applyIf = {"OptoPeephole", "true"})
-    public void testNoAllocSameArray() {
-        this.objArr8bit[OFFSET8BIT_IDX] = CURRENT;
-        this.objArr8bit[OFFSET32BIT_IDX] = OTHER;
-    }
-}
-
-class StoreNTestHelper {
-    Object o1;
-    Object o2;
-
-    public StoreNTestHelper(Object o1, Object o2) {
-        this.o1 = o1;
-        this.o2 = o2;
+    String test() {
+        String res = "";
+        for (int i = 0; i < cnt; i++) {
+            if (i != 0) {
+                res = res + ".";
+            }
+            res = res + b[i];
+        }
+        return res;
     }
 }
