Find better split positions in the register allocator.

In a standard if/else control flow graph, this avoids
doing a move in one branch if the other branch decided
to move an interval.

This also needs a new register hint kind, which is what
was the location of the interval at the predecessor block.

Change-Id: I18b78264587b4d693540fbb5e014d12df2add3e2

3 files changed, 142 insertions, 0 deletions

diff --git a/test/484-checker-register-hints/expected.txt b/test/484-checker-register-hints/expected.txt
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/test/484-checker-register-hints/expected.txt
diff --git a/test/484-checker-register-hints/info.txt b/test/484-checker-register-hints/info.txt
new file mode 100644
index 0000000000..8923680edc
--- /dev/null
+++ b/test/484-checker-register-hints/info.txt
@@ -0,0 +1,4 @@
+Checks that the register allocator does not punish other
+blocks because one block forced spilling. The block that
+forces the spilling should restore the registers at the merge
+point.
diff --git a/test/484-checker-register-hints/src/Main.java b/test/484-checker-register-hints/src/Main.java
new file mode 100644
index 0000000000..33952d9f7e
--- /dev/null
+++ b/test/484-checker-register-hints/src/Main.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public class Main {
+
+  // CHECK-START: void Main.test1(boolean, int, int, int, int, int) register (after)
+  // CHECK:       name "B0"
+  // CHECK-NOT:     ParallelMove
+  // CHECK:       name "B1"
+  // CHECK-NOT:   end_block
+  // CHECK:         If
+  // CHECK-NOT:     ParallelMove
+  // CHECK:       name "B3"
+  // CHECK-NOT:   end_block
+  // CHECK:         ArraySet
+  // We could check here that there is a parallel move, but it's only valid
+  // for some architectures (for example x86), as other architectures may
+  // not do move at all.
+  // CHECK:       end_block
+  // CHECK-NOT:     ParallelMove
+
+  public static void test1(boolean z, int a, int b, int c, int d, int m) {
+    int e = live1;
+    int f = live2;
+    int g = live3;
+    if (z) {
+    } else {
+      // Create enough live instructions to force spilling on x86.
+      int h = live4;
+      int i = live5;
+      array[2] = e + i + h;
+      array[3] = f + i + h;
+      array[4] = g + i + h;
+      array[0] = h;
+      array[1] = i + h;
+
+    }
+    live1 = e + f + g;
+  }
+
+  // CHECK-START: void Main.test2(boolean, int, int, int, int, int) register (after)
+  // CHECK:       name "B0"
+  // CHECK-NOT:     ParallelMove
+  // CHECK:       name "B1"
+  // CHECK-NOT:   end_block
+  // CHECK:         If
+  // CHECK-NOT:     ParallelMove
+  // CHECK:       name "B3"
+  // CHECK-NOT:   end_block
+  // CHECK:         ArraySet
+  // We could check here that there is a parallel move, but it's only valid
+  // for some architectures (for example x86), as other architectures may
+  // not do move at all.
+  // CHECK:       end_block
+  // CHECK-NOT:     ParallelMove
+
+  public static void test2(boolean z, int a, int b, int c, int d, int m) {
+    int e = live1;
+    int f = live2;
+    int g = live3;
+    if (z) {
+      if (y) {
+        int h = live4;
+        int i = live5;
+        array[2] = e + i + h;
+        array[3] = f + i + h;
+        array[4] = g + i + h;
+        array[0] = h;
+        array[1] = i + h;
+      }
+    }
+    live1 = e + f + g;
+  }
+
+  // CHECK-START: void Main.test3(boolean, int, int, int, int, int) register (after)
+  // CHECK:       name "B0"
+  // CHECK-NOT:     ParallelMove
+  // CHECK:       name "B1"
+  // CHECK-NOT:   end_block
+  // CHECK:         If
+  // CHECK-NOT:     ParallelMove
+  // CHECK:       name "B6"
+  // CHECK-NOT:   end_block
+  // CHECK:         ArraySet
+  // We could check here that there is a parallel move, but it's only valid
+  // for some architectures (for example x86), as other architectures may
+  // not do move at all.
+  // CHECK:       end_block
+  // CHECK-NOT:     ParallelMove
+
+  public static void test3(boolean z, int a, int b, int c, int d, int m) {
+    // Same version as test2, but with branches reversed, to ensure
+    // whatever linear order is computed, we will get the same results.
+    int e = live1;
+    int f = live2;
+    int g = live3;
+    if (z) {
+      live1 = e;
+    } else {
+      if (y) {
+        live1 = e;
+      } else {
+        int h = live4;
+        int i = live5;
+        array[2] = e + i + h;
+        array[3] = f + i + h;
+        array[4] = g + i + h;
+        array[0] = h;
+        array[1] = i + h;
+      }
+    }
+    live1 = e + f + g;
+  }
+
+  public static void main(String[] args) {
+  }
+
+  static boolean y;
+  static int live1;
+  static int live2;
+  static int live3;
+  static int live4;
+  static int live5;
+  static int[] array;
+}