1 /*
2 * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 import jdk.internal.org.objectweb.asm.*;
25
26 /*
27 * @test
28 * @summary Test scenarios for constant pool CONSTANT_Module and CONSTANT_Package
29 * types, for class file versions 53 and 52, when ACC_MODULE is set and
30 * not set in the access_flags.
31 * @bug 8175383
32 * @library /test/lib
33 * @modules java.base/jdk.internal.org.objectweb.asm
34 * @compile -XDignore.symbol.file ConstModule.java
35 * @run main ConstModule
36 */
37
38 public class ConstModule {
39
40 static final int ACC_MODULE = 0x8000;
41 static final boolean MODULE_TEST = true;
42 static final boolean PACKAGE_TEST = false;
43 static final boolean CFE_EXCEPTION = true;
44 static final boolean NCDFE_EXCEPTION = false;
45
46 public static void main(String[] args) throws Exception {
47
48 // Test that the JVM throws CFE for constant pool CONSTANT_Module type, for
49 // class file version 53, when ACC_MODULE is not set in the access_flags.
50 ConstModule.write_and_load(Opcodes.V9,
51 Opcodes.ACC_INTERFACE + Opcodes.ACC_ABSTRACT + Opcodes.ACC_SYNTHETIC,
52 "jdk.fooMod", "FooMod", MODULE_TEST, CFE_EXCEPTION);
53
54 // Test that the JVM throws NCDFE for constant pool CONSTANT_Module type,
55 // for class file version 53, when ACC_MODULE is set in the access_flags.
56 ConstModule.write_and_load(Opcodes.V9,
57 Opcodes.ACC_INTERFACE + Opcodes.ACC_ABSTRACT + Opcodes.ACC_SYNTHETIC + ACC_MODULE,
58 "jdk.fooModACC", "FooModACC", MODULE_TEST, NCDFE_EXCEPTION);
59
60 // Test that the JVM throws CFE for constant pool CONSTANT_Module type, for
61 // class file version 52, even when ACC_MODULE is set in the access_flags.
62 ConstModule.write_and_load(Opcodes.V1_8,
63 Opcodes.ACC_INTERFACE + Opcodes.ACC_ABSTRACT + Opcodes.ACC_SYNTHETIC + ACC_MODULE,
64 "jdk.fooModACC52", "FooModACC52", MODULE_TEST, CFE_EXCEPTION);
65
66 // Test that the JVM throws CFE for constant pool CONSTANT_Package type, for
67 // class file version 53, when ACC_MODULE is not set in the access_flags.
68 ConstModule.write_and_load(Opcodes.V9,
69 Opcodes.ACC_INTERFACE + Opcodes.ACC_ABSTRACT + Opcodes.ACC_SYNTHETIC,
70 "jdk.fooPkg", "FooPkg", PACKAGE_TEST, CFE_EXCEPTION);
71
72 // Test that the JVM throws NCDFE for constant pool CONSTANT_Package type,
73 // for class file version 53, when ACC_MODULE is set in the access_flags.
74 ConstModule.write_and_load(Opcodes.V9,
75 Opcodes.ACC_INTERFACE + Opcodes.ACC_ABSTRACT + Opcodes.ACC_SYNTHETIC + ACC_MODULE,
76 "jdk.fooModACC", "FooModACC", PACKAGE_TEST, NCDFE_EXCEPTION);
77
78 // Test that the JVM throws CFE for constant pool CONSTANT_Package type, for
79 // class file version 52, even when ACC_MODULE is set in the access_flags.
80 ConstModule.write_and_load(Opcodes.V1_8,
81 Opcodes.ACC_INTERFACE + Opcodes.ACC_ABSTRACT + Opcodes.ACC_SYNTHETIC + ACC_MODULE,
82 "jdk.fooModACC52", "FooModACC52", PACKAGE_TEST, CFE_EXCEPTION);
83
84 }
85
86 public static void write_and_load(int version,
87 int access_flags,
88 String attr,
89 String class_name,
90 boolean module_test,
91 boolean throwCFE) throws Exception {
92 ClassWriter cw = new ClassWriter(0);
93 cw.visit(version,
94 access_flags,
95 class_name,
96 null,
97 "java/lang/Object",
98 null);
99
100 if (module_test)
101 cw.visitAttribute(new TestModuleAttribute(attr));
102 else
103 cw.visitAttribute(new TestPackageAttribute(attr));
104
105 cw.visitEnd();
106 byte[] bytes = cw.toByteArray();
107
108
109 ClassLoader loader = new ClassLoader(ConstModule.class.getClassLoader()) {
110 @Override
111 protected Class<?> findClass(String cn)throws ClassNotFoundException {
112 if (cn.equals(class_name)) {
113 try {
114 Class superClass = super.defineClass(cn, bytes, 0, bytes.length);
115 throw new RuntimeException("Expected ClassFormatError not thrown");
116 } catch (java.lang.ClassFormatError e) {
117 if (!throwCFE) {
118 throw new RuntimeException("Unexpected ClassFormatError exception: " + e.getMessage());
119 }
120 if (module_test && !e.getMessage().contains(
121 "Unknown constant tag 19 in class file")) {
122 throw new RuntimeException("Wrong ClassFormatError exception: " + e.getMessage());
123 } else if (!module_test && !e.getMessage().contains(
124 "Unknown constant tag 20 in class file")) {
125 throw new RuntimeException("Wrong ClassFormatError exception: " + e.getMessage());
126 }
127 } catch (java.lang.NoClassDefFoundError f) {
128 if (throwCFE) {
129 throw new RuntimeException("Unexpected NoClassDefFoundError exception: " + f.getMessage());
130 }
131 if (!f.getMessage().contains(
132 "is not a class because access_flag ACC_MODULE is set")) {
133 throw new RuntimeException("Wrong NoClassDefFoundError exception: " + f.getMessage());
134 }
135 }
136 } else {
137 throw new ClassNotFoundException(cn);
138 }
139 return null;
140 }
141 };
142
143 Class<?> clazz = loader.loadClass(class_name);
144 }
145
146 /**
147 * ConstModuleAttr attribute.
148 *
149 * <pre> {@code
150 *
151 * MainClass_attribute {
152 * // index to CONSTANT_utf8_info structure in constant pool representing
153 * // the string "ConstModuleAttr"
154 * u2 attribute_name_index;
155 * u4 attribute_length;
156 *
157 * // index to CONSTANT_Module_info structure
158 * u2 module_name_index
159 * }
160 *
161 * } </pre>
162 */
163 public static class TestModuleAttribute extends Attribute {
164 private final String moduleName;
165
166 public TestModuleAttribute(String moduleName) {
167 super("ConstModuleAttr");
168 this.moduleName = moduleName;
169 }
170
171 public TestModuleAttribute() {
172 this(null);
173 }
174
175 @Override
176 protected Attribute read(ClassReader cr,
177 int off,
178 int len,
179 char[] buf,
180 int codeOff,
181 Label[] labels)
182 {
183 String mn = cr.readModule(off, buf);
184 off += 2;
185 return new TestModuleAttribute(mn);
186 }
187
188 @Override
189 protected ByteVector write(ClassWriter cw,
190 byte[] code,
191 int len,
192 int maxStack,
193 int maxLocals)
194 {
195 ByteVector attr = new ByteVector();
196 attr.putShort(cw.newModule(moduleName));
197 return attr;
198 }
199 }
200
201 /**
202 * ConstPackageAttr attribute.
203 *
204 * <pre> {@code
205 *
206 * MainClass_attribute {
207 * // index to CONSTANT_utf8_info structure in constant pool representing
208 * // the string "ConstPackageAttr"
209 * u2 attribute_name_index;
210 * u4 attribute_length;
211 *
212 * // index to CONSTANT_Package_info structure
213 * u2 module_name_index
214 * }
215 *
216 * } </pre>
217 */
218 public static class TestPackageAttribute extends Attribute {
219 private final String packageName;
220
221 public TestPackageAttribute(String packageName) {
222 super("ConstPackageAttr");
223 this.packageName = packageName;
224 }
225
226 public TestPackageAttribute() {
227 this(null);
228 }
229
230 @Override
231 protected Attribute read(ClassReader cr,
232 int off,
233 int len,
234 char[] buf,
235 int codeOff,
236 Label[] labels)
237 {
238 String mn = cr.readPackage(off, buf);
239 off += 2;
240 return new TestPackageAttribute(mn);
241 }
242
243 @Override
244 protected ByteVector write(ClassWriter cw,
245 byte[] code,
246 int len,
247 int maxStack,
248 int maxLocals)
249 {
250 ByteVector attr = new ByteVector();
251 attr.putShort(cw.newPackage(packageName));
252 return attr;
253 }
254 }
255 }