diff --git a/src/share/classes/com/sun/tools/javac/jvm/Gen.java b/src/share/classes/com/sun/tools/javac/jvm/Gen.java index 4dd587a9e14efe7027ef9c234f14b1501806d4c9..4c4b6a4be38cbd8f2faccbe35b36206e60c709f4 100644 --- a/src/share/classes/com/sun/tools/javac/jvm/Gen.java +++ b/src/share/classes/com/sun/tools/javac/jvm/Gen.java @@ -514,6 +514,10 @@ public class Gen extends JCTree.Visitor { clinitTAs.addAll(getAndRemoveNonFieldTAs(sym)); } else { checkStringConstant(vdef.init.pos(), sym.getConstValue()); + /* if the init contains a reference to an external class, add it to the + * constant's pool + */ + vdef.init.accept(classReferenceVisitor); } } break; @@ -2431,9 +2435,12 @@ public class Gen extends JCTree.Visitor { && !allowGenerics // no Miranda methods available with generics ) implementInterfaceMethods(c); - cdef.defs = normalizeDefs(cdef.defs, c); c.pool = pool; pool.reset(); + /* method normalizeDefs() can add references to external classes into the constant pool + * so it should be called after pool.reset() + */ + cdef.defs = normalizeDefs(cdef.defs, c); generateReferencesToPrunedTree(c, pool); Env localEnv = new Env(cdef, new GenContext()); diff --git a/test/tools/javac/7153958/CPoolRefClassContainingInlinedCts.java b/test/tools/javac/7153958/CPoolRefClassContainingInlinedCts.java index 2e26cf6b0cd43189bb9d403d35c57bb1181294ed..03376adc48445185bdc819251ef54ecf6a8d6b74 100644 --- a/test/tools/javac/7153958/CPoolRefClassContainingInlinedCts.java +++ b/test/tools/javac/7153958/CPoolRefClassContainingInlinedCts.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2015, 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 @@ -25,9 +25,9 @@ /* * @test - * @bug 7153958 + * @bug 7153958 8073372 * @summary add constant pool reference to class containing inlined constants - * @compile pkg/ClassToBeStaticallyImported.java CPoolRefClassContainingInlinedCts.java + * @compile pkg/ClassToBeStaticallyImportedA.java pkg/ClassToBeStaticallyImportedB.java CPoolRefClassContainingInlinedCts.java * @run main CPoolRefClassContainingInlinedCts */ @@ -38,7 +38,8 @@ import com.sun.tools.classfile.ConstantPoolException; import java.io.File; import java.io.IOException; -import static pkg.ClassToBeStaticallyImported.staticField; +import static pkg.ClassToBeStaticallyImportedA.staticFieldA; +import static pkg.ClassToBeStaticallyImportedB.staticFieldB; public class CPoolRefClassContainingInlinedCts { @@ -54,10 +55,14 @@ public class CPoolRefClassContainingInlinedCts { void checkClassName(String className) { switch (className) { - case "SimpleAssignClass" : case "BinaryExpClass": - case "UnaryExpClass" : case "CastClass": - case "ParensClass" : case "CondClass": - case "IfClass" : case "pkg/ClassToBeStaticallyImported": + case "SimpleAssignClassA" : case "BinaryExpClassA": + case "UnaryExpClassA" : case "CastClassA": + case "ParensClassA" : case "CondClassA": + case "IfClassA" : case "pkg/ClassToBeStaticallyImportedA": + case "SimpleAssignClassB" : case "BinaryExpClassB": + case "UnaryExpClassB" : case "CastClassB": + case "ParensClassB" : case "CondClassB": + case "IfClassB" : case "pkg/ClassToBeStaticallyImportedB": numberOfReferencedClassesToBeChecked++; } } @@ -76,59 +81,111 @@ public class CPoolRefClassContainingInlinedCts { } i += cpInfo.size(); } - if (numberOfReferencedClassesToBeChecked != 8) { + if (numberOfReferencedClassesToBeChecked != 16) { throw new AssertionError("Class reference missing in the constant pool"); } } - private int assign = SimpleAssignClass.x; - private int binary = BinaryExpClass.x + 1; - private int unary = -UnaryExpClass.x; - private int cast = (int)CastClass.x; - private int parens = (ParensClass.x); - private int cond = (CondClass.x == 1) ? 1 : 2; - private static int ifConstant; - private static int importStatic; + private int assignA = SimpleAssignClassA.x; + private int binaryA = BinaryExpClassA.x + 1; + private int unaryA = -UnaryExpClassA.x; + private int castA = (int)CastClassA.x; + private int parensA = (ParensClassA.x); + private int condA = (CondClassA.x == 1) ? 1 : 2; + private static int ifConstantA; + private static int importStaticA; static { - if (IfClass.x == 1) { - ifConstant = 1; + if (IfClassA.x == 1) { + ifConstantA = 1; } else { - ifConstant = 2; + ifConstantA = 2; } } static { - if (staticField == 1) { - importStatic = 1; + if (staticFieldA == 1) { + importStaticA = 1; } else { - importStatic = 2; + importStaticA = 2; } } + + // now as final constants + private static final int assignB = SimpleAssignClassB.x; + private static final int binaryB = BinaryExpClassB.x + 1; + private static final int unaryB = -UnaryExpClassB.x; + private static final int castB = (int)CastClassB.x; + private static final int parensB = (ParensClassB.x); + private static final int condB = (CondClassB.x == 1) ? 1 : 2; + private static final int ifConstantB; + private static final int importStaticB; + static { + if (IfClassB.x == 1) { + ifConstantB = 1; + } else { + ifConstantB = 2; + } + } + static { + if (staticFieldB == 1) { + importStaticB = 1; + } else { + importStaticB = 2; + } + } +} + +class SimpleAssignClassA { + public static final int x = 1; +} + +class SimpleAssignClassB { + public static final int x = 1; +} + +class BinaryExpClassA { + public static final int x = 1; +} + +class BinaryExpClassB { + public static final int x = 1; +} + +class UnaryExpClassA { + public static final int x = 1; +} + +class UnaryExpClassB { + public static final int x = 1; +} + +class CastClassA { + public static final int x = 1; } -class SimpleAssignClass { +class CastClassB { public static final int x = 1; } -class BinaryExpClass { +class ParensClassA { public static final int x = 1; } -class UnaryExpClass { +class ParensClassB { public static final int x = 1; } -class CastClass { +class CondClassA { public static final int x = 1; } -class ParensClass { +class CondClassB { public static final int x = 1; } -class CondClass { +class IfClassA { public static final int x = 1; } -class IfClass { +class IfClassB { public static final int x = 1; } diff --git a/test/tools/javac/7153958/pkg/ClassToBeStaticallyImported.java b/test/tools/javac/7153958/pkg/ClassToBeStaticallyImportedA.java similarity index 87% rename from test/tools/javac/7153958/pkg/ClassToBeStaticallyImported.java rename to test/tools/javac/7153958/pkg/ClassToBeStaticallyImportedA.java index 801098d02937884f2aea3b0680b1e33027ee983d..b8fb39f4ff32d25fdc042a05e5c7fd329b4bba53 100644 --- a/test/tools/javac/7153958/pkg/ClassToBeStaticallyImported.java +++ b/test/tools/javac/7153958/pkg/ClassToBeStaticallyImportedA.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2015, 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 @@ -24,6 +24,6 @@ */ package pkg; -public class ClassToBeStaticallyImported { - public static final int staticField = 1; +public class ClassToBeStaticallyImportedA { + public static final int staticFieldA = 1; } diff --git a/test/tools/javac/7153958/pkg/ClassToBeStaticallyImportedB.java b/test/tools/javac/7153958/pkg/ClassToBeStaticallyImportedB.java new file mode 100644 index 0000000000000000000000000000000000000000..d05c6fbab075f76b496a067ee3add665bae83d30 --- /dev/null +++ b/test/tools/javac/7153958/pkg/ClassToBeStaticallyImportedB.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2012, 2015, 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. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * 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. + */ +package pkg; + +public class ClassToBeStaticallyImportedB { + public static final int staticFieldB = 1; +}