asm4/src/org/objectweb/asm/tree/analysis/SimpleVerifier.java - toolchain/jill - Git at Google

 /***
  * ASM: a very small and fast Java bytecode manipulation framework
  * Copyright (c) 2000-2011 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<Type> currentClassInterfaces;

     /**
      * If the class that is verified is an interface.
      */
     private final boolean isInterface;

     /**
      * The loader to use for referenced classes.
      */
     private ClassLoader loader = getClass().getClassLoader();

     /**
      * 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<Type> currentClassInterfaces, final boolean isInterface) {
         this(ASM4, currentClass, currentSuperClass, currentClassInterfaces,
                 isInterface);
     }

     protected SimpleVerifier(final int api, final Type currentClass,
             final Type currentSuperClass,
             final List<Type> currentClassInterfaces, final boolean isInterface) {
         super(api);
         this.currentClass = currentClass;
         this.currentSuperClass = currentSuperClass;
         this.currentClassInterfaces = currentClassInterfaces;
         this.isInterface = isInterface;
     }

     /**
      * Set the <code>ClassLoader</code> which will be used to load referenced
      * classes. This is useful if you are verifying multiple interdependent
      * classes.
      *
      * @param loader
      *            a <code>ClassLoader</code> to use
      */
     public void setClassLoader(final ClassLoader loader) {
         this.loader = loader;
     }

     @Override
     public BasicValue newValue(final Type type) {
         if (type == null) {
             return BasicValue.UNINITIALIZED_VALUE;
         }

         boolean isArray = type.getSort() == Type.ARRAY;
         if (isArray) {
             switch (type.getElementType().getSort()) {
             case Type.BOOLEAN:
             case Type.CHAR:
             case Type.BYTE:
             case Type.SHORT:
                 return new BasicValue(type);
             }
         }

         BasicValue v = super.newValue(type);
         if (BasicValue.REFERENCE_VALUE.equals(v)) {
             if (isArray) {
                 v = newValue(type.getElementType());
                 String desc = v.getType().getDescriptor();
                 for (int i = 0; i < type.getDimensions(); ++i) {
                     desc = '[' + desc;
                 }
                 v = new BasicValue(Type.getType(desc));
             } else {
                 v = new BasicValue(type);
             }
         }
         return v;
     }

     @Override
     protected boolean isArrayValue(final BasicValue value) {
         Type t = value.getType();
         return t != null
                 && ("Lnull;".equals(t.getDescriptor()) || t.getSort() == Type.ARRAY);
     }

     @Override
     protected BasicValue getElementValue(final BasicValue objectArrayValue)
             throws AnalyzerException {
         Type arrayType = objectArrayValue.getType();
         if (arrayType != null) {
             if (arrayType.getSort() == Type.ARRAY) {
                 return newValue(Type.getType(arrayType.getDescriptor()
                         .substring(1)));
             } else if ("Lnull;".equals(arrayType.getDescriptor())) {
                 return objectArrayValue;
             }
         }
         throw new Error("Internal error");
     }

     @Override
     protected boolean isSubTypeOf(final BasicValue value,
             final BasicValue expected) {
         Type expectedType = expected.getType();
         Type type = value.getType();
         switch (expectedType.getSort()) {
         case Type.INT:
         case Type.FLOAT:
         case Type.LONG:
         case Type.DOUBLE:
             return type.equals(expectedType);
         case Type.ARRAY:
         case Type.OBJECT:
             if ("Lnull;".equals(type.getDescriptor())) {
                 return true;
             } else if (type.getSort() == Type.OBJECT
                     || type.getSort() == Type.ARRAY) {
                 return isAssignableFrom(expectedType, type);
             } else {
                 return false;
             }
         default:
             throw new Error("Internal error");
         }
     }

     @Override
     public BasicValue merge(final BasicValue v, final BasicValue w) {
         if (!v.equals(w)) {
             Type t = v.getType();
             Type u = 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 ("Lnull;".equals(t.getDescriptor())) {
                         return w;
                     }
                     if ("Lnull;".equals(u.getDescriptor())) {
                         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;
     }

     protected boolean isInterface(final Type t) {
         if (currentClass != null && t.equals(currentClass)) {
             return isInterface;
         }
         return getClass(t).isInterface();
     }

     protected 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);
     }

     protected boolean isAssignableFrom(final Type t, final Type u) {
         if (t.equals(u)) {
             return true;
         }
         if (currentClass != null && t.equals(currentClass)) {
             if (getSuperClass(u) == null) {
                 return false;
             } else {
                 if (isInterface) {
                     return u.getSort() == Type.OBJECT
                             || u.getSort() == Type.ARRAY;
                 }
                 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 = currentClassInterfaces.get(i);
                     if (isAssignableFrom(t, v)) {
                         return true;
                     }
                 }
             }
             return false;
         }
         Class<?> tc = getClass(t);
         if (tc.isInterface()) {
             tc = Object.class;
         }
         return tc.isAssignableFrom(getClass(u));
     }

     protected Class<?> getClass(final Type t) {
         try {
             if (t.getSort() == Type.ARRAY) {
                 return Class.forName(t.getDescriptor().replace('/', '.'),
                         false, loader);
             }
             return Class.forName(t.getClassName(), false, loader);
         } catch (ClassNotFoundException e) {
             throw new RuntimeException(e.toString());
         }
     }
 }
	/***
	* ASM: a very small and fast Java bytecode manipulation framework
	* Copyright (c) 2000-2011 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<Type> currentClassInterfaces;

	/**
	* If the class that is verified is an interface.
	*/
	private final boolean isInterface;

	/**
	* The loader to use for referenced classes.
	*/
	private ClassLoader loader = getClass().getClassLoader();

	/**
	* 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<Type> currentClassInterfaces, final boolean isInterface) {
	this(ASM4, currentClass, currentSuperClass, currentClassInterfaces,
	isInterface);
	}

	protected SimpleVerifier(final int api, final Type currentClass,
	final Type currentSuperClass,
	final List<Type> currentClassInterfaces, final boolean isInterface) {
	super(api);
	this.currentClass = currentClass;
	this.currentSuperClass = currentSuperClass;
	this.currentClassInterfaces = currentClassInterfaces;
	this.isInterface = isInterface;
	}

	/**
	* Set the <code>ClassLoader</code> which will be used to load referenced
	* classes. This is useful if you are verifying multiple interdependent
	* classes.
	*
	* @param loader
	* a <code>ClassLoader</code> to use
	*/
	public void setClassLoader(final ClassLoader loader) {
	this.loader = loader;
	}

	@Override
	public BasicValue newValue(final Type type) {
	if (type == null) {
	return BasicValue.UNINITIALIZED_VALUE;
	}

	boolean isArray = type.getSort() == Type.ARRAY;
	if (isArray) {
	switch (type.getElementType().getSort()) {
	case Type.BOOLEAN:
	case Type.CHAR:
	case Type.BYTE:
	case Type.SHORT:
	return new BasicValue(type);
	}
	}

	BasicValue v = super.newValue(type);
	if (BasicValue.REFERENCE_VALUE.equals(v)) {
	if (isArray) {
	v = newValue(type.getElementType());
	String desc = v.getType().getDescriptor();
	for (int i = 0; i < type.getDimensions(); ++i) {
	desc = '[' + desc;
	}
	v = new BasicValue(Type.getType(desc));
	} else {
	v = new BasicValue(type);
	}
	}
	return v;
	}

	@Override
	protected boolean isArrayValue(final BasicValue value) {
	Type t = value.getType();
	return t != null
	&& ("Lnull;".equals(t.getDescriptor()) \|\| t.getSort() == Type.ARRAY);
	}

	@Override
	protected BasicValue getElementValue(final BasicValue objectArrayValue)
	throws AnalyzerException {
	Type arrayType = objectArrayValue.getType();
	if (arrayType != null) {
	if (arrayType.getSort() == Type.ARRAY) {
	return newValue(Type.getType(arrayType.getDescriptor()
	.substring(1)));
	} else if ("Lnull;".equals(arrayType.getDescriptor())) {
	return objectArrayValue;
	}
	}
	throw new Error("Internal error");
	}

	@Override
	protected boolean isSubTypeOf(final BasicValue value,
	final BasicValue expected) {
	Type expectedType = expected.getType();
	Type type = value.getType();
	switch (expectedType.getSort()) {
	case Type.INT:
	case Type.FLOAT:
	case Type.LONG:
	case Type.DOUBLE:
	return type.equals(expectedType);
	case Type.ARRAY:
	case Type.OBJECT:
	if ("Lnull;".equals(type.getDescriptor())) {
	return true;
	} else if (type.getSort() == Type.OBJECT
	\|\| type.getSort() == Type.ARRAY) {
	return isAssignableFrom(expectedType, type);
	} else {
	return false;
	}
	default:
	throw new Error("Internal error");
	}
	}

	@Override
	public BasicValue merge(final BasicValue v, final BasicValue w) {
	if (!v.equals(w)) {
	Type t = v.getType();
	Type u = 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 ("Lnull;".equals(t.getDescriptor())) {
	return w;
	}
	if ("Lnull;".equals(u.getDescriptor())) {
	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;
	}

	protected boolean isInterface(final Type t) {
	if (currentClass != null && t.equals(currentClass)) {
	return isInterface;
	}
	return getClass(t).isInterface();
	}

	protected 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);
	}

	protected boolean isAssignableFrom(final Type t, final Type u) {
	if (t.equals(u)) {
	return true;
	}
	if (currentClass != null && t.equals(currentClass)) {
	if (getSuperClass(u) == null) {
	return false;
	} else {
	if (isInterface) {
	return u.getSort() == Type.OBJECT
	\|\| u.getSort() == Type.ARRAY;
	}
	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 = currentClassInterfaces.get(i);
	if (isAssignableFrom(t, v)) {
	return true;
	}
	}
	}
	return false;
	}
	Class<?> tc = getClass(t);
	if (tc.isInterface()) {
	tc = Object.class;
	}
	return tc.isAssignableFrom(getClass(u));
	}

	protected Class<?> getClass(final Type t) {
	try {
	if (t.getSort() == Type.ARRAY) {
	return Class.forName(t.getDescriptor().replace('/', '.'),
	false, loader);
	}
	return Class.forName(t.getClassName(), false, loader);
	} catch (ClassNotFoundException e) {
	throw new RuntimeException(e.toString());
	}
	}
	}