/*
* 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.
*/
// TODO: Add more tests after we can inline functions with calls.
class ClassWithoutFinals {
/// CHECK-START: void ClassWithoutFinals.<init>() inliner (after)
/// CHECK-NOT: ConstructorFence
public ClassWithoutFinals() {}
}
class ClassWithFinals {
public final int x;
public ClassWithFinals obj;
public static boolean doThrow = false;
public ClassWithFinals(boolean cond) {
x = 1;
throw new RuntimeException();
// should not inline this constructor
}
/// CHECK-START: void ClassWithFinals.<init>() inliner (after)
/// CHECK: ConstructorFence
/// CHECK-NOT: ConstructorFence
/*
* Check that the correct assembly instructions are selected for a Store/Store fence.
*
* - ARM variants: DMB ISHST (store-store fence for inner shareable domain)
* - Intel variants: no-op (store-store does not need a fence).
*/
/// CHECK-START-ARM64: void ClassWithFinals.<init>() disassembly (after)
/// CHECK: ConstructorFence
/// CHECK-NEXT: dmb ishst
/// CHECK-START-ARM: void ClassWithFinals.<init>() disassembly (after)
/// CHECK: ConstructorFence
/// CHECK-NEXT: dmb ishst
/// CHECK-START-X86_64: void ClassWithFinals.<init>() disassembly (after)
/// CHECK: ConstructorFence
/// CHECK-NOT: {{[slm]}}fence
/// CHECK-START-X86: void ClassWithFinals.<init>() disassembly (after)
/// CHECK: ConstructorFence
/// CHECK-NOT: {{[slm]}}fence
public ClassWithFinals() {
// Exactly one constructor barrier.
x = 0;
}
/// CHECK-START: void ClassWithFinals.<init>(int) inliner (after)
/// CHECK: <<This:l\d+>> ParameterValue
/// CHECK: <<NewInstance:l\d+>> NewInstance
/// CHECK-DAG: ConstructorFence [<<NewInstance>>]
/// CHECK-DAG: ConstructorFence [<<NewInstance>>]
/// CHECK-DAG: ConstructorFence [<<This>>]
/// CHECK-NOT: ConstructorFence
public ClassWithFinals(int x) {
// This should have exactly three barriers:
// - one for the new-instance
// - one for the constructor
// - one for the `new` which should be inlined.
obj = new ClassWithFinals();
this.x = x;
}
}
class InheritFromClassWithFinals extends ClassWithFinals {
/// CHECK-START: void InheritFromClassWithFinals.<init>() inliner (after)
/// CHECK: <<This:l\d+>> ParameterValue
/// CHECK: ConstructorFence [<<This>>]
/// CHECK-NOT: ConstructorFence
/// CHECK-START: void InheritFromClassWithFinals.<init>() inliner (after)
/// CHECK-NOT: InvokeStaticOrDirect
public InheritFromClassWithFinals() {
// Should inline the super constructor.
//
// Exactly one constructor barrier here.
}
/// CHECK-START: void InheritFromClassWithFinals.<init>(boolean) inliner (after)
/// CHECK: InvokeStaticOrDirect
/// CHECK-START: void InheritFromClassWithFinals.<init>(boolean) inliner (after)
/// CHECK-NOT: ConstructorFence
public InheritFromClassWithFinals(boolean cond) {
super(cond);
// should not inline the super constructor
}
/// CHECK-START: void InheritFromClassWithFinals.<init>(int) inliner (after)
/// CHECK: <<This:l\d+>> ParameterValue
/// CHECK-DAG: <<NewHere:l\d+>> NewInstance klass:InheritFromClassWithFinals
/// CHECK-DAG: ConstructorFence [<<This>>]
/// CHECK-DAG: ConstructorFence [<<NewHere>>]
/// CHECK-DAG: ConstructorFence [<<NewHere>>]
/// CHECK-NOT: ConstructorFence
/// CHECK-START: void InheritFromClassWithFinals.<init>(int) inliner (after)
/// CHECK-NOT: InvokeStaticOrDirect
public InheritFromClassWithFinals(int unused) {
// super(); // implicitly the first invoke in this constructor.
// Should inline the super constructor and insert a constructor fence there.
// Should inline the new instance call (barrier); and add another one
// because the superclass has finals.
new InheritFromClassWithFinals();
}
}
class HaveFinalsAndInheritFromClassWithFinals extends ClassWithFinals {
final int y;
/// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>() inliner (after)
/// CHECK: <<This:l\d+>> ParameterValue
/// CHECK: ConstructorFence [<<This>>]
/// CHECK: ConstructorFence [<<This>>]
/// CHECK-NOT: ConstructorFence
/// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>() inliner (after)
/// CHECK-NOT: InvokeStaticOrDirect
public HaveFinalsAndInheritFromClassWithFinals() {
// Should inline the super constructor and keep the memory barrier.
y = 0;
}
/// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(boolean) inliner (after)
/// CHECK: <<This:l\d+>> ParameterValue
/// CHECK: InvokeStaticOrDirect
/// CHECK: ConstructorFence [<<This>>]
/// CHECK-NOT: ConstructorFence
public HaveFinalsAndInheritFromClassWithFinals(boolean cond) {
super(cond);
// should not inline the super constructor
y = 0;
}
/// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(int) inliner (after)
/// CHECK: <<This:l\d+>> ParameterValue
/// CHECK-DAG: <<NewHF:l\d+>> NewInstance klass:HaveFinalsAndInheritFromClassWithFinals
/// CHECK-DAG: <<NewIF:l\d+>> NewInstance klass:InheritFromClassWithFinals
/// CHECK-DAG: ConstructorFence [<<This>>]
/// CHECK-DAG: ConstructorFence [<<NewHF>>]
/// CHECK-DAG: ConstructorFence [<<NewHF>>]
/// CHECK-DAG: ConstructorFence [<<NewHF>>]
/// CHECK-DAG: ConstructorFence [<<NewIF>>]
/// CHECK-DAG: ConstructorFence [<<NewIF>>]
/// CHECK-DAG: ConstructorFence [<<This>>]
/// CHECK-NOT: ConstructorFence
/// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(int) inliner (after)
/// CHECK-NOT: InvokeStaticOrDirect
public HaveFinalsAndInheritFromClassWithFinals(int unused) {
// super()
// -- Inlined super constructor, insert memory barrier here.
y = 0;
// Should inline new instance and keep both memory barriers.
// One more memory barrier for new-instance.
// (3 total for this new-instance #1)
new HaveFinalsAndInheritFromClassWithFinals();
// Should inline new instance and have exactly one barrier.
// One more barrier for new-instance.
// (2 total for this new-instance #2)
new InheritFromClassWithFinals();
// -- End of constructor, insert memory barrier here to freeze 'y'.
}
}
public class Main {
/// CHECK-START: ClassWithFinals Main.noInlineNoConstructorBarrier() inliner (after)
/// CHECK: InvokeStaticOrDirect
/// CHECK-START: ClassWithFinals Main.noInlineNoConstructorBarrier() inliner (after)
/// CHECK: <<NewInstance:l\d+>> NewInstance
/// CHECK: ConstructorFence [<<NewInstance>>]
/// CHECK-NOT: ConstructorFence
public static ClassWithFinals noInlineNoConstructorBarrier() {
// Exactly one barrier for the new-instance.
return new ClassWithFinals(false);
// should not inline the constructor
}
/// CHECK-START: void Main.inlineNew() inliner (after)
/// CHECK: <<NewInstance:l\d+>> NewInstance
/// CHECK-DAG: ConstructorFence [<<NewInstance>>]
/// CHECK-DAG: ConstructorFence [<<NewInstance>>]
/// CHECK-NOT: ConstructorFence
/// CHECK-START: void Main.inlineNew() inliner (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static void inlineNew() {
// Exactly 2 barriers. One for new-instance, one for constructor with finals.
new ClassWithFinals();
}
/// CHECK-START: void Main.inlineNew1() inliner (after)
/// CHECK: <<NewInstance:l\d+>> NewInstance
/// CHECK-DAG: ConstructorFence [<<NewInstance>>]
/// CHECK-DAG: ConstructorFence [<<NewInstance>>]
/// CHECK-NOT: ConstructorFence
/// CHECK-START: void Main.inlineNew1() inliner (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static void inlineNew1() {
new InheritFromClassWithFinals();
}
/// CHECK-START: void Main.inlineNew2() inliner (after)
/// CHECK: <<NewInstance:l\d+>> NewInstance
/// CHECK-DAG: ConstructorFence [<<NewInstance>>]
/// CHECK-DAG: ConstructorFence [<<NewInstance>>]
/// CHECK-DAG: ConstructorFence [<<NewInstance>>]
/// CHECK-NOT: ConstructorFence
/// CHECK-START: void Main.inlineNew2() inliner (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static void inlineNew2() {
new HaveFinalsAndInheritFromClassWithFinals();
}
/// CHECK-START: void Main.inlineNew3() inliner (after)
/// CHECK: <<NewInstance:l\d+>> NewInstance
/// CHECK-DAG: ConstructorFence [<<NewInstance>>]
/// CHECK-DAG: ConstructorFence [<<NewInstance>>]
/// CHECK-DAG: ConstructorFence [<<NewInstance>>]
/// CHECK-NOT: ConstructorFence
/// CHECK: <<NewInstance2:l\d+>> NewInstance
/// CHECK-DAG: ConstructorFence [<<NewInstance2>>]
/// CHECK-DAG: ConstructorFence [<<NewInstance2>>]
/// CHECK-DAG: ConstructorFence [<<NewInstance2>>]
/// CHECK-NOT: ConstructorFence
/// CHECK-START: void Main.inlineNew3() inliner (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static void inlineNew3() {
new HaveFinalsAndInheritFromClassWithFinals();
new HaveFinalsAndInheritFromClassWithFinals();
}
static int[] mCodePointsEmpty = new int[0];
/// CHECK-START: void Main.testNewString() inliner (after)
/// CHECK-NOT: ConstructorFence
/// CHECK: InvokeStaticOrDirect method_load_kind:StringInit
/// CHECK-NOT: ConstructorFence
/// CHECK-NOT: InvokeStaticOrDirect
public static void testNewString() {
// Strings are special because of StringFactory hackeries.
//
// Assume they handle their own fencing internally in the StringFactory.
int[] codePoints = null;
String some_new_string = new String(mCodePointsEmpty, 0, 0);
}
public static void main(String[] args) {}
}