Merge "Add synchronization to LambdaClass.synthesizeLambdaClass"
diff --git a/src/main/java/com/android/tools/r8/dex/FileWriter.java b/src/main/java/com/android/tools/r8/dex/FileWriter.java
index 6ac3826..f09d92a 100644
--- a/src/main/java/com/android/tools/r8/dex/FileWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/FileWriter.java
@@ -615,7 +615,7 @@
}
private void addStaticFieldValues(DexProgramClass clazz) {
- clazz.computeStaticValues(application.dexItemFactory);
+ clazz.computeStaticValues();
// We have collected the individual components of this array due to the data stored in
// DexEncodedField#staticValues. However, we have to collect the DexEncodedArray itself
// here.
diff --git a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
index 837b805..51fb04a 100644
--- a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
@@ -16,7 +16,6 @@
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
-import java.util.Set;
import java.util.function.Supplier;
public class DexProgramClass extends DexClass implements Supplier<DexProgramClass> {
@@ -99,7 +98,8 @@
skipNameValidationForTesting);
assert classAnnotations != null;
this.originKind = originKind;
- this.synthesizedFrom = accumulateSynthesizedFrom(new HashSet<>(), synthesizedDirectlyFrom);
+ this.synthesizedFrom = new HashSet<>();
+ synthesizedDirectlyFrom.forEach(this::addSynthesizedFrom);
}
public boolean originatesFromDexResource() {
@@ -266,20 +266,15 @@
}
}
- private static Collection<DexProgramClass> accumulateSynthesizedFrom(
- Set<DexProgramClass> accumulated,
- Collection<DexProgramClass> toAccumulate) {
- for (DexProgramClass dexProgramClass : toAccumulate) {
- if (dexProgramClass.synthesizedFrom.isEmpty()) {
- accumulated.add(dexProgramClass);
- } else {
- accumulateSynthesizedFrom(accumulated, dexProgramClass.synthesizedFrom);
- }
+ public void addSynthesizedFrom(DexProgramClass clazz) {
+ if (clazz.synthesizedFrom.isEmpty()) {
+ synthesizedFrom.add(clazz);
+ } else {
+ clazz.synthesizedFrom.forEach(this::addSynthesizedFrom);
}
- return accumulated;
}
- public void computeStaticValues(DexItemFactory factory) {
+ public void computeStaticValues() {
// It does not actually hurt to compute this multiple times. So racing on staticValues is OK.
if (staticValues == SENTINEL_NOT_YET_COMPUTED) {
synchronized (staticFields) {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
index 5e18649..03a3818 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
@@ -65,7 +65,7 @@
final DexField instanceField;
final Target target;
final AtomicBoolean addToMainDexList = new AtomicBoolean(false);
- private final Collection<DexProgramClass> synthesizedFrom = new ArrayList<DexProgramClass>(1);
+ private final Collection<DexProgramClass> synthesizedFrom = new ArrayList<>(1);
private final Supplier<DexProgramClass> lazyDexClass =
Suppliers.memoize(this::synthesizeLambdaClass); // NOTE: thread-safe.
@@ -128,26 +128,32 @@
}
private DexProgramClass synthesizeLambdaClass() {
- return new DexProgramClass(
- type,
- null,
- new SynthesizedOrigin("lambda desugaring", getClass()),
- // Make the synthesized class public, as it might end up being accessed from a different
- // classloader (package private access is not allowed across classloaders, b/72538146).
- ClassAccessFlags.fromDexAccessFlags(
- Constants.ACC_FINAL | Constants.ACC_SYNTHETIC | Constants.ACC_PUBLIC),
- rewriter.factory.objectType,
- buildInterfaces(),
- rewriter.factory.createString("lambda"),
- null,
- Collections.emptyList(),
- DexAnnotationSet.empty(),
- synthesizeStaticFields(),
- synthesizeInstanceFields(),
- synthesizeDirectMethods(),
- synthesizeVirtualMethods(),
- rewriter.factory.getSkipNameValidationForTesting(),
- synthesizedFrom);
+ DexProgramClass clazz =
+ new DexProgramClass(
+ type,
+ null,
+ new SynthesizedOrigin("lambda desugaring", getClass()),
+ // Make the synthesized class public, as it might end up being accessed from a different
+ // classloader (package private access is not allowed across classloaders, b/72538146).
+ ClassAccessFlags.fromDexAccessFlags(
+ Constants.ACC_FINAL | Constants.ACC_SYNTHETIC | Constants.ACC_PUBLIC),
+ rewriter.factory.objectType,
+ buildInterfaces(),
+ rewriter.factory.createString("lambda"),
+ null,
+ Collections.emptyList(),
+ DexAnnotationSet.empty(),
+ synthesizeStaticFields(),
+ synthesizeInstanceFields(),
+ synthesizeDirectMethods(),
+ synthesizeVirtualMethods(),
+ rewriter.factory.getSkipNameValidationForTesting());
+ // The method addSynthesizedFrom() may be called concurrently. To avoid a Concurrent-
+ // ModificationException we must use synchronization.
+ synchronized (synthesizedFrom) {
+ synthesizedFrom.forEach(clazz::addSynthesizedFrom);
+ }
+ return clazz;
}
final DexField getCaptureField(int index) {
@@ -159,9 +165,15 @@
return descriptor.isStateless();
}
- synchronized void addSynthesizedFrom(DexProgramClass synthesizedFrom) {
- assert synthesizedFrom != null;
- this.synthesizedFrom.add(synthesizedFrom);
+ void addSynthesizedFrom(DexProgramClass clazz) {
+ assert clazz != null;
+ synchronized (synthesizedFrom) {
+ if (synthesizedFrom.add(clazz)) {
+ // The lambda class may already have been synthesized, and we therefore need to update the
+ // synthesized lambda class as well.
+ getLambdaClass().addSynthesizedFrom(clazz);
+ }
+ }
}
// Synthesize virtual methods.
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
index ffca4d1..9d475c3 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
@@ -242,13 +242,13 @@
return lambdaClass;
}
- private <K, V> V getKnown(Map<K, V> map, K key) {
+ private static <K, V> V getKnown(Map<K, V> map, K key) {
synchronized (map) {
return map.get(key);
}
}
- private <K, V> V putIfAbsent(Map<K, V> map, K key, V value) {
+ private static <K, V> V putIfAbsent(Map<K, V> map, K key, V value) {
synchronized (map) {
V known = map.get(key);
if (known != null) {
