Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

  * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  */

 import java.io.DataInputStream;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileWriter;

 import java.io.IOException;

 import java.io.PrintWriter;

 import javax.tools.JavaCompiler;

 import javax.tools.ToolProvider;

 /**

  * A class loader that generates new classes.

  * The generated classes are made by first emitting java sources with nested

  * static classes, these are then compiled and the class files are read back.

  * Some efforts are made to make the class instances unique and of not insignificant

  * size.

  */

 public class GeneratedClassLoader extends ClassLoader {

     /**

      * Holds a pair of class bytecodes and class name (for use with defineClass).

      */

     private static class GeneratedClass {

         public byte[] bytes;

         public String name;

         public GeneratedClass(byte[] bytes, String name) {

             this.bytes = bytes; this.name = name;

         }

     }

     /**

      * Used to uniquely name every class generated.

      */

     private static int count = 0;

     /**

      * Used to enable/disable keeping the class files and java sources for

      * the generated classes.

      */

     private static boolean deleteFiles = Boolean.parseBoolean(

         System.getProperty("GeneratedClassLoader.deleteFiles", "true"));

     private static String bigstr =

         "Lorem ipsum dolor sit amet, consectetur adipiscing elit. "

         + "In facilisis scelerisque vehicula. Donec congue nisi a "

         + "leo posuere placerat lobortis felis ultrices. Pellentesque "

         + "habitant morbi tristique senectus et netus et malesuada "

         + "fames ac turpis egestas. Nam tristique velit at felis "

         + "iaculis at tempor sem vestibulum. Sed adipiscing lectus "

         + "non mi molestie sagittis. Morbi eu purus urna. Nam tempor "

         + "tristique massa eget semper. Mauris cursus, nulla et ornare "

         + "vehicula, leo dolor scelerisque metus, sit amet rutrum erat "

         + "sapien quis dui. Nullam eleifend risus et velit accumsan sed "

         + "suscipit felis pulvinar. Nullam faucibus suscipit gravida. "

         + "Pellentesque habitant morbi tristique senectus et netus et "

         + "malesuada fames ac turpis egestas. Nullam ut massa augue, "

         + "nec viverra mauris.";

     private static int getNextCount() {

         return count++;

     }

     ////// end statics

     private JavaCompiler javac;

     private String nameBase;

     public GeneratedClassLoader() {

         javac = ToolProvider.getSystemJavaCompiler();

         nameBase = "TestSimpleClass";

     }

     private long getBigValue(int which) {

         // > 65536 is too large to encode in the bytecode

         // so this will force us to emit a constant pool entry for this int

         return (long)which + 65537;

     }

     private String getBigString(int which) {

         return bigstr + which;

     }

     private String getClassName(int count) {

         return nameBase + count;

     }

     private String generateSource(int count, int sizeFactor, int numClasses) {

         StringBuilder sb = new StringBuilder();

         sb.append("public class ").append(getClassName(count)).append("{\n");

         for (int j = 0; j < numClasses; ++j) {

             sb.append("public static class ")

               .append("Class")

               .append(j)

               .append("{\n");

             for (int i = 0; i < sizeFactor; ++i) {

                 int value = i;

                 sb.append("private long field")

                   .append(i).append(" = ")

                   .append(getBigValue(value++))

                   .append(";\n");

                 sb.append("public long method")

                   .append(i)

                   .append("() {\n");

                 sb.append("return ")

                   .append(getBigValue(value++))

                   .append(";");

                 sb.append("}\n");

                 sb.append("private String str").append(i)

                   .append(" = \"")

                   .append(getBigString(i))

                   .append("\";");

             }

             sb.append("\n}");

         }

         sb.append("\n}");

         return sb.toString();

     }

     private GeneratedClass[] getGeneratedClass(int sizeFactor, int numClasses) throws IOException {

         int uniqueCount = getNextCount();

         String src = generateSource(uniqueCount, sizeFactor, numClasses);

         String className = getClassName(uniqueCount);

         File file = new File(className + ".java");

         try (PrintWriter pw = new PrintWriter(new FileWriter(file))) {

             pw.append(src);

             pw.flush();

         }

         int exitcode = javac.run(null, null, null, file.getCanonicalPath());

         if (exitcode != 0) {

             throw new RuntimeException("javac failure when compiling: " +

                     file.getCanonicalPath());

         } else {

             if (deleteFiles) {

                 file.delete();

             }

         }

         GeneratedClass[] gc = new GeneratedClass[numClasses];

         for (int i = 0; i < numClasses; ++i) {

             String name = className + "$" + "Class" + i;

             File classFile = new File(name + ".class");

             byte[] bytes;

             try (DataInputStream dis = new DataInputStream(new FileInputStream(classFile))) {

                 bytes = new byte[dis.available()];

                 dis.readFully(bytes);

             }

             if (deleteFiles) {

                 classFile.delete();

             }

             gc[i] = new GeneratedClass(bytes, name);

         }

         if (deleteFiles) {

             new File(className + ".class").delete();

         }

         return gc;

     }

     /**

      * Generate a single class, compile it and load it.

      * @param sizeFactor Fuzzy measure of how large the class should be.

      * @return the Class instance.

      * @throws IOException

      */

     public Class<?> generateClass(int sizeFactor) throws IOException {

         return getGeneratedClasses(sizeFactor, 1)[0];

     }

     /**

      * Generate several classes, compile and load them.

      * @param sizeFactor Fuzzy measure of how large each class should be.

      * @param numClasses The number of classes to create

      * @return an array of the Class instances.

      * @throws IOException

      */

     public Class<?>[] getGeneratedClasses(int sizeFactor, int numClasses) throws IOException {

         GeneratedClass[] gc = getGeneratedClass(sizeFactor, numClasses);

         Class<?>[] classes = new Class[numClasses];

         for (int i = 0; i < numClasses; ++i) {

             classes[i] = defineClass(gc[i].name, gc[i].bytes, 0 , gc[i].bytes.length);

         }

         return classes;

     }

 }