Merge "Reland "Implicitly add necessary rules for Java reflections in any R8 mode.""
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 16858af..bca3e00 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -490,6 +490,7 @@
ClassNameMapper classNameMapper =
LineNumberOptimizer.run(
application,
+ appView.getGraphLense(),
namingLens,
options.lineNumberOptimization == LineNumberOptimization.IDENTITY_MAPPING);
timing.end();
diff --git a/src/main/java/com/android/tools/r8/graph/DexField.java b/src/main/java/com/android/tools/r8/graph/DexField.java
index 98c523d..dcab5ae 100644
--- a/src/main/java/com/android/tools/r8/graph/DexField.java
+++ b/src/main/java/com/android/tools/r8/graph/DexField.java
@@ -117,6 +117,10 @@
return clazz;
}
+ public String qualifiedName() {
+ return clazz + "." + name;
+ }
+
@Override
public String toSmaliString() {
return clazz.toSmaliString() + "->" + name + ":" + type.toSmaliString();
diff --git a/src/main/java/com/android/tools/r8/graph/GraphLense.java b/src/main/java/com/android/tools/r8/graph/GraphLense.java
index 84ceac3..d264b87 100644
--- a/src/main/java/com/android/tools/r8/graph/GraphLense.java
+++ b/src/main/java/com/android/tools/r8/graph/GraphLense.java
@@ -93,6 +93,10 @@
public abstract DexMethod getOriginalMethodSignature(DexMethod method);
+ public abstract DexField getRenamedFieldSignature(DexField originalField);
+
+ public abstract DexMethod getRenamedMethodSignature(DexMethod originalMethod);
+
public abstract DexType lookupType(DexType type);
// This overload can be used when the graph lense is known to be context insensitive.
@@ -140,7 +144,7 @@
return this instanceof IdentityGraphLense;
}
- public boolean assertNotModified(Iterable<DexItem> items) {
+ public <T extends DexItem> boolean assertNotModified(Iterable<T> items) {
for (DexItem item : items) {
if (item instanceof DexClass) {
DexType type = ((DexClass) item).type;
@@ -172,6 +176,16 @@
}
@Override
+ public DexField getRenamedFieldSignature(DexField originalField) {
+ return originalField;
+ }
+
+ @Override
+ public DexMethod getRenamedMethodSignature(DexMethod originalMethod) {
+ return originalMethod;
+ }
+
+ @Override
public DexType lookupType(DexType type) {
return type;
}
@@ -254,6 +268,24 @@
}
@Override
+ public DexField getRenamedFieldSignature(DexField originalField) {
+ DexField renamedField =
+ originalFieldSignatures != null
+ ? originalFieldSignatures.inverse().getOrDefault(originalField, originalField)
+ : originalField;
+ return previousLense.getRenamedFieldSignature(renamedField);
+ }
+
+ @Override
+ public DexMethod getRenamedMethodSignature(DexMethod originalMethod) {
+ DexMethod renamedMethod =
+ originalMethodSignatures != null
+ ? originalMethodSignatures.inverse().getOrDefault(originalMethod, originalMethod)
+ : originalMethod;
+ return previousLense.getRenamedMethodSignature(renamedMethod);
+ }
+
+ @Override
public DexType lookupType(DexType type) {
if (type.isArrayType()) {
synchronized (this) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
index 631f234..998ebe9 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
@@ -93,11 +93,11 @@
private Reason computeInliningReason(DexEncodedMethod target) {
if (target.getOptimizationInfo().forceInline()
|| (inliner.appInfo.hasLiveness()
- && inliner.appInfo.withLiveness().forceInline.contains(target))) {
+ && inliner.appInfo.withLiveness().forceInline.contains(target.method))) {
return Reason.FORCE;
}
if (inliner.appInfo.hasLiveness()
- && inliner.appInfo.withLiveness().alwaysInline.contains(target)) {
+ && inliner.appInfo.withLiveness().alwaysInline.contains(target.method)) {
return Reason.ALWAYS;
}
if (callSiteInformation.hasSingleCallSite(target)) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
index 12baa2c..1cbd2d9 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Inliner.java
@@ -71,7 +71,7 @@
}
public boolean isBlackListed(DexEncodedMethod method) {
- return blackList.contains(method.method) || appInfo.neverInline.contains(method);
+ return blackList.contains(method.method) || appInfo.neverInline.contains(method.method);
}
private ConstraintWithTarget instructionAllowedForInlining(
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java b/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java
index c5d366a..e405bfb 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java
@@ -35,10 +35,10 @@
public class ClassNameMapper implements ProguardMap {
public static class Builder extends ProguardMap.Builder {
- final ImmutableMap.Builder<String, ClassNamingForNameMapper.Builder> mapBuilder;
+ private final ImmutableMap.Builder<String, ClassNamingForNameMapper.Builder> mapBuilder;
private Builder() {
- mapBuilder = ImmutableMap.builder();
+ this.mapBuilder = ImmutableMap.builder();
}
@Override
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java b/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
index 34fdd9d..f45a3de 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
@@ -14,6 +14,7 @@
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -68,17 +69,17 @@
/** The parameters are forwarded to MappedRange constructor, see explanation there. */
@Override
public void addMappedRange(
- Range obfuscatedRange,
+ Range minifiedRange,
MemberNaming.MethodSignature originalSignature,
Object originalRange,
- String obfuscatedName) {
+ String renamedName) {
mappedRangesByName
- .computeIfAbsent(obfuscatedName, k -> new ArrayList<>())
- .add(new MappedRange(obfuscatedRange, originalSignature, originalRange, obfuscatedName));
+ .computeIfAbsent(renamedName, k -> new ArrayList<>())
+ .add(new MappedRange(minifiedRange, originalSignature, originalRange, renamedName));
}
}
- /** List of MappedRanges that belong to the same obfuscated name. */
+ /** List of MappedRanges that belong to the same renamed name. */
public static class MappedRangesOfName {
private final List<MappedRange> mappedRanges;
@@ -93,14 +94,14 @@
public MappedRange firstRangeForLine(int line) {
MappedRange bestRange = null;
for (MappedRange range : mappedRanges) {
- if (range.obfuscatedRange == null) {
+ if (range.minifiedRange == null) {
if (bestRange == null) {
// This is an "a() -> b" mapping (no concrete line numbers), remember this if there'll
// be no better one.
bestRange = range;
}
- } else if (range.obfuscatedRange.contains(line)) {
- // Concrete obfuscated range found ("x:y:a()[:u[:v]] -> b")
+ } else if (range.minifiedRange.contains(line)) {
+ // Concrete minified range found ("x:y:a()[:u[:v]] -> b")
return range;
}
}
@@ -108,25 +109,25 @@
}
/**
- * Search for a MappedRange where the obfuscated range contains the specified {@code line} and
- * return that and the subsequent MappedRanges with the same obfuscated range. Return general
+ * Search for a MappedRange where the minified range contains the specified {@code line} and
+ * return that and the subsequent MappedRanges with the same minified range. Return general
* MappedRange ("a() -> b") if no concrete mapping found or empty list if nothing found.
*/
public List<MappedRange> allRangesForLine(int line) {
MappedRange noLineRange = null;
for (int i = 0; i < mappedRanges.size(); ++i) {
MappedRange rangeI = mappedRanges.get(i);
- if (rangeI.obfuscatedRange == null) {
+ if (rangeI.minifiedRange == null) {
if (noLineRange == null) {
// This is an "a() -> b" mapping (no concrete line numbers), remember this if there'll
// be no better one.
noLineRange = rangeI;
}
- } else if (rangeI.obfuscatedRange.contains(line)) {
- // Concrete obfuscated range found ("x:y:a()[:u[:v]] -> b")
+ } else if (rangeI.minifiedRange.contains(line)) {
+ // Concrete minified range found ("x:y:a()[:u[:v]] -> b")
int j = i + 1;
for (; j < mappedRanges.size(); ++j) {
- if (!Objects.equals(mappedRanges.get(j).obfuscatedRange, rangeI.obfuscatedRange)) {
+ if (!Objects.equals(mappedRanges.get(j).minifiedRange, rangeI.minifiedRange)) {
break;
}
}
@@ -165,27 +166,27 @@
/**
* Mapping from the renamed signature to the naming information for a member.
- * <p>
- * A renamed signature is a signature where the member's name has been obfuscated but not the type
+ *
+ * <p>A renamed signature is a signature where the member's name has been renamed but not the type
* information.
- **/
+ */
private final ImmutableMap<MethodSignature, MemberNaming> methodMembers;
private final ImmutableMap<FieldSignature, MemberNaming> fieldMembers;
- /** Map of obfuscated name -> MappedRangesOfName */
- public final Map<String, MappedRangesOfName> mappedRangesByName;
+ /** Map of renamed name -> MappedRangesOfName */
+ public final Map<String, MappedRangesOfName> mappedRangesByRenamedName;
private ClassNamingForNameMapper(
String renamedName,
String originalName,
Map<MethodSignature, MemberNaming> methodMembers,
Map<FieldSignature, MemberNaming> fieldMembers,
- Map<String, MappedRangesOfName> mappedRangesByName) {
+ Map<String, MappedRangesOfName> mappedRangesByRenamedName) {
this.renamedName = renamedName;
this.originalName = originalName;
this.methodMembers = ImmutableMap.copyOf(methodMembers);
this.fieldMembers = ImmutableMap.copyOf(fieldMembers);
- this.mappedRangesByName = mappedRangesByName;
+ this.mappedRangesByRenamedName = mappedRangesByRenamedName;
}
@Override
@@ -273,16 +274,13 @@
});
// Sort MappedRanges by sequence number to restore construction order (original Proguard-map
- // input)
- List<MappedRange> rangeList = new ArrayList<>();
- for (MappedRangesOfName ranges : mappedRangesByName.values()) {
- rangeList.addAll(ranges.mappedRanges);
+ // input).
+ List<MappedRange> mappedRangesSorted = new ArrayList<>();
+ for (MappedRangesOfName ranges : mappedRangesByRenamedName.values()) {
+ mappedRangesSorted.addAll(ranges.mappedRanges);
}
- rangeList.sort(
- (lhs, rhs) -> {
- return lhs.sequenceNumber - rhs.sequenceNumber;
- });
- for (MappedRange range : rangeList) {
+ mappedRangesSorted.sort(Comparator.comparingInt(range -> range.sequenceNumber));
+ for (MappedRange range : mappedRangesSorted) {
writer.append(" ").append(range.toString()).append('\n');
}
}
@@ -313,7 +311,7 @@
&& renamedName.equals(that.renamedName)
&& methodMembers.equals(that.methodMembers)
&& fieldMembers.equals(that.fieldMembers)
- && mappedRangesByName.equals(that.mappedRangesByName);
+ && mappedRangesByRenamedName.equals(that.mappedRangesByRenamedName);
}
@Override
@@ -322,27 +320,27 @@
result = 31 * result + renamedName.hashCode();
result = 31 * result + methodMembers.hashCode();
result = 31 * result + fieldMembers.hashCode();
- result = 31 * result + mappedRangesByName.hashCode();
+ result = 31 * result + mappedRangesByRenamedName.hashCode();
return result;
}
/**
- * MappedRange describes an (original line numbers, signature) <-> (obfuscated line numbers)
+ * MappedRange describes an (original line numbers, signature) <-> (minified line numbers)
* mapping. It can describe 3 different things:
*
* <p>1. The method is renamed. The original source lines are preserved. The corresponding
* Proguard-map syntax is "a(...) -> b"
*
- * <p>2. The source lines of a method in the original range are renumbered to the obfuscated
- * range. In this case the {@link MappedRange#originalRange} is either a {@code Range} or null,
+ * <p>2. The source lines of a method in the original range are renumbered to the minified range.
+ * In this case the {@link MappedRange#originalRange} is either a {@code Range} or null,
* indicating that the original range is unknown or is the same as the {@link
- * MappedRange#obfuscatedRange}. The corresponding Proguard-map syntax is "x:y:a(...) -> b" or
+ * MappedRange#minifiedRange}. The corresponding Proguard-map syntax is "x:y:a(...) -> b" or
* "x:y:a(...):u:v -> b"
*
* <p>3. The source line of a method is the inlining caller of the previous {@code MappedRange}.
* In this case the {@link MappedRange@originalRange} is either an {@code int} or null, indicating
- * that the original source line is unknown, or may be identical to a line of the obfuscated
- * range. The corresponding Proguard-map syntax is "x:y:a(...) -> b" or "x:y:a(...):u -> b"
+ * that the original source line is unknown, or may be identical to a line of the minified range.
+ * The corresponding Proguard-map syntax is "x:y:a(...) -> b" or "x:y:a(...):u -> b"
*/
public static class MappedRange {
@@ -352,10 +350,10 @@
return nextSequenceNumber++;
}
- public final Range obfuscatedRange; // Can be null, if so then originalRange must also be null.
+ public final Range minifiedRange; // Can be null, if so then originalRange must also be null.
public final MethodSignature signature;
public final Object originalRange; // null, Integer or Range.
- public final String obfuscatedName;
+ public final String renamedName;
/**
* The sole purpose of {@link #sequenceNumber} is to preserve the order of members read from a
@@ -364,52 +362,49 @@
private final int sequenceNumber = getNextSequenceNumber();
private MappedRange(
- Range obfuscatedRange,
- MethodSignature signature,
- Object originalRange,
- String obfuscatedName) {
+ Range minifiedRange, MethodSignature signature, Object originalRange, String renamedName) {
- assert obfuscatedRange != null || originalRange == null;
+ assert minifiedRange != null || originalRange == null;
assert originalRange == null
|| originalRange instanceof Integer
|| originalRange instanceof Range;
- this.obfuscatedRange = obfuscatedRange;
+ this.minifiedRange = minifiedRange;
this.signature = signature;
this.originalRange = originalRange;
- this.obfuscatedName = obfuscatedName;
+ this.renamedName = renamedName;
}
- public int originalLineFromObfuscated(int obfuscatedLineNumber) {
- if (obfuscatedRange == null) {
+ public int getOriginalLineNumber(int lineNumberAfterMinification) {
+ if (minifiedRange == null) {
// General mapping without concrete line numbers: "a() -> b"
- return obfuscatedLineNumber;
+ return lineNumberAfterMinification;
}
- assert obfuscatedRange.contains(obfuscatedLineNumber);
+ assert minifiedRange.contains(lineNumberAfterMinification);
if (originalRange == null) {
// Concrete identity mapping: "x:y:a() -> b"
- return obfuscatedLineNumber;
+ return lineNumberAfterMinification;
} else if (originalRange instanceof Integer) {
// Inlinee: "x:y:a():u -> b"
return (int) originalRange;
} else {
// "x:y:a():u:v -> b"
assert originalRange instanceof Range;
- return ((Range) originalRange).from + obfuscatedLineNumber - obfuscatedRange.from;
+ return ((Range) originalRange).from + lineNumberAfterMinification - minifiedRange.from;
}
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
- if (obfuscatedRange != null) {
- builder.append(obfuscatedRange).append(':');
+ if (minifiedRange != null) {
+ builder.append(minifiedRange).append(':');
}
builder.append(signature);
if (originalRange != null) {
builder.append(":").append(originalRange);
}
- builder.append(" -> ").append(obfuscatedName);
+ builder.append(" -> ").append(renamedName);
return builder.toString();
}
@@ -426,19 +421,19 @@
MappedRange that = (MappedRange) o;
- return Objects.equals(obfuscatedRange, that.obfuscatedRange)
+ return Objects.equals(minifiedRange, that.minifiedRange)
&& Objects.equals(originalRange, that.originalRange)
&& signature.equals(that.signature)
- && obfuscatedName.equals(that.obfuscatedName);
+ && renamedName.equals(that.renamedName);
}
@Override
public int hashCode() {
// sequenceNumber is intentionally omitted from hashCode since it's not used in equality test.
- int result = Objects.hashCode(obfuscatedRange);
+ int result = Objects.hashCode(minifiedRange);
result = 31 * result + Objects.hashCode(originalRange);
result = 31 * result + signature.hashCode();
- result = 31 * result + obfuscatedName.hashCode();
+ result = 31 * result + renamedName.hashCode();
return result;
}
}
diff --git a/src/main/java/com/android/tools/r8/naming/MemberNaming.java b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
index c766c37..094dcaf 100644
--- a/src/main/java/com/android/tools/r8/naming/MemberNaming.java
+++ b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
@@ -134,7 +134,12 @@
}
public static FieldSignature fromDexField(DexField field) {
- return new FieldSignature(field.name.toSourceString(),
+ return fromDexField(field, false);
+ }
+
+ public static FieldSignature fromDexField(DexField field, boolean withQualifiedName) {
+ return new FieldSignature(
+ withQualifiedName ? field.qualifiedName() : field.name.toSourceString(),
field.type.toSourceString());
}
diff --git a/src/main/java/com/android/tools/r8/optimize/BridgeMethodAnalysis.java b/src/main/java/com/android/tools/r8/optimize/BridgeMethodAnalysis.java
index 6ba18ac..46fdc82 100644
--- a/src/main/java/com/android/tools/r8/optimize/BridgeMethodAnalysis.java
+++ b/src/main/java/com/android/tools/r8/optimize/BridgeMethodAnalysis.java
@@ -100,6 +100,17 @@
}
@Override
+ public DexField getRenamedFieldSignature(DexField originalField) {
+ return previousLense.getRenamedFieldSignature(originalField);
+ }
+
+ @Override
+ public DexMethod getRenamedMethodSignature(DexMethod originalMethod) {
+ // TODO(b/79143143): implement this when re-enabling bridge analysis.
+ throw new Unimplemented("BridgeLense.getRenamedMethodSignature() not implemented");
+ }
+
+ @Override
public DexType lookupType(DexType type) {
return previousLense.lookupType(type);
}
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index 420af47..64387ce 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -1672,15 +1672,15 @@
/**
* All methods that should be inlined if possible due to a configuration directive.
*/
- public final Set<DexItem> alwaysInline;
+ public final Set<DexMethod> alwaysInline;
/**
* All methods that *must* be inlined due to a configuration directive (testing only).
*/
- public final Set<DexItem> forceInline;
+ public final Set<DexMethod> forceInline;
/**
* All methods that *must* never be inlined due to a configuration directive (testing only).
*/
- public final Set<DexItem> neverInline;
+ public final Set<DexMethod> neverInline;
/**
* All items with -identifiernamestring rule.
* Bound boolean value indicates the rule is explicitly specified by users (<code>true</code>)
@@ -1829,8 +1829,8 @@
this.assumedValues = previous.assumedValues;
assert lense.assertNotModified(previous.alwaysInline);
this.alwaysInline = previous.alwaysInline;
- this.forceInline = previous.forceInline;
- this.neverInline = previous.neverInline;
+ this.forceInline = rewriteMethodsWithRenamedSignature(previous.forceInline, lense);
+ this.neverInline = rewriteMethodsWithRenamedSignature(previous.neverInline, lense);
this.identifierNameStrings =
rewriteMixedItemsConservatively(previous.identifierNameStrings, lense);
// Switchmap classes should never be affected by renaming.
@@ -1954,6 +1954,16 @@
return builder.build();
}
+ private static ImmutableSortedSet<DexMethod> rewriteMethodsWithRenamedSignature(
+ Set<DexMethod> methods, GraphLense lense) {
+ ImmutableSortedSet.Builder<DexMethod> builder =
+ new ImmutableSortedSet.Builder<>(PresortedComparable::slowCompare);
+ for (DexMethod method : methods) {
+ builder.add(lense.getRenamedMethodSignature(method));
+ }
+ return builder.build();
+ }
+
private static ImmutableSortedSet<DexMethod> rewriteMethodsConservatively(
Set<DexMethod> original, GraphLense lense) {
ImmutableSortedSet.Builder<DexMethod> builder =
diff --git a/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java b/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
index c95cfe9..473c990 100644
--- a/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
+++ b/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
@@ -59,9 +59,9 @@
private final Set<ProguardConfigurationRule> rulesThatUseExtendsOrImplementsWrong =
Sets.newIdentityHashSet();
private final Set<DexItem> checkDiscarded = Sets.newIdentityHashSet();
- private final Set<DexItem> alwaysInline = Sets.newIdentityHashSet();
- private final Set<DexItem> forceInline = Sets.newIdentityHashSet();
- private final Set<DexItem> neverInline = Sets.newIdentityHashSet();
+ private final Set<DexMethod> alwaysInline = Sets.newIdentityHashSet();
+ private final Set<DexMethod> forceInline = Sets.newIdentityHashSet();
+ private final Set<DexMethod> neverInline = Sets.newIdentityHashSet();
private final Map<DexItem, Map<DexItem, ProguardKeepRule>> dependentNoShrinking =
new IdentityHashMap<>();
private final Map<DexItem, ProguardMemberRule> noSideEffects = new IdentityHashMap<>();
@@ -727,13 +727,19 @@
} else if (context instanceof InlineRule) {
switch (((InlineRule) context).getType()) {
case ALWAYS:
- alwaysInline.add(item);
+ if (item instanceof DexEncodedMethod) {
+ alwaysInline.add(((DexEncodedMethod) item).method);
+ }
break;
case FORCE:
- forceInline.add(item);
+ if (item instanceof DexEncodedMethod) {
+ forceInline.add(((DexEncodedMethod) item).method);
+ }
break;
case NEVER:
- neverInline.add(item);
+ if (item instanceof DexEncodedMethod) {
+ neverInline.add(((DexEncodedMethod) item).method);
+ }
break;
default:
throw new Unreachable();
@@ -755,9 +761,9 @@
public final Set<DexItem> reasonAsked;
public final Set<DexItem> keepPackageName;
public final Set<DexItem> checkDiscarded;
- public final Set<DexItem> alwaysInline;
- public final Set<DexItem> forceInline;
- public final Set<DexItem> neverInline;
+ public final Set<DexMethod> alwaysInline;
+ public final Set<DexMethod> forceInline;
+ public final Set<DexMethod> neverInline;
public final Map<DexItem, ProguardMemberRule> noSideEffects;
public final Map<DexItem, ProguardMemberRule> assumedValues;
private final Map<DexItem, Map<DexItem, ProguardKeepRule>> dependentNoShrinking;
@@ -792,9 +798,9 @@
Set<DexItem> reasonAsked,
Set<DexItem> keepPackageName,
Set<DexItem> checkDiscarded,
- Set<DexItem> alwaysInline,
- Set<DexItem> forceInline,
- Set<DexItem> neverInline,
+ Set<DexMethod> alwaysInline,
+ Set<DexMethod> forceInline,
+ Set<DexMethod> neverInline,
Map<DexItem, ProguardMemberRule> noSideEffects,
Map<DexItem, ProguardMemberRule> assumedValues,
Map<DexItem, Map<DexItem, ProguardKeepRule>> dependentNoShrinking,
diff --git a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
index ee596f3..a2dd383 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -252,7 +252,7 @@
}
}
- private void extractPinnedItems(Iterable<DexItem> items, AbortReason reason) {
+ private <T extends DexItem> void extractPinnedItems(Iterable<T> items, AbortReason reason) {
for (DexItem item : items) {
if (item instanceof DexType || item instanceof DexClass) {
DexType type = item instanceof DexType ? (DexType) item : ((DexClass) item).type;
@@ -1524,6 +1524,16 @@
}
@Override
+ public DexField getRenamedFieldSignature(DexField originalField) {
+ throw new Unreachable();
+ }
+
+ @Override
+ public DexMethod getRenamedMethodSignature(DexMethod originalMethod) {
+ throw new Unreachable();
+ }
+
+ @Override
public DexType lookupType(DexType type) {
return type == source ? target : mergedClasses.getOrDefault(type, type);
}
diff --git a/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java b/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
index 5163772..66490b2 100644
--- a/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
+++ b/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
@@ -20,6 +20,7 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.graph.GraphLense;
import com.android.tools.r8.ir.code.Position;
import com.android.tools.r8.naming.ClassNameMapper;
import com.android.tools.r8.naming.ClassNaming;
@@ -35,6 +36,7 @@
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.function.Function;
import java.util.function.Supplier;
public class LineNumberOptimizer {
@@ -202,7 +204,10 @@
}
public static ClassNameMapper run(
- DexApplication application, NamingLens namingLens, boolean identityMapping) {
+ DexApplication application,
+ GraphLense graphLense,
+ NamingLens namingLens,
+ boolean identityMapping) {
ClassNameMapper.Builder classNameMapperBuilder = ClassNameMapper.builder();
// Collect which files contain which classes that need to have their line numbers optimized.
for (DexProgramClass clazz : application.classes()) {
@@ -212,8 +217,8 @@
continue;
}
- IdentityHashMap<DexString, List<DexEncodedMethod>> methodsByName =
- groupMethodsByName(namingLens, clazz);
+ IdentityHashMap<DexString, List<DexEncodedMethod>> methodsByRenamedName =
+ groupMethodsByRenamedName(namingLens, clazz);
// At this point we don't know if we really need to add this class to the builder.
// It depends on whether any methods/fields are renamed or some methods contain positions.
@@ -230,10 +235,13 @@
addClassToClassNaming(clazz, renamedClassName, onDemandClassNamingBuilder);
// First transfer renamed fields to classNamingBuilder.
- addFieldsToClassNaming(namingLens, clazz, onDemandClassNamingBuilder);
+ addFieldsToClassNaming(graphLense, namingLens, clazz, onDemandClassNamingBuilder);
- // Then process the methods.
- for (List<DexEncodedMethod> methods : methodsByName.values()) {
+ // Then process the methods, ordered by renamed name.
+ List<DexString> renamedMethodNames = new ArrayList<>(methodsByRenamedName.keySet());
+ renamedMethodNames.sort(DexString::slowCompareTo);
+ for (DexString methodName : renamedMethodNames) {
+ List<DexEncodedMethod> methods = methodsByRenamedName.get(methodName);
if (methods.size() > 1) {
// If there are multiple methods with the same name (overloaded) then sort them for
// deterministic behaviour: the algorithm will assign new line numbers in this order.
@@ -258,7 +266,9 @@
}
}
- MethodSignature originalSignature = MethodSignature.fromDexMethod(method.method);
+ DexMethod originalMethod = graphLense.getOriginalMethodSignature(method.method);
+ MethodSignature originalSignature =
+ MethodSignature.fromDexMethod(originalMethod, originalMethod.holder != clazz.type);
DexString obfuscatedNameDexString = namingLens.lookupName(method.method);
String obfuscatedName = obfuscatedNameDexString.toString();
@@ -266,7 +276,8 @@
// Add simple "a() -> b" mapping if we won't have any other with concrete line numbers
if (mappedPositions.isEmpty()) {
// But only if it's been renamed.
- if (obfuscatedNameDexString != method.method.name) {
+ if (obfuscatedNameDexString != originalMethod.name
+ || originalMethod.holder != clazz.type) {
onDemandClassNamingBuilder
.get()
.addMappedRange(null, originalSignature, null, obfuscatedName);
@@ -275,7 +286,16 @@
}
Map<DexMethod, MethodSignature> signatures = new IdentityHashMap<>();
- signatures.put(method.method, originalSignature);
+ signatures.put(originalMethod, originalSignature);
+ Function<DexMethod, MethodSignature> getOriginalMethodSignature =
+ m -> {
+ DexMethod original = graphLense.getOriginalMethodSignature(m);
+ return signatures.computeIfAbsent(
+ original,
+ key ->
+ MethodSignature.fromDexMethod(
+ original, original.holder != clazz.getType()));
+ };
MemberNaming memberNaming = new MemberNaming(originalSignature, obfuscatedName);
onDemandClassNamingBuilder.get().addMemberEntry(memberNaming);
@@ -306,23 +326,14 @@
ClassNaming.Builder classNamingBuilder = onDemandClassNamingBuilder.get();
classNamingBuilder.addMappedRange(
obfuscatedRange,
- signatures.computeIfAbsent(
- firstPosition.method,
- m ->
- MethodSignature.fromDexMethod(
- m, firstPosition.method.holder != clazz.getType())),
+ getOriginalMethodSignature.apply(firstPosition.method),
originalRange,
obfuscatedName);
Position caller = firstPosition.caller;
while (caller != null) {
- Position finalCaller = caller;
classNamingBuilder.addMappedRange(
obfuscatedRange,
- signatures.computeIfAbsent(
- caller.method,
- m ->
- MethodSignature.fromDexMethod(
- m, finalCaller.method.holder != clazz.getType())),
+ getOriginalMethodSignature.apply(caller.method),
Math.max(caller.line, 0), // Prevent against "no-position".
obfuscatedName);
caller = caller.callerPosition;
@@ -378,42 +389,37 @@
}
}
- private static void addFieldsToClassNaming(NamingLens namingLens, DexProgramClass clazz,
+ private static void addFieldsToClassNaming(
+ GraphLense graphLense,
+ NamingLens namingLens,
+ DexProgramClass clazz,
Supplier<Builder> onDemandClassNamingBuilder) {
clazz.forEachField(
dexEncodedField -> {
DexField dexField = dexEncodedField.field;
+ DexField originalField = graphLense.getOriginalFieldSignature(dexField);
DexString renamedName = namingLens.lookupName(dexField);
- if (renamedName != dexField.name) {
- FieldSignature signature =
- new FieldSignature(dexField.name.toString(), dexField.type.toString());
- MemberNaming memberNaming = new MemberNaming(signature, renamedName.toString());
+ if (renamedName != originalField.name || originalField.clazz != clazz.type) {
+ FieldSignature originalSignature =
+ FieldSignature.fromDexField(originalField, originalField.clazz != clazz.type);
+ MemberNaming memberNaming = new MemberNaming(originalSignature, renamedName.toString());
onDemandClassNamingBuilder.get().addMemberEntry(memberNaming);
}
});
}
- private static IdentityHashMap<DexString, List<DexEncodedMethod>> groupMethodsByName(
+ private static IdentityHashMap<DexString, List<DexEncodedMethod>> groupMethodsByRenamedName(
NamingLens namingLens, DexProgramClass clazz) {
- IdentityHashMap<DexString, List<DexEncodedMethod>> methodsByName =
+ IdentityHashMap<DexString, List<DexEncodedMethod>> methodsByRenamedName =
new IdentityHashMap<>(clazz.directMethods().length + clazz.virtualMethods().length);
- clazz.forEachMethod(
- method -> {
- // Add method only if renamed or contains positions.
- if (namingLens.lookupName(method.method) != method.method.name
- || doesContainPositions(method)) {
- methodsByName.compute(
- method.method.name,
- (name, methods) -> {
- if (methods == null) {
- methods = new ArrayList<>();
- }
- methods.add(method);
- return methods;
- });
- }
- });
- return methodsByName;
+ for (DexEncodedMethod method : clazz.methods()) {
+ // Add method only if renamed or contains positions.
+ DexString renamedName = namingLens.lookupName(method.method);
+ if (renamedName != method.method.name || doesContainPositions(method)) {
+ methodsByRenamedName.computeIfAbsent(renamedName, key -> new ArrayList<>()).add(method);
+ }
+ }
+ return methodsByRenamedName;
}
private static boolean doesContainPositions(DexEncodedMethod method) {
diff --git a/src/test/examples/classmerging/ProguardFieldMapTest.java b/src/test/examples/classmerging/ProguardFieldMapTest.java
new file mode 100644
index 0000000..0cbf8a1
--- /dev/null
+++ b/src/test/examples/classmerging/ProguardFieldMapTest.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package classmerging;
+
+public class ProguardFieldMapTest {
+
+ public static void main(String[] args) {
+ B b = new B();
+ b.test();
+ }
+
+ public static class A {
+
+ public String f = "A.f";
+ }
+
+ public static class B extends A {
+
+ public void test() {
+ System.out.println(f);
+ }
+ }
+}
diff --git a/src/test/examples/classmerging/ProguardMethodMapTest.java b/src/test/examples/classmerging/ProguardMethodMapTest.java
new file mode 100644
index 0000000..9ce0ad7
--- /dev/null
+++ b/src/test/examples/classmerging/ProguardMethodMapTest.java
@@ -0,0 +1,29 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package classmerging;
+
+public class ProguardMethodMapTest {
+
+ public static void main(String[] args) {
+ B b = new B();
+ b.method();
+ }
+
+ public static class A {
+
+ public void method() {
+ System.out.println("In A.method()");
+ }
+ }
+
+ public static class B extends A {
+
+ @Override
+ public void method() {
+ System.out.println("In B.method()");
+ super.method();
+ }
+ }
+}
diff --git a/src/test/examples/classmerging/keep-rules.txt b/src/test/examples/classmerging/keep-rules.txt
index 37a3010..3a70504 100644
--- a/src/test/examples/classmerging/keep-rules.txt
+++ b/src/test/examples/classmerging/keep-rules.txt
@@ -37,6 +37,12 @@
-keep public class classmerging.PinnedParameterTypesTest$TestClass {
public static void method(...);
}
+-keep public class classmerging.ProguardFieldMapTest {
+ public static void main(...);
+}
+-keep public class classmerging.ProguardMethodMapTest {
+ public static void main(...);
+}
-keep public class classmerging.SimpleInterfaceAccessTest {
public static void main(...);
}
diff --git a/src/test/examples/shaking1/print-mapping-cf.ref b/src/test/examples/shaking1/print-mapping-cf.ref
new file mode 100644
index 0000000..9bf8013
--- /dev/null
+++ b/src/test/examples/shaking1/print-mapping-cf.ref
@@ -0,0 +1,7 @@
+shaking1.Shaking -> shaking1.Shaking:
+shaking1.Used -> a.a:
+ java.lang.String name -> a
+ 1:1:java.lang.String method():17:17 -> a
+ 1:1:void main(java.lang.String[]):8:8 -> main
+ 1:2:void <init>(java.lang.String):12:13 -> <init>
+ 1:1:java.lang.String aMethodThatIsNotUsedButKept():21:21 -> aMethodThatIsNotUsedButKept
diff --git a/src/test/java/com/android/tools/r8/classmerging/ClassMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/ClassMergingTest.java
index 6f3c97a..6322840 100644
--- a/src/test/java/com/android/tools/r8/classmerging/ClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/ClassMergingTest.java
@@ -3,9 +3,11 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.classmerging;
+import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.COMPANION_CLASS_NAME_SUFFIX;
import static com.android.tools.r8.smali.SmaliBuilder.buildCode;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.not;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
@@ -14,6 +16,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.OutputMode;
import com.android.tools.r8.R8Command;
+import com.android.tools.r8.StringConsumer.FileConsumer;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.DexVm.Version;
@@ -21,6 +24,10 @@
import com.android.tools.r8.VmTestRunner.IgnoreForRangeOfVmVersions;
import com.android.tools.r8.code.Instruction;
import com.android.tools.r8.code.MoveException;
+import com.android.tools.r8.debug.DebugTestBase;
+import com.android.tools.r8.debug.DebugTestBase.JUnit3Wrapper.Command;
+import com.android.tools.r8.debug.DebugTestBase.JUnit3Wrapper.DebuggeeState;
+import com.android.tools.r8.debug.DexDebugTestConfig;
import com.android.tools.r8.graph.DexCode;
import com.android.tools.r8.ir.optimize.Inliner.Reason;
import com.android.tools.r8.jasmin.JasminBuilder;
@@ -34,8 +41,11 @@
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.base.Joiner;
+import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
+import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
@@ -97,7 +107,7 @@
);
@Test
- public void testClassesHaveBeenMerged() throws Exception {
+ public void testClassesHaveBeenMerged() throws Throwable {
runR8(EXAMPLE_KEEP, this::configure);
// GenericInterface should be merged into GenericInterfaceImpl.
for (String candidate : CAN_BE_MERGED) {
@@ -109,7 +119,7 @@
}
@Test
- public void testClassesHaveNotBeenMerged() throws Exception {
+ public void testClassesHaveNotBeenMerged() throws Throwable {
runR8(DONT_OPTIMIZE, null);
for (String candidate : CAN_BE_MERGED) {
assertTrue(inspector.clazz(candidate).isPresent());
@@ -124,7 +134,7 @@
// Assuming that the chance of observing one of the two orderings is 50%, this test therefore has
// approximately 3% chance of succeeding although there is an issue.
@Test
- public void testCallGraphCycle() throws Exception {
+ public void testCallGraphCycle() throws Throwable {
String main = "classmerging.CallGraphCycleTest";
Path[] programFiles =
new Path[] {
@@ -140,7 +150,7 @@
}
@Test
- public void testConflictInGeneratedName() throws Exception {
+ public void testConflictInGeneratedName() throws Throwable {
String main = "classmerging.ConflictInGeneratedNameTest";
Path[] programFiles =
new Path[] {
@@ -162,7 +172,9 @@
configure(options);
// Avoid that direct methods in B get inlined.
options.testing.validInliningReasons = ImmutableSet.of(Reason.FORCE);
- });
+ },
+ // Disable debug testing since the test has a method with "$classmerging$" in the name.
+ null);
ClassSubject clazzSubject = inspector.clazz("classmerging.ConflictInGeneratedNameTest$B");
assertThat(clazzSubject, isPresent());
@@ -204,14 +216,14 @@
}
@Test
- public void testConflictWasDetected() throws Exception {
+ public void testConflictWasDetected() throws Throwable {
runR8(EXAMPLE_KEEP, this::configure);
assertTrue(inspector.clazz("classmerging.ConflictingInterface").isPresent());
assertTrue(inspector.clazz("classmerging.ConflictingInterfaceImpl").isPresent());
}
@Test
- public void testFieldCollision() throws Exception {
+ public void testFieldCollision() throws Throwable {
String main = "classmerging.FieldCollisionTest";
Path[] programFiles =
new Path[] {
@@ -227,7 +239,7 @@
}
@Test
- public void testLambdaRewriting() throws Exception {
+ public void testLambdaRewriting() throws Throwable {
String main = "classmerging.LambdaRewritingTest";
Path[] programFiles =
new Path[] {
@@ -250,7 +262,7 @@
}
@Test
- public void testMethodCollision() throws Exception {
+ public void testMethodCollision() throws Throwable {
String main = "classmerging.MethodCollisionTest";
Path[] programFiles =
new Path[] {
@@ -275,7 +287,7 @@
}
@Test
- public void testNestedDefaultInterfaceMethodsTest() throws Exception {
+ public void testNestedDefaultInterfaceMethodsTest() throws Throwable {
String main = "classmerging.NestedDefaultInterfaceMethodsTest";
Path[] programFiles =
new Path[] {
@@ -294,7 +306,7 @@
}
@Test
- public void testNestedDefaultInterfaceMethodsWithCDumpTest() throws Exception {
+ public void testNestedDefaultInterfaceMethodsWithCDumpTest() throws Throwable {
String main = "classmerging.NestedDefaultInterfaceMethodsTest";
Path[] programFiles =
new Path[] {
@@ -319,7 +331,7 @@
}
@Test
- public void testPinnedParameterTypes() throws Exception {
+ public void testPinnedParameterTypes() throws Throwable {
String main = "classmerging.PinnedParameterTypesTest";
Path[] programFiles =
new Path[] {
@@ -342,7 +354,210 @@
}
@Test
- public void testSuperCallWasDetected() throws Exception {
+ public void testProguardFieldMap() throws Throwable {
+ String main = "classmerging.ProguardFieldMapTest";
+ Path[] programFiles =
+ new Path[] {
+ CF_DIR.resolve("ProguardFieldMapTest.class"),
+ CF_DIR.resolve("ProguardFieldMapTest$A.class"),
+ CF_DIR.resolve("ProguardFieldMapTest$B.class")
+ };
+
+ // Try without vertical class merging, to check that output is as expected.
+ String expectedProguardMapWithoutClassMerging =
+ Joiner.on(System.lineSeparator())
+ .join(
+ "classmerging.ProguardFieldMapTest -> classmerging.ProguardFieldMapTest:",
+ " 1:2:void main(java.lang.String[]):10:11 -> main",
+ "classmerging.ProguardFieldMapTest$A -> classmerging.ProguardFieldMapTest$A:",
+ " 1:1:void <init>():14:14 -> <init>",
+ " 2:2:void <init>():16:16 -> <init>",
+ "classmerging.ProguardFieldMapTest$B -> classmerging.ProguardFieldMapTest$B:",
+ " 1:1:void <init>():19:19 -> <init>",
+ " 1:1:void test():22:22 -> test");
+ runTestOnInput(
+ main,
+ readProgramFiles(programFiles),
+ Predicates.alwaysTrue(),
+ getProguardConfig(EXAMPLE_KEEP),
+ options -> {
+ configure(options);
+ options.enableClassMerging = false;
+ options.testing.validInliningReasons = ImmutableSet.of(Reason.FORCE);
+ options.proguardMapConsumer =
+ (proguardMap, handler) ->
+ assertThat(proguardMap, containsString(expectedProguardMapWithoutClassMerging));
+ });
+
+ // Try with vertical class merging.
+ String expectedProguardMapWithClassMerging =
+ Joiner.on(System.lineSeparator())
+ .join(
+ "classmerging.ProguardFieldMapTest -> classmerging.ProguardFieldMapTest:",
+ " 1:2:void main(java.lang.String[]):10:11 -> main",
+ "classmerging.ProguardFieldMapTest$B -> classmerging.ProguardFieldMapTest$B:",
+ " java.lang.String classmerging.ProguardFieldMapTest$A.f -> f",
+ " 1:1:void classmerging.ProguardFieldMapTest$A.<init>():14:14 -> <init>",
+ " 1:1:void <init>():19 -> <init>",
+ " 2:2:void classmerging.ProguardFieldMapTest$A.<init>():16:16 -> <init>",
+ " 2:2:void <init>():19 -> <init>",
+ " 1:1:void test():22:22 -> test");
+ Set<String> preservedClassNames =
+ ImmutableSet.of("classmerging.ProguardFieldMapTest", "classmerging.ProguardFieldMapTest$B");
+ runTestOnInput(
+ main,
+ readProgramFiles(programFiles),
+ preservedClassNames::contains,
+ getProguardConfig(EXAMPLE_KEEP),
+ options -> {
+ configure(options);
+ options.testing.validInliningReasons = ImmutableSet.of(Reason.FORCE);
+ options.proguardMapConsumer =
+ (proguardMap, handler) ->
+ assertThat(proguardMap, containsString(expectedProguardMapWithClassMerging));
+ });
+ }
+
+ @Test
+ public void testProguardMethodMap() throws Throwable {
+ String main = "classmerging.ProguardMethodMapTest";
+ Path[] programFiles =
+ new Path[] {
+ CF_DIR.resolve("ProguardMethodMapTest.class"),
+ CF_DIR.resolve("ProguardMethodMapTest$A.class"),
+ CF_DIR.resolve("ProguardMethodMapTest$B.class")
+ };
+
+ // Try without vertical class merging, to check that output is as expected.
+ String expectedProguardMapWithoutClassMerging =
+ Joiner.on(System.lineSeparator())
+ .join(
+ "classmerging.ProguardMethodMapTest -> classmerging.ProguardMethodMapTest:",
+ " 1:2:void main(java.lang.String[]):10:11 -> main",
+ "classmerging.ProguardMethodMapTest$A -> classmerging.ProguardMethodMapTest$A:",
+ " 1:1:void <init>():14:14 -> <init>",
+ " 1:1:void method():17:17 -> method",
+ "classmerging.ProguardMethodMapTest$B -> classmerging.ProguardMethodMapTest$B:",
+ " 1:1:void <init>():21:21 -> <init>",
+ " 1:2:void method():25:26 -> method");
+ runTestOnInput(
+ main,
+ readProgramFiles(programFiles),
+ Predicates.alwaysTrue(),
+ getProguardConfig(EXAMPLE_KEEP),
+ options -> {
+ configure(options);
+ options.enableClassMerging = false;
+ options.testing.validInliningReasons = ImmutableSet.of(Reason.FORCE);
+ options.proguardMapConsumer =
+ (proguardMap, handler) ->
+ assertThat(proguardMap, containsString(expectedProguardMapWithoutClassMerging));
+ });
+
+ // Try with vertical class merging.
+ String expectedProguardMapWithClassMerging =
+ Joiner.on(System.lineSeparator())
+ .join(
+ "classmerging.ProguardMethodMapTest -> classmerging.ProguardMethodMapTest:",
+ " 1:2:void main(java.lang.String[]):10:11 -> main",
+ "classmerging.ProguardMethodMapTest$B -> classmerging.ProguardMethodMapTest$B:",
+ // TODO(christofferqa): Should this be "...<init>():14 -> <init>" to reflect that
+ // A.<init> has been inlined into B.<init>?
+ " 1:1:void classmerging.ProguardMethodMapTest$A.<init>():14:14 -> <init>",
+ // TODO(christofferqa): Should this be " ...<init>():21:21 -> <init>"?
+ " 1:1:void <init>():21 -> <init>",
+ " 1:2:void method():25:26 -> method",
+ " 1:1:void classmerging.ProguardMethodMapTest$A.method():17:17 -> "
+ + "method$classmerging$ProguardMethodMapTest$A");
+ Set<String> preservedClassNames =
+ ImmutableSet.of(
+ "classmerging.ProguardMethodMapTest", "classmerging.ProguardMethodMapTest$B");
+ runTestOnInput(
+ main,
+ readProgramFiles(programFiles),
+ preservedClassNames::contains,
+ getProguardConfig(EXAMPLE_KEEP),
+ options -> {
+ configure(options);
+ options.testing.validInliningReasons = ImmutableSet.of(Reason.FORCE);
+ options.proguardMapConsumer =
+ (proguardMap, handler) ->
+ assertThat(proguardMap, containsString(expectedProguardMapWithClassMerging));
+ });
+ }
+
+ @Test
+ public void testProguardMethodMapAfterInlining() throws Throwable {
+ String main = "classmerging.ProguardMethodMapTest";
+ Path[] programFiles =
+ new Path[] {
+ CF_DIR.resolve("ProguardMethodMapTest.class"),
+ CF_DIR.resolve("ProguardMethodMapTest$A.class"),
+ CF_DIR.resolve("ProguardMethodMapTest$B.class")
+ };
+
+ // Try without vertical class merging, to check that output is as expected.
+ String expectedProguardMapWithoutClassMerging =
+ Joiner.on(System.lineSeparator())
+ .join(
+ "classmerging.ProguardMethodMapTest -> classmerging.ProguardMethodMapTest:",
+ " 1:2:void main(java.lang.String[]):10:11 -> main",
+ "classmerging.ProguardMethodMapTest$A -> classmerging.ProguardMethodMapTest$A:",
+ " 1:1:void <init>():14:14 -> <init>",
+ "classmerging.ProguardMethodMapTest$B -> classmerging.ProguardMethodMapTest$B:",
+ " 1:1:void <init>():21:21 -> <init>",
+ " 1:1:void method():25:25 -> method",
+ " 2:2:void classmerging.ProguardMethodMapTest$A.method():17:17 -> method",
+ " 2:2:void method():26 -> method");
+ runTestOnInput(
+ main,
+ readProgramFiles(programFiles),
+ Predicates.alwaysTrue(),
+ getProguardConfig(
+ EXAMPLE_KEEP,
+ "-forceinline class classmerging.ProguardMethodMapTest$A { public void method(); }"),
+ options -> {
+ configure(options);
+ options.enableClassMerging = false;
+ options.testing.validInliningReasons = ImmutableSet.of(Reason.FORCE);
+ options.proguardMapConsumer =
+ (proguardMap, handler) ->
+ assertThat(proguardMap, containsString(expectedProguardMapWithoutClassMerging));
+ });
+
+ // Try with vertical class merging.
+ String expectedProguardMapWithClassMerging =
+ Joiner.on(System.lineSeparator())
+ .join(
+ "classmerging.ProguardMethodMapTest -> classmerging.ProguardMethodMapTest:",
+ " 1:2:void main(java.lang.String[]):10:11 -> main",
+ "classmerging.ProguardMethodMapTest$B -> classmerging.ProguardMethodMapTest$B:",
+ " 1:1:void classmerging.ProguardMethodMapTest$A.<init>():14:14 -> <init>",
+ " 1:1:void <init>():21 -> <init>",
+ " 1:1:void method():25:25 -> method",
+ " 2:2:void classmerging.ProguardMethodMapTest$A.method():17:17 -> method",
+ " 2:2:void method():26 -> method");
+ Set<String> preservedClassNames =
+ ImmutableSet.of(
+ "classmerging.ProguardMethodMapTest", "classmerging.ProguardMethodMapTest$B");
+ runTestOnInput(
+ main,
+ readProgramFiles(programFiles),
+ preservedClassNames::contains,
+ getProguardConfig(
+ EXAMPLE_KEEP,
+ "-forceinline class classmerging.ProguardMethodMapTest$A { public void method(); }"),
+ options -> {
+ configure(options);
+ options.testing.validInliningReasons = ImmutableSet.of(Reason.FORCE);
+ options.proguardMapConsumer =
+ (proguardMap, handler) ->
+ assertThat(proguardMap, containsString(expectedProguardMapWithClassMerging));
+ });
+ }
+
+ @Test
+ public void testSuperCallWasDetected() throws Throwable {
String main = "classmerging.SuperCallRewritingTest";
Path[] programFiles =
new Path[] {
@@ -366,7 +581,7 @@
// targets SubClassThatReferencesSuperMethod.referencedMethod. When running without class
// merging, R8 should not rewrite the invoke-super instruction into invoke-direct.
@Test
- public void testSuperCallNotRewrittenToDirect() throws Exception {
+ public void testSuperCallNotRewrittenToDirect() throws Throwable {
String main = "classmerging.SuperCallRewritingTest";
Path[] programFiles =
new Path[] {
@@ -446,7 +661,7 @@
// }
@Test
@IgnoreForRangeOfVmVersions(from = Version.V5_1_1, to = Version.V6_0_1)
- public void testSuperCallToMergedClassIsRewritten() throws Exception {
+ public void testSuperCallToMergedClassIsRewritten() throws Throwable {
String main = "classmerging.SuperCallToMergedClassIsRewrittenTest";
Set<String> preservedClassNames =
ImmutableSet.of(
@@ -569,7 +784,7 @@
}
@Test
- public void testConflictingInterfaceSignatures() throws Exception {
+ public void testConflictingInterfaceSignatures() throws Throwable {
String main = "classmerging.ConflictingInterfaceSignaturesTest";
Path[] programFiles =
new Path[] {
@@ -588,7 +803,7 @@
// If an exception class A is merged into another exception class B, then all exception tables
// should be updated, and class A should be removed entirely.
@Test
- public void testExceptionTables() throws Exception {
+ public void testExceptionTables() throws Throwable {
String main = "classmerging.ExceptionTest";
Path[] programFiles =
new Path[] {
@@ -624,7 +839,7 @@
}
@Test
- public void testMergeDefaultMethodIntoClass() throws Exception {
+ public void testMergeDefaultMethodIntoClass() throws Throwable {
String main = "classmerging.MergeDefaultMethodIntoClassTest";
Path[] programFiles =
new Path[] {
@@ -658,7 +873,7 @@
}
@Test
- public void testNativeMethod() throws Exception {
+ public void testNativeMethod() throws Throwable {
String main = "classmerging.ClassWithNativeMethodTest";
Path[] programFiles =
new Path[] {
@@ -676,7 +891,7 @@
}
@Test
- public void testNoIllegalClassAccess() throws Exception {
+ public void testNoIllegalClassAccess() throws Throwable {
String main = "classmerging.SimpleInterfaceAccessTest";
Path[] programFiles =
new Path[] {
@@ -701,7 +916,7 @@
}
@Test
- public void testNoIllegalClassAccessWithAccessModifications() throws Exception {
+ public void testNoIllegalClassAccessWithAccessModifications() throws Throwable {
// If access modifications are allowed then SimpleInterface should be merged into
// SimpleInterfaceImpl.
String main = "classmerging.SimpleInterfaceAccessTest";
@@ -736,7 +951,7 @@
// into an invoke-direct instruction after it gets merged into class C. We should add a test that
// checks that this works with and without inlining of the method B.m().
@Test
- public void testRewritePinnedMethod() throws Exception {
+ public void testRewritePinnedMethod() throws Throwable {
String main = "classmerging.RewritePinnedMethodTest";
Path[] programFiles =
new Path[] {
@@ -759,7 +974,7 @@
}
@Test
- public void testTemplateMethodPattern() throws Exception {
+ public void testTemplateMethodPattern() throws Throwable {
String main = "classmerging.TemplateMethodTest";
Path[] programFiles =
new Path[] {
@@ -774,7 +989,7 @@
}
private CodeInspector runTest(
- String main, Path[] programFiles, Predicate<String> preservedClassNames) throws Exception {
+ String main, Path[] programFiles, Predicate<String> preservedClassNames) throws Throwable {
return runTest(main, programFiles, preservedClassNames, getProguardConfig(EXAMPLE_KEEP));
}
@@ -783,14 +998,14 @@
Path[] programFiles,
Predicate<String> preservedClassNames,
String proguardConfig)
- throws Exception {
+ throws Throwable {
return runTestOnInput(
main, readProgramFiles(programFiles), preservedClassNames, proguardConfig);
}
private CodeInspector runTestOnInput(
String main, AndroidApp input, Predicate<String> preservedClassNames, String proguardConfig)
- throws Exception {
+ throws Throwable {
return runTestOnInput(main, input, preservedClassNames, proguardConfig, this::configure);
}
@@ -800,8 +1015,37 @@
Predicate<String> preservedClassNames,
String proguardConfig,
Consumer<InternalOptions> optionsConsumer)
- throws Exception {
- AndroidApp output = compileWithR8(input, proguardConfig, optionsConsumer);
+ throws Throwable {
+ return runTestOnInput(
+ main,
+ input,
+ preservedClassNames,
+ proguardConfig,
+ optionsConsumer,
+ new VerticalClassMergerDebugTest(main));
+ }
+
+ private CodeInspector runTestOnInput(
+ String main,
+ AndroidApp input,
+ Predicate<String> preservedClassNames,
+ String proguardConfig,
+ Consumer<InternalOptions> optionsConsumer,
+ VerticalClassMergerDebugTest debugTestRunner)
+ throws Throwable {
+ Path proguardMapPath = File.createTempFile("mapping", ".txt", temp.getRoot()).toPath();
+ R8Command.Builder commandBuilder =
+ ToolHelper.prepareR8CommandBuilder(input)
+ .addProguardConfiguration(ImmutableList.of(proguardConfig), Origin.unknown());
+ ToolHelper.allowTestProguardOptions(commandBuilder);
+ AndroidApp output =
+ ToolHelper.runR8(
+ commandBuilder.build(),
+ options -> {
+ optionsConsumer.accept(options);
+ options.proguardMapConsumer =
+ new FileConsumer(proguardMapPath, options.proguardMapConsumer);
+ });
CodeInspector inputInspector = new CodeInspector(input);
CodeInspector outputInspector = new CodeInspector(output);
// Check that all classes in [preservedClassNames] are in fact preserved.
@@ -815,6 +1059,11 @@
}
// Check that the R8-generated code produces the same result as D8-generated code.
assertEquals(runOnArt(compileWithD8(input), main), runOnArt(output, main));
+ // Check that we never come across a method that has a name with "$classmerging$" in it during
+ // debugging.
+ if (debugTestRunner != null) {
+ debugTestRunner.test(output, proguardMapPath);
+ }
return outputInspector;
}
@@ -830,4 +1079,82 @@
}
return builder.toString();
}
+
+ private class VerticalClassMergerDebugTest extends DebugTestBase {
+
+ private final String main;
+ private DebugTestRunner runner = null;
+
+ public VerticalClassMergerDebugTest(String main) {
+ this.main = main;
+ }
+
+ public void test(AndroidApp app, Path proguardMapPath) throws Throwable {
+ Path appPath =
+ File.createTempFile("app", ".zip", ClassMergingTest.this.temp.getRoot()).toPath();
+ app.writeToZip(appPath, OutputMode.DexIndexed);
+
+ DexDebugTestConfig config = new DexDebugTestConfig(appPath);
+ config.allowUnprocessedCommands();
+ config.setProguardMap(proguardMapPath);
+
+ this.runner =
+ getDebugTestRunner(
+ config, main, breakpoint(main, "main"), run(), stepIntoUntilNoLongerInApp());
+ this.runner.runBare();
+ }
+
+ private void checkState(DebuggeeState state) {
+ // If a class pkg.A is merged into pkg.B, and a method pkg.A.m() needs to be renamed, then
+ // it will be renamed to pkg.B.m$pkg$A(). Since all tests are in the package "classmerging",
+ // we check that no methods in the debugging state (i.e., after the Proguard map has been
+ // applied) contain "$classmerging$.
+ String qualifiedMethodSignature =
+ state.getClassSignature() + "->" + state.getMethodName() + state.getMethodSignature();
+ boolean holderIsCompanionClass = state.getClassName().endsWith(COMPANION_CLASS_NAME_SUFFIX);
+ if (!holderIsCompanionClass) {
+ assertThat(qualifiedMethodSignature, not(containsString("$classmerging$")));
+ }
+ }
+
+ // Keeps stepping in until it is no longer in a class from the classmerging package.
+ // Then starts stepping out until it is again in the classmerging package.
+ private Command stepIntoUntilNoLongerInApp() {
+ return stepUntil(
+ StepKind.INTO,
+ StepLevel.INSTRUCTION,
+ state -> {
+ if (state.getClassSignature().contains("classmerging")) {
+ checkState(state);
+
+ // Continue stepping into.
+ return false;
+ }
+
+ // Stop stepping into.
+ runner.enqueueCommandFirst(stepOutUntilInApp());
+ return true;
+ });
+ }
+
+ // Keeps stepping out until it is in a class from the classmerging package.
+ // Then starts stepping in until it is no longer in the classmerging package.
+ private Command stepOutUntilInApp() {
+ return stepUntil(
+ StepKind.OUT,
+ StepLevel.INSTRUCTION,
+ state -> {
+ if (state.getClassSignature().contains("classmerging")) {
+ checkState(state);
+
+ // Stop stepping out.
+ runner.enqueueCommandFirst(stepIntoUntilNoLongerInApp());
+ return true;
+ }
+
+ // Continue stepping out.
+ return false;
+ });
+ }
+ }
}
diff --git a/src/test/java/com/android/tools/r8/debug/DebugTestBase.java b/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
index 5707812..e9ef5ed 100644
--- a/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
+++ b/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
@@ -137,6 +137,18 @@
private void runInternal(
DebugTestConfig config, String debuggeeClass, List<JUnit3Wrapper.Command> commands)
throws Throwable {
+ getDebugTestRunner(config, debuggeeClass, commands).runBare();
+ }
+
+ protected DebugTestRunner getDebugTestRunner(
+ DebugTestConfig config, String debuggeeClass, JUnit3Wrapper.Command... commands)
+ throws Throwable {
+ return getDebugTestRunner(config, debuggeeClass, Arrays.asList(commands));
+ }
+
+ protected DebugTestRunner getDebugTestRunner(
+ DebugTestConfig config, String debuggeeClass, List<JUnit3Wrapper.Command> commands)
+ throws Throwable {
// Skip test due to unsupported runtime.
Assume.assumeTrue("Skipping test " + testName.getMethodName() + " because ART is not supported",
ToolHelper.artSupported());
@@ -152,7 +164,7 @@
? null
: ClassNameMapper.mapperFromFile(config.getProguardMap());
- new JUnit3Wrapper(config, debuggeeClass, commands, classNameMapper).runBare();
+ return new JUnit3Wrapper(config, debuggeeClass, commands, classNameMapper);
}
/**
@@ -495,8 +507,14 @@
return t -> inspector.accept(t.debuggeeState.getLocalValues().get(localName));
}
+ protected interface DebugTestRunner {
+ void enqueueCommandFirst(JUnit3Wrapper.Command command);
+
+ void runBare() throws Throwable;
+ }
+
@Ignore("Prevents Gradle from running the wrapper as a test.")
- static class JUnit3Wrapper extends JDWPTestCase {
+ public static class JUnit3Wrapper extends JDWPTestCase implements DebugTestRunner {
private final String debuggeeClassName;
@@ -630,7 +648,7 @@
return null;
}
ClassNamingForNameMapper.MappedRangesOfName ranges =
- classNaming.mappedRangesByName.get(obfuscatedMethodName);
+ classNaming.mappedRangesByRenamedName.get(obfuscatedMethodName);
if (ranges == null) {
return null;
}
@@ -683,7 +701,7 @@
if (range == null) {
return obfuscatedLineNumber;
}
- return range.originalLineFromObfuscated(obfuscatedLineNumber);
+ return range.getOriginalLineNumber(obfuscatedLineNumber);
}
@Override
@@ -694,7 +712,7 @@
return null;
}
ClassNamingForNameMapper.MappedRangesOfName ranges =
- classNaming.mappedRangesByName.get(obfuscatedMethodName);
+ classNaming.mappedRangesByRenamedName.get(obfuscatedMethodName);
if (ranges == null) {
return null;
}
@@ -706,8 +724,7 @@
for (MappedRange range : mappedRanges) {
lines.add(
new SignatureAndLine(
- range.signature.toString(),
- range.originalLineFromObfuscated(obfuscatedLineNumber)));
+ range.signature.toString(), range.getOriginalLineNumber(obfuscatedLineNumber)));
}
return lines;
}
@@ -801,8 +818,10 @@
// Continue stepping until mainLoopStep exits with false.
}
- assertTrue(
- "All commands have NOT been processed for config: " + config, commandsQueue.isEmpty());
+ if (config.mustProcessAllCommands()) {
+ assertTrue(
+ "All commands have NOT been processed for config: " + config, commandsQueue.isEmpty());
+ }
logWriter.println("Finish loop");
}
diff --git a/src/test/java/com/android/tools/r8/debug/DebugTestConfig.java b/src/test/java/com/android/tools/r8/debug/DebugTestConfig.java
index 556e17f..519b580 100644
--- a/src/test/java/com/android/tools/r8/debug/DebugTestConfig.java
+++ b/src/test/java/com/android/tools/r8/debug/DebugTestConfig.java
@@ -17,6 +17,7 @@
DEX
}
+ private boolean mustProcessAllCommands = true;
private List<Path> paths = new ArrayList<>();
private Path proguardMap = null;
@@ -47,6 +48,14 @@
return this;
}
+ public boolean mustProcessAllCommands() {
+ return mustProcessAllCommands;
+ }
+
+ public void allowUnprocessedCommands() {
+ mustProcessAllCommands = false;
+ }
+
/** Proguard map that the debuggee has been translated according to, null if not present. */
public Path getProguardMap() {
return proguardMap;
diff --git a/src/test/java/com/android/tools/r8/debuginfo/InliningWithoutPositionsTestRunner.java b/src/test/java/com/android/tools/r8/debuginfo/InliningWithoutPositionsTestRunner.java
index 0f8ac65..ce84f51 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/InliningWithoutPositionsTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/InliningWithoutPositionsTestRunner.java
@@ -185,7 +185,7 @@
ClassNamingForNameMapper classNaming = mapper.getClassNaming(TEST_PACKAGE + "." + TEST_CLASS);
assertNotNull(classNaming);
- MappedRangesOfName rangesForMain = classNaming.mappedRangesByName.get("main");
+ MappedRangesOfName rangesForMain = classNaming.mappedRangesByRenamedName.get("main");
assertNotNull(rangesForMain);
List<MappedRange> frames = rangesForMain.allRangesForLine(expectedLineNumber);
diff --git a/src/test/java/com/android/tools/r8/internal/R8GMSCoreDeterministicTest.java b/src/test/java/com/android/tools/r8/internal/R8GMSCoreDeterministicTest.java
index abc7a73..6ae151e 100644
--- a/src/test/java/com/android/tools/r8/internal/R8GMSCoreDeterministicTest.java
+++ b/src/test/java/com/android/tools/r8/internal/R8GMSCoreDeterministicTest.java
@@ -3,13 +3,14 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.internal;
+import static junit.framework.TestCase.assertEquals;
+
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.DexIndexedConsumer;
import com.android.tools.r8.OutputMode;
import com.android.tools.r8.R8Command;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.shaking.ProguardRuleParserException;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.AndroidApp;
import com.beust.jcommander.internal.Lists;
@@ -20,52 +21,60 @@
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
-import java.util.concurrent.ExecutionException;
import org.junit.Test;
public class R8GMSCoreDeterministicTest extends GMSCoreCompilationTestBase {
- public Set<DexEncodedMethod> shuffle(Set<DexEncodedMethod> methods) {
+ private static class CompilationResult {
+ AndroidApp app;
+ String proguardMap;
+ }
+
+ private static Set<DexEncodedMethod> shuffle(Set<DexEncodedMethod> methods) {
List<DexEncodedMethod> toShuffle = Lists.newArrayList(methods);
Collections.shuffle(toShuffle);
return new LinkedHashSet<>(toShuffle);
}
- private AndroidApp doRun()
- throws IOException, ProguardRuleParserException, ExecutionException,
- CompilationFailedException {
+ private CompilationResult doRun() throws IOException, CompilationFailedException {
R8Command command =
R8Command.builder()
.addProgramFiles(Paths.get(GMSCORE_V7_DIR, GMSCORE_APK))
.setProgramConsumer(DexIndexedConsumer.emptyConsumer())
.setMinApiLevel(AndroidApiLevel.L.getLevel())
.build();
- return ToolHelper.runR8(
- command,
- options -> {
- // For this test just do random shuffle.
- options.testing.irOrdering = this::shuffle;
- // Only use one thread to process to process in the order decided by the callback.
- options.numberOfThreads = 1;
- // Ignore the missing classes.
- options.ignoreMissingClasses = true;
- });
+ CompilationResult result = new CompilationResult();
+ result.app =
+ ToolHelper.runR8(
+ command,
+ options -> {
+ // For this test just do random shuffle.
+ options.testing.irOrdering = R8GMSCoreDeterministicTest::shuffle;
+ // Only use one thread to process to process in the order decided by the callback.
+ options.numberOfThreads = 1;
+ // Ignore the missing classes.
+ options.ignoreMissingClasses = true;
+ // Store the generated Proguard map.
+ options.proguardMapConsumer =
+ (proguardMap, handler) -> result.proguardMap = proguardMap;
+ });
+ return result;
}
@Test
public void deterministic() throws Exception {
-
// Run two independent compilations.
- AndroidApp app1 = doRun();
- AndroidApp app2 = doRun();
+ CompilationResult result1 = doRun();
+ CompilationResult result2 = doRun();
// Check that the generated bytecode runs through the dex2oat verifier with no errors.
Path combinedInput = temp.getRoot().toPath().resolve("all.jar");
Path oatFile = temp.getRoot().toPath().resolve("all.oat");
- app1.writeToZip(combinedInput, OutputMode.DexIndexed);
+ result1.app.writeToZip(combinedInput, OutputMode.DexIndexed);
ToolHelper.runDex2Oat(combinedInput, oatFile);
// Verify that the result of the two compilations was the same.
- assertIdenticalApplications(app1, app2);
+ assertIdenticalApplications(result1.app, result2.app);
+ assertEquals(result1.proguardMap, result2.proguardMap);
}
}
diff --git a/src/test/java/com/android/tools/r8/internal/R8GMSCoreV10DeployJarVerificationTest.java b/src/test/java/com/android/tools/r8/internal/R8GMSCoreV10DeployJarVerificationTest.java
index 6adf680..d881185 100644
--- a/src/test/java/com/android/tools/r8/internal/R8GMSCoreV10DeployJarVerificationTest.java
+++ b/src/test/java/com/android/tools/r8/internal/R8GMSCoreV10DeployJarVerificationTest.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.internal;
+import static org.junit.Assert.assertEquals;
+
import com.android.tools.r8.CompilationMode;
import com.android.tools.r8.R8RunArtTestsTest.CompilerUnderTest;
import com.android.tools.r8.utils.AndroidApp;
@@ -11,17 +13,33 @@
public class R8GMSCoreV10DeployJarVerificationTest extends GMSCoreDeployJarVerificationTest {
+ private String proguardMap1 = null;
+ private String proguardMap2 = null;
+
@Test
public void buildFromDeployJar() throws Exception {
// TODO(tamaskenez): set hasReference = true when we have the noshrink file for V10
- AndroidApp app1 = buildFromDeployJar(
- CompilerUnderTest.R8, CompilationMode.RELEASE,
- GMSCoreCompilationTestBase.GMSCORE_V10_DIR, false);
- AndroidApp app2 = buildFromDeployJar(
- CompilerUnderTest.R8, CompilationMode.RELEASE,
- GMSCoreCompilationTestBase.GMSCORE_V10_DIR, false);
+ AndroidApp app1 =
+ buildFromDeployJar(
+ CompilerUnderTest.R8,
+ CompilationMode.RELEASE,
+ GMSCoreCompilationTestBase.GMSCORE_V10_DIR,
+ false,
+ options ->
+ options.proguardMapConsumer =
+ (proguardMap, handler) -> this.proguardMap1 = proguardMap);
+ AndroidApp app2 =
+ buildFromDeployJar(
+ CompilerUnderTest.R8,
+ CompilationMode.RELEASE,
+ GMSCoreCompilationTestBase.GMSCORE_V10_DIR,
+ false,
+ options ->
+ options.proguardMapConsumer =
+ (proguardMap, handler) -> this.proguardMap2 = proguardMap);
// Verify that the result of the two compilations was the same.
assertIdenticalApplications(app1, app2);
+ assertEquals(proguardMap1, proguardMap2);
}
}
diff --git a/src/test/java/com/android/tools/r8/internal/R8GMSCoreV10TreeShakeJarVerificationTest.java b/src/test/java/com/android/tools/r8/internal/R8GMSCoreV10TreeShakeJarVerificationTest.java
index ae470c6..4374d0e 100644
--- a/src/test/java/com/android/tools/r8/internal/R8GMSCoreV10TreeShakeJarVerificationTest.java
+++ b/src/test/java/com/android/tools/r8/internal/R8GMSCoreV10TreeShakeJarVerificationTest.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.internal;
+import static org.junit.Assert.assertEquals;
+
import com.android.tools.r8.CompilationMode;
import com.android.tools.r8.utils.AndroidApp;
import org.junit.Test;
@@ -10,15 +12,33 @@
public class R8GMSCoreV10TreeShakeJarVerificationTest
extends R8GMSCoreTreeShakeJarVerificationTest {
+ private String proguardMap1 = null;
+ private String proguardMap2 = null;
+
@Test
public void buildAndTreeShakeFromDeployJar() throws Exception {
// TODO(tamaskenez): set hasReference = true when we have the noshrink file for V10
- AndroidApp app1 = buildAndTreeShakeFromDeployJar(
- CompilationMode.RELEASE, GMSCORE_V10_DIR, false, GMSCORE_V10_MAX_SIZE, null);
- AndroidApp app2 = buildAndTreeShakeFromDeployJar(
- CompilationMode.RELEASE, GMSCORE_V10_DIR, false, GMSCORE_V10_MAX_SIZE, null);
+ AndroidApp app1 =
+ buildAndTreeShakeFromDeployJar(
+ CompilationMode.RELEASE,
+ GMSCORE_V10_DIR,
+ false,
+ GMSCORE_V10_MAX_SIZE,
+ options ->
+ options.proguardMapConsumer =
+ (proguardMap, handler) -> this.proguardMap1 = proguardMap);
+ AndroidApp app2 =
+ buildAndTreeShakeFromDeployJar(
+ CompilationMode.RELEASE,
+ GMSCORE_V10_DIR,
+ false,
+ GMSCORE_V10_MAX_SIZE,
+ options ->
+ options.proguardMapConsumer =
+ (proguardMap, handler) -> this.proguardMap2 = proguardMap);
// Verify that the result of the two compilations was the same.
assertIdenticalApplications(app1, app2);
+ assertEquals(proguardMap1, proguardMap2);
}
}
diff --git a/src/test/java/com/android/tools/r8/regress/b69825683/Regress69825683Test.java b/src/test/java/com/android/tools/r8/regress/b69825683/Regress69825683Test.java
index 3421cfe..911ceb7 100644
--- a/src/test/java/com/android/tools/r8/regress/b69825683/Regress69825683Test.java
+++ b/src/test/java/com/android/tools/r8/regress/b69825683/Regress69825683Test.java
@@ -7,6 +7,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+import com.android.tools.r8.ClassFileConsumer;
import com.android.tools.r8.DexIndexedConsumer;
import com.android.tools.r8.R8Command;
import com.android.tools.r8.TestBase;
@@ -16,10 +17,25 @@
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
import com.google.common.collect.ImmutableList;
+import java.util.Arrays;
+import java.util.Collection;
import java.util.List;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class Regress69825683Test extends TestBase {
+ private Backend backend;
+
+ @Parameterized.Parameters(name = "Backend: {0}")
+ public static Collection<Backend> data() {
+ return Arrays.asList(Backend.values());
+ }
+
+ public Regress69825683Test(Backend backend) {
+ this.backend = backend;
+ }
@Test
public void outerConstructsInner() throws Exception {
@@ -32,9 +48,18 @@
"}",
"-dontobfuscate"),
Origin.unknown());
- builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
+ if (backend == Backend.DEX) {
+ builder
+ .setProgramConsumer(DexIndexedConsumer.emptyConsumer())
+ .addLibraryFiles(ToolHelper.getDefaultAndroidJar());
+ } else {
+ assert backend == Backend.CF;
+ builder
+ .setProgramConsumer(ClassFileConsumer.emptyConsumer())
+ .addLibraryFiles(ToolHelper.getJava8RuntimeJar());
+ }
AndroidApp app = ToolHelper.runR8(builder.build(), o -> o.enableClassInlining = false);
- CodeInspector inspector = new CodeInspector(app);
+ CodeInspector inspector = new CodeInspector(app, o -> o.enableCfFrontend = true);
List<FoundClassSubject> classes = inspector.allClasses();
// Check that the synthetic class is still present.
@@ -51,7 +76,9 @@
String innerName = innerClass.getCanonicalName();
int index = innerName.lastIndexOf('.');
innerName = innerName.substring(0, index) + "$" + innerName.substring(index + 1);
- assertTrue(runOnArt(app, mainClass).startsWith(innerName));
+ assertTrue(
+ (backend == Backend.DEX ? runOnArt(app, mainClass) : runOnJava(app, mainClass))
+ .startsWith(innerName));
}
@Test
@@ -65,9 +92,18 @@
"}",
"-dontobfuscate"),
Origin.unknown());
- builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
+ if (backend == Backend.DEX) {
+ builder
+ .setProgramConsumer(DexIndexedConsumer.emptyConsumer())
+ .addLibraryFiles(ToolHelper.getDefaultAndroidJar());
+ } else {
+ assert backend == Backend.CF;
+ builder
+ .setProgramConsumer(ClassFileConsumer.emptyConsumer())
+ .addLibraryFiles(ToolHelper.getJava8RuntimeJar());
+ }
AndroidApp app = ToolHelper.runR8(builder.build(), o -> o.enableClassInlining = false);
- CodeInspector inspector = new CodeInspector(app);
+ CodeInspector inspector = new CodeInspector(app, o -> o.enableCfFrontend = true);
List<FoundClassSubject> classes = inspector.allClasses();
// Check that the synthetic class is still present.
@@ -79,6 +115,8 @@
.count());
// Run code to check that the constructor with synthetic class as argument is present.
- assertTrue(runOnArt(app, mainClass).startsWith(mainClass.getCanonicalName()));
+ assertTrue(
+ (backend == Backend.DEX ? runOnArt(app, mainClass) : runOnJava(app, mainClass))
+ .startsWith(mainClass.getCanonicalName()));
}
}
diff --git a/src/test/java/com/android/tools/r8/regress/b71604169/Regress71604169Test.java b/src/test/java/com/android/tools/r8/regress/b71604169/Regress71604169Test.java
index f40ecfd..cc356c3 100644
--- a/src/test/java/com/android/tools/r8/regress/b71604169/Regress71604169Test.java
+++ b/src/test/java/com/android/tools/r8/regress/b71604169/Regress71604169Test.java
@@ -6,15 +6,32 @@
import static junit.framework.TestCase.assertEquals;
+import com.android.tools.r8.ClassFileConsumer;
import com.android.tools.r8.DexIndexedConsumer;
import com.android.tools.r8.R8Command;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.origin.Origin;
import com.google.common.collect.ImmutableList;
+import java.util.Arrays;
+import java.util.Collection;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class Regress71604169Test extends TestBase {
+ private Backend backend;
+
+ @Parameterized.Parameters(name = "Backend: {0}")
+ public static Collection<Backend> data() {
+ return Arrays.asList(Backend.values());
+ }
+
+ public Regress71604169Test(Backend backend) {
+ this.backend = backend;
+ }
+
@Test
public void test() throws Exception {
R8Command.Builder builder = R8Command.builder();
@@ -28,7 +45,20 @@
builder.addProguardConfiguration(
ImmutableList.of(keepMainProguardConfiguration(mainClass, true, false)), Origin.unknown());
- builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
- assertEquals("Hello, world!", runOnArt(ToolHelper.runR8(builder.build()), mainClass));
+ if (backend == Backend.DEX) {
+ builder
+ .setProgramConsumer(DexIndexedConsumer.emptyConsumer())
+ .addLibraryFiles(ToolHelper.getDefaultAndroidJar());
+ } else {
+ assert backend == Backend.CF;
+ builder
+ .setProgramConsumer(ClassFileConsumer.emptyConsumer())
+ .addLibraryFiles(ToolHelper.getJava8RuntimeJar());
+ }
+ assertEquals(
+ "Hello, world!",
+ backend == Backend.DEX
+ ? runOnArt(ToolHelper.runR8(builder.build()), mainClass)
+ : runOnJava(ToolHelper.runR8(builder.build()), mainClass));
}
}
diff --git a/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java b/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
index cba8686..ad67919 100644
--- a/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
@@ -14,12 +14,15 @@
import com.android.tools.r8.R8Command;
import com.android.tools.r8.ToolHelper;
import java.io.BufferedReader;
+import java.io.IOException;
import java.io.PrintStream;
import java.io.StringReader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collection;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.junit.Assert;
@@ -27,8 +30,28 @@
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+@RunWith(Parameterized.class)
public class TreeShakingSpecificTest {
+ enum Backend {
+ DEX,
+ CF
+ }
+
+ private Backend backend;
+
+ @Parameters(name = "Backend: {0}")
+ public static Collection<Backend> data() {
+ return Arrays.asList(Backend.values());
+ }
+
+ public TreeShakingSpecificTest(Backend backend) {
+ this.backend = backend;
+ }
+
private static final String VALID_PROGUARD_DIR = "src/test/proguard/valid/";
@Rule
@@ -37,18 +60,28 @@
@Rule
public ExpectedException thrown = ExpectedException.none();
+ private void finishBuild(R8Command.Builder builder, Path out, String test) throws IOException {
+ Path input;
+ if (backend == Backend.DEX) {
+ builder.setOutput(out, OutputMode.DexIndexed);
+ input = Paths.get(EXAMPLES_BUILD_DIR, test, "classes.dex");
+ } else {
+ builder.setOutput(out, OutputMode.ClassFile);
+ input = Paths.get(EXAMPLES_BUILD_DIR, test + ".jar");
+ }
+ ToolHelper.getAppBuilder(builder).addProgramFiles(input);
+ }
+
@Test
public void testIgnoreWarnings() throws Exception {
// Generate R8 processed version without library option.
Path out = temp.getRoot().toPath();
String test = "shaking2";
- Path originalDex = Paths.get(EXAMPLES_BUILD_DIR, test, "classes.dex");
Path keepRules = Paths.get(EXAMPLES_DIR, test, "keep-rules.txt");
Path ignoreWarnings = Paths.get(VALID_PROGUARD_DIR, "ignorewarnings.flags");
R8Command.Builder builder = R8Command.builder()
- .setOutput(out, OutputMode.DexIndexed)
.addProguardConfigurationFiles(keepRules, ignoreWarnings);
- ToolHelper.getAppBuilder(builder).addProgramFiles(originalDex);
+ finishBuild(builder, out, test);
R8.run(builder.build());
}
@@ -57,7 +90,6 @@
// Generate R8 processed version without library option.
Path out = temp.getRoot().toPath();
String test = "shaking2";
- Path originalDex = Paths.get(EXAMPLES_BUILD_DIR, test, "classes.dex");
Path keepRules = Paths.get(EXAMPLES_DIR, test, "keep-rules.txt");
DiagnosticsHandler handler = new DiagnosticsHandler() {
@Override
@@ -68,9 +100,8 @@
}
};
R8Command.Builder builder = R8Command.builder(handler)
- .setOutput(out, OutputMode.DexIndexed)
.addProguardConfigurationFiles(keepRules);
- ToolHelper.getAppBuilder(builder).addProgramFiles(originalDex);
+ finishBuild(builder, out, test);
R8.run(builder.build());
}
@@ -79,7 +110,6 @@
// Generate R8 processed version without library option.
String test = "shaking1";
Path out = temp.getRoot().toPath();
- Path originalDex = Paths.get(EXAMPLES_BUILD_DIR, test, "classes.dex");
Path keepRules = Paths.get(EXAMPLES_DIR, test, "keep-rules.txt");
// Create a flags file in temp dir requesting dump of the mapping.
@@ -90,10 +120,15 @@
}
R8Command.Builder builder = R8Command.builder()
- .setOutput(out, OutputMode.DexIndexed)
.addProguardConfigurationFiles(keepRules, printMapping);
- ToolHelper.getAppBuilder(builder).addProgramFiles(originalDex);
// Turn off inlining, as we want the mapping that is printed to be stable.
+ finishBuild(builder, out, test);
+ if (backend == Backend.DEX) {
+ builder.addLibraryFiles(ToolHelper.getDefaultAndroidJar());
+ } else {
+ assert backend == Backend.CF;
+ builder.addLibraryFiles(ToolHelper.getJava8RuntimeJar());
+ }
ToolHelper.runR8(builder.build(), options -> options.enableInlining = false);
Path outputmapping = out.resolve("mapping.txt");
@@ -102,8 +137,15 @@
Stream.of(new String(Files.readAllBytes(outputmapping), StandardCharsets.UTF_8).split("\n"))
.filter(line -> !line.startsWith("#"))
.collect(Collectors.joining("\n"));
- String refMapping = new String(Files.readAllBytes(
- Paths.get(EXAMPLES_DIR, "shaking1", "print-mapping.ref")), StandardCharsets.UTF_8);
+ // For the CF backend we treat ConstString/LDC as a (potentially always) throwing instruction,
+ // as opposed to the DEX backend where it's throwing only if its string is ill-formed.
+ // When ConstString is throwing we preserve its position which makes it show up in the
+ // the output Proguard map. That's why the reference CF map is different from the DEX one.
+ String mapping_ref = backend == Backend.CF ? "print-mapping-cf.ref" : "print-mapping.ref";
+ String refMapping =
+ new String(
+ Files.readAllBytes(Paths.get(EXAMPLES_DIR, "shaking1", mapping_ref)),
+ StandardCharsets.UTF_8);
Assert.assertEquals(sorted(refMapping), sorted(actualMapping));
}
diff --git a/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java
index eab5197..d753632 100644
--- a/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java
@@ -7,6 +7,7 @@
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import com.android.tools.r8.ClassFileConsumer;
import com.android.tools.r8.DexIndexedConsumer;
import com.android.tools.r8.R8Command;
import com.android.tools.r8.TestBase;
@@ -19,18 +20,43 @@
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
import com.google.common.collect.ImmutableList;
+import java.util.Arrays;
+import java.util.Collection;
import java.util.List;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class DefaultMethodsTest extends TestBase {
+
+ private Backend backend;
+
+ @Parameterized.Parameters(name = "Backend: {0}")
+ public static Collection<Backend> data() {
+ return Arrays.asList(Backend.values());
+ }
+
+ public DefaultMethodsTest(Backend backend) {
+ this.backend = backend;
+ }
+
private void runTest(List<String> additionalKeepRules, Consumer<CodeInspector> inspection)
throws Exception {
R8Command.Builder builder = R8Command.builder();
builder.addProgramFiles(ToolHelper.getClassFileForTestClass(InterfaceWithDefaultMethods.class));
builder.addProgramFiles(ToolHelper.getClassFileForTestClass(ClassImplementingInterface.class));
builder.addProgramFiles(ToolHelper.getClassFileForTestClass(TestClass.class));
- builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
- builder.setMinApiLevel(AndroidApiLevel.O.getLevel());
+ if (backend == Backend.DEX) {
+ builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
+ int apiLevel = AndroidApiLevel.O.getLevel();
+ builder.setMinApiLevel(apiLevel);
+ builder.addLibraryFiles(ToolHelper.getAndroidJar(apiLevel));
+ } else {
+ assert backend == Backend.CF;
+ builder.setProgramConsumer(ClassFileConsumer.emptyConsumer());
+ builder.addLibraryFiles(ToolHelper.getJava8RuntimeJar());
+ }
// Always keep main in the test class, so the output never becomes empty.
builder.addProguardConfiguration(ImmutableList.of(
"-keep class " + TestClass.class.getCanonicalName() + "{",
diff --git a/src/test/java/com/android/tools/r8/shaking/proxy/ProxiesTest.java b/src/test/java/com/android/tools/r8/shaking/proxy/ProxiesTest.java
index 8d38aee..b3e6367 100644
--- a/src/test/java/com/android/tools/r8/shaking/proxy/ProxiesTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/proxy/ProxiesTest.java
@@ -6,14 +6,11 @@
import static org.junit.Assert.assertEquals;
+import com.android.tools.r8.ClassFileConsumer;
import com.android.tools.r8.DexIndexedConsumer;
import com.android.tools.r8.R8Command;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.code.Instruction;
-import com.android.tools.r8.code.InvokeInterface;
-import com.android.tools.r8.code.InvokeVirtual;
-import com.android.tools.r8.graph.DexCode;
import com.android.tools.r8.graph.invokesuper.Consumer;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
import com.android.tools.r8.origin.Origin;
@@ -24,11 +21,32 @@
import com.android.tools.r8.shaking.proxy.testclasses.TestClass;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.InvokeInstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Streams;
+import java.util.Arrays;
+import java.util.Collection;
import java.util.List;
+import java.util.function.Predicate;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class ProxiesTest extends TestBase {
+ private Backend backend;
+
+ @Parameterized.Parameters(name = "Backend: {0}")
+ public static Collection<Backend> data() {
+ return Arrays.asList(Backend.values());
+ }
+
+ public ProxiesTest(Backend backend) {
+ this.backend = backend;
+ }
private void runTest(List<String> additionalKeepRules, Consumer<CodeInspector> inspection,
String expectedResult)
@@ -49,52 +67,91 @@
Origin.unknown()
);
builder.addProguardConfiguration(additionalKeepRules, Origin.unknown());
- builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
+ if (backend == Backend.DEX) {
+ builder
+ .setProgramConsumer(DexIndexedConsumer.emptyConsumer())
+ .addLibraryFiles(ToolHelper.getDefaultAndroidJar());
+ } else {
+ assert backend == Backend.CF;
+ builder
+ .setProgramConsumer(ClassFileConsumer.emptyConsumer())
+ .addLibraryFiles(ToolHelper.getJava8RuntimeJar());
+ }
AndroidApp app = ToolHelper.runR8(builder.build(), o -> o.enableDevirtualization = false);
- inspection.accept(new CodeInspector(app));
- assertEquals(expectedResult, runOnArt(app, mainClass));
+ inspection.accept(new CodeInspector(app, o -> o.enableCfFrontend = true));
+ String result = backend == Backend.DEX ? runOnArt(app, mainClass) : runOnJava(app, mainClass);
+ if (ToolHelper.isWindows()) {
+ result = result.replace(System.lineSeparator(), "\n");
+ }
+ assertEquals(expectedResult, result);
}
- private int countInstructionInX(CodeInspector inspector, Class<? extends Instruction> invoke) {
+ private int countInstructionInX(CodeInspector inspector, Predicate<InstructionSubject> invoke) {
MethodSignature signatureForX =
new MethodSignature("x", "void", ImmutableList.of(BaseInterface.class.getCanonicalName()));
- DexCode x = inspector.clazz(Main.class).method(signatureForX).getMethod().getCode().asDexCode();
- return (int) filterInstructionKind(x, invoke).count();
+ MethodSubject method = inspector.clazz(Main.class).method(signatureForX);
+ assert method instanceof FoundMethodSubject;
+ FoundMethodSubject foundMethod = (FoundMethodSubject) method;
+ return (int) Streams.stream(foundMethod.iterateInstructions(invoke)).count();
}
- private int countInstructionInY(CodeInspector inspector, Class<? extends Instruction> invoke) {
+ private int countInstructionInY(CodeInspector inspector, Predicate<InstructionSubject> invoke) {
MethodSignature signatureForY =
new MethodSignature("y", "void", ImmutableList.of(SubInterface.class.getCanonicalName()));
- DexCode y = inspector.clazz(Main.class).method(signatureForY).getMethod().getCode().asDexCode();
- return (int) filterInstructionKind(y, invoke)
- .filter(instruction -> instruction.getMethod().qualifiedName().endsWith("method"))
- .count();
+ MethodSubject method = inspector.clazz(Main.class).method(signatureForY);
+ assert method instanceof FoundMethodSubject;
+ FoundMethodSubject foundMethod = (FoundMethodSubject) method;
+ return (int)
+ Streams.stream(foundMethod.iterateInstructions(invoke))
+ .filter(
+ instruction -> {
+ InvokeInstructionSubject invokeInstruction =
+ (InvokeInstructionSubject) instruction;
+ return invokeInstruction.invokedMethod().qualifiedName().endsWith("method");
+ })
+ .count();
}
- private int countInstructionInZ(CodeInspector inspector, Class<? extends Instruction> invoke) {
+ private int countInstructionInZ(CodeInspector inspector, Predicate<InstructionSubject> invoke) {
MethodSignature signatureForZ =
new MethodSignature("z", "void", ImmutableList.of(TestClass.class.getCanonicalName()));
- DexCode z = inspector.clazz(Main.class).method(signatureForZ).getMethod().getCode().asDexCode();
- return (int) filterInstructionKind(z, invoke)
- .filter(instruction -> instruction.getMethod().qualifiedName().endsWith("method"))
- .count();
+ MethodSubject method = inspector.clazz(Main.class).method(signatureForZ);
+ assert method instanceof FoundMethodSubject;
+ FoundMethodSubject foundMethod = (FoundMethodSubject) method;
+ return (int)
+ Streams.stream(foundMethod.iterateInstructions(invoke))
+ .filter(
+ instruction -> {
+ InvokeInstructionSubject invokeInstruction =
+ (InvokeInstructionSubject) instruction;
+ return invokeInstruction.invokedMethod().qualifiedName().endsWith("method");
+ })
+ .count();
}
private int countInstructionInZSubClass(
- CodeInspector inspector, Class<? extends Instruction> invoke) {
+ CodeInspector inspector, Predicate<InstructionSubject> invoke) {
MethodSignature signatureForZ =
new MethodSignature("z", "void", ImmutableList.of(SubClass.class.getCanonicalName()));
- DexCode z = inspector.clazz(Main.class).method(signatureForZ).getMethod().getCode().asDexCode();
- return (int) filterInstructionKind(z, invoke)
- .filter(instruction -> instruction.getMethod().qualifiedName().endsWith("method"))
- .count();
+ MethodSubject method = inspector.clazz(Main.class).method(signatureForZ);
+ assert method instanceof FoundMethodSubject;
+ FoundMethodSubject foundMethod = (FoundMethodSubject) method;
+ return (int)
+ Streams.stream(foundMethod.iterateInstructions(invoke))
+ .filter(
+ instruction -> {
+ InvokeInstructionSubject invokeInstruction =
+ (InvokeInstructionSubject) instruction;
+ return invokeInstruction.invokedMethod().qualifiedName().endsWith("method");
+ })
+ .count();
}
private void noInterfaceKept(CodeInspector inspector) {
// Indirectly assert that method is inlined into x, y and z.
- assertEquals(1, countInstructionInX(inspector, InvokeInterface.class));
- assertEquals(1, countInstructionInY(inspector, InvokeInterface.class));
- assertEquals(1, countInstructionInZ(inspector, InvokeVirtual.class));
+ assertEquals(1, countInstructionInX(inspector, InstructionSubject::isInvokeInterface));
+ assertEquals(1, countInstructionInY(inspector, InstructionSubject::isInvokeInterface));
+ assertEquals(1, countInstructionInZ(inspector, InstructionSubject::isInvokeVirtual));
}
@Test
@@ -106,11 +163,11 @@
private void baseInterfaceKept(CodeInspector inspector) {
// Indirectly assert that method is not inlined into x.
- assertEquals(3, countInstructionInX(inspector, InvokeInterface.class));
+ assertEquals(3, countInstructionInX(inspector, InstructionSubject::isInvokeInterface));
// Indirectly assert that method is inlined into y and z.
- assertEquals(1, countInstructionInY(inspector, InvokeInterface.class));
- assertEquals(1, countInstructionInZ(inspector, InvokeVirtual.class));
- assertEquals(1, countInstructionInZSubClass(inspector, InvokeVirtual.class));
+ assertEquals(1, countInstructionInY(inspector, InstructionSubject::isInvokeInterface));
+ assertEquals(1, countInstructionInZ(inspector, InstructionSubject::isInvokeVirtual));
+ assertEquals(1, countInstructionInZSubClass(inspector, InstructionSubject::isInvokeVirtual));
}
@Test
@@ -126,11 +183,11 @@
private void subInterfaceKept(CodeInspector inspector) {
// Indirectly assert that method is not inlined into x or y.
- assertEquals(3, countInstructionInX(inspector, InvokeInterface.class));
- assertEquals(3, countInstructionInY(inspector, InvokeInterface.class));
+ assertEquals(3, countInstructionInX(inspector, InstructionSubject::isInvokeInterface));
+ assertEquals(3, countInstructionInY(inspector, InstructionSubject::isInvokeInterface));
// Indirectly assert that method is inlined into z.
- assertEquals(1, countInstructionInZ(inspector, InvokeVirtual.class));
- assertEquals(1, countInstructionInZSubClass(inspector, InvokeVirtual.class));
+ assertEquals(1, countInstructionInZ(inspector, InstructionSubject::isInvokeVirtual));
+ assertEquals(1, countInstructionInZSubClass(inspector, InstructionSubject::isInvokeVirtual));
}
@Test
@@ -148,10 +205,10 @@
private void classKept(CodeInspector inspector) {
// Indirectly assert that method is not inlined into x, y or z.
- assertEquals(3, countInstructionInX(inspector, InvokeInterface.class));
- assertEquals(3, countInstructionInY(inspector, InvokeInterface.class));
- assertEquals(3, countInstructionInZ(inspector, InvokeVirtual.class));
- assertEquals(3, countInstructionInZSubClass(inspector, InvokeVirtual.class));
+ assertEquals(3, countInstructionInX(inspector, InstructionSubject::isInvokeInterface));
+ assertEquals(3, countInstructionInY(inspector, InstructionSubject::isInvokeInterface));
+ assertEquals(3, countInstructionInZ(inspector, InstructionSubject::isInvokeVirtual));
+ assertEquals(3, countInstructionInZSubClass(inspector, InstructionSubject::isInvokeVirtual));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/shaking/testrules/ForceInlineTest.java b/src/test/java/com/android/tools/r8/shaking/testrules/ForceInlineTest.java
index 147b1b4..d12f41a 100644
--- a/src/test/java/com/android/tools/r8/shaking/testrules/ForceInlineTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/testrules/ForceInlineTest.java
@@ -13,6 +13,9 @@
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
+import com.android.tools.r8.ClassFileConsumer;
+import com.android.tools.r8.DexIndexedConsumer;
+import com.android.tools.r8.ProgramConsumer;
import com.android.tools.r8.R8Command;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
@@ -20,17 +23,45 @@
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.google.common.collect.ImmutableList;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collection;
import java.util.List;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class ForceInlineTest extends TestBase {
+ private Backend backend;
+
+ @Parameterized.Parameters(name = "Backend: {0}")
+ public static Collection<Backend> data() {
+ return Arrays.asList(Backend.values());
+ }
+
+ public ForceInlineTest(Backend backend) {
+ this.backend = backend;
+ }
private CodeInspector runTest(List<String> proguardConfiguration) throws Exception {
+ ProgramConsumer programConsumer;
+ Path library;
+ if (backend == Backend.DEX) {
+ programConsumer = DexIndexedConsumer.emptyConsumer();
+ library = ToolHelper.getDefaultAndroidJar();
+ } else {
+ assert backend == Backend.CF;
+ programConsumer = ClassFileConsumer.emptyConsumer();
+ library = ToolHelper.getJava8RuntimeJar();
+ }
R8Command.Builder builder =
- ToolHelper.prepareR8CommandBuilder(readClasses(Main.class, A.class, B.class, C.class));
+ ToolHelper.prepareR8CommandBuilder(
+ readClasses(Main.class, A.class, B.class, C.class), programConsumer)
+ .addLibraryFiles(library);
ToolHelper.allowTestProguardOptions(builder);
builder.addProguardConfiguration(proguardConfiguration, Origin.unknown());
- return new CodeInspector(ToolHelper.runR8(builder.build()));
+ return new CodeInspector(ToolHelper.runR8(builder.build(), o -> o.enableCfFrontend = true));
}
@Test
