| /*** |
| * ASM: a very small and fast Java bytecode manipulation framework |
| * Copyright (c) 2000-2005 INRIA, France Telecom |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the copyright holders nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
| * THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| package org.objectweb.asm.tree.analysis; |
| |
| import java.util.List; |
| |
| import org.objectweb.asm.Type; |
| |
| /** |
| * An extended {@link BasicVerifier} that performs more precise verifications. |
| * This verifier computes exact class types, instead of using a single "object |
| * reference" type (as done in the {@link BasicVerifier}). |
| * |
| * @author Eric Bruneton |
| * @author Bing Ran |
| */ |
| public class SimpleVerifier extends BasicVerifier { |
| |
| /** |
| * The class that is verified. |
| */ |
| private final Type currentClass; |
| |
| /** |
| * The super class of the class that is verified. |
| */ |
| private final Type currentSuperClass; |
| |
| /** |
| * The interfaces implemented by the class that is verified. |
| */ |
| private final List currentClassInterfaces; |
| |
| /** |
| * If the class that is verified is an interface. |
| */ |
| private final boolean isInterface; |
| |
| /** |
| * Constructs a new {@link SimpleVerifier}. |
| */ |
| public SimpleVerifier() { |
| this(null, null, false); |
| } |
| |
| /** |
| * Constructs a new {@link SimpleVerifier} to verify a specific class. This |
| * class will not be loaded into the JVM since it may be incorrect. |
| * |
| * @param currentClass the class that is verified. |
| * @param currentSuperClass the super class of the class that is verified. |
| * @param isInterface if the class that is verified is an interface. |
| */ |
| public SimpleVerifier( |
| final Type currentClass, |
| final Type currentSuperClass, |
| final boolean isInterface) |
| { |
| this(currentClass, currentSuperClass, null, isInterface); |
| } |
| |
| /** |
| * Constructs a new {@link SimpleVerifier} to verify a specific class. This |
| * class will not be loaded into the JVM since it may be incorrect. |
| * |
| * @param currentClass the class that is verified. |
| * @param currentSuperClass the super class of the class that is verified. |
| * @param currentClassInterfaces the interfaces implemented by the class |
| * that is verified. |
| * @param isInterface if the class that is verified is an interface. |
| */ |
| public SimpleVerifier( |
| final Type currentClass, |
| final Type currentSuperClass, |
| final List currentClassInterfaces, |
| final boolean isInterface) |
| { |
| this.currentClass = currentClass; |
| this.currentSuperClass = currentSuperClass; |
| this.currentClassInterfaces = currentClassInterfaces; |
| this.isInterface = isInterface; |
| } |
| |
| public Value newValue(final Type type) { |
| Value v = super.newValue(type); |
| if (v == BasicValue.REFERENCE_VALUE) { |
| v = new BasicValue(type); |
| } |
| return v; |
| } |
| |
| protected boolean isArrayValue(final Value value) { |
| Type t = ((BasicValue) value).getType(); |
| if (t != null) { |
| return t.getDescriptor().equals("Lnull;") |
| || t.getSort() == Type.ARRAY; |
| } |
| return false; |
| } |
| |
| protected Value getElementValue(final Value objectArrayValue) |
| throws AnalyzerException |
| { |
| Type arrayType = ((BasicValue) objectArrayValue).getType(); |
| if (arrayType != null) { |
| if (arrayType.getSort() == Type.ARRAY) { |
| return newValue(Type.getType(arrayType.getDescriptor() |
| .substring(1))); |
| } else if (arrayType.getDescriptor().equals("Lnull;")) { |
| return objectArrayValue; |
| } |
| } |
| throw new AnalyzerException("Not an array type"); |
| } |
| |
| protected boolean isSubTypeOf(final Value value, final Value expected) { |
| Type expectedType = ((BasicValue) expected).getType(); |
| Type type = ((BasicValue) value).getType(); |
| if (expectedType == null) { |
| return type == null; |
| } |
| switch (expectedType.getSort()) { |
| case Type.INT: |
| case Type.FLOAT: |
| case Type.LONG: |
| case Type.DOUBLE: |
| return type == expectedType; |
| case Type.ARRAY: |
| case Type.OBJECT: |
| if (expectedType.getDescriptor().equals("Lnull;")) { |
| return type.getSort() == Type.OBJECT |
| || type.getSort() == Type.ARRAY; |
| } |
| if (type.getDescriptor().equals("Lnull;")) { |
| return true; |
| } else if (type.getSort() == Type.OBJECT |
| || type.getSort() == Type.ARRAY) |
| { |
| return isAssignableFrom(expectedType, type); |
| } else { |
| return false; |
| } |
| default: |
| throw new RuntimeException("Internal error"); |
| } |
| } |
| |
| public Value merge(final Value v, final Value w) { |
| if (!v.equals(w)) { |
| Type t = ((BasicValue) v).getType(); |
| Type u = ((BasicValue) w).getType(); |
| if (t != null |
| && (t.getSort() == Type.OBJECT || t.getSort() == Type.ARRAY)) |
| { |
| if (u != null |
| && (u.getSort() == Type.OBJECT || u.getSort() == Type.ARRAY)) |
| { |
| if (t.getDescriptor().equals("Lnull;")) { |
| return w; |
| } |
| if (u.getDescriptor().equals("Lnull;")) { |
| return v; |
| } |
| if (isAssignableFrom(t, u)) { |
| return v; |
| } |
| if (isAssignableFrom(u, t)) { |
| return w; |
| } |
| // TODO case of array classes of the same dimension |
| // TODO should we look also for a common super interface? |
| // problem: there may be several possible common super |
| // interfaces |
| do { |
| if (t == null || isInterface(t)) { |
| return BasicValue.REFERENCE_VALUE; |
| } |
| t = getSuperClass(t); |
| if (isAssignableFrom(t, u)) { |
| return newValue(t); |
| } |
| } while (true); |
| } |
| } |
| return BasicValue.UNINITIALIZED_VALUE; |
| } |
| return v; |
| } |
| |
| private boolean isInterface(final Type t) { |
| if (currentClass != null && t.equals(currentClass)) { |
| return isInterface; |
| } |
| return getClass(t).isInterface(); |
| } |
| |
| private Type getSuperClass(final Type t) { |
| if (currentClass != null && t.equals(currentClass)) { |
| return currentSuperClass; |
| } |
| Class c = getClass(t).getSuperclass(); |
| return c == null ? null : Type.getType(c); |
| } |
| |
| private boolean isAssignableFrom(final Type t, final Type u) { |
| if (t.equals(u)) { |
| return true; |
| } |
| if (currentClass != null && t.equals(currentClass)) { |
| return isAssignableFrom(t, getSuperClass(u)); |
| } |
| if (currentClass != null && u.equals(currentClass)) { |
| if (isAssignableFrom(t, currentSuperClass)) { |
| return true; |
| } |
| if (currentClassInterfaces != null) { |
| for (int i = 0; i < currentClassInterfaces.size(); ++i) { |
| Type v = (Type) currentClassInterfaces.get(i); |
| if (isAssignableFrom(t, v)) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| return getClass(t).isAssignableFrom(getClass(u)); |
| } |
| |
| protected Class getClass(final Type t) { |
| try { |
| if (t.getSort() == Type.ARRAY) { |
| return Class.forName(t.getDescriptor().replace('/', '.')); |
| } |
| return Class.forName(t.getClassName()); |
| } catch (ClassNotFoundException e) { |
| throw new RuntimeException(e.toString()); |
| } |
| } |
| } |
