/*
 * Copyright (C) 2017 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.
 */

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

// Baseline class. This has no final fields, so there are no additional freezes
// in its constructor.
//
// The new-instance itself always has 1 freeze for the happens-before on the object header
// write (i.e. [obj.class = X] happens-before any access to obj).
//
// Total freezes for "new Base()": 1.
class Base {
  int w0;
  int w1;
  int w2;
  int w3;

  @Override
  public String toString() {
    return getClass().getName() + "(" + baseString() + ")";
  }

  protected String baseString() {
    return String.format("w0: %d, w1: %d, w2: %d, w3: %d", w0, w1, w2, w3);
  }
}

// This has a final field in its constructor, so there must be a field freeze
// at the end of <init>.
//
// Total freezes for "new OneFinal()": 2.
class OneFinal extends Base {
  final int x;
  OneFinal(int x) {
    this.x = x;
  }

  @Override
  protected String baseString() {
    return String.format("%s, x: %d", super.baseString(), x);
  }
}

class Assert {
  public static void stringEquals(String expected, Object actual) {
    stringEquals$noinline$(expected, actual);
  }

  // Forbid compiler from inlining this to avoid overly clever optimizations.
  private static void stringEquals$noinline$(String expected, Object actual) {
    String actualStr = Main.valueToString(actual);
    if (!expected.equals(actualStr)) {
      throw new AssertionError("Expected: " + expected + ", actual: " + actualStr);
    }
  }
}

interface Test {
  public void exercise();
  public void check();
}

class TestOneFinal implements Test {
  // Initialize at least once before actual test.
  public static Object external;

  /// CHECK-START: void TestOneFinal.exercise() constructor_fence_redundancy_elimination (before)
  /// CHECK: <<NewInstance:l\d+>>     NewInstance
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance>>]
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance>>]
  /// CHECK-NOT:                      ConstructorFence
  /// CHECK-DAG:                      StaticFieldSet [<<External:l\d+>>,<<NewInstance>>]

  /// CHECK-START: void TestOneFinal.exercise() constructor_fence_redundancy_elimination (after)
  /// CHECK: <<NewInstance:l\d+>>     NewInstance
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance>>]
  /// CHECK-NOT:                      ConstructorFence
  /// CHECK-DAG:                      StaticFieldSet [<<External:l\d+>>,<<NewInstance>>]
  @Override
  public void exercise() {
      Base b = new OneFinal(1);
      // 1 store, 2 freezes.

      // Stores to 'b' do not escape b.
      b.w0 = 1;
      b.w1 = 2;
      b.w2 = 3;

      // Publish the result to a global so that it is not LSE-eliminated.
      external = b;
  }

  @Override
  public void check() {
    Assert.stringEquals("OneFinal(w0: 1, w1: 2, w2: 3, w3: 0, x: 1)", external);
  }
}

// This has a final field in its constructor, so there must be a field freeze
// at the end of <init>. The previous base class's freezes accumulate on top
// of this one.
//
// Total freezes for "new TwoFinal()": 3.
class TwoFinal extends OneFinal {
  final int y;
  TwoFinal(int x, int y) {
    super(x);
    this.y = y;
  }

  @Override
  protected String baseString() {
    return String.format("%s, y: %d", super.baseString(), y);
  }
}

// This has a final field in its constructor, so there must be a field freeze
// at the end of <init>. The previous base class's freezes accumulate on top
// of this one.
//
// Total freezes for "new ThreeFinal()": 4.
class ThreeFinal extends TwoFinal {
  final int z;
  ThreeFinal(int x, int y, int z) {
    super(x, y);
    this.z = z;
  }

  @Override
  protected String baseString() {
    return String.format("%s, z: %d", super.baseString(), z);
  }
}

class TestThreeFinal implements Test {
  // Initialize at least once before actual test.
  public static Object external;

  /// CHECK-START: void TestThreeFinal.exercise() constructor_fence_redundancy_elimination (before)
  /// CHECK: <<NewInstance:l\d+>>     NewInstance
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance>>]
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance>>]
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance>>]
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance>>]
  /// CHECK-NOT:                      ConstructorFence
  /// CHECK-DAG:                      StaticFieldSet [<<External:l\d+>>,<<NewInstance>>]

  /// CHECK-START: void TestThreeFinal.exercise() constructor_fence_redundancy_elimination (after)
  /// CHECK: <<NewInstance:l\d+>>     NewInstance
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance>>]
  /// CHECK-NOT:                      ConstructorFence
  /// CHECK-DAG:                      StaticFieldSet [<<External:l\d+>>,<<NewInstance>>]
  @Override
  public void exercise() {
    Base b = new ThreeFinal(1, 1, 2);
    // 3 store, 4 freezes.

    // Stores to 'b' do not escape b.
    b.w0 = 3;

    // Publish the result to a global so that it is not LSE-eliminated.
    external = b;
  }

  @Override
  public void check() {
    Assert.stringEquals("ThreeFinal(w0: 3, w1: 0, w2: 0, w3: 0, x: 1, y: 1, z: 2)", external);
  }
}

// Ensure "freezes" between multiple new-instances are optimized out.
class TestMultiAlloc implements Test {
  public static Object external;
  public static Object external2;

  /// CHECK-START: void TestMultiAlloc.exercise() constructor_fence_redundancy_elimination (before)
  /// CHECK: <<NewInstance:l\d+>>     NewInstance
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance>>]
  /// CHECK: <<NewInstance2:l\d+>>    NewInstance
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
  /// CHECK-NOT:                      ConstructorFence
  /// CHECK-DAG:                      StaticFieldSet [<<External:l\d+>>,<<NewInstance>>]
  /// CHECK-DAG:                      StaticFieldSet [<<External2:l\d+>>,<<NewInstance2>>]

  /// CHECK-START: void TestMultiAlloc.exercise() constructor_fence_redundancy_elimination (after)
  /// CHECK: <<NewInstance:l\d+>>     NewInstance
  /// CHECK: <<NewInstance2:l\d+>>    NewInstance
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>,<<NewInstance>>]
  /// CHECK-NOT:                      ConstructorFence
  /// CHECK-DAG:                      StaticFieldSet [<<External:l\d+>>,<<NewInstance>>]
  /// CHECK-DAG:                      StaticFieldSet [<<External2:l\d+>>,<<NewInstance2>>]
  @Override
  public void exercise() {
    // 1 freeze
    Base b = new Base();
    // 1 freeze
    Base b2 = new Base();

    // Merge 2 freezes above into 1 constructor fence.
    external = b;
    external2 = b2;
  }

  @Override
  public void check() {
    Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external);
    Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external2);
  }
}

// Ensure "freezes" between multiple new-instances are optimized out.
class TestThreeFinalTwice implements Test {
  // Initialize at least once before actual test.
  public static Object external;
  public static Object external2;

  /// CHECK-START: void TestThreeFinalTwice.exercise() constructor_fence_redundancy_elimination (before)
  /// CHECK: <<NewInstance:l\d+>>     NewInstance
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance>>]
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance>>]
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance>>]
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance>>]
  /// CHECK: <<NewInstance2:l\d+>>    NewInstance
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
  /// CHECK-NOT:                      ConstructorFence
  /// CHECK-DAG:                      StaticFieldSet [<<External:l\d+>>,<<NewInstance>>]
  /// CHECK-DAG:                      StaticFieldSet [<<External2:l\d+>>,<<NewInstance2>>]

  /// CHECK-START: void TestThreeFinalTwice.exercise() constructor_fence_redundancy_elimination (after)
  /// CHECK: <<NewInstance:l\d+>>     NewInstance
  /// CHECK: <<NewInstance2:l\d+>>    NewInstance
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>,<<NewInstance>>]
  /// CHECK-NOT:                      ConstructorFence
  /// CHECK-DAG:                      StaticFieldSet [<<External:l\d+>>,<<NewInstance>>]
  /// CHECK-DAG:                      StaticFieldSet [<<External2:l\d+>>,<<NewInstance2>>]
  @Override
  public void exercise() {
    Base b = new ThreeFinal(1, 1, 2);
    // 3 store, 4 freezes.

    // Stores to 'b' do not escape b.
    b.w0 = 3;

    Base b2 = new ThreeFinal(4, 5, 6);
    // 3 store, 4 freezes.

    // Stores to 'b2' do not escape b2.
    b2.w0 = 7;

    // Publish the result to a global so that it is not LSE-eliminated.
    // Publishing is done at the end to give freezes above a chance to merge.
    external = b;
    external2 = b2;
  }

  @Override
  public void check() {
    Assert.stringEquals("ThreeFinal(w0: 3, w1: 0, w2: 0, w3: 0, x: 1, y: 1, z: 2)", external);
    Assert.stringEquals("ThreeFinal(w0: 7, w1: 0, w2: 0, w3: 0, x: 4, y: 5, z: 6)", external2);
  }
}

class TestNonEscaping {
  // Prevent constant folding.
  static boolean test;

  static Object external;
  static Object external2;
  static Object external3;
  static Object external4;

  static class Invoke implements Test {
    /// CHECK-START: void TestNonEscaping$Invoke.exercise() constructor_fence_redundancy_elimination (before)
    /// CHECK: <<NewInstance:l\d+>>     NewInstance
    /// CHECK:                          ConstructorFence [<<NewInstance>>]
    /// CHECK:                          InvokeStaticOrDirect
    /// CHECK: <<NewInstance2:l\d+>>    NewInstance
    /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
    /// CHECK-NOT:                      ConstructorFence

    /// CHECK-START: void TestNonEscaping$Invoke.exercise() constructor_fence_redundancy_elimination (after)
    /// CHECK: <<NewInstance:l\d+>>     NewInstance
    /// CHECK:                          InvokeStaticOrDirect
    /// CHECK: <<NewInstance2:l\d+>>    NewInstance
    /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>,<<NewInstance>>]
    /// CHECK-NOT:                      ConstructorFence
    @Override
    public void exercise() {
      Base b = new Base();

      // b cannot possibly escape into this invoke because it hasn't escaped onto the heap earlier,
      // and the invoke doesn't take it as a parameter.
      noEscape$noinline$();

      // Remove the Constructor Fence for b, merging into the fence for b2.
      Base b2 = new Base();

      // Do not LSE-eliminate b,b2
      external = b;
      external2 = b2;
    }

    @Override
    public void check() {
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external2);
    }
  }

  public static int[] array = new int[1];
  static Base base = new Base();

  static class Store implements Test {
    /// CHECK-START: void TestNonEscaping$Store.exercise() constructor_fence_redundancy_elimination (before)
    /// CHECK: <<NewInstance:l\d+>>     NewInstance
    /// CHECK:                          ConstructorFence [<<NewInstance>>]
    /// CHECK-DAG:                      ArraySet
    /// CHECK-DAG:                      StaticFieldSet
    /// CHECK-DAG:                      InstanceFieldSet
    /// CHECK: <<NewInstance2:l\d+>>    NewInstance
    /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
    /// CHECK-NOT:                      ConstructorFence

    /// CHECK-START: void TestNonEscaping$Store.exercise() constructor_fence_redundancy_elimination (after)
    /// CHECK-DAG: <<NewInstance:l\d+>>   NewInstance
    /// CHECK-DAG: <<NewInstance2:l\d+>>  NewInstance
    /// CHECK-DAG:                        ConstructorFence [<<NewInstance2>>,<<NewInstance>>]
    /// CHECK-NOT:                        ConstructorFence
    @Override
    public void exercise() {
      Base b = new Base();

      // Stores of inputs other than the fence target do not publish 'b'.
      array[0] = b.w0;  // aput
      external = array; // sput
      base.w0 = b.w0;   // iput

      // Remove the Constructor Fence for b, merging into the fence for b2.
      Base b2 = new Base();

      // Do not LSE-eliminate b,b2
      external3 = b;
      external4 = b2;
    }

    @Override
    public void check() {
      Assert.stringEquals("[0]", array);
      Assert.stringEquals("[0]", external);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", base);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external3);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external4);
    }
  }

  private static void noEscape$noinline$() {
  }
}

class TestDontOptimizeAcrossBlocks implements Test {
  // Prevent constant folding.
  static boolean test;

  static Object external;
  static Object external3;

  /// CHECK-START: void TestDontOptimizeAcrossBlocks.exercise() constructor_fence_redundancy_elimination (before)
  /// CHECK: <<NewInstance:l\d+>>     NewInstance
  /// CHECK:                          ConstructorFence [<<NewInstance>>]
  /// CHECK: <<NewInstance2:l\d+>>    NewInstance
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
  /// CHECK-NOT:                      ConstructorFence
  /// CHECK-DAG:                      StaticFieldSet [<<External:l\d+>>,<<NewInstance>>]
  /// CHECK-DAG:                      StaticFieldSet [<<External2:l\d+>>,<<NewInstance2>>]

  /// CHECK-START: void TestDontOptimizeAcrossBlocks.exercise() constructor_fence_redundancy_elimination (after)
  /// CHECK: <<NewInstance:l\d+>>     NewInstance
  /// CHECK:                          ConstructorFence [<<NewInstance>>]
  /// CHECK: <<NewInstance2:l\d+>>    NewInstance
  /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
  /// CHECK-NOT:                      ConstructorFence
  /// CHECK-DAG:                      StaticFieldSet [<<External:l\d+>>,<<NewInstance>>]
  /// CHECK-DAG:                      StaticFieldSet [<<External2:l\d+>>,<<NewInstance2>>]
  @Override
  public void exercise() {
    Base b = new Base();

    // Do not move constructor fence across this block, even though 'b' is not published yet.
    if (test) {
      external = null;
    }

    Base b2 = new Base();
    external = b2;
    external3 = b;
  }

  @Override
  public void check() {
    Assert.stringEquals("false", test);
    Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external);
    Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external3);
  }
}

class TestDontOptimizeAcrossEscape {
  // Prevent constant folding.
  static boolean test;

  static Object external;
  static Object external2;
  static Object external3;
  static Object external4;

  static class Invoke implements Test {
    /// CHECK-START: void TestDontOptimizeAcrossEscape$Invoke.exercise() constructor_fence_redundancy_elimination (before)
    /// CHECK: <<NewInstance:l\d+>>     NewInstance
    /// CHECK:                          ConstructorFence [<<NewInstance>>]
    /// CHECK:                          InvokeStaticOrDirect
    /// CHECK: <<NewInstance2:l\d+>>    NewInstance
    /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
    /// CHECK-NOT:                      ConstructorFence

    /// CHECK-START: void TestDontOptimizeAcrossEscape$Invoke.exercise() constructor_fence_redundancy_elimination (after)
    /// CHECK: <<NewInstance:l\d+>>     NewInstance
    /// CHECK:                          ConstructorFence [<<NewInstance>>]
    /// CHECK:                          InvokeStaticOrDirect
    /// CHECK: <<NewInstance2:l\d+>>    NewInstance
    /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
    /// CHECK-NOT:                      ConstructorFence
    @Override
    public void exercise() {
      Base b = new Base();
      // Do not optimize across invokes into which the fence target escapes.
      invoke$noinline$(b);

      Base b2 = new Base();

      // Do not LSE-eliminate b,b2
      external = b;
      external2 = b2;
    }

    private static void invoke$noinline$(Object b) {
      // Even though 'b' does not escape this method, we conservatively assume all parameters
      // of an invoke escape.
    }

    @Override
    public void check() {
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external2);
    }
  }

  public static Object[] array = new Object[3];
  static Base base = new Base();

  static class InstanceEscaper {
    public Object holder;

    @Override
    public String toString() {
      return getClass().getName() + "(" + baseString() + ")";
    }

    protected String baseString() {
      return String.format("holder: %s", Main.valueToString(holder));
    }
  }

  static InstanceEscaper instanceEscaper = new InstanceEscaper();

  static class StoreIput implements Test {
    /// CHECK-START: void TestDontOptimizeAcrossEscape$StoreIput.exercise() constructor_fence_redundancy_elimination (before)
    /// CHECK: <<NewInstance:l\d+>>     NewInstance
    /// CHECK:                          ConstructorFence [<<NewInstance>>]
    /// CHECK-DAG:                      InstanceFieldSet
    /// CHECK: <<NewInstance2:l\d+>>    NewInstance
    /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
    /// CHECK-NOT:                      ConstructorFence

    /// CHECK-START: void TestDontOptimizeAcrossEscape$StoreIput.exercise() constructor_fence_redundancy_elimination (after)
    /// CHECK-DAG: <<NewInstance:l\d+>>   NewInstance
    /// CHECK:                            ConstructorFence [<<NewInstance>>]
    /// CHECK-DAG: <<NewInstance2:l\d+>>  NewInstance
    /// CHECK-DAG:                        ConstructorFence [<<NewInstance2>>]
    /// CHECK-NOT:                        ConstructorFence
    @Override
    public void exercise() {
      Base b = new Base();

      // A store of 'b' into another instance will publish 'b'.
      instanceEscaper.holder = b;

      // Do not remove any constructor fences above.
      Base b2 = new Base();

      // Do not LSE-eliminate b,b2
      external3 = b;
      external4 = b2;
    }

    @Override
    public void check() {
      Assert.stringEquals(
          "TestDontOptimizeAcrossEscape$InstanceEscaper(holder: Base(w0: 0, w1: 0, w2: 0, w3: 0))",
          instanceEscaper);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external3);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external4);
    }
  }

  static class StoreAput implements Test {
    /// CHECK-START: void TestDontOptimizeAcrossEscape$StoreAput.exercise() constructor_fence_redundancy_elimination (before)
    /// CHECK: <<NewInstance:l\d+>>     NewInstance
    /// CHECK:                          ConstructorFence [<<NewInstance>>]
    /// CHECK-DAG:                      ArraySet
    /// CHECK: <<NewInstance2:l\d+>>    NewInstance
    /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
    /// CHECK-NOT:                      ConstructorFence

    /// CHECK-START: void TestDontOptimizeAcrossEscape$StoreAput.exercise() constructor_fence_redundancy_elimination (after)
    /// CHECK-DAG: <<NewInstance:l\d+>>   NewInstance
    /// CHECK:                            ConstructorFence [<<NewInstance>>]
    /// CHECK-DAG: <<NewInstance2:l\d+>>  NewInstance
    /// CHECK-DAG:                        ConstructorFence [<<NewInstance2>>]
    /// CHECK-NOT:                        ConstructorFence
    @Override
    public void exercise() {
      Base b = new Base();

      // A store of 'b' into another array will publish 'b'.
      array[0] = b;  // aput

      // Do not remove any constructor fences above.
      Base b2 = new Base();

      // Do not LSE-eliminate b,b2
      external3 = b;
      external4 = b2;
    }

    @Override
    public void check() {
      Assert.stringEquals("[Base(w0: 0, w1: 0, w2: 0, w3: 0),<null>,<null>]", array);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external3);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external4);
    }
  }

  static class StoreSput implements Test {
    /// CHECK-START: void TestDontOptimizeAcrossEscape$StoreSput.exercise() constructor_fence_redundancy_elimination (before)
    /// CHECK: <<NewInstance:l\d+>>     NewInstance
    /// CHECK:                          ConstructorFence [<<NewInstance>>]
    /// CHECK-DAG:                      StaticFieldSet
    /// CHECK: <<NewInstance2:l\d+>>    NewInstance
    /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
    /// CHECK-NOT:                      ConstructorFence

    /// CHECK-START: void TestDontOptimizeAcrossEscape$StoreSput.exercise() constructor_fence_redundancy_elimination (after)
    /// CHECK-DAG: <<NewInstance:l\d+>>   NewInstance
    /// CHECK:                            ConstructorFence [<<NewInstance>>]
    /// CHECK-DAG: <<NewInstance2:l\d+>>  NewInstance
    /// CHECK-DAG:                        ConstructorFence [<<NewInstance2>>]
    /// CHECK-NOT:                        ConstructorFence
    @Override
    public void exercise() {
      Base b = new Base();

      // A store of 'b' into a static will publish 'b'.
      external = b;

      // Do not remove any constructor fences above.
      Base b2 = new Base();

      // Do not LSE-eliminate b,b2
      external3 = b;
      external4 = b2;
    }

    @Override
    public void check() {
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external3);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external4);
    }
  }

  static class Deopt implements Test {
    /// CHECK-START: void TestDontOptimizeAcrossEscape$Deopt.exercise() constructor_fence_redundancy_elimination (before)
    /// CHECK: <<NewInstance:l\d+>>     NewInstance
    /// CHECK:                          ConstructorFence [<<NewInstance>>]
    /// CHECK-DAG:                      Deoptimize
    /// CHECK: <<NewInstance2:l\d+>>    NewInstance
    /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
    /// CHECK-NOT:                      ConstructorFence

    /// CHECK-START: void TestDontOptimizeAcrossEscape$Deopt.exercise() constructor_fence_redundancy_elimination (after)
    /// CHECK-DAG: <<NewInstance:l\d+>>   NewInstance
    /// CHECK:                            ConstructorFence [<<NewInstance>>]
    /// CHECK-DAG: <<NewInstance2:l\d+>>  NewInstance
    /// CHECK-DAG:                        ConstructorFence [<<NewInstance2>>]
    /// CHECK-NOT:                        ConstructorFence
    @Override
    public void exercise() {
      Base b = new Base();

      // An array access generates a Deopt to avoid doing bounds check.
      array[0] = external;  // aput
      array[1] = external;  // aput
      array[2] = external;  // aput

      // Do not remove any constructor fences above.
      Base b2 = new Base();

      // Do not LSE-eliminate b,b2
      external3 = b;
      external4 = b2;
    }

    @Override
    public void check() {
      Assert.stringEquals("[Base(w0: 0, w1: 0, w2: 0, w3: 0),"
              + "Base(w0: 0, w1: 0, w2: 0, w3: 0),"
              + "Base(w0: 0, w1: 0, w2: 0, w3: 0)]",
          array);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external3);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external4);
    }
  }

  static class Select implements Test {
    /// CHECK-START: void TestDontOptimizeAcrossEscape$Select.exercise() constructor_fence_redundancy_elimination (before)
    /// CHECK: <<NewInstance:l\d+>>     NewInstance
    /// CHECK:                          ConstructorFence [<<NewInstance>>]
    /// CHECK-DAG:                      Select
    /// CHECK: <<NewInstance2:l\d+>>    NewInstance
    /// CHECK-DAG:                      ConstructorFence [<<NewInstance2>>]
    /// CHECK-NOT:                      ConstructorFence

    /// CHECK-START: void TestDontOptimizeAcrossEscape$Select.exercise() constructor_fence_redundancy_elimination (after)
    /// CHECK-DAG: <<NewInstance:l\d+>>   NewInstance
    /// CHECK:                            ConstructorFence [<<NewInstance>>]
    /// CHECK-DAG: <<NewInstance2:l\d+>>  NewInstance
    /// CHECK-DAG:                        ConstructorFence [<<NewInstance2>>]
    /// CHECK-NOT:                        ConstructorFence
    @Override
    public void exercise() {
      Base b = new Base();

      boolean localTest = test;
      Object localExternal = external3;

      // Selecting 'b' creates an alias, which we conservatively assume escapes immediately.
      external = localTest ? b : localExternal;

      // Do not remove any constructor fences above.
      Base b2 = new Base();

      // Do not LSE-eliminate b,b2
      external3 = b;
      external4 = b2;
    }

    @Override
    public void check() {
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external3);
      Assert.stringEquals("Base(w0: 0, w1: 0, w2: 0, w3: 0)", external4);
    }
  }

  static class MakeBoundTypeTest implements Test {
    public static Object makeBoundType;
    public static Object makeBoundTypeSub;

    @Override
    public void exercise() {
      // Note: MakeBoundType is special and we have to call the constructor directly
      // to prevent inlining it.
      try {
        makeBoundType = exerciseNewInstance(MakeBoundType.class, 123);
        makeBoundTypeSub = exerciseNewInstance(MakeBoundTypeSub.class, 123);
      } catch (Exception e) {
        throw new RuntimeException(e);
      }
    }

    @Override
    public void check() {
      Assert.stringEquals(
          "TestDontOptimizeAcrossEscape$MakeBoundTypeTest$MakeBoundType(abcdefgh: 123, x: 2)",
          makeBoundType);
      Assert.stringEquals(
          "TestDontOptimizeAcrossEscape$MakeBoundTypeTest$MakeBoundTypeSub(abcdefgh: 123, x: 1)",
          makeBoundTypeSub);
    }

    // Make a new instance of 'klass'.
    private static <T> T exerciseNewInstance(Class<T> klass, int params) throws Exception {
      return klass.cast(klass.getDeclaredConstructor(int.class).newInstance(params));
    }

    /// CHECK-START: void TestDontOptimizeAcrossEscape$MakeBoundTypeTest$MakeBoundType.<init>(int) constructor_fence_redundancy_elimination (before)
    /// CHECK-DAG: <<This:l\d+>>         ParameterValue
    /// CHECK-DAG: <<NewInstance:l\d+>>  NewInstance
    /// CHECK:                           ConstructorFence [<<NewInstance>>]
    /// CHECK-DAG:                       BoundType
    /// CHECK-DAG:                       ConstructorFence [<<This>>]
    /// CHECK-NOT:                       ConstructorFence

    /// CHECK-START: void TestDontOptimizeAcrossEscape$MakeBoundTypeTest$MakeBoundType.<init>(int) constructor_fence_redundancy_elimination (after)
    /// CHECK-DAG: <<This:l\d+>>         ParameterValue
    /// CHECK-DAG: <<NewInstance:l\d+>>  NewInstance
    /// CHECK:                           ConstructorFence [<<NewInstance>>]
    /// CHECK-DAG:                       BoundType
    /// CHECK-DAG:                       ConstructorFence [<<This>>]
    /// CHECK-NOT:                       ConstructorFence
    static class MakeBoundType {
      final int abcdefgh;
      int x;

      MakeBoundType(int param) {
        abcdefgh = param;

        Base b = new Base();
        // constructor-fence(b)

        if (this instanceof MakeBoundTypeSub) {
          // Create a "BoundType(this)" which prevents
          // a merged constructor-fence(this, b)
          x = 1;
        } else {
          x = 2;
        }

        // publish(b).
        external = b;

        // constructor-fence(this)
      }

      @Override
      public String toString() {
        return getClass().getName() + "(" + baseString() + ")";
      }

      protected String baseString() {
        return String.format("abcdefgh: %d, x: %d", abcdefgh, x);
      }
    }

    static class MakeBoundTypeSub extends MakeBoundType {
      MakeBoundTypeSub(int xyz) {
        super(xyz);
      }
    }
  }
}

public class Main {
  public static void main(String[] args) throws Exception {
    // Ensure that all of this code does not get optimized out into a no-op
    // by actually running the code with reflection, then validating
    // the result by asserting it against a string.
    Class<? extends Test>[] testClasses = new Class[] {
      TestOneFinal.class,
      TestThreeFinal.class,
      TestMultiAlloc.class,
      TestThreeFinalTwice.class,
      TestNonEscaping.Invoke.class,
      TestNonEscaping.Store.class,
      TestDontOptimizeAcrossBlocks.class,
      TestDontOptimizeAcrossEscape.Invoke.class,
      TestDontOptimizeAcrossEscape.StoreIput.class,
      TestDontOptimizeAcrossEscape.StoreAput.class,
      TestDontOptimizeAcrossEscape.StoreSput.class,
      TestDontOptimizeAcrossEscape.Deopt.class,
      TestDontOptimizeAcrossEscape.Select.class,
      TestDontOptimizeAcrossEscape.MakeBoundTypeTest.class,
    };

    for (Class<? extends Test> klass : testClasses) {
      exerciseTestClass(klass);
    }
  }

  /**
   * Invoke Test#exercise(), then Test#check().
   * @throws AssertionError if test fails.
   */
  private static void exerciseTestClass(Class<? extends Test> klass) throws Exception {
    Test instance = klass.cast(klass.getDeclaredConstructor().newInstance());

    // Use reflection as a best-effort to avoid compiler optimizations (e.g. inlining).
    instance.getClass().getDeclaredMethod("exercise").invoke(instance);
    instance.getClass().getDeclaredMethod("check").invoke(instance);
  }

  // Print an object, with special handling for array and null.
  public static String valueToString(Object val) {
    if (val == null) {
      return "<null>";
    }
    if (val.getClass().isArray()) {
      String fmt = "[";
      int length = Array.getLength(val);
      for (int i = 0; i < length; ++i) {
        Object arrayElement = Array.get(val, i);
        fmt += valueToString(arrayElement);

        if (i != length - 1) {
          fmt += ",";
        }
      }
      fmt += "]";

      return fmt;
    }

    return val.toString();
  }
}