1
2 import java.lang.reflect.Method;
3 import java.net.URI;
4 import java.nio.file.FileSystem;
5 import java.nio.file.FileSystems;
6 import java.nio.file.Files;
7 import java.nio.file.Path;
8 import java.nio.file.Paths;
9 import java.util.ArrayList;
10 import java.util.Collections;
11 import java.util.HashMap;
12 import java.util.Iterator;
13 import java.util.List;
14 import java.util.Map;
15 import java.util.stream.Stream;
16 import jdk.internal.org.objectweb.asm.ClassReader;
17 import jdk.internal.org.objectweb.asm.Opcodes;
18 import jdk.internal.org.objectweb.asm.tree.AbstractInsnNode;
19 import jdk.internal.org.objectweb.asm.tree.ClassNode;
20 import jdk.internal.org.objectweb.asm.tree.MethodInsnNode;
21 import jdk.internal.org.objectweb.asm.tree.MethodNode;
22 import jdk.internal.org.objectweb.asm.tree.TryCatchBlockNode;
23 import jdk.tools.jlink.internal.PluginRepository;
24 import jdk.tools.jlink.internal.ModulePoolImpl;
25 import jdk.tools.jlink.internal.plugins.OptimizationPlugin;
26 import jdk.tools.jlink.internal.plugins.asm.AsmModulePool;
27 import jdk.tools.jlink.internal.plugins.asm.AsmPlugin;
28 import jdk.tools.jlink.internal.plugins.asm.AsmPools;
29 import jdk.tools.jlink.internal.plugins.optim.ControlFlow;
30 import jdk.tools.jlink.internal.plugins.optim.ControlFlow.Block;
31 import jdk.tools.jlink.plugin.ModuleEntry;
32 import jdk.tools.jlink.plugin.ModulePool;
33
34 import tests.Helper;
35 import tests.JImageGenerator;
36
37 /*
38 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
39 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
40 *
41 * This code is free software; you can redistribute it and/or modify it
42 * under the terms of the GNU General Public License version 2 only, as
43 * published by the Free Software Foundation.
44 *
45 * This code is distributed in the hope that it will be useful, but WITHOUT
46 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
47 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
48 * version 2 for more details (a copy is included in the LICENSE file that
49 * accompanied this code).
50 *
51 * You should have received a copy of the GNU General Public License version
52 * 2 along with this work; if not, write to the Free Software Foundation,
53 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
54 *
55 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
56 * or visit www.oracle.com if you need additional information or have any
57 * questions.
58 */
59
60 /*
61 * @test
62 * @summary Test image creation with class optimization
63 * @author Jean-Francois Denise
64 * @library ../lib
65 * @modules java.base/jdk.internal.jimage
66 * jdk.jdeps/com.sun.tools.classfile
67 * jdk.jlink/jdk.tools.jlink.internal
68 * jdk.jlink/jdk.tools.jmod
69 * jdk.jlink/jdk.tools.jimage
70 * jdk.jlink/jdk.tools.jlink.internal.plugins
71 * jdk.jlink/jdk.tools.jlink.internal.plugins.asm
72 * jdk.jlink/jdk.tools.jlink.internal.plugins.optim
73 * java.base/jdk.internal.org.objectweb.asm
74 * java.base/jdk.internal.org.objectweb.asm.tree
75 * java.base/jdk.internal.org.objectweb.asm.util
76 * jdk.compiler
77 * @build tests.*
78 * @run main JLinkOptimTest
79 */
80 public class JLinkOptimTest {
81
82 private static final String EXPECTED = "expected";
83 private static Helper helper;
84
85 public static class ControlFlowPlugin extends AsmPlugin {
86
87 private boolean called;
88 private int numMethods;
89 private int numBlocks;
90
91 private static final String NAME = "test-optim";
92
93 private ControlFlowPlugin() {
94 }
95
96 @Override
97 public void visit(AsmPools pools) {
98 called = true;
99 for (AsmModulePool p : pools.getModulePools()) {
100
101 p.visitClassReaders((reader) -> {
102 ClassNode cn = new ClassNode();
103 if ((reader.getAccess() & Opcodes.ACC_INTERFACE) == 0) {
104 reader.accept(cn, ClassReader.EXPAND_FRAMES);
105 for (MethodNode m : cn.methods) {
106 if ((m.access & Opcodes.ACC_ABSTRACT) == 0
107 && (m.access & Opcodes.ACC_NATIVE) == 0) {
108 numMethods += 1;
109 try {
110 ControlFlow f
111 = ControlFlow.createControlFlow(cn.name, m);
112 for (Block b : f.getBlocks()) {
113 numBlocks += 1;
114 f.getClosure(b);
115 }
116 } catch (Throwable ex) {
117 //ex.printStackTrace();
118 throw new RuntimeException("Exception in "
119 + cn.name + "." + m.name, ex);
120 }
121 }
122 }
123 }
124 return null;
125 });
126 }
127 }
128
129 @Override
130 public String getName() {
131 return NAME;
132 }
133 }
134
135 private static void testForName() throws Exception {
136 String moduleName = "optimplugin";
137 Path src = Paths.get(System.getProperty("test.src")).resolve(moduleName);
138 Path classes = helper.getJmodClassesDir().resolve(moduleName);
139 JImageGenerator.compile(src, classes);
140
141 FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
142 Path root = fs.getPath("/modules/java.base");
143 // Access module-info.class to be reused as fake module-info.class
144 List<ModuleEntry> javabaseResources = new ArrayList<>();
145 try (Stream<Path> stream = Files.walk(root)) {
146 for (Iterator<Path> iterator = stream.iterator(); iterator.hasNext();) {
147 Path p = iterator.next();
148 if (Files.isRegularFile(p)) {
149 try {
150 javabaseResources.add(ModuleEntry.create(p.toString().
151 substring("/modules".length()), Files.readAllBytes(p)));
152 } catch (Exception ex) {
153 throw new RuntimeException(ex);
154 }
155 }
156 }
157 }
158
159 //forName folding
160 ModulePoolImpl pool = new ModulePoolImpl();
161 byte[] content = Files.readAllBytes(classes.
162 resolve("optim").resolve("ForNameTestCase.class"));
163 byte[] content2 = Files.readAllBytes(classes.
164 resolve("optim").resolve("AType.class"));
165 byte[] mcontent = Files.readAllBytes(classes.resolve("module-info.class"));
166
167 pool.add(ModuleEntry.create("/optimplugin/optim/ForNameTestCase.class", content));
168 pool.add(ModuleEntry.create("/optimplugin/optim/AType.class", content2));
169 pool.add(ModuleEntry.create("/optimplugin/module-info.class", mcontent));
170
171 for (ModuleEntry r : javabaseResources) {
172 pool.add(r);
173 }
174
175 OptimizationPlugin plugin = new OptimizationPlugin();
176 Map<String, String> optional = new HashMap<>();
177 optional.put(OptimizationPlugin.NAME, OptimizationPlugin.FORNAME_REMOVAL);
178 optional.put(OptimizationPlugin.LOG, "forName.log");
179 plugin.configure(optional);
180 ModulePool out = new ModulePoolImpl();
181 plugin.visit(pool, out);
182
183 ModuleEntry result = out.entries().iterator().next();
184
185 ClassReader optimReader = new ClassReader(result.getBytes());
186 ClassNode optimClass = new ClassNode();
187 optimReader.accept(optimClass, ClassReader.EXPAND_FRAMES);
188
189 if (!optimClass.name.equals("optim/ForNameTestCase")) {
190 throw new Exception("Invalid class " + optimClass.name);
191 }
192 if (optimClass.methods.size() < 2) {
193 throw new Exception("Not enough methods in new class");
194 }
195 for (MethodNode mn : optimClass.methods) {
196 if (!mn.name.contains("forName") && !mn.name.contains("<clinit>")) {
197 continue;
198 }
199 if (mn.name.startsWith("negative")) {
200 checkForName(mn);
201 } else {
202 checkNoForName(mn);
203 }
204 }
205 Map<String, byte[]> newClasses = new HashMap<>();
206 newClasses.put("optim.ForNameTestCase", result.getBytes());
207 newClasses.put("optim.AType", content2);
208 MemClassLoader loader = new MemClassLoader(newClasses);
209 Class<?> loaded = loader.loadClass("optim.ForNameTestCase");
210 if (loaded.getDeclaredMethods().length < 2) {
211 throw new Exception("Not enough methods in new class");
212 }
213 for (Method m : loaded.getDeclaredMethods()) {
214 if (m.getName().contains("Exception")) {
215 try {
216 m.invoke(null);
217 } catch (Exception ex) {
218 //ex.getCause().printStackTrace();
219 if (!ex.getCause().getMessage().equals(EXPECTED)) {
220 throw new Exception("Unexpected exception " + ex);
221 }
222 }
223 } else if (!m.getName().startsWith("negative")) {
224 Class<?> clazz = (Class<?>) m.invoke(null);
225 if (clazz != String.class && clazz != loader.findClass("optim.AType")) {
226 throw new Exception("Invalid class " + clazz);
227 }
228 }
229 }
230 }
231
232 private static void checkNoForName(MethodNode m) throws Exception {
233 Iterator<AbstractInsnNode> it = m.instructions.iterator();
234 while (it.hasNext()) {
235 AbstractInsnNode n = it.next();
236 if (n instanceof MethodInsnNode) {
237 MethodInsnNode met = (MethodInsnNode) n;
238 if (met.name.equals("forName")
239 && met.owner.equals("java/lang/Class")
240 && met.desc.equals("(Ljava/lang/String;)Ljava/lang/Class;")) {
241 throw new Exception("forName not removed in " + m.name);
242 }
243 }
244 }
245 for (TryCatchBlockNode tcb : m.tryCatchBlocks) {
246 if (tcb.type.equals(ClassNotFoundException.class.getName().replaceAll("\\.", "/"))) {
247 throw new Exception("ClassNotFoundException Block not removed for " + m.name);
248 }
249 }
250 }
251
252 private static void checkForName(MethodNode m) throws Exception {
253 Iterator<AbstractInsnNode> it = m.instructions.iterator();
254 boolean found = false;
255 while (it.hasNext()) {
256 AbstractInsnNode n = it.next();
257 if (n instanceof MethodInsnNode) {
258 MethodInsnNode met = (MethodInsnNode) n;
259 if (met.name.equals("forName")
260 && met.owner.equals("java/lang/Class")
261 && met.desc.equals("(Ljava/lang/String;)Ljava/lang/Class;")) {
262 found = true;
263 break;
264 }
265 }
266 }
267 if (!found) {
268 throw new Exception("forName removed but shouldn't have");
269 }
270 found = false;
271 for (TryCatchBlockNode tcb : m.tryCatchBlocks) {
272 if (tcb.type.equals(ClassNotFoundException.class.getName().replaceAll("\\.", "/"))) {
273 found = true;
274 break;
275 }
276 }
277 if (!found) {
278 throw new Exception("tryCatchBlocks removed but shouldn't have");
279 }
280 }
281
282 static class MemClassLoader extends ClassLoader {
283
284 private final Map<String, byte[]> classes;
285 private final Map<String, Class<?>> cache = new HashMap<>();
286
287 MemClassLoader(Map<String, byte[]> classes) {
288 super(null);
289 this.classes = classes;
290 }
291
292 @Override
293 public Class findClass(String name) throws ClassNotFoundException {
294 Class<?> clazz = cache.get(name);
295 if (clazz == null) {
296 byte[] b = classes.get(name);
297 if (b == null) {
298 return super.findClass(name);
299 } else {
300 clazz = defineClass(name, b, 0, b.length);
301 cache.put(name, clazz);
302 }
303 }
304 return clazz;
305 }
306 }
307
308 public static void main(String[] args) throws Exception {
309 helper = Helper.newHelper();
310 if (helper == null) {
311 System.err.println("Test not run");
312 return;
313 }
314
315 testForName();
316
317 helper.generateDefaultModules();
318 helper.generateDefaultJModule("optim1", "java.se");
319 {
320 String[] userOptions = {"--class-optim=all:log=./class-optim-log.txt"};
321
322 Path imageDir = helper.generateDefaultImage(userOptions, "optim1").assertSuccess();
323 helper.checkImage(imageDir, "optim1", null, null);
324 }
325
326 {
327 String[] userOptions = {"--class-optim=forName-folding:log=./class-optim-log.txt"};
328 Path imageDir = helper.generateDefaultImage(userOptions, "optim1").assertSuccess();
329 helper.checkImage(imageDir, "optim1", null, null);
330 }
331
332 {
333 ControlFlowPlugin plugin = new ControlFlowPlugin();
334 PluginRepository.registerPlugin(plugin);
335 String[] userOptions = {"--test-optim"};
336 Path imageDir = helper.generateDefaultImage(userOptions, "optim1").assertSuccess();
337 helper.checkImage(imageDir, "optim1", null, null);
338 //System.out.println("Num methods analyzed " + provider.numMethods
339 // + "num blocks " + provider.numBlocks);
340 if (!plugin.called) {
341 throw new Exception("Plugin not called");
342 }
343 if (plugin.numMethods < 1000) {
344 throw new Exception("Not enough method called, should be "
345 + "around 10000 but is " + plugin.numMethods);
346 }
347 if (plugin.numBlocks < 100000) {
348 throw new Exception("Not enough blocks, should be "
349 + "around 640000 but is " + plugin.numMethods);
350 }
351 }
352 }
353
354 }