/*
|
* 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 extends UnresolvedSuperClass {
|
|
/// CHECK-START: void Main.callInvokeUnresolvedStatic() register (before)
|
/// CHECK: InvokeUnresolved invoke_type:static
|
static public void callInvokeUnresolvedStatic() {
|
UnresolvedClass.staticMethod();
|
}
|
|
/// CHECK-START: void Main.callInvokeUnresolvedVirtual(UnresolvedClass) register (before)
|
/// CHECK: InvokeUnresolved invoke_type:virtual
|
static public void callInvokeUnresolvedVirtual(UnresolvedClass c) {
|
c.virtualMethod();
|
}
|
|
/// CHECK-START: void Main.callInvokeUnresolvedInterface(UnresolvedInterface) register (before)
|
/// CHECK: InvokeUnresolved invoke_type:interface
|
static public void callInvokeUnresolvedInterface(UnresolvedInterface c) {
|
c.interfaceMethod();
|
}
|
|
static public void callInvokeUnresolvedSuper(Main c) {
|
c.superMethod();
|
}
|
|
/// CHECK-START: void Main.superMethod() register (before)
|
/// CHECK: InvokeUnresolved invoke_type:super
|
public void superMethod() {
|
super.superMethod();
|
}
|
|
/// CHECK-START: void Main.callUnresolvedStaticFieldAccess() register (before)
|
/// CHECK: UnresolvedStaticFieldSet field_type:Int8
|
/// CHECK: UnresolvedStaticFieldSet field_type:Uint16
|
/// CHECK: UnresolvedStaticFieldSet field_type:Int32
|
/// CHECK: UnresolvedStaticFieldSet field_type:Int64
|
/// CHECK: UnresolvedStaticFieldSet field_type:Float32
|
/// CHECK: UnresolvedStaticFieldSet field_type:Float64
|
/// CHECK: UnresolvedStaticFieldSet field_type:Reference
|
|
/// CHECK: UnresolvedStaticFieldGet field_type:Int8
|
/// CHECK: UnresolvedStaticFieldGet field_type:Uint16
|
/// CHECK: UnresolvedStaticFieldGet field_type:Int32
|
/// CHECK: UnresolvedStaticFieldGet field_type:Int64
|
/// CHECK: UnresolvedStaticFieldGet field_type:Float32
|
/// CHECK: UnresolvedStaticFieldGet field_type:Float64
|
/// CHECK: UnresolvedStaticFieldGet field_type:Reference
|
static public void callUnresolvedStaticFieldAccess() {
|
Object o = new Object();
|
UnresolvedClass.staticByte = (byte)1;
|
UnresolvedClass.staticChar = '1';
|
UnresolvedClass.staticInt = 123456789;
|
UnresolvedClass.staticLong = 123456789123456789l;
|
UnresolvedClass.staticFloat = 123456789123456789f;
|
UnresolvedClass.staticDouble = 123456789123456789d;
|
UnresolvedClass.staticObject = o;
|
|
expectEquals((byte)1, UnresolvedClass.staticByte);
|
expectEquals('1', UnresolvedClass.staticChar);
|
expectEquals(123456789, UnresolvedClass.staticInt);
|
expectEquals(123456789123456789l, UnresolvedClass.staticLong);
|
expectEquals(123456789123456789f, UnresolvedClass.staticFloat);
|
expectEquals(123456789123456789d, UnresolvedClass.staticDouble);
|
expectEquals(o, UnresolvedClass.staticObject);
|
|
// Check "large" values.
|
|
UnresolvedClass.staticByte = (byte)-1;
|
UnresolvedClass.staticChar = (char)32768;
|
UnresolvedClass.staticInt = -1;
|
|
expectEquals((byte)-1, UnresolvedClass.staticByte);
|
expectEquals((char)32768, UnresolvedClass.staticChar);
|
expectEquals(-1, UnresolvedClass.staticInt);
|
}
|
|
/// CHECK-START: void Main.callUnresolvedInstanceFieldAccess(UnresolvedClass) register (before)
|
/// CHECK: UnresolvedInstanceFieldSet field_type:Int8
|
/// CHECK: UnresolvedInstanceFieldSet field_type:Uint16
|
/// CHECK: UnresolvedInstanceFieldSet field_type:Int32
|
/// CHECK: UnresolvedInstanceFieldSet field_type:Int64
|
/// CHECK: UnresolvedInstanceFieldSet field_type:Float32
|
/// CHECK: UnresolvedInstanceFieldSet field_type:Float64
|
/// CHECK: UnresolvedInstanceFieldSet field_type:Reference
|
|
/// CHECK: UnresolvedInstanceFieldGet field_type:Int8
|
/// CHECK: UnresolvedInstanceFieldGet field_type:Uint16
|
/// CHECK: UnresolvedInstanceFieldGet field_type:Int32
|
/// CHECK: UnresolvedInstanceFieldGet field_type:Int64
|
/// CHECK: UnresolvedInstanceFieldGet field_type:Float32
|
/// CHECK: UnresolvedInstanceFieldGet field_type:Float64
|
/// CHECK: UnresolvedInstanceFieldGet field_type:Reference
|
static public void callUnresolvedInstanceFieldAccess(UnresolvedClass c) {
|
Object o = new Object();
|
c.instanceByte = (byte)1;
|
c.instanceChar = '1';
|
c.instanceInt = 123456789;
|
c.instanceLong = 123456789123456789l;
|
c.instanceFloat = 123456789123456789f;
|
c.instanceDouble = 123456789123456789d;
|
c.instanceObject = o;
|
|
expectEquals((byte)1, c.instanceByte);
|
expectEquals('1', c.instanceChar);
|
expectEquals(123456789, c.instanceInt);
|
expectEquals(123456789123456789l, c.instanceLong);
|
expectEquals(123456789123456789f, c.instanceFloat);
|
expectEquals(123456789123456789d, c.instanceDouble);
|
expectEquals(o, c.instanceObject);
|
|
// Check "large" values.
|
|
c.instanceByte = (byte)-1;
|
c.instanceChar = (char)32768;
|
c.instanceInt = -1;
|
|
expectEquals((byte)-1, c.instanceByte);
|
expectEquals((char)32768, c.instanceChar);
|
expectEquals(-1, c.instanceInt);
|
}
|
|
/// CHECK-START: void Main.callUnresolvedNull(UnresolvedClass) register (before)
|
/// CHECK-NOT: NullCheck
|
static public void callUnresolvedNull(UnresolvedClass c) {
|
int x = 0;
|
try {
|
x = c.instanceInt;
|
throw new Error("Expected NPE");
|
} catch (NullPointerException e) {
|
x -= 1;
|
}
|
expectEquals(-1, x);
|
try {
|
c.instanceInt = -1;
|
throw new Error("Expected NPE");
|
} catch (NullPointerException e) {
|
x -= 1;
|
}
|
expectEquals(-2, x);
|
try {
|
c.virtualMethod();
|
throw new Error("Expected NPE");
|
} catch (NullPointerException e) {
|
x -= 1;
|
}
|
expectEquals(-3, x);
|
}
|
|
static public void testInstanceOf(Object o) {
|
if (o instanceof UnresolvedSuperClass) {
|
System.out.println("instanceof ok");
|
}
|
}
|
|
static public UnresolvedSuperClass testCheckCast(Object o) {
|
UnresolvedSuperClass c = (UnresolvedSuperClass) o;
|
System.out.println("checkcast ok");
|
return c;
|
}
|
/// CHECK-START: void Main.main(java.lang.String[]) register (before)
|
/// CHECK: InvokeUnresolved invoke_type:direct
|
static public void main(String[] args) {
|
UnresolvedClass c = new UnresolvedClass();
|
Main m = new Main();
|
callInvokeUnresolvedStatic();
|
callInvokeUnresolvedVirtual(c);
|
callInvokeUnresolvedInterface(c);
|
callInvokeUnresolvedSuper(m);
|
callUnresolvedStaticFieldAccess();
|
callUnresolvedInstanceFieldAccess(c);
|
callUnresolvedNull(null);
|
testInstanceOf(m);
|
testCheckCast(m);
|
testLicm(2);
|
}
|
|
/// CHECK-START: void Main.testLicm(int) licm (before)
|
/// CHECK: <<Class:l\d+>> LoadClass loop:<<LoopLabel:B\d+>>
|
/// CHECK-NEXT: <<Clinit:l\d+>> ClinitCheck [<<Class>>] loop:<<LoopLabel>>
|
/// CHECK-NEXT: <<New:l\d+>> NewInstance [<<Clinit>>] loop:<<LoopLabel>>
|
/// CHECK-NEXT: ConstructorFence [<<New>>] loop:<<LoopLabel>>
|
/// CHECK-NEXT: InvokeUnresolved [<<New>>] loop:<<LoopLabel>>
|
|
/// CHECK-START: void Main.testLicm(int) licm (after)
|
/// CHECK: <<Class:l\d+>> LoadClass loop:none
|
/// CHECK-NEXT: <<Clinit:l\d+>> ClinitCheck [<<Class>>] loop:none
|
/// CHECK: <<New:l\d+>> NewInstance [<<Clinit>>] loop:<<LoopLabel:B\d+>>
|
/// CHECK-NEXT: ConstructorFence [<<New>>] loop:<<LoopLabel>>
|
/// CHECK-NEXT: InvokeUnresolved [<<New>>] loop:<<LoopLabel>>
|
static public void testLicm(int count) {
|
// Test to make sure we keep the initialization check after loading an unresolved class.
|
UnresolvedClass c;
|
int i = 0;
|
do {
|
c = new UnresolvedClass();
|
} while (i++ != count);
|
}
|
|
public static void expectEquals(byte expected, byte result) {
|
if (expected != result) {
|
throw new Error("Expected: " + expected + ", found: " + result);
|
}
|
}
|
|
public static void expectEquals(char expected, char result) {
|
if (expected != result) {
|
throw new Error("Expected: " + expected + ", found: " + result);
|
}
|
}
|
|
public static void expectEquals(int expected, int result) {
|
if (expected != result) {
|
throw new Error("Expected: " + expected + ", found: " + result);
|
}
|
}
|
|
public static void expectEquals(long expected, long result) {
|
if (expected != result) {
|
throw new Error("Expected: " + expected + ", found: " + result);
|
}
|
}
|
|
public static void expectEquals(float expected, float result) {
|
if (expected != result) {
|
throw new Error("Expected: " + expected + ", found: " + result);
|
}
|
}
|
|
public static void expectEquals(double expected, double result) {
|
if (expected != result) {
|
throw new Error("Expected: " + expected + ", found: " + result);
|
}
|
}
|
|
public static void expectEquals(Object expected, Object result) {
|
if (expected != result) {
|
throw new Error("Expected: " + expected + ", found: " + result);
|
}
|
}
|
}
|
