/* * 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:PrimByte /// CHECK: UnresolvedStaticFieldSet field_type:PrimChar /// CHECK: UnresolvedStaticFieldSet field_type:PrimInt /// CHECK: UnresolvedStaticFieldSet field_type:PrimLong /// CHECK: UnresolvedStaticFieldSet field_type:PrimFloat /// CHECK: UnresolvedStaticFieldSet field_type:PrimDouble /// CHECK: UnresolvedStaticFieldSet field_type:PrimNot /// CHECK: UnresolvedStaticFieldGet field_type:PrimByte /// CHECK: UnresolvedStaticFieldGet field_type:PrimChar /// CHECK: UnresolvedStaticFieldGet field_type:PrimInt /// CHECK: UnresolvedStaticFieldGet field_type:PrimLong /// CHECK: UnresolvedStaticFieldGet field_type:PrimFloat /// CHECK: UnresolvedStaticFieldGet field_type:PrimDouble /// CHECK: UnresolvedStaticFieldGet field_type:PrimNot 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-START: void Main.callUnresolvedInstanceFieldAccess(UnresolvedClass) register (before) /// CHECK: UnresolvedInstanceFieldSet field_type:PrimByte /// CHECK: UnresolvedInstanceFieldSet field_type:PrimChar /// CHECK: UnresolvedInstanceFieldSet field_type:PrimInt /// CHECK: UnresolvedInstanceFieldSet field_type:PrimLong /// CHECK: UnresolvedInstanceFieldSet field_type:PrimFloat /// CHECK: UnresolvedInstanceFieldSet field_type:PrimDouble /// CHECK: UnresolvedInstanceFieldSet field_type:PrimNot /// CHECK: UnresolvedInstanceFieldGet field_type:PrimByte /// CHECK: UnresolvedInstanceFieldGet field_type:PrimChar /// CHECK: UnresolvedInstanceFieldGet field_type:PrimInt /// CHECK: UnresolvedInstanceFieldGet field_type:PrimLong /// CHECK: UnresolvedInstanceFieldGet field_type:PrimFloat /// CHECK: UnresolvedInstanceFieldGet field_type:PrimDouble /// CHECK: UnresolvedInstanceFieldGet field_type:PrimNot 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); } 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); testInstanceOf(m); testCheckCast(m); testLicm(2); } /// CHECK-START: void Main.testLicm(int) licm (before) /// CHECK: <<Class:l\d+>> LoadClass loop:B2 /// CHECK-NEXT: <<Clinit:l\d+>> ClinitCheck [<<Class>>] loop:B2 /// CHECK-NEXT: <<New:l\d+>> NewInstance [<<Clinit>>,<<Method:[i|j]\d+>>] loop:B2 /// CHECK-NEXT: InvokeUnresolved [<<New>>] loop:B2 /// 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>>,<<Method:[i|j]\d+>>] loop:B2 /// CHECK-NEXT: InvokeUnresolved [<<New>>] loop:B2 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); } } }