java-allocation-instrumenter/src/main/java/com/google/monitoring/runtime/instrumentation/StaticClassWriter.java - toolchain/jack - Git at Google

 /***
  * ASM tests
  * Copyright (c) 2002-2005 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.
  */

 // Portions Copyright 2011 Google, Inc.
 //
 // This is an extracted version of the ClassInfo and ClassWriter
 // portions of ClassWriterComputeFramesTest in the set of ASM tests.
 // We have done a fair bit of rewriting for readability, and changed
 // the comments.  The original author is Eric Bruneton.


 package com.google.monitoring.runtime.instrumentation;

 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;

 import java.io.InputStream;
 import java.io.IOException;

 /**
  * A {@link ClassWriter} that looks for static class data in the
  * classpath when the classes are not available at runtime.
  *
  * <p>ClassWriter uses class hierarchy information, which it gets by
  * looking at loaded classes, to make some decisions about the best
  * way to write classes.  The problem with this is that it fails if
  * the superclass hasn't been loaded yet.  StaticClassWriter fails
  * over to looking for the class hierarchy information in the
  * ClassLoader's resources (usually the classpath) if the class it
  * needs hasn't been loaded yet.
  *
  * <p>This class was heavily influenced by ASM's
  * org.objectweb.asm.util.ClassWriterComputeFramesTest, which contains
  * the same logic in a subclass.  The code here has been slightly
  * cleaned up for readability.
  *
  * @author jeremymanson@google.com (Jeremy Manson)
  */
 class StaticClassWriter extends ClassWriter {

   /* The classloader that we use to look for the unloaded class */
   private final ClassLoader classLoader;

   /**
    * {@inheritDoc}
    * @param classLoader the class loader that loaded this class
    */
   public StaticClassWriter(
       ClassReader classReader, int flags, ClassLoader classLoader) {
     super(classReader, flags);
     this.classLoader = classLoader;
   }

   /**
    * {@inheritDoc}
    */
   @Override protected String getCommonSuperClass(
       final String type1, final String type2) {
     try {
       return super.getCommonSuperClass(type1, type2);
     } catch (Throwable e) {
       // Try something else...
     }
     // Exactly the same as in ClassWriter, but gets the superclass
     // directly from the class file.
     ClassInfo ci1, ci2;
     try {
       ci1 = new ClassInfo(type1, classLoader);
       ci2 = new ClassInfo(type2, classLoader);
     } catch (Throwable e) {
       throw new RuntimeException(e);
     }
     if (ci1.isAssignableFrom(ci2)) {
       return type1;
     }
     if (ci2.isAssignableFrom(ci1)) {
       return type2;
     }
     if (ci1.isInterface() || ci2.isInterface()) {
       return "java/lang/Object";
     }

     do {
       // Should never be null, because if ci1 were the Object class
       // or an interface, it would have been caught above.
       ci1 = ci1.getSuperclass();
     } while (!ci1.isAssignableFrom(ci2));
     return ci1.getType().getInternalName();
   }

   /**
    * For a given class, this stores the information needed by the
    * getCommonSuperClass test.  This determines if the class is
    * available at runtime, and then, if it isn't, it tries to get the
    * class file, and extract the appropriate information from that.
    */
   static class ClassInfo {

     private final Type type;
     private final ClassLoader loader;
     private final boolean isInterface;
     private final String superClass;
     private final String[] interfaces;

     public ClassInfo(String type, ClassLoader loader) {
       Class cls = null;
       // First, see if we can extract the information from the class...
       try {
         cls = Class.forName(type);
       } catch (Exception e) {
         // failover...
       }

       if (cls != null) {
         this.type = Type.getType(cls);
         this.loader = loader;
         this.isInterface = cls.isInterface();
         this.superClass = cls.getSuperclass().getName();
         Class[] ifs = cls.getInterfaces();
         this.interfaces = new String[ifs.length];
         for (int i = 0; i < ifs.length; i++) {
           this.interfaces[i] = ifs[i].getName();
         }
         return;
       }

       // The class isn't loaded.  Try to get the class file, and
       // extract the information from that.
       this.loader = loader;
       this.type = Type.getObjectType(type);
       String fileName = type.replace('.', '/') + ".class";
       InputStream is = null;
       ClassReader cr;
       try {
         is = (loader == null) ?
             ClassLoader.getSystemResourceAsStream(fileName) :
             loader.getResourceAsStream(fileName);
         cr = new ClassReader(is);
       } catch (IOException e) {
         throw new RuntimeException(e);
       } finally {
         if (is != null) {
           try {
             is.close();
           } catch (Exception e) {
           }
         }
       }

       int offset = cr.header;
       isInterface = (cr.readUnsignedShort(offset) & Opcodes.ACC_INTERFACE) != 0;
       char[] buf = new char[2048];

       // Read the superclass
       offset += 4;
       superClass = readConstantPoolString(cr, offset, buf);

       // Read the interfaces
       offset += 2;
       int numInterfaces = cr.readUnsignedShort(offset);
       interfaces = new String[numInterfaces];
       offset += 2;
       for (int i = 0; i < numInterfaces; i++) {
         interfaces[i] = readConstantPoolString(cr, offset, buf);
         offset += 2;
       }
     }

     String readConstantPoolString(ClassReader cr, int offset, char[] buf) {
       int cpIndex = cr.getItem(cr.readUnsignedShort(offset));
       if (cpIndex == 0) {
         return null;
         // throw new RuntimeException("Bad constant pool index");
       }
       return cr.readUTF8(cpIndex, buf);
     }

     Type getType() {
       return type;
     }

     ClassInfo getSuperclass() {
       if (superClass == null) {
         return null;
       }
       return new ClassInfo(superClass, loader);
     }

     /**
      * Same as {@link Class#getInterfaces()}
      */
     ClassInfo[] getInterfaces() {
       if (interfaces == null) {
         return new ClassInfo[0];
       }
       ClassInfo[] result = new ClassInfo[interfaces.length];
       for (int i = 0; i < result.length; ++i) {
         result[i] = new ClassInfo(interfaces[i], loader);
       }
       return result;
     }

     /**
      * Same as {@link Class#isInterface}
      */
     boolean isInterface() {
       return isInterface;
     }

     private boolean implementsInterface(ClassInfo that) {
       for (ClassInfo c = this; c != null; c = c.getSuperclass()) {
         for (ClassInfo iface : c.getInterfaces()) {
           if (iface.type.equals(that.type) ||
               iface.implementsInterface(that)) {
             return true;
           }
         }
       }
       return false;
     }

     private boolean isSubclassOf(ClassInfo that) {
       for (ClassInfo ci = this; ci != null; ci = ci.getSuperclass()) {
         if (ci.getSuperclass() != null &&
             ci.getSuperclass().type.equals(that.type)) {
           return true;
         }
       }
       return false;
     }

     /**
      * Same as {@link Class#isAssignableFrom(Class)}
      */
     boolean isAssignableFrom(ClassInfo that) {
       return (this == that ||
               that.isSubclassOf(this) ||
               that.implementsInterface(this) ||
               (that.isInterface()
                && getType().getDescriptor().equals("Ljava/lang/Object;")));
     }
   }

 }
	/***
	* ASM tests
	* Copyright (c) 2002-2005 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.
	*/

	// Portions Copyright 2011 Google, Inc.
	//
	// This is an extracted version of the ClassInfo and ClassWriter
	// portions of ClassWriterComputeFramesTest in the set of ASM tests.
	// We have done a fair bit of rewriting for readability, and changed
	// the comments. The original author is Eric Bruneton.


	package com.google.monitoring.runtime.instrumentation;

	import org.objectweb.asm.ClassReader;
	import org.objectweb.asm.ClassWriter;
	import org.objectweb.asm.Opcodes;
	import org.objectweb.asm.Type;

	import java.io.InputStream;
	import java.io.IOException;

	/**
	* A {@link ClassWriter} that looks for static class data in the
	* classpath when the classes are not available at runtime.
	*
	* <p>ClassWriter uses class hierarchy information, which it gets by
	* looking at loaded classes, to make some decisions about the best
	* way to write classes. The problem with this is that it fails if
	* the superclass hasn't been loaded yet. StaticClassWriter fails
	* over to looking for the class hierarchy information in the
	* ClassLoader's resources (usually the classpath) if the class it
	* needs hasn't been loaded yet.
	*
	* <p>This class was heavily influenced by ASM's
	* org.objectweb.asm.util.ClassWriterComputeFramesTest, which contains
	* the same logic in a subclass. The code here has been slightly
	* cleaned up for readability.
	*
	* @author jeremymanson@google.com (Jeremy Manson)
	*/
	class StaticClassWriter extends ClassWriter {

	/* The classloader that we use to look for the unloaded class */
	private final ClassLoader classLoader;

	/**
	* {@inheritDoc}
	* @param classLoader the class loader that loaded this class
	*/
	public StaticClassWriter(
	ClassReader classReader, int flags, ClassLoader classLoader) {
	super(classReader, flags);
	this.classLoader = classLoader;
	}

	/**
	* {@inheritDoc}
	*/
	@Override protected String getCommonSuperClass(
	final String type1, final String type2) {
	try {
	return super.getCommonSuperClass(type1, type2);
	} catch (Throwable e) {
	// Try something else...
	}
	// Exactly the same as in ClassWriter, but gets the superclass
	// directly from the class file.
	ClassInfo ci1, ci2;
	try {
	ci1 = new ClassInfo(type1, classLoader);
	ci2 = new ClassInfo(type2, classLoader);
	} catch (Throwable e) {
	throw new RuntimeException(e);
	}
	if (ci1.isAssignableFrom(ci2)) {
	return type1;
	}
	if (ci2.isAssignableFrom(ci1)) {
	return type2;
	}
	if (ci1.isInterface() \|\| ci2.isInterface()) {
	return "java/lang/Object";
	}

	do {
	// Should never be null, because if ci1 were the Object class
	// or an interface, it would have been caught above.
	ci1 = ci1.getSuperclass();
	} while (!ci1.isAssignableFrom(ci2));
	return ci1.getType().getInternalName();
	}

	/**
	* For a given class, this stores the information needed by the
	* getCommonSuperClass test. This determines if the class is
	* available at runtime, and then, if it isn't, it tries to get the
	* class file, and extract the appropriate information from that.
	*/
	static class ClassInfo {

	private final Type type;
	private final ClassLoader loader;
	private final boolean isInterface;
	private final String superClass;
	private final String[] interfaces;

	public ClassInfo(String type, ClassLoader loader) {
	Class cls = null;
	// First, see if we can extract the information from the class...
	try {
	cls = Class.forName(type);
	} catch (Exception e) {
	// failover...
	}

	if (cls != null) {
	this.type = Type.getType(cls);
	this.loader = loader;
	this.isInterface = cls.isInterface();
	this.superClass = cls.getSuperclass().getName();
	Class[] ifs = cls.getInterfaces();
	this.interfaces = new String[ifs.length];
	for (int i = 0; i < ifs.length; i++) {
	this.interfaces[i] = ifs[i].getName();
	}
	return;
	}

	// The class isn't loaded. Try to get the class file, and
	// extract the information from that.
	this.loader = loader;
	this.type = Type.getObjectType(type);
	String fileName = type.replace('.', '/') + ".class";
	InputStream is = null;
	ClassReader cr;
	try {
	is = (loader == null) ?
	ClassLoader.getSystemResourceAsStream(fileName) :
	loader.getResourceAsStream(fileName);
	cr = new ClassReader(is);
	} catch (IOException e) {
	throw new RuntimeException(e);
	} finally {
	if (is != null) {
	try {
	is.close();
	} catch (Exception e) {
	}
	}
	}

	int offset = cr.header;
	isInterface = (cr.readUnsignedShort(offset) & Opcodes.ACC_INTERFACE) != 0;
	char[] buf = new char[2048];

	// Read the superclass
	offset += 4;
	superClass = readConstantPoolString(cr, offset, buf);

	// Read the interfaces
	offset += 2;
	int numInterfaces = cr.readUnsignedShort(offset);
	interfaces = new String[numInterfaces];
	offset += 2;
	for (int i = 0; i < numInterfaces; i++) {
	interfaces[i] = readConstantPoolString(cr, offset, buf);
	offset += 2;
	}
	}

	String readConstantPoolString(ClassReader cr, int offset, char[] buf) {
	int cpIndex = cr.getItem(cr.readUnsignedShort(offset));
	if (cpIndex == 0) {
	return null;
	// throw new RuntimeException("Bad constant pool index");
	}
	return cr.readUTF8(cpIndex, buf);
	}

	Type getType() {
	return type;
	}

	ClassInfo getSuperclass() {
	if (superClass == null) {
	return null;
	}
	return new ClassInfo(superClass, loader);
	}

	/**
	* Same as {@link Class#getInterfaces()}
	*/
	ClassInfo[] getInterfaces() {
	if (interfaces == null) {
	return new ClassInfo[0];
	}
	ClassInfo[] result = new ClassInfo[interfaces.length];
	for (int i = 0; i < result.length; ++i) {
	result[i] = new ClassInfo(interfaces[i], loader);
	}
	return result;
	}

	/**
	* Same as {@link Class#isInterface}
	*/
	boolean isInterface() {
	return isInterface;
	}

	private boolean implementsInterface(ClassInfo that) {
	for (ClassInfo c = this; c != null; c = c.getSuperclass()) {
	for (ClassInfo iface : c.getInterfaces()) {
	if (iface.type.equals(that.type) \|\|
	iface.implementsInterface(that)) {
	return true;
	}
	}
	}
	return false;
	}

	private boolean isSubclassOf(ClassInfo that) {
	for (ClassInfo ci = this; ci != null; ci = ci.getSuperclass()) {
	if (ci.getSuperclass() != null &&
	ci.getSuperclass().type.equals(that.type)) {
	return true;
	}
	}
	return false;
	}

	/**
	* Same as {@link Class#isAssignableFrom(Class)}
	*/
	boolean isAssignableFrom(ClassInfo that) {
	return (this == that \|\|
	that.isSubclassOf(this) \|\|
	that.implementsInterface(this) \|\|
	(that.isInterface()
	&& getType().getDescriptor().equals("Ljava/lang/Object;")));
	}
	}

	}