/*
* 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();
}
}