| /* |
| * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. |
| */ |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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. |
| */ |
| |
| package com.sun.org.apache.bcel.internal.generic; |
| |
| import com.sun.org.apache.bcel.internal.Const; |
| import com.sun.org.apache.bcel.internal.Repository; |
| import com.sun.org.apache.bcel.internal.classfile.JavaClass; |
| |
| /** |
| * Super class for object and array types. |
| * |
| */ |
| public abstract class ReferenceType extends Type { |
| |
| protected ReferenceType(final byte t, final String s) { |
| super(t, s); |
| } |
| |
| |
| /** Class is non-abstract but not instantiable from the outside |
| */ |
| ReferenceType() { |
| super(Const.T_OBJECT, "<null object>"); |
| } |
| |
| |
| /** |
| * Return true iff this type is castable to another type t as defined in |
| * the JVM specification. The case where this is Type.NULL is not |
| * defined (see the CHECKCAST definition in the JVM specification). |
| * However, because e.g. CHECKCAST doesn't throw a |
| * ClassCastException when casting a null reference to any Object, |
| * true is returned in this case. |
| * |
| * @throws ClassNotFoundException if any classes or interfaces required |
| * to determine assignment compatibility can't be found |
| */ |
| public boolean isCastableTo( final Type t ) throws ClassNotFoundException { |
| if (this.equals(Type.NULL)) { |
| return t instanceof ReferenceType; // If this is ever changed in isAssignmentCompatible() |
| } |
| return isAssignmentCompatibleWith(t); |
| /* Yes, it's true: It's the same definition. |
| * See vmspec2 AASTORE / CHECKCAST definitions. |
| */ |
| } |
| |
| |
| /** |
| * Return true iff this is assignment compatible with another type t |
| * as defined in the JVM specification; see the AASTORE definition |
| * there. |
| * @throws ClassNotFoundException if any classes or interfaces required |
| * to determine assignment compatibility can't be found |
| */ |
| public boolean isAssignmentCompatibleWith( final Type t ) throws ClassNotFoundException { |
| if (!(t instanceof ReferenceType)) { |
| return false; |
| } |
| final ReferenceType T = (ReferenceType) t; |
| if (this.equals(Type.NULL)) { |
| return true; // This is not explicitely stated, but clear. Isn't it? |
| } |
| /* If this is a class type then |
| */ |
| if ((this instanceof ObjectType) && (((ObjectType) this).referencesClassExact())) { |
| /* If T is a class type, then this must be the same class as T, |
| or this must be a subclass of T; |
| */ |
| if ((T instanceof ObjectType) && (((ObjectType) T).referencesClassExact())) { |
| if (this.equals(T)) { |
| return true; |
| } |
| if (Repository.instanceOf(((ObjectType) this).getClassName(), ((ObjectType) T) |
| .getClassName())) { |
| return true; |
| } |
| } |
| /* If T is an interface type, this must implement interface T. |
| */ |
| if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterfaceExact())) { |
| if (Repository.implementationOf(((ObjectType) this).getClassName(), |
| ((ObjectType) T).getClassName())) { |
| return true; |
| } |
| } |
| } |
| /* If this is an interface type, then: |
| */ |
| if ((this instanceof ObjectType) && (((ObjectType) this).referencesInterfaceExact())) { |
| /* If T is a class type, then T must be Object (2.4.7). |
| */ |
| if ((T instanceof ObjectType) && (((ObjectType) T).referencesClassExact())) { |
| if (T.equals(Type.OBJECT)) { |
| return true; |
| } |
| } |
| /* If T is an interface type, then T must be the same interface |
| * as this or a superinterface of this (2.13.2). |
| */ |
| if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterfaceExact())) { |
| if (this.equals(T)) { |
| return true; |
| } |
| if (Repository.implementationOf(((ObjectType) this).getClassName(), |
| ((ObjectType) T).getClassName())) { |
| return true; |
| } |
| } |
| } |
| /* If this is an array type, namely, the type SC[], that is, an |
| * array of components of type SC, then: |
| */ |
| if (this instanceof ArrayType) { |
| /* If T is a class type, then T must be Object (2.4.7). |
| */ |
| if ((T instanceof ObjectType) && (((ObjectType) T).referencesClassExact())) { |
| if (T.equals(Type.OBJECT)) { |
| return true; |
| } |
| } |
| /* If T is an array type TC[], that is, an array of components |
| * of type TC, then one of the following must be true: |
| */ |
| if (T instanceof ArrayType) { |
| /* TC and SC are the same primitive type (2.4.1). |
| */ |
| final Type sc = ((ArrayType) this).getElementType(); |
| final Type tc = ((ArrayType) T).getElementType(); |
| if (sc instanceof BasicType && tc instanceof BasicType && sc.equals(tc)) { |
| return true; |
| } |
| /* TC and SC are reference types (2.4.6), and type SC is |
| * assignable to TC by these runtime rules. |
| */ |
| if (tc instanceof ReferenceType && sc instanceof ReferenceType |
| && ((ReferenceType) sc).isAssignmentCompatibleWith(tc)) { |
| return true; |
| } |
| } |
| /* If T is an interface type, T must be one of the interfaces implemented by arrays (2.15). */ |
| // TODO: Check if this is still valid or find a way to dynamically find out which |
| // interfaces arrays implement. However, as of the JVM specification edition 2, there |
| // are at least two different pages where assignment compatibility is defined and |
| // on one of them "interfaces implemented by arrays" is exchanged with "'Cloneable' or |
| // 'java.io.Serializable'" |
| if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterfaceExact())) { |
| for (final String element : Const.getInterfacesImplementedByArrays()) { |
| if (T.equals(ObjectType.getInstance(element))) { |
| return true; |
| } |
| } |
| } |
| } |
| return false; // default. |
| } |
| |
| |
| /** |
| * This commutative operation returns the first common superclass (narrowest ReferenceType |
| * referencing a class, not an interface). |
| * If one of the types is a superclass of the other, the former is returned. |
| * If "this" is Type.NULL, then t is returned. |
| * If t is Type.NULL, then "this" is returned. |
| * If "this" equals t ['this.equals(t)'] "this" is returned. |
| * If "this" or t is an ArrayType, then Type.OBJECT is returned; |
| * unless their dimensions match. Then an ArrayType of the same |
| * number of dimensions is returned, with its basic type being the |
| * first common super class of the basic types of "this" and t. |
| * If "this" or t is a ReferenceType referencing an interface, then Type.OBJECT is returned. |
| * If not all of the two classes' superclasses cannot be found, "null" is returned. |
| * See the JVM specification edition 2, "4.9.2 The Bytecode Verifier". |
| * |
| * @throws ClassNotFoundException on failure to find superclasses of this |
| * type, or the type passed as a parameter |
| */ |
| public ReferenceType getFirstCommonSuperclass( final ReferenceType t ) throws ClassNotFoundException { |
| if (this.equals(Type.NULL)) { |
| return t; |
| } |
| if (t.equals(Type.NULL)) { |
| return this; |
| } |
| if (this.equals(t)) { |
| return this; |
| /* |
| * TODO: Above sounds a little arbitrary. On the other hand, there is |
| * no object referenced by Type.NULL so we can also say all the objects |
| * referenced by Type.NULL were derived from java.lang.Object. |
| * However, the Java Language's "instanceof" operator proves us wrong: |
| * "null" is not referring to an instance of java.lang.Object :) |
| */ |
| } |
| /* This code is from a bug report by Konstantin Shagin <konst@cs.technion.ac.il> */ |
| if ((this instanceof ArrayType) && (t instanceof ArrayType)) { |
| final ArrayType arrType1 = (ArrayType) this; |
| final ArrayType arrType2 = (ArrayType) t; |
| if ((arrType1.getDimensions() == arrType2.getDimensions()) |
| && arrType1.getBasicType() instanceof ObjectType |
| && arrType2.getBasicType() instanceof ObjectType) { |
| return new ArrayType(((ObjectType) arrType1.getBasicType()) |
| .getFirstCommonSuperclass((ObjectType) arrType2.getBasicType()), arrType1 |
| .getDimensions()); |
| } |
| } |
| if ((this instanceof ArrayType) || (t instanceof ArrayType)) { |
| return Type.OBJECT; |
| // TODO: Is there a proof of OBJECT being the direct ancestor of every ArrayType? |
| } |
| if (((this instanceof ObjectType) && ((ObjectType) this).referencesInterfaceExact()) |
| || ((t instanceof ObjectType) && ((ObjectType) t).referencesInterfaceExact())) { |
| return Type.OBJECT; |
| // TODO: The above line is correct comparing to the vmspec2. But one could |
| // make class file verification a bit stronger here by using the notion of |
| // superinterfaces or even castability or assignment compatibility. |
| } |
| // this and t are ObjectTypes, see above. |
| final ObjectType thiz = (ObjectType) this; |
| final ObjectType other = (ObjectType) t; |
| final JavaClass[] thiz_sups = Repository.getSuperClasses(thiz.getClassName()); |
| final JavaClass[] other_sups = Repository.getSuperClasses(other.getClassName()); |
| if ((thiz_sups == null) || (other_sups == null)) { |
| return null; |
| } |
| // Waaahh... |
| final JavaClass[] this_sups = new JavaClass[thiz_sups.length + 1]; |
| final JavaClass[] t_sups = new JavaClass[other_sups.length + 1]; |
| System.arraycopy(thiz_sups, 0, this_sups, 1, thiz_sups.length); |
| System.arraycopy(other_sups, 0, t_sups, 1, other_sups.length); |
| this_sups[0] = Repository.lookupClass(thiz.getClassName()); |
| t_sups[0] = Repository.lookupClass(other.getClassName()); |
| for (final JavaClass t_sup : t_sups) { |
| for (final JavaClass this_sup : this_sups) { |
| if (this_sup.equals(t_sup)) { |
| return ObjectType.getInstance(this_sup.getClassName()); |
| } |
| } |
| } |
| // Huh? Did you ask for Type.OBJECT's superclass?? |
| return null; |
| } |
| |
| /** |
| * This commutative operation returns the first common superclass (narrowest ReferenceType |
| * referencing a class, not an interface). |
| * If one of the types is a superclass of the other, the former is returned. |
| * If "this" is Type.NULL, then t is returned. |
| * If t is Type.NULL, then "this" is returned. |
| * If "this" equals t ['this.equals(t)'] "this" is returned. |
| * If "this" or t is an ArrayType, then Type.OBJECT is returned. |
| * If "this" or t is a ReferenceType referencing an interface, then Type.OBJECT is returned. |
| * If not all of the two classes' superclasses cannot be found, "null" is returned. |
| * See the JVM specification edition 2, "4.9.2 The Bytecode Verifier". |
| * |
| * @deprecated use getFirstCommonSuperclass(ReferenceType t) which has |
| * slightly changed semantics. |
| * @throws ClassNotFoundException on failure to find superclasses of this |
| * type, or the type passed as a parameter |
| */ |
| @Deprecated |
| public ReferenceType firstCommonSuperclass( final ReferenceType t ) throws ClassNotFoundException { |
| if (this.equals(Type.NULL)) { |
| return t; |
| } |
| if (t.equals(Type.NULL)) { |
| return this; |
| } |
| if (this.equals(t)) { |
| return this; |
| /* |
| * TODO: Above sounds a little arbitrary. On the other hand, there is |
| * no object referenced by Type.NULL so we can also say all the objects |
| * referenced by Type.NULL were derived from java.lang.Object. |
| * However, the Java Language's "instanceof" operator proves us wrong: |
| * "null" is not referring to an instance of java.lang.Object :) |
| */ |
| } |
| if ((this instanceof ArrayType) || (t instanceof ArrayType)) { |
| return Type.OBJECT; |
| // TODO: Is there a proof of OBJECT being the direct ancestor of every ArrayType? |
| } |
| if (((this instanceof ObjectType) && ((ObjectType) this).referencesInterface()) |
| || ((t instanceof ObjectType) && ((ObjectType) t).referencesInterface())) { |
| return Type.OBJECT; |
| // TODO: The above line is correct comparing to the vmspec2. But one could |
| // make class file verification a bit stronger here by using the notion of |
| // superinterfaces or even castability or assignment compatibility. |
| } |
| // this and t are ObjectTypes, see above. |
| final ObjectType thiz = (ObjectType) this; |
| final ObjectType other = (ObjectType) t; |
| final JavaClass[] thiz_sups = Repository.getSuperClasses(thiz.getClassName()); |
| final JavaClass[] other_sups = Repository.getSuperClasses(other.getClassName()); |
| if ((thiz_sups == null) || (other_sups == null)) { |
| return null; |
| } |
| // Waaahh... |
| final JavaClass[] this_sups = new JavaClass[thiz_sups.length + 1]; |
| final JavaClass[] t_sups = new JavaClass[other_sups.length + 1]; |
| System.arraycopy(thiz_sups, 0, this_sups, 1, thiz_sups.length); |
| System.arraycopy(other_sups, 0, t_sups, 1, other_sups.length); |
| this_sups[0] = Repository.lookupClass(thiz.getClassName()); |
| t_sups[0] = Repository.lookupClass(other.getClassName()); |
| for (final JavaClass t_sup : t_sups) { |
| for (final JavaClass this_sup : this_sups) { |
| if (this_sup.equals(t_sup)) { |
| return ObjectType.getInstance(this_sup.getClassName()); |
| } |
| } |
| } |
| // Huh? Did you ask for Type.OBJECT's superclass?? |
| return null; |
| } |
| } |