jdk8-mips64-public/langtools: test/tools/javac/lambda/bytecode/TestLambdaBytecode.java@c6728c9addff (annotated)

test/tools/javac/lambda/bytecode/TestLambdaBytecode.java@c6728c9addff (annotated)

test/tools/javac/lambda/bytecode/TestLambdaBytecode.java

Fri, 22 Mar 2013 12:43:09 +0000

author: mcimadamore
date: Fri, 22 Mar 2013 12:43:09 +0000
changeset 1655: c6728c9addff
parent 1652: cc38a6723663
child 1752: c09b7234cded
permissions: -rw-r--r--

8010303: Graph inference: missing incorporation step causes spurious inference error
Summary: Multiple equality constraints on inference vars are not used to generate new inference constraints
Reviewed-by: jjg

 /*
  * 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.
  */
 /*
  * @test
  * @bug 8009649
  * @summary Lambda back-end should generate invokespecial for method handles referring to private instance methods
  * @library ../../lib
  * @build JavacTestingAbstractThreadedTest
  * @run main/othervm TestLambdaBytecode
  */
 // use /othervm to avoid jtreg timeout issues (CODETOOLS-7900047)
 // see JDK-8006746
 import com.sun.tools.classfile.Attribute;
 import com.sun.tools.classfile.BootstrapMethods_attribute;
 import com.sun.tools.classfile.ClassFile;
 import com.sun.tools.classfile.Code_attribute;
 import com.sun.tools.classfile.ConstantPool.*;
 import com.sun.tools.classfile.Instruction;
 import com.sun.tools.classfile.Method;
 import com.sun.tools.javac.api.JavacTaskImpl;
 import java.io.File;
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Locale;
 import javax.tools.Diagnostic;
 import javax.tools.JavaFileObject;
 import javax.tools.SimpleJavaFileObject;
 import static com.sun.tools.javac.jvm.ClassFile.*;
 public class TestLambdaBytecode
     extends JavacTestingAbstractThreadedTest
     implements Runnable {
     enum ClassKind {
         CLASS("class"),
         INTERFACE("interface");
         String classStr;
         ClassKind(String classStr) {
             this.classStr = classStr;
         }
     }
     enum AccessKind {
         PUBLIC("public"),
         PRIVATE("private");
         String accessStr;
         AccessKind(String accessStr) {
             this.accessStr = accessStr;
         }
     }
     enum StaticKind {
         STATIC("static"),
         INSTANCE("");
         String staticStr;
         StaticKind(String staticStr) {
             this.staticStr = staticStr;
         }
     }
     enum DefaultKind {
         DEFAULT("default"),
         NO_DEFAULT("");
         String defaultStr;
         DefaultKind(String defaultStr) {
             this.defaultStr = defaultStr;
         }
     }
     enum ExprKind {
         LAMBDA("Runnable r = ()->{ target(); };");
         String exprString;
         ExprKind(String exprString) {
             this.exprString = exprString;
         }
     }
     static class MethodKind {
         ClassKind ck;
         AccessKind ak;
         StaticKind sk;
         DefaultKind dk;
         MethodKind(ClassKind ck, AccessKind ak, StaticKind sk, DefaultKind dk) {
             this.ck = ck;
             this.ak = ak;
             this.sk = sk;
             this.dk = dk;
         }
         boolean inInterface() {
             return ck == ClassKind.INTERFACE;
         }
         boolean isPrivate() {
             return ak == AccessKind.PRIVATE;
         }
         boolean isStatic() {
             return sk == StaticKind.STATIC;
         }
         boolean isDefault() {
             return dk == DefaultKind.DEFAULT;
         }
         boolean isOK() {
             if (isDefault() && (!inInterface() || isStatic())) {
                 return false;
             } else if (inInterface() &&
                     ((!isStatic() && !isDefault()) || isPrivate())) {
                 return false;
             } else {
                 return true;
             }
         }
         String mods() {
             StringBuilder buf = new StringBuilder();
             buf.append(ak.accessStr);
             buf.append(' ');
             buf.append(sk.staticStr);
             buf.append(' ');
             buf.append(dk.defaultStr);
             return buf.toString();
         }
     }
     public static void main(String... args) throws Exception {
         for (ClassKind ck : ClassKind.values()) {
             for (AccessKind ak1 : AccessKind.values()) {
                 for (StaticKind sk1 : StaticKind.values()) {
                     for (DefaultKind dk1 : DefaultKind.values()) {
                         for (AccessKind ak2 : AccessKind.values()) {
                             for (StaticKind sk2 : StaticKind.values()) {
                                 for (DefaultKind dk2 : DefaultKind.values()) {
                                     for (ExprKind ek : ExprKind.values()) {
                                         pool.execute(new TestLambdaBytecode(ck, ak1, ak2, sk1, sk2, dk1, dk2, ek));
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
         checkAfterExec();
     }
     MethodKind mk1, mk2;
     ExprKind ek;
     DiagChecker dc;
     TestLambdaBytecode(ClassKind ck, AccessKind ak1, AccessKind ak2, StaticKind sk1,
             StaticKind sk2, DefaultKind dk1, DefaultKind dk2, ExprKind ek) {
         mk1 = new MethodKind(ck, ak1, sk1, dk1);
         mk2 = new MethodKind(ck, ak2, sk2, dk2);
         this.ek = ek;
         dc = new DiagChecker();
     }
     public void run() {
         int id = checkCount.incrementAndGet();
         JavaSource source = new JavaSource(id);
         JavacTaskImpl ct = (JavacTaskImpl)comp.getTask(null, fm.get(), dc,
                 null, null, Arrays.asList(source));
         try {
             ct.generate();
         } catch (Throwable t) {
             t.printStackTrace();
             throw new AssertionError(
                     String.format("Error thrown when compiling following code\n%s",
                     source.source));
         }
         if (dc.diagFound) {
             boolean errorExpected = !mk1.isOK() || !mk2.isOK();
             errorExpected |= mk1.isStatic() && !mk2.isStatic();
             if (!errorExpected) {
                 throw new AssertionError(
                         String.format("Diags found when compiling following code\n%s\n\n%s",
                         source.source, dc.printDiags()));
             }
             return;
         }
         verifyBytecode(id, source);
     }
     void verifyBytecode(int id, JavaSource source) {
         File compiledTest = new File(String.format("Test%d.class", id));
         try {
             ClassFile cf = ClassFile.read(compiledTest);
             Method testMethod = null;
             for (Method m : cf.methods) {
                 if (m.getName(cf.constant_pool).equals("test")) {
                     testMethod = m;
                     break;
                 }
             }
             if (testMethod == null) {
                 throw new Error("Test method not found");
             }
             Code_attribute ea =
                     (Code_attribute)testMethod.attributes.get(Attribute.Code);
             if (testMethod == null) {
                 throw new Error("Code attribute for test() method not found");
             }
             int bsmIdx = -1;
             for (Instruction i : ea.getInstructions()) {
                 if (i.getMnemonic().equals("invokedynamic")) {
                     CONSTANT_InvokeDynamic_info indyInfo =
                          (CONSTANT_InvokeDynamic_info)cf
                             .constant_pool.get(i.getShort(1));
                     bsmIdx = indyInfo.bootstrap_method_attr_index;
                     if (!indyInfo.getNameAndTypeInfo().getType().equals(makeIndyType(id))) {
                         throw new
                             AssertionError("type mismatch for CONSTANT_InvokeDynamic_info " + source.source + "\n" + indyInfo.getNameAndTypeInfo().getType() + "\n" + makeIndyType(id));
                     }
                 }
             }
             if (bsmIdx == -1) {
                 throw new Error("Missing invokedynamic in generated code");
             }
             BootstrapMethods_attribute bsm_attr =
                     (BootstrapMethods_attribute)cf
                     .getAttribute(Attribute.BootstrapMethods);
             if (bsm_attr.bootstrap_method_specifiers.length != 1) {
                 throw new Error("Bad number of method specifiers " +
                         "in BootstrapMethods attribute");
             }
             BootstrapMethods_attribute.BootstrapMethodSpecifier bsm_spec =
                     bsm_attr.bootstrap_method_specifiers[0];
             if (bsm_spec.bootstrap_arguments.length != MF_ARITY) {
                 throw new Error("Bad number of static invokedynamic args " +
                         "in BootstrapMethod attribute");
             }
             CONSTANT_MethodHandle_info mh =
                     (CONSTANT_MethodHandle_info)cf.constant_pool.get(bsm_spec.bootstrap_arguments[1]);
             boolean kindOK;
             switch (mh.reference_kind) {
                 case REF_invokeStatic: kindOK = mk2.isStatic(); break;
                 case REF_invokeSpecial: kindOK = !mk2.isStatic(); break;
                 case REF_invokeInterface: kindOK = mk2.inInterface(); break;
                 default:
                     kindOK = false;
             }
             if (!kindOK) {
                 throw new Error("Bad invoke kind in implementation method handle");
             }
             if (!mh.getCPRefInfo().getNameAndTypeInfo().getType().toString().equals(MH_SIG)) {
                 throw new Error("Type mismatch in implementation method handle");
             }
         } catch (Exception e) {
             e.printStackTrace();
             throw new Error("error reading " + compiledTest +": " + e);
         }
     }
     String makeIndyType(int id) {
         StringBuilder buf = new StringBuilder();
         buf.append("(");
         if (!mk2.isStatic() || mk1.inInterface()) {
             buf.append(String.format("LTest%d;", id));
         }
         buf.append(")Ljava/lang/Runnable;");
         return buf.toString();
     }
     static final int MF_ARITY = 3;
     static final String MH_SIG = "()V";
     class JavaSource extends SimpleJavaFileObject {
         static final String source_template =
                 "#CK Test#ID {\n" +
                 "   #MOD1 void test() { #EK }\n" +
                 "   #MOD2 void target() { }\n" +
                 "}\n";
         String source;
         JavaSource(int id) {
             super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
             source = source_template.replace("#CK", mk1.ck.classStr)
                     .replace("#MOD1", mk1.mods())
                     .replace("#MOD2", mk2.mods())
                     .replace("#EK", ek.exprString)
                     .replace("#ID", String.valueOf(id));
         }
         @Override
         public CharSequence getCharContent(boolean ignoreEncodingErrors) {
             return source;
         }
     }
     static class DiagChecker
         implements javax.tools.DiagnosticListener<JavaFileObject> {
         boolean diagFound;
         ArrayList<String> diags = new ArrayList<>();
         public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
             diags.add(diagnostic.getMessage(Locale.getDefault()));
             diagFound = true;
         }
         String printDiags() {
             StringBuilder buf = new StringBuilder();
             for (String s : diags) {
                 buf.append(s);
                 buf.append("\n");
             }
             return buf.toString();
         }
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

test/tools/javac/lambda/bytecode/TestLambdaBytecode.java@c6728c9addff (annotated)

test/tools/javac/lambda/bytecode/TestLambdaBytecode.java