1 /*
2 * Copyright (c) 2009, 2012, 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package com.sun.tools.classfile;
26
27 import java.util.Deque;
28 import java.util.HashMap;
29 import java.util.HashSet;
30 import java.util.LinkedList;
31 import java.util.List;
32 import java.util.Map;
33 import java.util.Set;
34 import java.util.regex.Pattern;
35
36 import com.sun.tools.classfile.Dependency.Filter;
37 import com.sun.tools.classfile.Dependency.Finder;
38 import com.sun.tools.classfile.Dependency.Location;
39 import com.sun.tools.classfile.Type.ArrayType;
40 import com.sun.tools.classfile.Type.ClassSigType;
41 import com.sun.tools.classfile.Type.ClassType;
42 import com.sun.tools.classfile.Type.MethodType;
43 import com.sun.tools.classfile.Type.SimpleType;
44 import com.sun.tools.classfile.Type.TypeParamType;
45 import com.sun.tools.classfile.Type.WildcardType;
46 import static com.sun.tools.classfile.ConstantPool.*;
47
48 /**
49 * A framework for determining {@link Dependency dependencies} between class files.
50 *
51 * A {@link Dependency.Finder finder} is used to identify the dependencies of
52 * individual classes. Some finders may return subtypes of {@code Dependency} to
53 * further characterize the type of dependency, such as a dependency on a
54 * method within a class.
55 *
56 * A {@link Dependency.Filter filter} may be used to restrict the set of
57 * dependencies found by a finder.
58 *
59 * Dependencies that are found may be passed to a {@link Dependencies.Recorder
60 * recorder} so that the dependencies can be stored in a custom data structure.
61 */
62 public class Dependencies {
63 /**
64 * Thrown when a class file cannot be found.
65 */
66 public static class ClassFileNotFoundException extends Exception {
67 private static final long serialVersionUID = 3632265927794475048L;
68
69 public ClassFileNotFoundException(String className) {
70 super(className);
71 this.className = className;
72 }
73
74 public ClassFileNotFoundException(String className, Throwable cause) {
75 this(className);
76 initCause(cause);
77 }
78
79 public final String className;
80 }
81
82 /**
83 * Thrown when an exception is found processing a class file.
84 */
85 public static class ClassFileError extends Error {
86 private static final long serialVersionUID = 4111110813961313203L;
87
88 public ClassFileError(Throwable cause) {
89 initCause(cause);
90 }
91 }
92
93 /**
94 * Service provider interface to locate and read class files.
95 */
96 public interface ClassFileReader {
97 /**
98 * Get the ClassFile object for a specified class.
99 * @param className the name of the class to be returned.
100 * @return the ClassFile for the given class
101 * @throws Dependencies.ClassFileNotFoundException if the classfile cannot be
102 * found
103 */
104 public ClassFile getClassFile(String className)
105 throws ClassFileNotFoundException;
106 }
107
108 /**
109 * Service provide interface to handle results.
110 */
111 public interface Recorder {
112 /**
113 * Record a dependency that has been found.
114 * @param d
115 */
116 public void addDependency(Dependency d);
117 }
118
119 /**
120 * Get the default finder used to locate the dependencies for a class.
121 * @return the default finder
122 */
123 public static Finder getDefaultFinder() {
124 return new APIDependencyFinder(AccessFlags.ACC_PRIVATE);
125 }
126
127 /**
128 * Get a finder used to locate the API dependencies for a class.
129 * These include the superclass, superinterfaces, and classes referenced in
130 * the declarations of fields and methods. The fields and methods that
131 * are checked can be limited according to a specified access.
132 * The access parameter must be one of {@link AccessFlags#ACC_PUBLIC ACC_PUBLIC},
133 * {@link AccessFlags#ACC_PRIVATE ACC_PRIVATE},
134 * {@link AccessFlags#ACC_PROTECTED ACC_PROTECTED}, or 0 for
135 * package private access. Members with greater than or equal accessibility
136 * to that specified will be searched for dependencies.
137 * @param access the access of members to be checked
138 * @return an API finder
139 */
140 public static Finder getAPIFinder(int access) {
141 return new APIDependencyFinder(access);
142 }
143
144 /**
145 * Get a finder to do class dependency analysis.
146 *
147 * @return a Class dependency finder
148 */
149 public static Finder getClassDependencyFinder() {
150 return new ClassDependencyFinder();
151 }
152
153 /**
154 * Get the finder used to locate the dependencies for a class.
155 * @return the finder
156 */
157 public Finder getFinder() {
158 if (finder == null)
159 finder = getDefaultFinder();
160 return finder;
161 }
162
163 /**
164 * Set the finder used to locate the dependencies for a class.
165 * @param f the finder
166 */
167 public void setFinder(Finder f) {
168 f.getClass(); // null check
169 finder = f;
170 }
171
172 /**
173 * Get the default filter used to determine included when searching
174 * the transitive closure of all the dependencies.
175 * Unless overridden, the default filter accepts all dependencies.
176 * @return the default filter.
177 */
178 public static Filter getDefaultFilter() {
179 return DefaultFilter.instance();
180 }
181
182 /**
183 * Get a filter which uses a regular expression on the target's class name
184 * to determine if a dependency is of interest.
185 * @param pattern the pattern used to match the target's class name
186 * @return a filter for matching the target class name with a regular expression
187 */
188 public static Filter getRegexFilter(Pattern pattern) {
189 return new TargetRegexFilter(pattern);
190 }
191
192 /**
193 * Get a filter which checks the package of a target's class name
194 * to determine if a dependency is of interest. The filter checks if the
195 * package of the target's class matches any of a set of given package
196 * names. The match may optionally match subpackages of the given names as well.
197 * @param packageNames the package names used to match the target's class name
198 * @param matchSubpackages whether or not to match subpackages as well
199 * @return a filter for checking the target package name against a list of package names
200 */
201 public static Filter getPackageFilter(Set<String> packageNames, boolean matchSubpackages) {
202 return new TargetPackageFilter(packageNames, matchSubpackages);
203 }
204
205 /**
206 * Get the filter used to determine the dependencies included when searching
207 * the transitive closure of all the dependencies.
208 * Unless overridden, the default filter accepts all dependencies.
209 * @return the filter
210 */
211 public Filter getFilter() {
212 if (filter == null)
213 filter = getDefaultFilter();
214 return filter;
215 }
216
217 /**
218 * Set the filter used to determine the dependencies included when searching
219 * the transitive closure of all the dependencies.
220 * @param f the filter
221 */
222 public void setFilter(Filter f) {
223 f.getClass(); // null check
224 filter = f;
225 }
226
227 /**
228 * Find the dependencies of a class, using the current
229 * {@link Dependencies#getFinder finder} and
230 * {@link Dependencies#getFilter filter}.
231 * The search may optionally include the transitive closure of all the
232 * filtered dependencies, by also searching in the classes named in those
233 * dependencies.
234 * @param classFinder a finder to locate class files
235 * @param rootClassNames the names of the root classes from which to begin
236 * searching
237 * @param transitiveClosure whether or not to also search those classes
238 * named in any filtered dependencies that are found.
239 * @return the set of dependencies that were found
240 * @throws ClassFileNotFoundException if a required class file cannot be found
241 * @throws ClassFileError if an error occurs while processing a class file,
242 * such as an error in the internal class file structure.
243 */
244 public Set<Dependency> findAllDependencies(
245 ClassFileReader classFinder, Set<String> rootClassNames,
246 boolean transitiveClosure)
247 throws ClassFileNotFoundException {
248 final Set<Dependency> results = new HashSet<Dependency>();
249 Recorder r = new Recorder() {
250 public void addDependency(Dependency d) {
251 results.add(d);
252 }
253 };
254 findAllDependencies(classFinder, rootClassNames, transitiveClosure, r);
255 return results;
256 }
257
258 /**
259 * Find the dependencies of a class, using the current
260 * {@link Dependencies#getFinder finder} and
261 * {@link Dependencies#getFilter filter}.
262 * The search may optionally include the transitive closure of all the
263 * filtered dependencies, by also searching in the classes named in those
264 * dependencies.
265 * @param classFinder a finder to locate class files
266 * @param rootClassNames the names of the root classes from which to begin
267 * searching
268 * @param transitiveClosure whether or not to also search those classes
269 * named in any filtered dependencies that are found.
270 * @param recorder a recorder for handling the results
271 * @throws ClassFileNotFoundException if a required class file cannot be found
272 * @throws ClassFileError if an error occurs while processing a class file,
273 * such as an error in the internal class file structure.
274 */
275 public void findAllDependencies(
276 ClassFileReader classFinder, Set<String> rootClassNames,
277 boolean transitiveClosure, Recorder recorder)
278 throws ClassFileNotFoundException {
279 Set<String> doneClasses = new HashSet<String>();
280
281 getFinder(); // ensure initialized
282 getFilter(); // ensure initialized
283
284 // Work queue of names of classfiles to be searched.
285 // Entries will be unique, and for classes that do not yet have
286 // dependencies in the results map.
287 Deque<String> deque = new LinkedList<String>(rootClassNames);
288
289 String className;
290 while ((className = deque.poll()) != null) {
291 assert (!doneClasses.contains(className));
292 doneClasses.add(className);
293
294 ClassFile cf = classFinder.getClassFile(className);
295
296 // The following code just applies the filter to the dependencies
297 // followed for the transitive closure.
298 for (Dependency d: finder.findDependencies(cf)) {
299 recorder.addDependency(d);
300 if (transitiveClosure && filter.accepts(d)) {
301 String cn = d.getTarget().getClassName();
302 if (!doneClasses.contains(cn))
303 deque.add(cn);
304 }
305 }
306 }
307 }
308
309 private Filter filter;
310 private Finder finder;
311
312 /**
313 * A location identifying a class.
314 */
315 static class SimpleLocation implements Location {
316 public SimpleLocation(String name) {
317 this.name = name;
318 this.className = name.replace('/', '.');
319 }
320
321 public String getName() {
322 return name;
323 }
324
325 public String getClassName() {
326 return className;
327 }
328
329 public String getPackageName() {
330 int i = className.lastIndexOf('.');
331 return (i > 0) ? className.substring(0, i) : "";
332 }
333
334 @Override
335 public boolean equals(Object other) {
336 if (this == other)
337 return true;
338 if (!(other instanceof SimpleLocation))
339 return false;
340 return (name.equals(((SimpleLocation) other).name));
341 }
342
343 @Override
344 public int hashCode() {
345 return name.hashCode();
346 }
347
348 @Override
349 public String toString() {
350 return name;
351 }
352
353 private String name;
354 private String className;
355 }
356
357 /**
358 * A dependency of one class on another.
359 */
360 static class SimpleDependency implements Dependency {
361 public SimpleDependency(Location origin, Location target) {
362 this.origin = origin;
363 this.target = target;
364 }
365
366 public Location getOrigin() {
367 return origin;
368 }
369
370 public Location getTarget() {
371 return target;
372 }
373
374 @Override
375 public boolean equals(Object other) {
376 if (this == other)
377 return true;
378 if (!(other instanceof SimpleDependency))
379 return false;
380 SimpleDependency o = (SimpleDependency) other;
381 return (origin.equals(o.origin) && target.equals(o.target));
382 }
383
384 @Override
385 public int hashCode() {
386 return origin.hashCode() * 31 + target.hashCode();
387 }
388
389 @Override
390 public String toString() {
391 return origin + ":" + target;
392 }
393
394 private Location origin;
395 private Location target;
396 }
397
398
399 /**
400 * This class accepts all dependencies.
401 */
402 static class DefaultFilter implements Filter {
403 private static DefaultFilter instance;
404
405 static DefaultFilter instance() {
406 if (instance == null)
407 instance = new DefaultFilter();
408 return instance;
409 }
410
411 public boolean accepts(Dependency dependency) {
412 return true;
413 }
414 }
415
416 /**
417 * This class accepts those dependencies whose target's class name matches a
418 * regular expression.
419 */
420 static class TargetRegexFilter implements Filter {
421 TargetRegexFilter(Pattern pattern) {
422 this.pattern = pattern;
423 }
424
425 public boolean accepts(Dependency dependency) {
426 return pattern.matcher(dependency.getTarget().getClassName()).matches();
427 }
428
429 private final Pattern pattern;
430 }
431
432 /**
433 * This class accepts those dependencies whose class name is in a given
434 * package.
435 */
436 static class TargetPackageFilter implements Filter {
437 TargetPackageFilter(Set<String> packageNames, boolean matchSubpackages) {
438 for (String pn: packageNames) {
439 if (pn.length() == 0) // implies null check as well
440 throw new IllegalArgumentException();
441 }
442 this.packageNames = packageNames;
443 this.matchSubpackages = matchSubpackages;
444 }
445
446 public boolean accepts(Dependency dependency) {
447 String pn = dependency.getTarget().getPackageName();
448 if (packageNames.contains(pn))
449 return true;
450
451 if (matchSubpackages) {
452 for (String n: packageNames) {
453 if (pn.startsWith(n + "."))
454 return true;
455 }
456 }
457
458 return false;
459 }
460
461 private final Set<String> packageNames;
462 private final boolean matchSubpackages;
463 }
464
465 /**
466 * This class identifies class names directly or indirectly in the constant pool.
467 */
468 static class ClassDependencyFinder extends BasicDependencyFinder {
469 public Iterable<? extends Dependency> findDependencies(ClassFile classfile) {
470 Visitor v = new Visitor(classfile);
471 for (CPInfo cpInfo: classfile.constant_pool.entries()) {
472 v.scan(cpInfo);
473 }
474 try {
475 v.addClass(classfile.super_class);
476 v.addClasses(classfile.interfaces);
477 v.scan(classfile.attributes);
478
479 for (Field f : classfile.fields) {
480 v.scan(f.descriptor, f.attributes);
481 }
482 for (Method m : classfile.methods) {
483 v.scan(m.descriptor, m.attributes);
484 Exceptions_attribute e =
485 (Exceptions_attribute)m.attributes.get(Attribute.Exceptions);
486 if (e != null) {
487 v.addClasses(e.exception_index_table);
488 }
489 }
490 } catch (ConstantPoolException e) {
491 throw new ClassFileError(e);
492 }
493
494 return v.deps;
495 }
496 }
497
498 /**
499 * This class identifies class names in the signatures of classes, fields,
500 * and methods in a class.
501 */
502 static class APIDependencyFinder extends BasicDependencyFinder {
503 APIDependencyFinder(int access) {
504 switch (access) {
505 case AccessFlags.ACC_PUBLIC:
506 case AccessFlags.ACC_PROTECTED:
507 case AccessFlags.ACC_PRIVATE:
508 case 0:
509 showAccess = access;
510 break;
511 default:
512 throw new IllegalArgumentException("invalid access 0x"
513 + Integer.toHexString(access));
514 }
515 }
516
517 public Iterable<? extends Dependency> findDependencies(ClassFile classfile) {
518 try {
519 Visitor v = new Visitor(classfile);
520 v.addClass(classfile.super_class);
521 v.addClasses(classfile.interfaces);
522 // inner classes?
523 for (Field f : classfile.fields) {
524 if (checkAccess(f.access_flags))
525 v.scan(f.descriptor, f.attributes);
526 }
527 for (Method m : classfile.methods) {
528 if (checkAccess(m.access_flags)) {
529 v.scan(m.descriptor, m.attributes);
530 Exceptions_attribute e =
531 (Exceptions_attribute) m.attributes.get(Attribute.Exceptions);
532 if (e != null)
533 v.addClasses(e.exception_index_table);
534 }
535 }
536 return v.deps;
537 } catch (ConstantPoolException e) {
538 throw new ClassFileError(e);
539 }
540 }
541
542 boolean checkAccess(AccessFlags flags) {
543 // code copied from javap.Options.checkAccess
544 boolean isPublic = flags.is(AccessFlags.ACC_PUBLIC);
545 boolean isProtected = flags.is(AccessFlags.ACC_PROTECTED);
546 boolean isPrivate = flags.is(AccessFlags.ACC_PRIVATE);
547 boolean isPackage = !(isPublic || isProtected || isPrivate);
548
549 if ((showAccess == AccessFlags.ACC_PUBLIC) && (isProtected || isPrivate || isPackage))
550 return false;
551 else if ((showAccess == AccessFlags.ACC_PROTECTED) && (isPrivate || isPackage))
552 return false;
553 else if ((showAccess == 0) && (isPrivate))
554 return false;
555 else
556 return true;
557 }
558
559 private int showAccess;
560 }
561
562 static abstract class BasicDependencyFinder implements Finder {
563 private Map<String,Location> locations = new HashMap<String,Location>();
564
565 Location getLocation(String className) {
566 Location l = locations.get(className);
567 if (l == null)
568 locations.put(className, l = new SimpleLocation(className));
569 return l;
570 }
571
572 class Visitor implements ConstantPool.Visitor<Void,Void>, Type.Visitor<Void, Void> {
573 private ConstantPool constant_pool;
574 private Location origin;
575 Set<Dependency> deps;
576
577 Visitor(ClassFile classFile) {
578 try {
579 constant_pool = classFile.constant_pool;
580 origin = getLocation(classFile.getName());
581 deps = new HashSet<Dependency>();
582 } catch (ConstantPoolException e) {
583 throw new ClassFileError(e);
584 }
585 }
586
587 void scan(Descriptor d, Attributes attrs) {
588 try {
589 scan(new Signature(d.index).getType(constant_pool));
590 scan(attrs);
591 } catch (ConstantPoolException e) {
592 throw new ClassFileError(e);
593 }
594 }
595
596 void scan(CPInfo cpInfo) {
597 cpInfo.accept(this, null);
598 }
599
600 void scan(Type t) {
601 t.accept(this, null);
602 }
603
604 void scan(Attributes attrs) {
605 try {
606 Signature_attribute sa = (Signature_attribute)attrs.get(Attribute.Signature);
607 if (sa != null)
608 scan(sa.getParsedSignature().getType(constant_pool));
609
610 scan((RuntimeVisibleAnnotations_attribute)
611 attrs.get(Attribute.RuntimeVisibleAnnotations));
612 scan((RuntimeVisibleParameterAnnotations_attribute)
613 attrs.get(Attribute.RuntimeVisibleParameterAnnotations));
614 } catch (ConstantPoolException e) {
615 throw new ClassFileError(e);
616 }
617 }
618
619 private void scan(RuntimeAnnotations_attribute attr) throws ConstantPoolException {
620 if (attr == null) {
621 return;
622 }
623 for (int i = 0; i < attr.annotations.length; i++) {
624 int index = attr.annotations[i].type_index;
625 scan(new Signature(index).getType(constant_pool));
626 }
627 }
628
629 private void scan(RuntimeParameterAnnotations_attribute attr) throws ConstantPoolException {
630 if (attr == null) {
631 return;
632 }
633 for (int param = 0; param < attr.parameter_annotations.length; param++) {
634 for (int i = 0; i < attr.parameter_annotations[param].length; i++) {
635 int index = attr.parameter_annotations[param][i].type_index;
636 scan(new Signature(index).getType(constant_pool));
637 }
638 }
639 }
640
641 void addClass(int index) throws ConstantPoolException {
642 if (index != 0) {
643 String name = constant_pool.getClassInfo(index).getBaseName();
644 if (name != null)
645 addDependency(name);
646 }
647 }
648
649 void addClasses(int[] indices) throws ConstantPoolException {
650 for (int i: indices)
651 addClass(i);
652 }
653
654 private void addDependency(String name) {
655 deps.add(new SimpleDependency(origin, getLocation(name)));
656 }
657
658 // ConstantPool.Visitor methods
659
660 public Void visitClass(CONSTANT_Class_info info, Void p) {
661 try {
662 if (info.getName().startsWith("["))
663 new Signature(info.name_index).getType(constant_pool).accept(this, null);
664 else
665 addDependency(info.getBaseName());
666 return null;
667 } catch (ConstantPoolException e) {
668 throw new ClassFileError(e);
669 }
670 }
671
672 public Void visitDouble(CONSTANT_Double_info info, Void p) {
673 return null;
674 }
675
676 public Void visitFieldref(CONSTANT_Fieldref_info info, Void p) {
677 return visitRef(info, p);
678 }
679
680 public Void visitFloat(CONSTANT_Float_info info, Void p) {
681 return null;
682 }
683
684 public Void visitInteger(CONSTANT_Integer_info info, Void p) {
685 return null;
686 }
687
688 public Void visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, Void p) {
689 return visitRef(info, p);
690 }
691
692 public Void visitInvokeDynamic(CONSTANT_InvokeDynamic_info info, Void p) {
693 return null;
694 }
695
696 public Void visitLong(CONSTANT_Long_info info, Void p) {
697 return null;
698 }
699
700 public Void visitMethodHandle(CONSTANT_MethodHandle_info info, Void p) {
701 return null;
702 }
703
704 public Void visitMethodType(CONSTANT_MethodType_info info, Void p) {
705 return null;
706 }
707
708 public Void visitMethodref(CONSTANT_Methodref_info info, Void p) {
709 return visitRef(info, p);
710 }
711
712 public Void visitNameAndType(CONSTANT_NameAndType_info info, Void p) {
713 try {
714 new Signature(info.type_index).getType(constant_pool).accept(this, null);
715 return null;
716 } catch (ConstantPoolException e) {
717 throw new ClassFileError(e);
718 }
719 }
720
721 public Void visitString(CONSTANT_String_info info, Void p) {
722 return null;
723 }
724
725 public Void visitUtf8(CONSTANT_Utf8_info info, Void p) {
726 return null;
727 }
728
729 private Void visitRef(CPRefInfo info, Void p) {
730 try {
731 visitClass(info.getClassInfo(), p);
732 return null;
733 } catch (ConstantPoolException e) {
734 throw new ClassFileError(e);
735 }
736 }
737
738 // Type.Visitor methods
739
740 private void findDependencies(Type t) {
741 if (t != null)
742 t.accept(this, null);
743 }
744
745 private void findDependencies(List<? extends Type> ts) {
746 if (ts != null) {
747 for (Type t: ts)
748 t.accept(this, null);
749 }
750 }
751
752 public Void visitSimpleType(SimpleType type, Void p) {
753 return null;
754 }
755
756 public Void visitArrayType(ArrayType type, Void p) {
757 findDependencies(type.elemType);
758 return null;
759 }
760
761 public Void visitMethodType(MethodType type, Void p) {
762 findDependencies(type.paramTypes);
763 findDependencies(type.returnType);
764 findDependencies(type.throwsTypes);
765 findDependencies(type.typeParamTypes);
766 return null;
767 }
768
769 public Void visitClassSigType(ClassSigType type, Void p) {
770 findDependencies(type.superclassType);
771 findDependencies(type.superinterfaceTypes);
772 return null;
773 }
774
775 public Void visitClassType(ClassType type, Void p) {
776 findDependencies(type.outerType);
777 addDependency(type.getBinaryName());
778 findDependencies(type.typeArgs);
779 return null;
780 }
781
782 public Void visitTypeParamType(TypeParamType type, Void p) {
783 findDependencies(type.classBound);
784 findDependencies(type.interfaceBounds);
785 return null;
786 }
787
788 public Void visitWildcardType(WildcardType type, Void p) {
789 findDependencies(type.boundType);
790 return null;
791 }
792 }
793 }
794 }