Merge commit 'a848fa8fca4e37f7fb6fae4f2475ed559ec1b8f3' into dev-release
diff --git a/PRESUBMIT.py b/PRESUBMIT.py
index a329c0f..9b4bb2a 100644
--- a/PRESUBMIT.py
+++ b/PRESUBMIT.py
@@ -5,6 +5,10 @@
from os import path
import datetime
from subprocess import check_output, Popen, PIPE, STDOUT
+import sys
+import inspect
+sys.path.append(path.dirname(inspect.getfile(lambda: None)))
+from tools.utils import EnsureDepFromGoogleCloudStorage
FMT_CMD = path.join(
'third_party',
@@ -16,7 +20,10 @@
'google-java-format-diff.py')
FMT_CMD_JDK17 = path.join('tools','google-java-format-diff.py')
-
+FMT_SHA1 = path.join(
+ 'third_party', 'google', 'google-java-format', '1.14.0.tar.gz.sha1')
+FMT_TGZ = path.join(
+ 'third_party', 'google', 'google-java-format', '1.14.0.tar.gz')
def CheckDoNotMerge(input_api, output_api):
for l in input_api.change.FullDescriptionText().splitlines():
@@ -26,6 +33,7 @@
return []
def CheckFormatting(input_api, output_api, branch):
+ EnsureDepFromGoogleCloudStorage(FMT_CMD, FMT_TGZ, FMT_SHA1, 'google-format')
results = []
for f in input_api.AffectedFiles():
path = f.LocalPath()
diff --git a/build.gradle b/build.gradle
index 332b74a..834e3d6 100644
--- a/build.gradle
+++ b/build.gradle
@@ -341,8 +341,6 @@
"jsr223-api-1.0",
"rhino-1.7.10",
"rhino-android-1.1.1",
- "kotlin/kotlin-compiler-1.3.11",
- "kotlin/kotlin-compiler-1.3.41",
"kotlin/kotlin-compiler-1.3.72",
"kotlin/kotlin-compiler-1.4.20",
"kotlin/kotlin-compiler-1.5.0",
@@ -1578,28 +1576,26 @@
task buildKotlinR8TestResources {
def examplesDir = file("src/test/kotlinR8TestResources")
examplesDir.eachDir { dir ->
- kotlin.Kotlinc.KotlinTargetVersion.values().each { kotlinTargetVersion ->
- def name = dir.getName()
- def taskName = "jar_kotlinR8TestResources_${name}_${kotlinTargetVersion}"
- def javaOutput = "build/test/kotlinR8TestResources/${kotlinTargetVersion}/${name}/java"
- def javaOutputJarName = "${name}.java.jar"
- def javaOutputJarDir = "build/test/kotlinR8TestResources/${kotlinTargetVersion}"
- task "${taskName}Java"(type: JavaCompile) {
- source = fileTree(dir: file("${examplesDir}/${name}"), include: '**/*.java')
- destinationDir = file(javaOutput)
- classpath = sourceSets.main.compileClasspath
- sourceCompatibility = JavaVersion.VERSION_1_6
- targetCompatibility = JavaVersion.VERSION_1_6
- options.compilerArgs += ["-g", "-Xlint:-options"]
- }
- task "${taskName}JavaJar"(type: Jar, dependsOn: "${taskName}Java") {
- archiveName = javaOutputJarName
- destinationDir = file(javaOutputJarDir)
- from javaOutput
- include "**/*.class"
- }
- dependsOn "${taskName}JavaJar"
+ def name = dir.getName()
+ def taskName = "jar_kotlinR8TestResources_${name}"
+ def javaOutput = "build/test/kotlinR8TestResources/${name}/java"
+ def javaOutputJarName = "${name}.jar"
+ def javaOutputJarDir = "build/test/kotlinR8TestResources"
+ task "${taskName}Java"(type: JavaCompile) {
+ source = fileTree(dir: file("${examplesDir}/${name}"), include: '**/*.java')
+ destinationDir = file(javaOutput)
+ classpath = sourceSets.main.compileClasspath
+ sourceCompatibility = JavaVersion.VERSION_1_8
+ targetCompatibility = JavaVersion.VERSION_1_8
+ options.compilerArgs += ["-g", "-Xlint:-options"]
}
+ task "${taskName}JavaJar"(type: Jar, dependsOn: "${taskName}Java") {
+ archiveName = javaOutputJarName
+ destinationDir = file(javaOutputJarDir)
+ from javaOutput
+ include "**/*.class"
+ }
+ dependsOn "${taskName}JavaJar"
}
}
diff --git a/d8_r8/commonBuildSrc/src/main/kotlin/DependenciesPlugin.kt b/d8_r8/commonBuildSrc/src/main/kotlin/DependenciesPlugin.kt
index ab4a518..8af5714 100644
--- a/d8_r8/commonBuildSrc/src/main/kotlin/DependenciesPlugin.kt
+++ b/d8_r8/commonBuildSrc/src/main/kotlin/DependenciesPlugin.kt
@@ -11,6 +11,7 @@
import org.gradle.api.Task
import org.gradle.api.file.ConfigurableFileCollection
import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.tasks.JavaExec
import org.gradle.api.tasks.SourceSet
import org.gradle.jvm.tasks.Jar
import org.gradle.kotlin.dsl.register
@@ -96,7 +97,7 @@
}
/**
- * Builds a jar for each subfolder in an examples test source set.
+ * Builds a jar for each subfolder in an test source set.
*
* <p> As an example, src/test/examplesJava9 contains subfolders: backport, collectionof, ..., .
* These are compiled to individual jars and placed in <repo-root>/build/test/examplesJava9/ as:
@@ -105,37 +106,58 @@
* Calling this from a project will amend the task graph with the task named
* getExamplesJarsTaskName(examplesName) such that it can be referenced from the test runners.
*/
-fun Project.buildJavaExamplesJars(examplesName : String) : Task {
+fun Project.buildExampleJars(name : String) : Task {
val outputFiles : MutableList<File> = mutableListOf()
val jarTasks : MutableList<Task> = mutableListOf()
- var testSourceSet = extensions
+ val testSourceSet = extensions
.getByType(JavaPluginExtension::class.java)
.sourceSets
// The TEST_SOURCE_SET_NAME is the source set defined by writing java { sourcesets.test { ... }}
.getByName(SourceSet.TEST_SOURCE_SET_NAME)
+ val destinationDir = getRoot().resolveAll("build", "test", name)
+ val classesOutput = destinationDir.resolve("classes")
+ testSourceSet.java.destinationDirectory.set(classesOutput)
+ testSourceSet.resources.destinationDirectory.set(destinationDir)
testSourceSet
.java
.sourceDirectories
.files
.forEach { srcDir ->
srcDir.listFiles(File::isDirectory)?.forEach { exampleDir ->
- jarTasks.add(tasks.register<Jar>("jar-examples$examplesName-${exampleDir.name}") {
+ var generationTask : Task? = null
+ if (exampleDir.resolve("TestGenerator.java").isFile) {
+ generationTask = tasks.register<JavaExec>(
+ "generate-$name-${exampleDir.name}") {
+ dependsOn("compileTestJava")
+ mainClass.set("${exampleDir.name}.TestGenerator")
+ classpath = files(
+ classesOutput,
+ testSourceSet.compileClasspath)
+ args(classesOutput.toString())
+ }.get()
+ }
+ jarTasks.add(tasks.register<Jar>(
+ "jar-$name-${exampleDir.name}") {
dependsOn("compileTestJava")
+ if (generationTask != null) {
+ dependsOn(generationTask)
+ }
archiveFileName.set("${exampleDir.name}.jar")
- destinationDirectory.set(getRoot().resolveAll("build", "test", "examples$examplesName"))
- from(testSourceSet.output.classesDirs.files.map{ it.resolve(exampleDir.name) }) {
- include("**/*.class")
+ destinationDirectory.set(destinationDir)
+ from(classesOutput) {
+ include("${exampleDir.name}/**/*.class")
+ exclude("**/TestGenerator*")
}
}.get())
}
}
- return tasks.register(getExamplesJarsTaskName(examplesName)) {
- dependsOn(jarTasks)
+ return tasks.register(getExampleJarsTaskName(name)) {
+ dependsOn(jarTasks.toTypedArray())
outputs.files(outputFiles)
}.get()
}
-fun Project.getExamplesJarsTaskName(name: String) : String {
+fun Project.getExampleJarsTaskName(name: String) : String {
return "build-example-jars-$name"
}
@@ -275,6 +297,8 @@
}
object ThirdPartyDeps {
+ val androidJars = getThirdPartyAndroidJars()
+ val androidVMs = getThirdPartyAndroidVms()
val apiDatabase = ThirdPartyDependency(
"apiDatabase",
Paths.get(
@@ -284,26 +308,42 @@
"resources",
"new_api_database.ser").toFile(),
Paths.get("third_party", "api_database", "api_database.tar.gz.sha1").toFile())
+ val compilerApi = ThirdPartyDependency(
+ "compiler-api",
+ Paths.get(
+ "third_party",
+ "binary_compatibility_tests",
+ "compiler_api_tests",
+ "tests.jar").toFile(),
+ Paths.get(
+ "third_party",
+ "binary_compatibility_tests",
+ "compiler_api_tests.tar.gz.sha1").toFile())
val ddmLib = ThirdPartyDependency(
"ddmlib",
Paths.get("third_party", "ddmlib", "ddmlib.jar").toFile(),
Paths.get("third_party", "ddmlib.tar.gz.sha1").toFile())
+ val jacoco = ThirdPartyDependency(
+ "jacoco",
+ Paths.get("third_party", "jacoco", "0.8.6", "lib", "jacocoagent.jar").toFile(),
+ Paths.get("third_party", "jacoco", "0.8.6.tar.gz.sha1").toFile()
+ )
val jasmin = ThirdPartyDependency(
"jasmin",
Paths.get("third_party", "jasmin", "jasmin-2.4.jar").toFile(),
Paths.get("third_party", "jasmin.tar.gz.sha1").toFile())
- val jdwpTests = ThirdPartyDependency(
- "jdwp-tests",
- Paths.get("third_party", "jdwp-tests", "apache-harmony-jdwp-tests-host.jar").toFile(),
- Paths.get("third_party", "jdwp-tests.tar.gz.sha1").toFile())
- val androidJars : List<ThirdPartyDependency> = getThirdPartyAndroidJars()
val java8Runtime = ThirdPartyDependency(
"openjdk-rt-1.8",
Paths.get("third_party", "openjdk", "openjdk-rt-1.8", "rt.jar").toFile(),
Paths.get("third_party", "openjdk", "openjdk-rt-1.8.tar.gz.sha1").toFile()
)
- val androidVMs : List<ThirdPartyDependency> = getThirdPartyAndroidVms()
- val jdks : List<ThirdPartyDependency> = getJdks()
+ val jdks = getJdks()
+ val jdwpTests = ThirdPartyDependency(
+ "jdwp-tests",
+ Paths.get("third_party", "jdwp-tests", "apache-harmony-jdwp-tests-host.jar").toFile(),
+ Paths.get("third_party", "jdwp-tests.tar.gz.sha1").toFile())
+ val kotlinCompilers = getThirdPartyKotlinCompilers()
+ val proguards = getThirdPartyProguards()
}
fun getThirdPartyAndroidJars() : List<ThirdPartyDependency> {
@@ -373,4 +413,39 @@
} else {
return Jdk.values().filter{ !it.isJdk8() }.map{ it.getThirdPartyDependency()}
}
+}
+
+fun getThirdPartyProguards() : List<ThirdPartyDependency> {
+ val os: OperatingSystem = DefaultNativePlatform.getCurrentOperatingSystem()
+ return listOf("proguard5.2.1", "proguard6.0.1", "proguard-7.0.0")
+ .map { ThirdPartyDependency(
+ it,
+ Paths.get(
+ "third_party",
+ "proguard",
+ it,
+ "bin",
+ if (os.isWindows) "proguard.bat" else "proguard.sh").toFile(),
+ Paths.get("third_party", "proguard", "${it}.tar.gz.sha1").toFile())}
+}
+
+fun getThirdPartyKotlinCompilers() : List<ThirdPartyDependency> {
+ return listOf(
+ "kotlin-compiler-1.3.72",
+ "kotlin-compiler-1.4.20",
+ "kotlin-compiler-1.5.0",
+ "kotlin-compiler-1.6.0",
+ "kotlin-compiler-1.7.0",
+ "kotlin-compiler-1.8.0",
+ "kotlin-compiler-dev")
+ .map { ThirdPartyDependency(
+ it,
+ Paths.get(
+ "third_party",
+ "kotlin",
+ it,
+ "kotlinc",
+ "lib",
+ "kotlin-stdlib.jar").toFile(),
+ Paths.get("third_party", "kotlin", "${it}.tar.gz.sha1").toFile())}
}
\ No newline at end of file
diff --git a/d8_r8/commonBuildSrc/src/main/kotlin/DownloadDependencyTask.kt b/d8_r8/commonBuildSrc/src/main/kotlin/DownloadDependencyTask.kt
index 24185c6..4d43b40 100644
--- a/d8_r8/commonBuildSrc/src/main/kotlin/DownloadDependencyTask.kt
+++ b/d8_r8/commonBuildSrc/src/main/kotlin/DownloadDependencyTask.kt
@@ -40,7 +40,7 @@
option = "dependency",
description = "Sets the dependency information for a cloud stored file")
fun setDependency(
- dependencyName : String, sha1File: File, outputDir : File, dependencyType: DependencyType) {
+ dependencyName: String, sha1File: File, outputDir: File, dependencyType: DependencyType) {
_outputDir = outputDir
_sha1File = sha1File
_tarGzFile = sha1File.resolveSibling(sha1File.name.replace(".sha1", ""))
@@ -70,12 +70,11 @@
getWorkerExecutor()!!
.noIsolation()
.submit(RunDownload::class.java) {
- this.type.set(dependencyType)
+ type.set(dependencyType)
this.sha1File.set(sha1File)
}
}
-
interface RunDownloadParameters : WorkParameters {
val type : Property<DependencyType>
val sha1File : RegularFileProperty
diff --git a/d8_r8/settings.gradle.kts b/d8_r8/settings.gradle.kts
index 402137e..9907334 100644
--- a/d8_r8/settings.gradle.kts
+++ b/d8_r8/settings.gradle.kts
@@ -23,20 +23,20 @@
"download_from_google_storage.py",
"--extract",
"--bucket",
- "${dependencies_bucket}",
+ dependencies_bucket,
"--sha1_file",
"${sha1File}"
)
println("Executing command: ${cmd.joinToString(" ")}")
- var process = ProcessBuilder().command(cmd).start()
+ val process = ProcessBuilder().command(cmd).start()
process.waitFor()
if (process.exitValue() != 0) {
throw GradleException(
"Bootstrapping dependencies_new download failed:\n"
+ "${String(process.getErrorStream().readAllBytes(),
java.nio.charset.StandardCharsets.UTF_8)}\n"
- + "${String(process.getInputStream().readAllBytes(),
- java.nio.charset.StandardCharsets.UTF_8)}")
+ + String(process.getInputStream().readAllBytes(),
+ java.nio.charset.StandardCharsets.UTF_8))
}
}
@@ -44,9 +44,11 @@
downloadFromGoogleStorage(thirdParty.resolve("dependencies.tar.gz.sha1"))
downloadFromGoogleStorage(thirdParty.resolve("dependencies_new.tar.gz.sha1"))
+pluginManagement {
+ includeBuild(rootProject.projectDir.resolve("commonBuildSrc"))
+}
// This project is temporarily located in d8_r8. When moved to root, the parent
// folder should just be removed.
-includeBuild(root.resolve("commonBuildSrc"))
includeBuild(root.resolve("keepanno"))
// We need to include src/main as a composite-build otherwise our test-modules
diff --git a/d8_r8/test/settings.gradle.kts b/d8_r8/test/settings.gradle.kts
index ed1f4ea..cec4093 100644
--- a/d8_r8/test/settings.gradle.kts
+++ b/d8_r8/test/settings.gradle.kts
@@ -6,13 +6,14 @@
val root = rootProject.projectDir.parentFile
includeBuild(root.resolve("main"))
-includeBuild(root.resolve("test_modules").resolve("tests_java_examples"))
-includeBuild(root.resolve("test_modules").resolve("tests_java_examplesAndroidN"))
-includeBuild(root.resolve("test_modules").resolve("tests_java_examplesAndroidP"))
-includeBuild(root.resolve("test_modules").resolve("tests_java_examplesAndroidO"))
includeBuild(root.resolve("test_modules").resolve("tests_java_8"))
includeBuild(root.resolve("test_modules").resolve("tests_java_9"))
includeBuild(root.resolve("test_modules").resolve("tests_java_10"))
includeBuild(root.resolve("test_modules").resolve("tests_java_11"))
includeBuild(root.resolve("test_modules").resolve("tests_java_17"))
includeBuild(root.resolve("test_modules").resolve("tests_java_20"))
+includeBuild(root.resolve("test_modules").resolve("tests_java_examples"))
+includeBuild(root.resolve("test_modules").resolve("tests_java_examplesAndroidN"))
+includeBuild(root.resolve("test_modules").resolve("tests_java_examplesAndroidP"))
+includeBuild(root.resolve("test_modules").resolve("tests_java_examplesAndroidO"))
+includeBuild(root.resolve("test_modules").resolve("tests_java_kotlinR8TestResources"))
diff --git a/d8_r8/test_modules/tests_java_10/build.gradle.kts b/d8_r8/test_modules/tests_java_10/build.gradle.kts
index f24610d..aec1b33 100644
--- a/d8_r8/test_modules/tests_java_10/build.gradle.kts
+++ b/d8_r8/test_modules/tests_java_10/build.gradle.kts
@@ -24,7 +24,7 @@
dependencies { }
// We just need to register the examples jars for it to be referenced by other modules.
-val buildExampleJars = buildJavaExamplesJars("Java10")
+val buildExampleJars = buildExampleJars("examplesJava10")
tasks {
withType<JavaCompile> {
diff --git a/d8_r8/test_modules/tests_java_11/build.gradle.kts b/d8_r8/test_modules/tests_java_11/build.gradle.kts
index 1ff3ea8..bbf8d9c 100644
--- a/d8_r8/test_modules/tests_java_11/build.gradle.kts
+++ b/d8_r8/test_modules/tests_java_11/build.gradle.kts
@@ -24,7 +24,7 @@
dependencies { }
// We just need to register the examples jars for it to be referenced by other modules.
-val buildExampleJars = buildJavaExamplesJars("Java11")
+val buildExampleJars = buildExampleJars("examplesJava11")
tasks {
withType<JavaCompile> {
diff --git a/d8_r8/test_modules/tests_java_17/build.gradle.kts b/d8_r8/test_modules/tests_java_17/build.gradle.kts
index 9e0f2b7..e68b356 100644
--- a/d8_r8/test_modules/tests_java_17/build.gradle.kts
+++ b/d8_r8/test_modules/tests_java_17/build.gradle.kts
@@ -24,7 +24,7 @@
dependencies { }
// We just need to register the examples jars for it to be referenced by other modules.
-val buildExampleJars = buildJavaExamplesJars("Java17")
+val buildExampleJars = buildExampleJars("examplesJava17")
tasks {
withType<JavaCompile> {
diff --git a/d8_r8/test_modules/tests_java_20/build.gradle.kts b/d8_r8/test_modules/tests_java_20/build.gradle.kts
index 85cd393..5c348ed 100644
--- a/d8_r8/test_modules/tests_java_20/build.gradle.kts
+++ b/d8_r8/test_modules/tests_java_20/build.gradle.kts
@@ -24,7 +24,7 @@
dependencies { }
// We just need to register the examples jars for it to be referenced by other modules.
-val buildExampleJars = buildJavaExamplesJars("Java20")
+val buildExampleJars = buildExampleJars("examplesJava20")
tasks {
withType<JavaCompile> {
diff --git a/d8_r8/test_modules/tests_java_8/build.gradle.kts b/d8_r8/test_modules/tests_java_8/build.gradle.kts
index 3493286..f7e52e5 100644
--- a/d8_r8/test_modules/tests_java_8/build.gradle.kts
+++ b/d8_r8/test_modules/tests_java_8/build.gradle.kts
@@ -55,21 +55,25 @@
val thirdPartyRuntimeDependenciesTask = ensureThirdPartyDependencies(
"runtimeDeps",
- listOf(ThirdPartyDeps.java8Runtime)
+ listOf(ThirdPartyDeps.compilerApi, ThirdPartyDeps.jacoco, ThirdPartyDeps.java8Runtime)
+ ThirdPartyDeps.androidJars
+ ThirdPartyDeps.androidVMs
- + ThirdPartyDeps.jdks)
+ + ThirdPartyDeps.jdks
+ + ThirdPartyDeps.kotlinCompilers
+ + ThirdPartyDeps.proguards)
val sourceSetDependenciesTasks = arrayOf(
- projectTask("tests_java_examples", getExamplesJarsTaskName("")),
- projectTask("tests_java_examplesAndroidN", getExamplesJarsTaskName("AndroidN")),
- projectTask("tests_java_examplesAndroidO", getExamplesJarsTaskName("AndroidO")),
- projectTask("tests_java_examplesAndroidP", getExamplesJarsTaskName("AndroidP")),
- projectTask("tests_java_9", getExamplesJarsTaskName("Java9")),
- projectTask("tests_java_10", getExamplesJarsTaskName("Java10")),
- projectTask("tests_java_11", getExamplesJarsTaskName("Java11")),
- projectTask("tests_java_17", getExamplesJarsTaskName("Java17")),
- projectTask("tests_java_20", getExamplesJarsTaskName("Java20")))
+ projectTask("tests_java_examples", getExampleJarsTaskName("examples")),
+ projectTask("tests_java_9", getExampleJarsTaskName("examplesJava9")),
+ projectTask("tests_java_10", getExampleJarsTaskName("examplesJava10")),
+ projectTask("tests_java_11", getExampleJarsTaskName("examplesJava11")),
+ projectTask("tests_java_17", getExampleJarsTaskName("examplesJava17")),
+ projectTask("tests_java_20", getExampleJarsTaskName("examplesJava20")),
+ projectTask("tests_java_examplesAndroidN", getExampleJarsTaskName("examplesAndroidN")),
+ projectTask("tests_java_examplesAndroidO", getExampleJarsTaskName("examplesAndroidO")),
+ projectTask("tests_java_examplesAndroidP", getExampleJarsTaskName("examplesAndroidP")),
+ projectTask("tests_java_kotlinR8TestResources", getExampleJarsTaskName("kotlinR8TestResources")),
+)
fun testDependencies() : FileCollection {
return sourceSets
diff --git a/d8_r8/test_modules/tests_java_8/settings.gradle.kts b/d8_r8/test_modules/tests_java_8/settings.gradle.kts
index 73f5d73..4935653 100644
--- a/d8_r8/test_modules/tests_java_8/settings.gradle.kts
+++ b/d8_r8/test_modules/tests_java_8/settings.gradle.kts
@@ -11,13 +11,14 @@
// will compete with the test to compile the source files.
includeBuild(root.resolve("main"))
-includeBuild(root.resolve("test_modules").resolve("tests_java_examples"))
-includeBuild(root.resolve("test_modules").resolve("tests_java_examplesAndroidN"))
-includeBuild(root.resolve("test_modules").resolve("tests_java_examplesAndroidO"))
-includeBuild(root.resolve("test_modules").resolve("tests_java_examplesAndroidP"))
includeBuild(root.resolve("test_modules").resolve("tests_java_9"))
includeBuild(root.resolve("test_modules").resolve("tests_java_10"))
includeBuild(root.resolve("test_modules").resolve("tests_java_11"))
includeBuild(root.resolve("test_modules").resolve("tests_java_17"))
includeBuild(root.resolve("test_modules").resolve("tests_java_20"))
+includeBuild(root.resolve("test_modules").resolve("tests_java_examples"))
+includeBuild(root.resolve("test_modules").resolve("tests_java_examplesAndroidN"))
+includeBuild(root.resolve("test_modules").resolve("tests_java_examplesAndroidO"))
+includeBuild(root.resolve("test_modules").resolve("tests_java_examplesAndroidP"))
+includeBuild(root.resolve("test_modules").resolve("tests_java_kotlinR8TestResources"))
diff --git a/d8_r8/test_modules/tests_java_9/build.gradle.kts b/d8_r8/test_modules/tests_java_9/build.gradle.kts
index ac5923f..e7a55e1 100644
--- a/d8_r8/test_modules/tests_java_9/build.gradle.kts
+++ b/d8_r8/test_modules/tests_java_9/build.gradle.kts
@@ -24,7 +24,7 @@
dependencies { }
// We just need to register the examples jars for it to be referenced by other modules.
-val buildExampleJars = buildJavaExamplesJars("Java9")
+val buildExampleJars = buildExampleJars("examplesJava9")
tasks {
withType<JavaCompile> {
diff --git a/d8_r8/test_modules/tests_java_examples/build.gradle.kts b/d8_r8/test_modules/tests_java_examples/build.gradle.kts
index 05798be..16fec67 100644
--- a/d8_r8/test_modules/tests_java_examples/build.gradle.kts
+++ b/d8_r8/test_modules/tests_java_examples/build.gradle.kts
@@ -27,7 +27,7 @@
}
// We just need to register the examples jars for it to be referenced by other modules.
-val buildExampleJars = buildJavaExamplesJars("")
+val buildExampleJars = buildExampleJars("examples")
tasks {
withType<JavaCompile> {
diff --git a/d8_r8/test_modules/tests_java_examplesAndroidN/build.gradle.kts b/d8_r8/test_modules/tests_java_examplesAndroidN/build.gradle.kts
index 8cfe7d2..54b5a45 100644
--- a/d8_r8/test_modules/tests_java_examplesAndroidN/build.gradle.kts
+++ b/d8_r8/test_modules/tests_java_examplesAndroidN/build.gradle.kts
@@ -27,7 +27,7 @@
}
// We just need to register the examples jars for it to be referenced by other modules.
-val buildExampleJars = buildJavaExamplesJars("AndroidN")
+val buildExampleJars = buildExampleJars("examplesAndroidN")
tasks {
withType<JavaCompile> {
diff --git a/d8_r8/test_modules/tests_java_examplesAndroidO/build.gradle.kts b/d8_r8/test_modules/tests_java_examplesAndroidO/build.gradle.kts
index 44ed59d..43020e3 100644
--- a/d8_r8/test_modules/tests_java_examplesAndroidO/build.gradle.kts
+++ b/d8_r8/test_modules/tests_java_examplesAndroidO/build.gradle.kts
@@ -27,11 +27,13 @@
}
// We just need to register the examples jars for it to be referenced by other modules.
-val buildExampleJars = buildJavaExamplesJars("AndroidO")
+val buildExampleJars = buildExampleJars("examplesAndroidO")
tasks {
withType<JavaCompile> {
options.setFork(true)
+ options.compilerArgs.add("-Xlint:-options")
+ options.compilerArgs.add("-parameters")
options.forkOptions.memoryMaximumSize = "3g"
options.forkOptions.jvmArgs = listOf(
"-Xss256m",
diff --git a/d8_r8/test_modules/tests_java_examplesAndroidP/build.gradle.kts b/d8_r8/test_modules/tests_java_examplesAndroidP/build.gradle.kts
index 7e58f3b..13c2530 100644
--- a/d8_r8/test_modules/tests_java_examplesAndroidP/build.gradle.kts
+++ b/d8_r8/test_modules/tests_java_examplesAndroidP/build.gradle.kts
@@ -27,7 +27,7 @@
}
// We just need to register the examples jars for it to be referenced by other modules.
-val buildExampleJars = buildJavaExamplesJars("AndroidP")
+val buildExampleJars = buildExampleJars("examplesAndroidP")
tasks {
withType<JavaCompile> {
diff --git a/d8_r8/test_modules/tests_java_kotlinR8TestResources/build.gradle.kts b/d8_r8/test_modules/tests_java_kotlinR8TestResources/build.gradle.kts
new file mode 100644
index 0000000..353d621
--- /dev/null
+++ b/d8_r8/test_modules/tests_java_kotlinR8TestResources/build.gradle.kts
@@ -0,0 +1,46 @@
+// Copyright (c) 2023, 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.
+
+import org.gradle.api.JavaVersion
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+ `kotlin-dsl`
+ `java-library`
+ id("dependencies-plugin")
+}
+
+val root = getRoot()
+
+java {
+ sourceSets.test.configure {
+ java.srcDirs.clear()
+ java.srcDir(root.resolveAll("src", "test", "kotlinR8TestResources"))
+ }
+ sourceCompatibility = JavaVersion.VERSION_1_8
+ targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+dependencies {
+ testCompileOnly(Deps.asm)
+}
+
+// We just need to register the examples jars for it to be referenced by other modules.
+val buildExampleJars = buildExampleJars("kotlinR8TestResources")
+
+tasks {
+ withType<JavaCompile> {
+ options.setFork(true)
+ options.forkOptions.memoryMaximumSize = "3g"
+ options.forkOptions.jvmArgs = listOf(
+ "-Xss256m",
+ // Set the bootclass path so compilation is consistent with 1.8 target compatibility.
+ "-Xbootclasspath/a:third_party/openjdk/openjdk-rt-1.8/rt.jar")
+ }
+ withType<KotlinCompile> {
+ kotlinOptions {
+ jvmTarget = "1.8"
+ }
+ }
+}
diff --git a/d8_r8/test_modules/tests_java_kotlinR8TestResources/gradle.properties b/d8_r8/test_modules/tests_java_kotlinR8TestResources/gradle.properties
new file mode 100644
index 0000000..1de43f9
--- /dev/null
+++ b/d8_r8/test_modules/tests_java_kotlinR8TestResources/gradle.properties
@@ -0,0 +1,17 @@
+# Copyright (c) 2023, 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.
+
+org.gradle.jvmargs=-Xmx2048M -Dfile.encoding=UTF-8
+kotlin.daemon.jvmargs=-Xmx3g -Dkotlin.js.compiler.legacy.force_enabled=true
+systemProp.file.encoding=UTF-8
+
+# Enable new incremental compilation
+kotlin.incremental.useClasspathSnapshot=true
+
+org.gradle.parallel=true
+org.gradle.caching=true
+
+# Do not download any jdks or detect them. We provide them.
+org.gradle.java.installations.auto-detect=false
+org.gradle.java.installations.auto-download=false
diff --git a/d8_r8/test_modules/tests_java_kotlinR8TestResources/settings.gradle.kts b/d8_r8/test_modules/tests_java_kotlinR8TestResources/settings.gradle.kts
new file mode 100644
index 0000000..58a9232
--- /dev/null
+++ b/d8_r8/test_modules/tests_java_kotlinR8TestResources/settings.gradle.kts
@@ -0,0 +1,5 @@
+// Copyright (c) 2023, 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.
+
+rootProject.name = "tests_java_kotlinR8TestResources"
diff --git a/infra/config/global/generated/luci-scheduler.cfg b/infra/config/global/generated/luci-scheduler.cfg
index 03691dd3..91a12e2 100644
--- a/infra/config/global/generated/luci-scheduler.cfg
+++ b/infra/config/global/generated/luci-scheduler.cfg
@@ -41,7 +41,7 @@
triggering_policy {
kind: GREEDY_BATCHING
max_concurrent_invocations: 1
- max_batch_size: 1
+ max_batch_size: 42
}
buildbucket {
server: "cr-buildbucket.appspot.com"
diff --git a/infra/config/global/main.star b/infra/config/global/main.star
index 358def3..dd14d77 100755
--- a/infra/config/global/main.star
+++ b/infra/config/global/main.star
@@ -307,7 +307,7 @@
dimensions = get_dimensions(),
triggering_policy = scheduler.policy(
kind = scheduler.GREEDY_BATCHING_KIND,
- max_batch_size = 1,
+ max_batch_size = 42,
max_concurrent_invocations = 1
),
priority = 25,
diff --git a/src/main/java/com/android/tools/r8/GlobalSyntheticsGenerator.java b/src/main/java/com/android/tools/r8/GlobalSyntheticsGenerator.java
index e3a2cbb..be74e08 100644
--- a/src/main/java/com/android/tools/r8/GlobalSyntheticsGenerator.java
+++ b/src/main/java/com/android/tools/r8/GlobalSyntheticsGenerator.java
@@ -68,6 +68,7 @@
* The GlobalSyntheticsGenerator, a tool for generating a dex file for all possible global
* synthetics.
*/
+@Keep
public class GlobalSyntheticsGenerator {
private static boolean ensureAllGlobalSyntheticsModeled(SyntheticNaming naming) {
diff --git a/src/main/java/com/android/tools/r8/GlobalSyntheticsGeneratorCommand.java b/src/main/java/com/android/tools/r8/GlobalSyntheticsGeneratorCommand.java
index 4ae00bd..1d85164 100644
--- a/src/main/java/com/android/tools/r8/GlobalSyntheticsGeneratorCommand.java
+++ b/src/main/java/com/android/tools/r8/GlobalSyntheticsGeneratorCommand.java
@@ -25,6 +25,7 @@
/**
* Immutable command structure for an invocation of the {@link GlobalSyntheticsGenerator} compiler.
*/
+@Keep
public final class GlobalSyntheticsGeneratorCommand {
private final ProgramConsumer programConsumer;
@@ -151,6 +152,7 @@
*
* <p>A builder is obtained by calling {@link GlobalSyntheticsGeneratorCommand#builder}.
*/
+ @Keep
public static class Builder {
private ProgramConsumer programConsumer = null;
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 86b5b5f..080447c 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -505,6 +505,9 @@
.appInfo()
.notifyHorizontalClassMergerFinished(HorizontalClassMerger.Mode.INITIAL);
+ // TODO(b/225838009): Horizontal merging currently assumes pre-phase CF conversion.
+ appView.testing().enterLirSupportedPhase();
+
new ProtoNormalizer(appViewWithLiveness).run(executorService, timing);
// Clear traced methods roots to not hold on to the main dex live method set.
@@ -541,6 +544,9 @@
appView.setGraphLens(new AppliedGraphLens(appView));
timing.end();
+ // TODO(b/225838009): Support tracing and building LIR in Enqueuer.
+ PrimaryR8IRConverter.finalizeLirToOutputFormat(appView, timing, executorService);
+
if (options.shouldRerunEnqueuer()) {
timing.begin("Post optimization code stripping");
try {
diff --git a/src/main/java/com/android/tools/r8/dump/CompilerDump.java b/src/main/java/com/android/tools/r8/dump/CompilerDump.java
index eaf9e53..7655a6e 100644
--- a/src/main/java/com/android/tools/r8/dump/CompilerDump.java
+++ b/src/main/java/com/android/tools/r8/dump/CompilerDump.java
@@ -45,6 +45,10 @@
return directory.resolve("proguard.config");
}
+ public Path getDesugaredLibraryFile() {
+ return directory.resolve("desugared-library.json");
+ }
+
public void sanitizeProguardConfig(ProguardConfigSanitizer sanitizer) throws IOException {
try (BufferedReader reader = Files.newBufferedReader(getProguardConfigFile())) {
String next = reader.readLine();
diff --git a/src/main/java/com/android/tools/r8/graph/AppView.java b/src/main/java/com/android/tools/r8/graph/AppView.java
index 5a20e3d..06deed3 100644
--- a/src/main/java/com/android/tools/r8/graph/AppView.java
+++ b/src/main/java/com/android/tools/r8/graph/AppView.java
@@ -26,6 +26,8 @@
import com.android.tools.r8.ir.analysis.proto.GeneratedMessageLiteShrinker;
import com.android.tools.r8.ir.analysis.proto.ProtoShrinker;
import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+import com.android.tools.r8.ir.analysis.value.AbstractValueJoiner.AbstractValueFieldJoiner;
+import com.android.tools.r8.ir.analysis.value.AbstractValueJoiner.AbstractValueParameterJoiner;
import com.android.tools.r8.ir.desugar.TypeRewriter;
import com.android.tools.r8.ir.optimize.enums.EnumDataMap;
import com.android.tools.r8.ir.optimize.info.field.InstanceFieldInitializationInfoFactory;
@@ -100,6 +102,8 @@
private KeepInfoCollection keepInfo = null;
private final AbstractValueFactory abstractValueFactory = new AbstractValueFactory();
+ private final AbstractValueFieldJoiner abstractValueFieldJoiner;
+ private final AbstractValueParameterJoiner abstractValueParameterJoiner;
private final InstanceFieldInitializationInfoFactory instanceFieldInitializationInfoFactory =
new InstanceFieldInitializationInfoFactory();
private final SimpleInliningConstraintFactory simpleInliningConstraintFactory =
@@ -170,13 +174,20 @@
this.context =
timing.time(
"Compilation context", () -> CompilationContext.createInitialContext(options()));
+ this.wholeProgramOptimizations = wholeProgramOptimizations;
+ if (enableWholeProgramOptimizations()) {
+ abstractValueFieldJoiner = new AbstractValueFieldJoiner(withClassHierarchy());
+ abstractValueParameterJoiner = new AbstractValueParameterJoiner(withClassHierarchy());
+ } else {
+ abstractValueFieldJoiner = null;
+ abstractValueParameterJoiner = null;
+ }
this.artProfileCollection = artProfileCollection;
this.startupProfile = startupProfile;
this.dontWarnConfiguration =
timing.time(
"Dont warn config",
() -> DontWarnConfiguration.create(options().getProguardConfiguration()));
- this.wholeProgramOptimizations = wholeProgramOptimizations;
this.initClassLens = timing.time("Init class lens", InitClassLens::getThrowingInstance);
this.typeRewriter = mapper;
timing.begin("Create argument propagator");
@@ -314,6 +325,14 @@
return abstractValueFactory;
}
+ public AbstractValueFieldJoiner getAbstractValueFieldJoiner() {
+ return abstractValueFieldJoiner;
+ }
+
+ public AbstractValueParameterJoiner getAbstractValueParameterJoiner() {
+ return abstractValueParameterJoiner;
+ }
+
public InstanceFieldInitializationInfoFactory instanceFieldInitializationInfoFactory() {
return instanceFieldInitializationInfoFactory;
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexClass.java b/src/main/java/com/android/tools/r8/graph/DexClass.java
index cc8e00f..a87febd 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -1043,6 +1043,10 @@
permittedSubclasses.clear();
}
+ public void removePermittedSubclassAttribute(Predicate<PermittedSubclassAttribute> predicate) {
+ permittedSubclasses.removeIf(predicate);
+ }
+
public boolean isLocalClass() {
InnerClassAttribute innerClass = getInnerClassAttributeForThisClass();
// The corresponding enclosing-method attribute might be not available, e.g., CF version 50.
@@ -1139,6 +1143,10 @@
return permittedSubclasses;
}
+ public void setPermittedSubclassAttributes(List<PermittedSubclassAttribute> permittedSubclasses) {
+ this.permittedSubclasses = permittedSubclasses;
+ }
+
public List<RecordComponentInfo> getRecordComponents() {
return recordComponents;
}
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 1aa866f..fb50d0e 100644
--- a/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexProgramClass.java
@@ -415,6 +415,18 @@
.traverse((field, value) -> fn.apply(field.asProgramField(), value), initialValue);
}
+ public TraversalContinuation<?, ?> traverseProgramInstanceFields(
+ Function<? super ProgramField, TraversalContinuation<?, ?>> fn) {
+ return getFieldCollection().traverseInstanceFields(field -> fn.apply(field.asProgramField()));
+ }
+
+ public <BT, CT> TraversalContinuation<BT, CT> traverseProgramInstanceFields(
+ BiFunction<? super ProgramField, CT, TraversalContinuation<BT, CT>> fn, CT initialValue) {
+ return getFieldCollection()
+ .traverseInstanceFields(
+ (field, value) -> fn.apply(field.asProgramField(), value), initialValue);
+ }
+
public TraversalContinuation<?, ?> traverseProgramMethods(
Function<? super ProgramMethod, TraversalContinuation<?, ?>> fn) {
return getMethodCollection().traverse(method -> fn.apply(new ProgramMethod(this, method)));
diff --git a/src/main/java/com/android/tools/r8/graph/FieldArrayBacking.java b/src/main/java/com/android/tools/r8/graph/FieldArrayBacking.java
index dee7446..ec0758a 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldArrayBacking.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldArrayBacking.java
@@ -72,15 +72,61 @@
@Override
<BT, CT> TraversalContinuation<BT, CT> traverse(
DexClass holder, Function<? super DexClassAndField, TraversalContinuation<BT, CT>> fn) {
- TraversalContinuation<BT, CT> traversalContinuation = TraversalContinuation.doContinue();
- for (DexEncodedField definition : staticFields) {
- DexClassAndField field = DexClassAndField.create(holder, definition);
- traversalContinuation = fn.apply(field);
- if (traversalContinuation.shouldBreak()) {
- return traversalContinuation;
- }
+ TraversalContinuation<BT, CT> traversalContinuation = traverseStaticFields(holder, fn);
+ if (traversalContinuation.shouldBreak()) {
+ return traversalContinuation;
}
- for (DexEncodedField definition : instanceFields) {
+ return traverseInstanceFields(holder, fn);
+ }
+
+ @Override
+ <BT, CT> TraversalContinuation<BT, CT> traverse(
+ DexClass holder,
+ BiFunction<? super DexClassAndField, ? super CT, TraversalContinuation<BT, CT>> fn,
+ CT initialValue) {
+ TraversalContinuation<BT, CT> traversalContinuation =
+ traverseStaticFields(holder, fn, initialValue);
+ if (traversalContinuation.shouldBreak()) {
+ return traversalContinuation;
+ }
+ return traverseInstanceFields(
+ holder, fn, traversalContinuation.asContinue().getValueOrDefault(null));
+ }
+
+ @Override
+ <BT, CT> TraversalContinuation<BT, CT> traverseInstanceFields(
+ DexClass holder, Function<? super DexClassAndField, TraversalContinuation<BT, CT>> fn) {
+ return traverseInstanceOrStaticFields(holder, instanceFields, fn);
+ }
+
+ @Override
+ <BT, CT> TraversalContinuation<BT, CT> traverseInstanceFields(
+ DexClass holder,
+ BiFunction<? super DexClassAndField, ? super CT, TraversalContinuation<BT, CT>> fn,
+ CT initialValue) {
+ return traverseInstanceOrStaticFields(holder, instanceFields, fn, initialValue);
+ }
+
+ @Override
+ <BT, CT> TraversalContinuation<BT, CT> traverseStaticFields(
+ DexClass holder, Function<? super DexClassAndField, TraversalContinuation<BT, CT>> fn) {
+ return traverseInstanceOrStaticFields(holder, staticFields, fn);
+ }
+
+ @Override
+ <BT, CT> TraversalContinuation<BT, CT> traverseStaticFields(
+ DexClass holder,
+ BiFunction<? super DexClassAndField, ? super CT, TraversalContinuation<BT, CT>> fn,
+ CT initialValue) {
+ return traverseInstanceOrStaticFields(holder, staticFields, fn, initialValue);
+ }
+
+ private static <BT, CT> TraversalContinuation<BT, CT> traverseInstanceOrStaticFields(
+ DexClass holder,
+ DexEncodedField[] fields,
+ Function<? super DexClassAndField, TraversalContinuation<BT, CT>> fn) {
+ TraversalContinuation<BT, CT> traversalContinuation = TraversalContinuation.doContinue();
+ for (DexEncodedField definition : fields) {
DexClassAndField field = DexClassAndField.create(holder, definition);
traversalContinuation = fn.apply(field);
if (traversalContinuation.shouldBreak()) {
@@ -90,21 +136,14 @@
return traversalContinuation;
}
- @Override
- <BT, CT> TraversalContinuation<BT, CT> traverse(
+ private static <BT, CT> TraversalContinuation<BT, CT> traverseInstanceOrStaticFields(
DexClass holder,
+ DexEncodedField[] fields,
BiFunction<? super DexClassAndField, ? super CT, TraversalContinuation<BT, CT>> fn,
CT initialValue) {
TraversalContinuation<BT, CT> traversalContinuation =
TraversalContinuation.doContinue(initialValue);
- for (DexEncodedField definition : staticFields) {
- DexClassAndField field = DexClassAndField.create(holder, definition);
- traversalContinuation = fn.apply(field, traversalContinuation.asContinue().getValue());
- if (traversalContinuation.shouldBreak()) {
- return traversalContinuation;
- }
- }
- for (DexEncodedField definition : instanceFields) {
+ for (DexEncodedField definition : fields) {
DexClassAndField field = DexClassAndField.create(holder, definition);
traversalContinuation = fn.apply(field, traversalContinuation.asContinue().getValue());
if (traversalContinuation.shouldBreak()) {
diff --git a/src/main/java/com/android/tools/r8/graph/FieldCollection.java b/src/main/java/com/android/tools/r8/graph/FieldCollection.java
index 729b238..9b3c09b 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldCollection.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldCollection.java
@@ -73,6 +73,28 @@
return backing.traverse(holder, fn, initialValue);
}
+ public <BT, CT> TraversalContinuation<BT, CT> traverseInstanceFields(
+ Function<? super DexClassAndField, TraversalContinuation<BT, CT>> fn) {
+ return backing.traverseInstanceFields(holder, fn);
+ }
+
+ public <BT, CT> TraversalContinuation<BT, CT> traverseInstanceFields(
+ BiFunction<? super DexClassAndField, ? super CT, TraversalContinuation<BT, CT>> fn,
+ CT initialValue) {
+ return backing.traverseInstanceFields(holder, fn, initialValue);
+ }
+
+ public <BT, CT> TraversalContinuation<BT, CT> traverseStaticFields(
+ Function<? super DexClassAndField, TraversalContinuation<BT, CT>> fn) {
+ return backing.traverseStaticFields(holder, fn);
+ }
+
+ public <BT, CT> TraversalContinuation<BT, CT> traverseStaticFields(
+ BiFunction<? super DexClassAndField, ? super CT, TraversalContinuation<BT, CT>> fn,
+ CT initialValue) {
+ return backing.traverseStaticFields(holder, fn, initialValue);
+ }
+
public boolean verify() {
forEachField(
field -> {
diff --git a/src/main/java/com/android/tools/r8/graph/FieldCollectionBacking.java b/src/main/java/com/android/tools/r8/graph/FieldCollectionBacking.java
index 522748e..cce38fd 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldCollectionBacking.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldCollectionBacking.java
@@ -34,6 +34,22 @@
BiFunction<? super DexClassAndField, ? super CT, TraversalContinuation<BT, CT>> fn,
CT initialValue);
+ abstract <BT, CT> TraversalContinuation<BT, CT> traverseInstanceFields(
+ DexClass holder, Function<? super DexClassAndField, TraversalContinuation<BT, CT>> fn);
+
+ abstract <BT, CT> TraversalContinuation<BT, CT> traverseInstanceFields(
+ DexClass holder,
+ BiFunction<? super DexClassAndField, ? super CT, TraversalContinuation<BT, CT>> fn,
+ CT initialValue);
+
+ abstract <BT, CT> TraversalContinuation<BT, CT> traverseStaticFields(
+ DexClass holder, Function<? super DexClassAndField, TraversalContinuation<BT, CT>> fn);
+
+ abstract <BT, CT> TraversalContinuation<BT, CT> traverseStaticFields(
+ DexClass holder,
+ BiFunction<? super DexClassAndField, ? super CT, TraversalContinuation<BT, CT>> fn,
+ CT initialValue);
+
// Collection methods.
abstract int size();
diff --git a/src/main/java/com/android/tools/r8/graph/FieldMapBacking.java b/src/main/java/com/android/tools/r8/graph/FieldMapBacking.java
index 6b74673..a6d9b57 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldMapBacking.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldMapBacking.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.graph;
+import static com.google.common.base.Predicates.alwaysTrue;
+
import com.android.tools.r8.utils.IterableUtils;
import com.android.tools.r8.utils.TraversalContinuation;
import it.unimi.dsi.fastutil.objects.Object2ReferenceLinkedOpenHashMap;
@@ -49,15 +51,7 @@
@Override
<BT, CT> TraversalContinuation<BT, CT> traverse(
DexClass holder, Function<? super DexClassAndField, TraversalContinuation<BT, CT>> fn) {
- TraversalContinuation<BT, CT> traversalContinuation = TraversalContinuation.doContinue();
- for (DexEncodedField definition : fieldMap.values()) {
- DexClassAndField field = DexClassAndField.create(holder, definition);
- traversalContinuation = fn.apply(field);
- if (traversalContinuation.shouldBreak()) {
- return traversalContinuation;
- }
- }
- return traversalContinuation;
+ return traverseFieldsThatMatches(holder, fn, alwaysTrue());
}
@Override
@@ -65,13 +59,68 @@
DexClass holder,
BiFunction<? super DexClassAndField, ? super CT, TraversalContinuation<BT, CT>> fn,
CT initialValue) {
+ return traverseFieldsThatMatches(holder, fn, alwaysTrue(), initialValue);
+ }
+
+ @Override
+ <BT, CT> TraversalContinuation<BT, CT> traverseInstanceFields(
+ DexClass holder, Function<? super DexClassAndField, TraversalContinuation<BT, CT>> fn) {
+ return traverseFieldsThatMatches(holder, fn, DexEncodedField::isInstance);
+ }
+
+ @Override
+ <BT, CT> TraversalContinuation<BT, CT> traverseInstanceFields(
+ DexClass holder,
+ BiFunction<? super DexClassAndField, ? super CT, TraversalContinuation<BT, CT>> fn,
+ CT initialValue) {
+ return traverseFieldsThatMatches(holder, fn, DexEncodedField::isInstance, initialValue);
+ }
+
+ @Override
+ <BT, CT> TraversalContinuation<BT, CT> traverseStaticFields(
+ DexClass holder, Function<? super DexClassAndField, TraversalContinuation<BT, CT>> fn) {
+ return traverseFieldsThatMatches(holder, fn, DexEncodedField::isStatic);
+ }
+
+ @Override
+ <BT, CT> TraversalContinuation<BT, CT> traverseStaticFields(
+ DexClass holder,
+ BiFunction<? super DexClassAndField, ? super CT, TraversalContinuation<BT, CT>> fn,
+ CT initialValue) {
+ return traverseFieldsThatMatches(holder, fn, DexEncodedField::isStatic, initialValue);
+ }
+
+ private <BT, CT> TraversalContinuation<BT, CT> traverseFieldsThatMatches(
+ DexClass holder,
+ Function<? super DexClassAndField, TraversalContinuation<BT, CT>> fn,
+ Predicate<? super DexEncodedField> predicate) {
+ TraversalContinuation<BT, CT> traversalContinuation = TraversalContinuation.doContinue();
+ for (DexEncodedField definition : fieldMap.values()) {
+ if (predicate.test(definition)) {
+ DexClassAndField field = DexClassAndField.create(holder, definition);
+ traversalContinuation = fn.apply(field);
+ if (traversalContinuation.shouldBreak()) {
+ return traversalContinuation;
+ }
+ }
+ }
+ return traversalContinuation;
+ }
+
+ private <BT, CT> TraversalContinuation<BT, CT> traverseFieldsThatMatches(
+ DexClass holder,
+ BiFunction<? super DexClassAndField, ? super CT, TraversalContinuation<BT, CT>> fn,
+ Predicate<? super DexEncodedField> predicate,
+ CT initialValue) {
TraversalContinuation<BT, CT> traversalContinuation =
TraversalContinuation.doContinue(initialValue);
for (DexEncodedField definition : fieldMap.values()) {
- DexClassAndField field = DexClassAndField.create(holder, definition);
- traversalContinuation = fn.apply(field, traversalContinuation.asContinue().getValue());
- if (traversalContinuation.shouldBreak()) {
- return traversalContinuation;
+ if (predicate.test(definition)) {
+ DexClassAndField field = DexClassAndField.create(holder, definition);
+ traversalContinuation = fn.apply(field, traversalContinuation.asContinue().getValue());
+ if (traversalContinuation.shouldBreak()) {
+ return traversalContinuation;
+ }
}
}
return traversalContinuation;
diff --git a/src/main/java/com/android/tools/r8/graph/fixup/TreeFixerBase.java b/src/main/java/com/android/tools/r8/graph/fixup/TreeFixerBase.java
index a84af1a..035ab26 100644
--- a/src/main/java/com/android/tools/r8/graph/fixup/TreeFixerBase.java
+++ b/src/main/java/com/android/tools/r8/graph/fixup/TreeFixerBase.java
@@ -28,6 +28,7 @@
import java.util.ArrayList;
import java.util.Collection;
import java.util.IdentityHashMap;
+import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
@@ -297,15 +298,23 @@
return permittedSubclassAttributes;
}
boolean changed = false;
- List<PermittedSubclassAttribute> newPermittedSubclassAttributes =
- new ArrayList<>(permittedSubclassAttributes.size());
+ LinkedHashSet<DexType> newPermittedSubclassTypes =
+ new LinkedHashSet<>(permittedSubclassAttributes.size());
for (PermittedSubclassAttribute permittedSubclassAttribute : permittedSubclassAttributes) {
- DexType permittedSubclassType = permittedSubclassAttribute.getPermittedSubclass();
- DexType newPermittedSubclassType = fixupType(permittedSubclassType);
- newPermittedSubclassAttributes.add(new PermittedSubclassAttribute(newPermittedSubclassType));
- changed |= newPermittedSubclassType != permittedSubclassType;
+ DexType permittedSubClassType = permittedSubclassAttribute.getPermittedSubclass();
+ DexType newPermittedSubClassType = fixupType(permittedSubClassType);
+ newPermittedSubclassTypes.add(newPermittedSubClassType);
+ changed |= newPermittedSubClassType != permittedSubClassType;
}
- return changed ? newPermittedSubclassAttributes : permittedSubclassAttributes;
+ if (!changed) {
+ return permittedSubclassAttributes;
+ }
+ List<PermittedSubclassAttribute> newPermittedSubclassAttributes =
+ new ArrayList<>(newPermittedSubclassTypes.size());
+ for (DexType newPermittedSubclassType : newPermittedSubclassTypes) {
+ newPermittedSubclassAttributes.add(new PermittedSubclassAttribute(newPermittedSubclassType));
+ }
+ return newPermittedSubclassAttributes;
}
protected List<RecordComponentInfo> fixupRecordComponents(
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerUtils.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerUtils.java
index bd83a89..6eecb7a 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerUtils.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/HorizontalClassMergerUtils.java
@@ -7,9 +7,14 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.ProgramField;
public class HorizontalClassMergerUtils {
+ public static boolean isClassIdField(AppView<?> appView, ProgramField field) {
+ return isClassIdField(appView, field.getDefinition());
+ }
+
public static boolean isClassIdField(AppView<?> appView, DexEncodedField field) {
DexField classIdField = appView.dexItemFactory().objectMembers.classIdField;
if (field.isD8R8Synthesized() && field.getType().isIntType()) {
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java
index 804b505..ee56cc7 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/TreeFixer.java
@@ -157,6 +157,8 @@
clazz.setInnerClasses(fixupInnerClassAttributes(clazz.getInnerClasses()));
clazz.setNestHostAttribute(fixupNestHost(clazz.getNestHostClassAttribute()));
clazz.setNestMemberAttributes(fixupNestMemberAttributes(clazz.getNestMembersClassAttributes()));
+ clazz.setPermittedSubclassAttributes(
+ fixupPermittedSubclassAttribute(clazz.getPermittedSubclassAttributes()));
}
private void fixupProgramClassSuperTypes(DexProgramClass clazz) {
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/constant/SparseConditionalConstantPropagation.java b/src/main/java/com/android/tools/r8/ir/analysis/constant/SparseConditionalConstantPropagation.java
index ec226d9..9676db7 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/constant/SparseConditionalConstantPropagation.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/constant/SparseConditionalConstantPropagation.java
@@ -19,6 +19,7 @@
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.conversion.passes.CodeRewriterPass;
import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
+import com.android.tools.r8.utils.BooleanBox;
import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.BitSet;
@@ -36,24 +37,8 @@
*/
public class SparseConditionalConstantPropagation extends CodeRewriterPass<AppInfo> {
- private final IRCode code;
- private final Map<Value, LatticeElement> mapping = new HashMap<>();
- // TODO(b/270398965): Replace LinkedList.
- @SuppressWarnings("JdkObsolete")
- private final Deque<Value> ssaEdges = new LinkedList<>();
- // TODO(b/270398965): Replace LinkedList.
- @SuppressWarnings("JdkObsolete")
- private final Deque<BasicBlock> flowEdges = new LinkedList<>();
-
- private final BitSet[] executableFlowEdges;
- private final BitSet visitedBlocks;
-
- public SparseConditionalConstantPropagation(AppView<?> appView, IRCode code) {
+ public SparseConditionalConstantPropagation(AppView<?> appView) {
super(appView);
- this.code = code;
- int maxBlockNumber = code.getCurrentBlockNumber() + 1;
- executableFlowEdges = new BitSet[maxBlockNumber];
- visitedBlocks = new BitSet(maxBlockNumber);
}
@Override
@@ -68,220 +53,255 @@
@Override
protected CodeRewriterResult rewriteCode(IRCode code) {
- BasicBlock firstBlock = code.entryBlock();
- visitInstructions(firstBlock);
+ return new SparseConditionalConstantPropagationOnCode(code).run();
+ }
- while (!flowEdges.isEmpty() || !ssaEdges.isEmpty()) {
- while (!flowEdges.isEmpty()) {
- BasicBlock block = flowEdges.poll();
- for (Phi phi : block.getPhis()) {
- visitPhi(phi);
+ private class SparseConditionalConstantPropagationOnCode {
+
+ private final IRCode code;
+ private final Map<Value, LatticeElement> mapping = new HashMap<>();
+
+ // TODO(b/270398965): Replace LinkedList.
+ @SuppressWarnings("JdkObsolete")
+ private final Deque<Value> ssaEdges = new LinkedList<>();
+
+ // TODO(b/270398965): Replace LinkedList.
+ @SuppressWarnings("JdkObsolete")
+ private final Deque<BasicBlock> flowEdges = new LinkedList<>();
+
+ private final BitSet[] executableFlowEdges;
+ private final BitSet visitedBlocks;
+
+ private SparseConditionalConstantPropagationOnCode(IRCode code) {
+ this.code = code;
+ int maxBlockNumber = code.getCurrentBlockNumber() + 1;
+ executableFlowEdges = new BitSet[maxBlockNumber];
+ visitedBlocks = new BitSet(maxBlockNumber);
+ }
+
+ protected CodeRewriterResult run() {
+ BasicBlock firstBlock = code.entryBlock();
+ visitInstructions(firstBlock);
+
+ while (!flowEdges.isEmpty() || !ssaEdges.isEmpty()) {
+ while (!flowEdges.isEmpty()) {
+ BasicBlock block = flowEdges.poll();
+ for (Phi phi : block.getPhis()) {
+ visitPhi(phi);
+ }
+ if (!visitedBlocks.get(block.getNumber())) {
+ visitInstructions(block);
+ }
}
- if (!visitedBlocks.get(block.getNumber())) {
- visitInstructions(block);
- }
- }
- while (!ssaEdges.isEmpty()) {
- Value value = ssaEdges.poll();
- for (Phi phi : value.uniquePhiUsers()) {
- visitPhi(phi);
- }
- for (Instruction user : value.uniqueUsers()) {
- BasicBlock userBlock = user.getBlock();
- if (visitedBlocks.get(userBlock.getNumber())) {
- visitInstruction(user);
+ while (!ssaEdges.isEmpty()) {
+ Value value = ssaEdges.poll();
+ for (Phi phi : value.uniquePhiUsers()) {
+ visitPhi(phi);
+ }
+ for (Instruction user : value.uniqueUsers()) {
+ BasicBlock userBlock = user.getBlock();
+ if (visitedBlocks.get(userBlock.getNumber())) {
+ visitInstruction(user);
+ }
}
}
}
+ boolean hasChanged = rewriteConstants();
+ assert code.isConsistentSSA(appView);
+ return CodeRewriterResult.hasChanged(hasChanged);
}
- rewriteConstants();
- assert code.isConsistentSSA(appView);
- return CodeRewriterResult.NONE;
- }
- private void rewriteConstants() {
- Set<Value> affectedValues = Sets.newIdentityHashSet();
- List<BasicBlock> blockToAnalyze = new ArrayList<>();
- mapping.entrySet().stream()
- .filter(entry -> entry.getValue().isConst())
- .forEach(
- entry -> {
- Value value = entry.getKey();
- ConstNumber evaluatedConst = entry.getValue().asConst().getConstNumber();
- if (value.definition != evaluatedConst) {
- value.addAffectedValuesTo(affectedValues);
- if (value.isPhi()) {
- // D8 relies on dead code removal to get rid of the dead phi itself.
- if (value.hasAnyUsers()) {
- BasicBlock block = value.asPhi().getBlock();
- blockToAnalyze.add(block);
- // Create a new constant, because it can be an existing constant that flow
- // directly
- // into the phi.
- ConstNumber newConst = ConstNumber.copyOf(code, evaluatedConst);
- InstructionListIterator iterator = block.listIterator(code);
- Instruction inst = iterator.nextUntil(i -> !i.isMoveException());
- newConst.setPosition(inst.getPosition());
- if (!inst.isDebugPosition()) {
- iterator.previous();
+ private boolean rewriteConstants() {
+ Set<Value> affectedValues = Sets.newIdentityHashSet();
+ List<BasicBlock> blockToAnalyze = new ArrayList<>();
+ BooleanBox hasChanged = new BooleanBox(false);
+ mapping.entrySet().stream()
+ .filter(entry -> entry.getValue().isConst())
+ .forEach(
+ entry -> {
+ Value value = entry.getKey();
+ ConstNumber evaluatedConst = entry.getValue().asConst().getConstNumber();
+ if (value.definition != evaluatedConst) {
+ value.addAffectedValuesTo(affectedValues);
+ if (value.isPhi()) {
+ // D8 relies on dead code removal to get rid of the dead phi itself.
+ if (value.hasAnyUsers()) {
+ BasicBlock block = value.asPhi().getBlock();
+ blockToAnalyze.add(block);
+ // Create a new constant, because it can be an existing constant that flow
+ // directly
+ // into the phi.
+ ConstNumber newConst = ConstNumber.copyOf(code, evaluatedConst);
+ InstructionListIterator iterator = block.listIterator(code);
+ Instruction inst = iterator.nextUntil(i -> !i.isMoveException());
+ newConst.setPosition(inst.getPosition());
+ if (!inst.isDebugPosition()) {
+ iterator.previous();
+ }
+ iterator.add(newConst);
+ value.replaceUsers(newConst.outValue());
+ hasChanged.set();
}
- iterator.add(newConst);
- value.replaceUsers(newConst.outValue());
+ } else {
+ BasicBlock block = value.definition.getBlock();
+ InstructionListIterator iterator = block.listIterator(code);
+ iterator.nextUntil(i -> i == value.definition);
+ iterator.replaceCurrentInstruction(evaluatedConst);
+ hasChanged.set();
}
- } else {
- BasicBlock block = value.definition.getBlock();
- InstructionListIterator iterator = block.listIterator(code);
- iterator.nextUntil(i -> i == value.definition);
- iterator.replaceCurrentInstruction(evaluatedConst);
}
- }
- });
- for (BasicBlock block : blockToAnalyze) {
- block.deduplicatePhis();
+ });
+ for (BasicBlock block : blockToAnalyze) {
+ block.deduplicatePhis();
+ }
+ if (!affectedValues.isEmpty()) {
+ new TypeAnalysis(appView).narrowing(affectedValues);
+ }
+ boolean changed = hasChanged.get();
+ if (changed) {
+ code.removeAllDeadAndTrivialPhis();
+ code.removeRedundantBlocks();
+ }
+ return changed;
}
- if (!affectedValues.isEmpty()) {
- new TypeAnalysis(appView).narrowing(affectedValues);
+
+ private LatticeElement getLatticeElement(Value value) {
+ return mapping.getOrDefault(value, Top.getInstance());
}
- code.removeAllDeadAndTrivialPhis();
- code.removeRedundantBlocks();
- }
- private LatticeElement getLatticeElement(Value value) {
- return mapping.getOrDefault(value, Top.getInstance());
- }
+ private void setLatticeElement(Value value, LatticeElement element) {
+ mapping.put(value, element);
+ }
- private void setLatticeElement(Value value, LatticeElement element) {
- mapping.put(value, element);
- }
-
- private void visitPhi(Phi phi) {
- BasicBlock phiBlock = phi.getBlock();
- int phiBlockNumber = phiBlock.getNumber();
- LatticeElement element = Top.getInstance();
- List<BasicBlock> predecessors = phiBlock.getPredecessors();
- int size = predecessors.size();
- for (int i = 0; i < size; i++) {
- BasicBlock predecessor = predecessors.get(i);
- if (isExecutableEdge(predecessor.getNumber(), phiBlockNumber)) {
- element = element.meet(getLatticeElement(phi.getOperand(i)));
- // bottom lattice can no longer be changed, thus no need to continue
- if (element.isBottom()) {
- break;
+ private void visitPhi(Phi phi) {
+ BasicBlock phiBlock = phi.getBlock();
+ int phiBlockNumber = phiBlock.getNumber();
+ LatticeElement element = Top.getInstance();
+ List<BasicBlock> predecessors = phiBlock.getPredecessors();
+ int size = predecessors.size();
+ for (int i = 0; i < size; i++) {
+ BasicBlock predecessor = predecessors.get(i);
+ if (isExecutableEdge(predecessor.getNumber(), phiBlockNumber)) {
+ element = element.meet(getLatticeElement(phi.getOperand(i)));
+ // bottom lattice can no longer be changed, thus no need to continue
+ if (element.isBottom()) {
+ break;
+ }
+ }
+ }
+ if (!element.isTop()) {
+ LatticeElement currentPhiElement = getLatticeElement(phi);
+ if (currentPhiElement.meet(element) != currentPhiElement) {
+ ssaEdges.add(phi);
+ setLatticeElement(phi, element);
}
}
}
- if (!element.isTop()) {
- LatticeElement currentPhiElement = getLatticeElement(phi);
- if (currentPhiElement.meet(element) != currentPhiElement) {
- ssaEdges.add(phi);
- setLatticeElement(phi, element);
+
+ private void visitInstructions(BasicBlock block) {
+ for (Instruction instruction : block.getInstructions()) {
+ visitInstruction(instruction);
+ }
+ visitedBlocks.set(block.getNumber());
+ }
+
+ private void visitInstruction(Instruction instruction) {
+ if (instruction.outValue() != null && !instruction.isDebugLocalUninitialized()) {
+ LatticeElement element = instruction.evaluate(code, this::getLatticeElement);
+ LatticeElement currentLattice = getLatticeElement(instruction.outValue());
+ if (currentLattice.meet(element) != currentLattice) {
+ setLatticeElement(instruction.outValue(), element);
+ ssaEdges.add(instruction.outValue());
+ }
+ }
+ if (instruction.isJumpInstruction()) {
+ addFlowEdgesForJumpInstruction(instruction.asJumpInstruction());
}
}
- }
- private void visitInstructions(BasicBlock block) {
- for (Instruction instruction : block.getInstructions()) {
- visitInstruction(instruction);
- }
- visitedBlocks.set(block.getNumber());
- }
-
- private void visitInstruction(Instruction instruction) {
- if (instruction.outValue() != null && !instruction.isDebugLocalUninitialized()) {
- LatticeElement element = instruction.evaluate(code, this::getLatticeElement);
- LatticeElement currentLattice = getLatticeElement(instruction.outValue());
- if (currentLattice.meet(element) != currentLattice) {
- setLatticeElement(instruction.outValue(), element);
- ssaEdges.add(instruction.outValue());
- }
- }
- if (instruction.isJumpInstruction()) {
- addFlowEdgesForJumpInstruction(instruction.asJumpInstruction());
- }
- }
-
- private void addFlowEdgesForJumpInstruction(JumpInstruction jumpInstruction) {
- BasicBlock jumpInstBlock = jumpInstruction.getBlock();
- int jumpInstBlockNumber = jumpInstBlock.getNumber();
- if (jumpInstruction.isIf()) {
- If theIf = jumpInstruction.asIf();
- if (theIf.isZeroTest()) {
- LatticeElement element = getLatticeElement(theIf.inValues().get(0));
- if (element.isConst()) {
- BasicBlock target = theIf.targetFromCondition(element.asConst().getConstNumber());
- if (!isExecutableEdge(jumpInstBlockNumber, target.getNumber())) {
- setExecutableEdge(jumpInstBlockNumber, target.getNumber());
- flowEdges.add(target);
+ private void addFlowEdgesForJumpInstruction(JumpInstruction jumpInstruction) {
+ BasicBlock jumpInstBlock = jumpInstruction.getBlock();
+ int jumpInstBlockNumber = jumpInstBlock.getNumber();
+ if (jumpInstruction.isIf()) {
+ If theIf = jumpInstruction.asIf();
+ if (theIf.isZeroTest()) {
+ LatticeElement element = getLatticeElement(theIf.inValues().get(0));
+ if (element.isConst()) {
+ BasicBlock target = theIf.targetFromCondition(element.asConst().getConstNumber());
+ if (!isExecutableEdge(jumpInstBlockNumber, target.getNumber())) {
+ setExecutableEdge(jumpInstBlockNumber, target.getNumber());
+ flowEdges.add(target);
+ }
+ return;
}
+ } else {
+ LatticeElement leftElement = getLatticeElement(theIf.inValues().get(0));
+ LatticeElement rightElement = getLatticeElement(theIf.inValues().get(1));
+ if (leftElement.isConst() && rightElement.isConst()) {
+ ConstNumber leftNumber = leftElement.asConst().getConstNumber();
+ ConstNumber rightNumber = rightElement.asConst().getConstNumber();
+ BasicBlock target = theIf.targetFromCondition(leftNumber, rightNumber);
+ if (!isExecutableEdge(jumpInstBlockNumber, target.getNumber())) {
+ setExecutableEdge(jumpInstBlockNumber, target.getNumber());
+ flowEdges.add(target);
+ }
+ return;
+ }
+ assert !leftElement.isTop();
+ assert !rightElement.isTop();
+ }
+ } else if (jumpInstruction.isIntSwitch()) {
+ IntSwitch switchInst = jumpInstruction.asIntSwitch();
+ LatticeElement switchElement = getLatticeElement(switchInst.value());
+ if (switchElement.isConst()) {
+ BasicBlock target =
+ switchInst.getKeyToTargetMap().get(switchElement.asConst().getIntValue());
+ if (target == null) {
+ target = switchInst.fallthroughBlock();
+ }
+ assert target != null;
+ setExecutableEdge(jumpInstBlockNumber, target.getNumber());
+ flowEdges.add(target);
+ return;
+ }
+ } else if (jumpInstruction.isStringSwitch()) {
+ StringSwitch switchInst = jumpInstruction.asStringSwitch();
+ LatticeElement switchElement = getLatticeElement(switchInst.value());
+ if (switchElement.isConst()) {
+ // There is currently no constant propagation for strings, so it must be null.
+ assert switchElement.asConst().getConstNumber().isZero();
+ BasicBlock target = switchInst.fallthroughBlock();
+ setExecutableEdge(jumpInstBlockNumber, target.getNumber());
+ flowEdges.add(target);
return;
}
} else {
- LatticeElement leftElement = getLatticeElement(theIf.inValues().get(0));
- LatticeElement rightElement = getLatticeElement(theIf.inValues().get(1));
- if (leftElement.isConst() && rightElement.isConst()) {
- ConstNumber leftNumber = leftElement.asConst().getConstNumber();
- ConstNumber rightNumber = rightElement.asConst().getConstNumber();
- BasicBlock target = theIf.targetFromCondition(leftNumber, rightNumber);
- if (!isExecutableEdge(jumpInstBlockNumber, target.getNumber())) {
- setExecutableEdge(jumpInstBlockNumber, target.getNumber());
- flowEdges.add(target);
- }
- return;
+ assert jumpInstruction.isGoto() || jumpInstruction.isReturn() || jumpInstruction.isThrow();
+ }
+
+ for (BasicBlock dst : jumpInstBlock.getSuccessors()) {
+ if (!isExecutableEdge(jumpInstBlockNumber, dst.getNumber())) {
+ setExecutableEdge(jumpInstBlockNumber, dst.getNumber());
+ flowEdges.add(dst);
}
- assert !leftElement.isTop();
- assert !rightElement.isTop();
}
- } else if (jumpInstruction.isIntSwitch()) {
- IntSwitch switchInst = jumpInstruction.asIntSwitch();
- LatticeElement switchElement = getLatticeElement(switchInst.value());
- if (switchElement.isConst()) {
- BasicBlock target = switchInst.getKeyToTargetMap()
- .get(switchElement.asConst().getIntValue());
- if (target == null) {
- target = switchInst.fallthroughBlock();
- }
- assert target != null;
- setExecutableEdge(jumpInstBlockNumber, target.getNumber());
- flowEdges.add(target);
- return;
- }
- } else if (jumpInstruction.isStringSwitch()) {
- StringSwitch switchInst = jumpInstruction.asStringSwitch();
- LatticeElement switchElement = getLatticeElement(switchInst.value());
- if (switchElement.isConst()) {
- // There is currently no constant propagation for strings, so it must be null.
- assert switchElement.asConst().getConstNumber().isZero();
- BasicBlock target = switchInst.fallthroughBlock();
- setExecutableEdge(jumpInstBlockNumber, target.getNumber());
- flowEdges.add(target);
- return;
- }
- } else {
- assert jumpInstruction.isGoto() || jumpInstruction.isReturn() || jumpInstruction.isThrow();
}
- for (BasicBlock dst : jumpInstBlock.getSuccessors()) {
- if (!isExecutableEdge(jumpInstBlockNumber, dst.getNumber())) {
- setExecutableEdge(jumpInstBlockNumber, dst.getNumber());
- flowEdges.add(dst);
+ private void setExecutableEdge(int from, int to) {
+ BitSet previousExecutable = executableFlowEdges[to];
+ if (previousExecutable == null) {
+ previousExecutable = new BitSet(executableFlowEdges.length);
+ executableFlowEdges[to] = previousExecutable;
}
+ previousExecutable.set(from);
}
- }
- private void setExecutableEdge(int from, int to) {
- BitSet previousExecutable = executableFlowEdges[to];
- if (previousExecutable == null) {
- previousExecutable = new BitSet(executableFlowEdges.length);
- executableFlowEdges[to] = previousExecutable;
+ private boolean isExecutableEdge(int from, int to) {
+ BitSet previousExecutable = executableFlowEdges[to];
+ if (previousExecutable == null) {
+ return false;
+ }
+ return previousExecutable.get(from);
}
- previousExecutable.set(from);
- }
-
- private boolean isExecutableEdge(int from, int to) {
- BitSet previousExecutable = executableFlowEdges[to];
- if (previousExecutable == null) {
- return false;
- }
- return previousExecutable.get(from);
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java
index d871616..e6ac132 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAccessAnalysis.java
@@ -85,7 +85,7 @@
appView.appInfo().resolveField(fieldInstruction.getField()).getProgramField();
if (field != null) {
if (fieldAssignmentTracker != null) {
- fieldAssignmentTracker.recordFieldAccess(fieldInstruction, field, code.context());
+ fieldAssignmentTracker.recordFieldAccess(fieldInstruction, field);
}
if (fieldBitAccessAnalysis != null) {
fieldBitAccessAnalysis.recordFieldAccess(
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java
index 0781787..0f47d7e 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/FieldAssignmentTracker.java
@@ -45,12 +45,13 @@
import com.android.tools.r8.optimize.argumentpropagation.utils.WideningUtils;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.shaking.KeepFieldInfo;
+import com.android.tools.r8.utils.TraversalContinuation;
+import com.android.tools.r8.utils.collections.ProgramFieldMap;
import com.android.tools.r8.utils.collections.ProgramMethodSet;
import it.unimi.dsi.fastutil.objects.Reference2IntMap;
import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
import java.util.ArrayList;
import java.util.IdentityHashMap;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@@ -76,7 +77,7 @@
// has been seen to the field.
private final Map<DexEncodedField, FieldState> fieldStates = new ConcurrentHashMap<>();
- private final Map<DexProgramClass, Map<DexEncodedField, AbstractValue>>
+ private final Map<DexProgramClass, ProgramFieldMap<AbstractValue>>
abstractFinalInstanceFieldValues = new ConcurrentHashMap<>();
FieldAssignmentTracker(AppView<AppInfoWithLiveness> appView) {
@@ -116,15 +117,14 @@
// No instance fields to track.
return;
}
- Map<DexEncodedField, AbstractValue> abstractFinalInstanceFieldValuesForClass =
- new IdentityHashMap<>();
+ ProgramFieldMap<AbstractValue> abstractFinalInstanceFieldValuesForClass =
+ ProgramFieldMap.create();
clazz.forEachProgramInstanceField(
field -> {
if (field.isFinalOrEffectivelyFinal(appView)) {
FieldAccessInfo fieldAccessInfo = fieldAccessInfos.get(field.getReference());
if (fieldAccessInfo != null && !fieldAccessInfo.hasReflectiveAccess()) {
- abstractFinalInstanceFieldValuesForClass.put(
- field.getDefinition(), BottomValue.getInstance());
+ abstractFinalInstanceFieldValuesForClass.put(field, BottomValue.getInstance());
}
}
});
@@ -185,13 +185,13 @@
});
}
- void recordFieldAccess(FieldInstruction instruction, ProgramField field, ProgramMethod context) {
+ void recordFieldAccess(FieldInstruction instruction, ProgramField field) {
if (instruction.isFieldPut()) {
- recordFieldPut(field, instruction.value(), context);
+ recordFieldPut(field, instruction.value());
}
}
- private void recordFieldPut(ProgramField field, Value value, ProgramMethod context) {
+ private void recordFieldPut(ProgramField field, Value value) {
// For now only attempt to prove that fields are definitely null. In order to prove a single
// value for fields that are not definitely null, we need to prove that the given field is never
// read before it is written.
@@ -225,12 +225,12 @@
if (fieldState.isArray()) {
ConcreteArrayTypeFieldState arrayFieldState = fieldState.asArray();
- return arrayFieldState.mutableJoin(appView, abstractValue);
+ return arrayFieldState.mutableJoin(appView, field, abstractValue);
}
if (fieldState.isPrimitive()) {
ConcretePrimitiveTypeFieldState primitiveFieldState = fieldState.asPrimitive();
- return primitiveFieldState.mutableJoin(abstractValue, abstractValueFactory);
+ return primitiveFieldState.mutableJoin(appView, field, abstractValue);
}
assert fieldState.isClass();
@@ -242,7 +242,7 @@
}
void recordAllocationSite(NewInstance instruction, DexProgramClass clazz, ProgramMethod context) {
- Map<DexEncodedField, AbstractValue> abstractInstanceFieldValuesForClass =
+ ProgramFieldMap<AbstractValue> abstractInstanceFieldValuesForClass =
abstractFinalInstanceFieldValues.get(clazz);
if (abstractInstanceFieldValuesForClass == null) {
// We are not tracking the value of any of clazz' instance fields.
@@ -273,75 +273,59 @@
// Synchronize on the lattice element (abstractInstanceFieldValuesForClass) in case we process
// another allocation site of `clazz` concurrently.
synchronized (abstractInstanceFieldValuesForClass) {
- Iterator<Map.Entry<DexEncodedField, AbstractValue>> iterator =
- abstractInstanceFieldValuesForClass.entrySet().iterator();
- while (iterator.hasNext()) {
- Map.Entry<DexEncodedField, AbstractValue> entry = iterator.next();
- DexEncodedField field = entry.getKey();
- AbstractValue abstractValue = entry.getValue();
-
- // The power set lattice is an expensive abstraction, so use it with caution.
- boolean isClassIdField = HorizontalClassMergerUtils.isClassIdField(appView, field);
-
- InstanceFieldInitializationInfo initializationInfo =
- initializationInfoCollection.get(field);
- if (initializationInfo.isArgumentInitializationInfo()) {
- InstanceFieldArgumentInitializationInfo argumentInitializationInfo =
- initializationInfo.asArgumentInitializationInfo();
- Value argument = invoke.arguments().get(argumentInitializationInfo.getArgumentIndex());
- AbstractValue argumentAbstractValue = argument.getAbstractValue(appView, context);
- abstractValue =
- abstractValue.join(
- argumentAbstractValue,
- appView.abstractValueFactory(),
- field.getType().isReferenceType(),
- isClassIdField);
- assert !abstractValue.isBottom();
- } else if (initializationInfo.isSingleValue()) {
- SingleValue singleValueInitializationInfo = initializationInfo.asSingleValue();
- abstractValue =
- abstractValue.join(
- singleValueInitializationInfo,
- appView.abstractValueFactory(),
- field.getType().isReferenceType(),
- isClassIdField);
- } else if (initializationInfo.isTypeInitializationInfo()) {
- // TODO(b/149732532): Not handled, for now.
- abstractValue = UnknownValue.getInstance();
- } else {
- assert initializationInfo.isUnknown();
- abstractValue = UnknownValue.getInstance();
- }
-
- assert !abstractValue.isBottom();
-
- // When approximating the possible values for the $r8$classId fields from horizontal class
- // merging, give up if the set of possible values equals the size of the merge group. In
- // this case, the information is useless.
- if (isClassIdField && abstractValue.isNonConstantNumberValue()) {
- NonConstantNumberValue initialAbstractValue =
- field.getOptimizationInfo().getAbstractValue().asNonConstantNumberValue();
- if (initialAbstractValue != null) {
- if (abstractValue.asNonConstantNumberValue().getAbstractionSize()
- >= initialAbstractValue.getAbstractionSize()) {
+ abstractInstanceFieldValuesForClass.removeIf(
+ (field, abstractValue, entry) -> {
+ InstanceFieldInitializationInfo initializationInfo =
+ initializationInfoCollection.get(field);
+ if (initializationInfo.isArgumentInitializationInfo()) {
+ InstanceFieldArgumentInitializationInfo argumentInitializationInfo =
+ initializationInfo.asArgumentInitializationInfo();
+ Value argument =
+ invoke.arguments().get(argumentInitializationInfo.getArgumentIndex());
+ AbstractValue argumentAbstractValue = argument.getAbstractValue(appView, context);
+ abstractValue =
+ appView
+ .getAbstractValueFieldJoiner()
+ .join(abstractValue, argumentAbstractValue, field);
+ } else if (initializationInfo.isSingleValue()) {
+ SingleValue singleValueInitializationInfo = initializationInfo.asSingleValue();
+ abstractValue =
+ appView
+ .getAbstractValueFieldJoiner()
+ .join(abstractValue, singleValueInitializationInfo, field);
+ } else if (initializationInfo.isTypeInitializationInfo()) {
+ // TODO(b/149732532): Not handled, for now.
+ abstractValue = UnknownValue.getInstance();
+ } else {
+ assert initializationInfo.isUnknown();
abstractValue = UnknownValue.getInstance();
}
- }
- }
- if (!abstractValue.isUnknown()) {
- entry.setValue(abstractValue);
- continue;
- }
+ assert !abstractValue.isBottom();
- // We just lost track for this field.
- iterator.remove();
- }
+ // When approximating the possible values for the $r8$classId fields from horizontal
+ // class
+ // merging, give up if the set of possible values equals the size of the merge group. In
+ // this case, the information is useless.
+ if (abstractValue.isNonConstantNumberValue()) {
+ assert HorizontalClassMergerUtils.isClassIdField(appView, field);
+ NonConstantNumberValue initialAbstractValue =
+ field.getOptimizationInfo().getAbstractValue().asNonConstantNumberValue();
+ if (initialAbstractValue != null
+ && abstractValue.asNonConstantNumberValue().getAbstractionSize()
+ >= initialAbstractValue.getAbstractionSize()) {
+ abstractValue = UnknownValue.getInstance();
+ }
+ }
+
+ entry.setValue(abstractValue);
+ return abstractValue.isUnknown();
+ });
}
}
private void recordAllFieldPutsProcessed(
- ProgramField field, ProgramMethod context, OptimizationFeedbackDelayed feedback) {
+ ProgramField field, OptimizationFeedbackDelayed feedback) {
FieldState fieldState = fieldStates.getOrDefault(field.getDefinition(), FieldState.bottom());
AbstractValue abstractValue = fieldState.getAbstractValue(appView.abstractValueFactory());
if (abstractValue.isNonTrivial()) {
@@ -384,10 +368,9 @@
.get(field);
if (fieldInitializationInfo.isSingleValue()) {
abstractValue =
- abstractValue.join(
- fieldInitializationInfo.asSingleValue(),
- appView.abstractValueFactory(),
- field.getType());
+ appView
+ .getAbstractValueFieldJoiner()
+ .join(abstractValue, fieldInitializationInfo.asSingleValue(), field);
if (abstractValue.isUnknown()) {
break;
}
@@ -413,24 +396,25 @@
private void recordAllAllocationsSitesProcessed(
DexProgramClass clazz, OptimizationFeedbackDelayed feedback) {
- Map<DexEncodedField, AbstractValue> abstractInstanceFieldValuesForClass =
+ ProgramFieldMap<AbstractValue> abstractInstanceFieldValuesForClass =
abstractFinalInstanceFieldValues.get(clazz);
if (abstractInstanceFieldValuesForClass == null) {
return;
}
- for (DexEncodedField field : clazz.instanceFields()) {
- AbstractValue abstractValue =
- abstractInstanceFieldValuesForClass.getOrDefault(field, UnknownValue.getInstance());
- if (abstractValue.isBottom()) {
- feedback.modifyAppInfoWithLiveness(modifier -> modifier.removeInstantiatedType(clazz));
- break;
- }
- if (abstractValue.isUnknown()) {
- continue;
- }
- feedback.recordFieldHasAbstractValue(field, appView, abstractValue);
- }
+ clazz.traverseProgramInstanceFields(
+ field -> {
+ AbstractValue abstractValue =
+ abstractInstanceFieldValuesForClass.getOrDefault(field, UnknownValue.getInstance());
+ if (abstractValue.isBottom()) {
+ feedback.modifyAppInfoWithLiveness(modifier -> modifier.removeInstantiatedType(clazz));
+ return TraversalContinuation.doBreak();
+ }
+ if (abstractValue.isNonTrivial()) {
+ feedback.recordFieldHasAbstractValue(field, appView, abstractValue);
+ }
+ return TraversalContinuation.doContinue();
+ });
}
public void waveDone(ProgramMethodSet wave, OptimizationFeedbackDelayed feedback) {
@@ -438,8 +422,7 @@
// therefore important that the optimization info has been flushed in advance.
assert feedback.noUpdatesLeft();
for (ProgramMethod method : wave) {
- fieldAccessGraph.markProcessed(
- method, field -> recordAllFieldPutsProcessed(field, method, feedback));
+ fieldAccessGraph.markProcessed(method, field -> recordAllFieldPutsProcessed(field, feedback));
objectAllocationGraph.markProcessed(
method, clazz -> recordAllAllocationsSitesProcessed(clazz, feedback));
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteArrayTypeFieldState.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteArrayTypeFieldState.java
index 1b82558..fef8935 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteArrayTypeFieldState.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteArrayTypeFieldState.java
@@ -5,6 +5,7 @@
package com.android.tools.r8.ir.analysis.fieldaccess.state;
import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.ProgramField;
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
@@ -36,9 +37,10 @@
return this;
}
- public FieldState mutableJoin(AppView<AppInfoWithLiveness> appView, AbstractValue abstractValue) {
+ public FieldState mutableJoin(
+ AppView<AppInfoWithLiveness> appView, ProgramField field, AbstractValue abstractValue) {
this.abstractValue =
- this.abstractValue.joinReference(abstractValue, appView.abstractValueFactory());
+ appView.getAbstractValueFieldJoiner().join(this.abstractValue, abstractValue, field);
return isEffectivelyUnknown() ? unknown() : this;
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteClassTypeFieldState.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteClassTypeFieldState.java
index 3f51c25..a323ba6 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteClassTypeFieldState.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcreteClassTypeFieldState.java
@@ -48,7 +48,7 @@
ProgramField field) {
assert field.getType().isClassType();
this.abstractValue =
- this.abstractValue.joinReference(abstractValue, appView.abstractValueFactory());
+ appView.getAbstractValueFieldJoiner().join(this.abstractValue, abstractValue, field);
this.dynamicType =
WideningUtils.widenDynamicNonReceiverType(
appView, this.dynamicType.join(appView, dynamicType), field.getType());
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcretePrimitiveTypeFieldState.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcretePrimitiveTypeFieldState.java
index c2eb778..1f329f5 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcretePrimitiveTypeFieldState.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldaccess/state/ConcretePrimitiveTypeFieldState.java
@@ -4,8 +4,11 @@
package com.android.tools.r8.ir.analysis.fieldaccess.state;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.ProgramField;
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
/** The information that we track for fields whose type is a primitive type. */
public class ConcretePrimitiveTypeFieldState extends ConcreteFieldState {
@@ -38,11 +41,12 @@
}
public FieldState mutableJoin(
- AbstractValue abstractValue, AbstractValueFactory abstractValueFactory) {
+ AppView<AppInfoWithLiveness> appView, ProgramField field, AbstractValue abstractValue) {
if (abstractValue.isUnknown()) {
return FieldState.unknown();
}
- this.abstractValue = this.abstractValue.joinPrimitive(abstractValue, abstractValueFactory);
+ this.abstractValue =
+ appView.getAbstractValueFieldJoiner().join(this.abstractValue, abstractValue, field);
return isEffectivelyUnknown() ? unknown() : this;
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java
index c4e0a83..f657c65 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValue.java
@@ -5,7 +5,6 @@
package com.android.tools.r8.ir.analysis.value;
import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.lens.GraphLens;
import com.android.tools.r8.ir.analysis.value.objectstate.ObjectState;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
@@ -75,6 +74,10 @@
return null;
}
+ public boolean hasDefinitelySetAndUnsetBitsInformation() {
+ return false;
+ }
+
public boolean hasKnownArrayLength() {
return false;
}
@@ -176,71 +179,12 @@
return null;
}
- public AbstractValue join(AbstractValue other, AbstractValueFactory factory, DexType type) {
- return join(other, factory, type.isReferenceType(), false);
+ public boolean isDefiniteBitsNumberValue() {
+ return false;
}
- public AbstractValue joinPrimitive(AbstractValue other, AbstractValueFactory factory) {
- return join(other, factory, false, false);
- }
-
- public AbstractValue joinReference(AbstractValue other, AbstractValueFactory factory) {
- return join(other, factory, true, false);
- }
-
- // TODO(b/196321452): Clean this up, in particular, replace the "allow" parameters by a
- // configuration object.
- public AbstractValue join(
- AbstractValue other,
- AbstractValueFactory factory,
- boolean allowNullOrAbstractValue,
- boolean allowNonConstantNumbers) {
- if (isBottom() || other.isUnknown()) {
- return other;
- }
- if (isUnknown() || other.isBottom()) {
- return this;
- }
- if (equals(other)) {
- return this;
- }
- if (allowNullOrAbstractValue) {
- if (isNull()) {
- return NullOrAbstractValue.create(other);
- }
- if (other.isNull()) {
- return NullOrAbstractValue.create(this);
- }
- if (isNullOrAbstractValue() && asNullOrAbstractValue().getNonNullValue().equals(other)) {
- return this;
- }
- if (other.isNullOrAbstractValue()
- && other.asNullOrAbstractValue().getNonNullValue().equals(this)) {
- return other;
- }
- return unknown();
- }
- assert !isNullOrAbstractValue();
- assert !other.isNullOrAbstractValue();
- if (allowNonConstantNumbers
- && isConstantOrNonConstantNumberValue()
- && other.isConstantOrNonConstantNumberValue()) {
- NumberFromSetValue.Builder numberFromSetValueBuilder;
- if (isSingleNumberValue()) {
- numberFromSetValueBuilder = NumberFromSetValue.builder(asSingleNumberValue());
- } else {
- assert isNumberFromSetValue();
- numberFromSetValueBuilder = asNumberFromSetValue().instanceBuilder();
- }
- if (other.isSingleNumberValue()) {
- numberFromSetValueBuilder.addInt(other.asSingleNumberValue().getIntValue());
- } else {
- assert other.isNumberFromSetValue();
- numberFromSetValueBuilder.addInts(other.asNumberFromSetValue());
- }
- return numberFromSetValueBuilder.build(factory);
- }
- return unknown();
+ public DefiniteBitsNumberValue asDefiniteBitsNumberValue() {
+ return null;
}
public abstract AbstractValue rewrittenWithLens(
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueFactory.java b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueFactory.java
index bab5e75..bc50262 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueFactory.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueFactory.java
@@ -23,6 +23,14 @@
private ConcurrentHashMap<Integer, KnownLengthArrayState> knownArrayLengthStates =
new ConcurrentHashMap<>();
+ public AbstractValue createDefiniteBitsNumberValue(
+ int definitelySetBits, int definitelyUnsetBits) {
+ if (definitelySetBits != 0 && definitelyUnsetBits != 0) {
+ return new DefiniteBitsNumberValue(definitelySetBits, definitelyUnsetBits);
+ }
+ return AbstractValue.unknown();
+ }
+
public SingleConstClassValue createSingleConstClassValue(DexType type) {
return singleConstClassValues.computeIfAbsent(type, SingleConstClassValue::new);
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueJoiner.java b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueJoiner.java
new file mode 100644
index 0000000..0c49fca
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueJoiner.java
@@ -0,0 +1,217 @@
+// Copyright (c) 2023, 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 com.android.tools.r8.ir.analysis.value;
+
+import static com.android.tools.r8.ir.analysis.value.AbstractValue.unknown;
+
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramField;
+import com.android.tools.r8.horizontalclassmerging.HorizontalClassMergerUtils;
+
+public abstract class AbstractValueJoiner {
+
+ protected final AppView<? extends AppInfoWithClassHierarchy> appView;
+
+ private AbstractValueJoiner(AppView<? extends AppInfoWithClassHierarchy> appView) {
+ this.appView = appView;
+ }
+
+ private AbstractValueFactory factory() {
+ return appView.abstractValueFactory();
+ }
+
+ final AbstractValue internalJoin(
+ AbstractValue abstractValue,
+ AbstractValue otherAbstractValue,
+ AbstractValueJoinerConfig config,
+ DexType type) {
+ if (abstractValue.isBottom() || otherAbstractValue.isUnknown()) {
+ return otherAbstractValue;
+ }
+ if (abstractValue.isUnknown()
+ || otherAbstractValue.isBottom()
+ || abstractValue.equals(otherAbstractValue)) {
+ return abstractValue;
+ }
+ return type.isReferenceType()
+ ? joinReference(abstractValue, otherAbstractValue)
+ : joinPrimitive(abstractValue, otherAbstractValue, config, type);
+ }
+
+ private AbstractValue joinPrimitive(
+ AbstractValue abstractValue,
+ AbstractValue otherAbstractValue,
+ AbstractValueJoinerConfig config,
+ DexType type) {
+ assert !abstractValue.isNullOrAbstractValue();
+ assert !otherAbstractValue.isNullOrAbstractValue();
+
+ if (config.canUseNumberIntervalAndNumberSetAbstraction()
+ && abstractValue.isConstantOrNonConstantNumberValue()
+ && otherAbstractValue.isConstantOrNonConstantNumberValue()) {
+ NumberFromSetValue.Builder numberFromSetValueBuilder;
+ if (abstractValue.isSingleNumberValue()) {
+ numberFromSetValueBuilder = NumberFromSetValue.builder(abstractValue.asSingleNumberValue());
+ } else {
+ assert abstractValue.isNumberFromSetValue();
+ numberFromSetValueBuilder = abstractValue.asNumberFromSetValue().instanceBuilder();
+ }
+ if (otherAbstractValue.isSingleNumberValue()) {
+ numberFromSetValueBuilder.addInt(otherAbstractValue.asSingleNumberValue().getIntValue());
+ } else {
+ assert otherAbstractValue.isNumberFromSetValue();
+ numberFromSetValueBuilder.addInts(otherAbstractValue.asNumberFromSetValue());
+ }
+ return numberFromSetValueBuilder.build(factory());
+ }
+
+ if (config.canUseDefiniteBitsAbstraction()) {
+ return joinPrimitiveToDefiniteBitsNumberValue(abstractValue, otherAbstractValue, type);
+ }
+
+ return unknown();
+ }
+
+ private AbstractValue joinPrimitiveToDefiniteBitsNumberValue(
+ AbstractValue abstractValue, AbstractValue otherAbstractValue, DexType type) {
+ assert type.isIntType();
+ if (!abstractValue.hasDefinitelySetAndUnsetBitsInformation()
+ || !otherAbstractValue.hasDefinitelySetAndUnsetBitsInformation()) {
+ return unknown();
+ }
+ // Normalize order.
+ if (!abstractValue.isSingleNumberValue() && otherAbstractValue.isSingleNumberValue()) {
+ AbstractValue tmp = abstractValue;
+ abstractValue = otherAbstractValue;
+ otherAbstractValue = tmp;
+ }
+ if (abstractValue.isSingleNumberValue()) {
+ SingleNumberValue singleNumberValue = abstractValue.asSingleNumberValue();
+ if (otherAbstractValue.isSingleNumberValue()) {
+ SingleNumberValue otherSingleNumberValue = otherAbstractValue.asSingleNumberValue();
+ return factory()
+ .createDefiniteBitsNumberValue(
+ singleNumberValue.getDefinitelySetIntBits()
+ & otherSingleNumberValue.getDefinitelySetIntBits(),
+ singleNumberValue.getDefinitelyUnsetIntBits()
+ & otherSingleNumberValue.getDefinitelyUnsetIntBits());
+ } else {
+ assert otherAbstractValue.isDefiniteBitsNumberValue();
+ DefiniteBitsNumberValue otherDefiniteBitsNumberValue =
+ otherAbstractValue.asDefiniteBitsNumberValue();
+ return otherDefiniteBitsNumberValue.join(factory(), singleNumberValue);
+ }
+ } else {
+ // Both are guaranteed to be non-const due to normalization.
+ assert abstractValue.isDefiniteBitsNumberValue();
+ assert otherAbstractValue.isDefiniteBitsNumberValue();
+ DefiniteBitsNumberValue definiteBitsNumberValue = abstractValue.asDefiniteBitsNumberValue();
+ DefiniteBitsNumberValue otherDefiniteBitsNumberValue =
+ otherAbstractValue.asDefiniteBitsNumberValue();
+ return definiteBitsNumberValue.join(factory(), otherDefiniteBitsNumberValue);
+ }
+ }
+
+ private AbstractValue joinReference(
+ AbstractValue abstractValue, AbstractValue otherAbstractValue) {
+ if (abstractValue.isNull()) {
+ return NullOrAbstractValue.create(otherAbstractValue);
+ }
+ if (otherAbstractValue.isNull()) {
+ return NullOrAbstractValue.create(abstractValue);
+ }
+ if (abstractValue.isNullOrAbstractValue()
+ && abstractValue.asNullOrAbstractValue().getNonNullValue().equals(otherAbstractValue)) {
+ return abstractValue;
+ }
+ if (otherAbstractValue.isNullOrAbstractValue()
+ && otherAbstractValue.asNullOrAbstractValue().getNonNullValue().equals(abstractValue)) {
+ return otherAbstractValue;
+ }
+ return unknown();
+ }
+
+ public static class AbstractValueFieldJoiner extends AbstractValueJoiner {
+
+ public AbstractValueFieldJoiner(AppView<? extends AppInfoWithClassHierarchy> appView) {
+ super(appView);
+ }
+
+ public AbstractValue join(
+ AbstractValue abstractValue, AbstractValue otherAbstractValue, ProgramField field) {
+ AbstractValueJoinerConfig config = getConfig(field);
+ AbstractValue result =
+ internalJoin(abstractValue, otherAbstractValue, config, field.getType());
+ assert result.equals(
+ internalJoin(otherAbstractValue, abstractValue, config, field.getType()));
+ return result;
+ }
+
+ private AbstractValueJoinerConfig getConfig(ProgramField field) {
+ if (HorizontalClassMergerUtils.isClassIdField(appView, field)) {
+ return AbstractValueJoinerConfig.getClassIdFieldConfig();
+ }
+ return AbstractValueJoinerConfig.getDefaultConfig();
+ }
+ }
+
+ public static class AbstractValueParameterJoiner extends AbstractValueJoiner {
+
+ public AbstractValueParameterJoiner(AppView<? extends AppInfoWithClassHierarchy> appView) {
+ super(appView);
+ }
+
+ public AbstractValue join(
+ AbstractValue abstractValue, AbstractValue otherAbstractValue, DexType type) {
+ // TODO(b/196017578): Use a config that allows the definite bits abstraction for parameters
+ // used in bitwise operations.
+ AbstractValueJoinerConfig config = AbstractValueJoinerConfig.getDefaultConfig();
+ AbstractValue result = internalJoin(abstractValue, otherAbstractValue, config, type);
+ assert result.equals(internalJoin(otherAbstractValue, abstractValue, config, type));
+ return result;
+ }
+ }
+
+ private static class AbstractValueJoinerConfig {
+
+ // The power set lattice is an expensive abstraction, so use it with caution.
+ private static final AbstractValueJoinerConfig CLASS_ID_FIELD_CONFIG =
+ new AbstractValueJoinerConfig().setCanUseNumberIntervalAndNumberSetAbstraction();
+
+ private static final AbstractValueJoinerConfig DEFAULT_CONFIG = new AbstractValueJoinerConfig();
+
+ public static AbstractValueJoinerConfig getClassIdFieldConfig() {
+ return CLASS_ID_FIELD_CONFIG;
+ }
+
+ public static AbstractValueJoinerConfig getDefaultConfig() {
+ return DEFAULT_CONFIG;
+ }
+
+ private boolean canUseDefiniteBitsAbstraction;
+ private boolean canUseNumberIntervalAndNumberSetAbstraction;
+
+ boolean canUseDefiniteBitsAbstraction() {
+ return canUseDefiniteBitsAbstraction;
+ }
+
+ @SuppressWarnings("UnusedMethod")
+ AbstractValueJoinerConfig setCanUseDefiniteBitsAbstraction() {
+ canUseDefiniteBitsAbstraction = true;
+ return this;
+ }
+
+ boolean canUseNumberIntervalAndNumberSetAbstraction() {
+ return canUseNumberIntervalAndNumberSetAbstraction;
+ }
+
+ AbstractValueJoinerConfig setCanUseNumberIntervalAndNumberSetAbstraction() {
+ canUseNumberIntervalAndNumberSetAbstraction = true;
+ return this;
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/DefiniteBitsNumberValue.java b/src/main/java/com/android/tools/r8/ir/analysis/value/DefiniteBitsNumberValue.java
new file mode 100644
index 0000000..b081050
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/DefiniteBitsNumberValue.java
@@ -0,0 +1,126 @@
+// Copyright (c) 2023, 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 com.android.tools.r8.ir.analysis.value;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.lens.GraphLens;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.OptionalBool;
+import java.util.Objects;
+
+public class DefiniteBitsNumberValue extends NonConstantNumberValue {
+
+ private final int definitelySetBits;
+ private final int definitelyUnsetBits;
+
+ public DefiniteBitsNumberValue(int definitelySetBits, int definitelyUnsetBits) {
+ assert (definitelySetBits & definitelyUnsetBits) == 0;
+ this.definitelySetBits = definitelySetBits;
+ this.definitelyUnsetBits = definitelyUnsetBits;
+ }
+
+ @Override
+ public boolean containsInt(int value) {
+ return false;
+ }
+
+ @Override
+ public long getAbstractionSize() {
+ return Long.MAX_VALUE;
+ }
+
+ @Override
+ public boolean hasDefinitelySetAndUnsetBitsInformation() {
+ return true;
+ }
+
+ @Override
+ public boolean isDefiniteBitsNumberValue() {
+ return true;
+ }
+
+ @Override
+ public DefiniteBitsNumberValue asDefiniteBitsNumberValue() {
+ return this;
+ }
+
+ @Override
+ public boolean isNonTrivial() {
+ return true;
+ }
+
+ @Override
+ public OptionalBool isSubsetOf(int[] values) {
+ return OptionalBool.unknown();
+ }
+
+ public AbstractValue join(
+ AbstractValueFactory abstractValueFactory, DefiniteBitsNumberValue definiteBitsNumberValue) {
+ return join(
+ abstractValueFactory,
+ definiteBitsNumberValue.definitelySetBits,
+ definiteBitsNumberValue.definitelyUnsetBits);
+ }
+
+ public AbstractValue join(
+ AbstractValueFactory abstractValueFactory, SingleNumberValue singleNumberValue) {
+ return join(
+ abstractValueFactory,
+ singleNumberValue.getDefinitelySetIntBits(),
+ singleNumberValue.getDefinitelyUnsetIntBits());
+ }
+
+ public AbstractValue join(
+ AbstractValueFactory abstractValueFactory,
+ int otherDefinitelySetBits,
+ int otherDefinitelyUnsetBits) {
+ if (definitelySetBits == otherDefinitelySetBits
+ && definitelyUnsetBits == otherDefinitelyUnsetBits) {
+ return this;
+ }
+ return abstractValueFactory.createDefiniteBitsNumberValue(
+ definitelySetBits & otherDefinitelySetBits, definitelyUnsetBits & otherDefinitelyUnsetBits);
+ }
+
+ @Override
+ public boolean mayOverlapWith(ConstantOrNonConstantNumberValue other) {
+ return true;
+ }
+
+ @Override
+ public AbstractValue rewrittenWithLens(
+ AppView<AppInfoWithLiveness> appView, GraphLens lens, GraphLens codeLens) {
+ return this;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || o.getClass() != getClass()) {
+ return false;
+ }
+ DefiniteBitsNumberValue definiteBitsNumberValue = (DefiniteBitsNumberValue) o;
+ return definitelySetBits == definiteBitsNumberValue.definitelySetBits
+ && definitelyUnsetBits == definiteBitsNumberValue.definitelyUnsetBits;
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = 31 * (31 * (31 + definitelySetBits) + definitelyUnsetBits);
+ assert hash == Objects.hash(definitelySetBits, definitelyUnsetBits);
+ return hash;
+ }
+
+ @Override
+ public String toString() {
+ return "DefiniteBitsNumberValue(set: "
+ + Integer.toBinaryString(definitelySetBits)
+ + "; unset: "
+ + Integer.toBinaryString(definitelyUnsetBits)
+ + ")";
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java b/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java
index 5327427..e29e468 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/SingleNumberValue.java
@@ -37,6 +37,11 @@
}
@Override
+ public boolean hasDefinitelySetAndUnsetBitsInformation() {
+ return true;
+ }
+
+ @Override
public OptionalBool isSubsetOf(int[] values) {
return OptionalBool.of(ArrayUtils.containsInt(values, getIntValue()));
}
@@ -81,6 +86,14 @@
return value != 0;
}
+ public int getDefinitelySetIntBits() {
+ return getIntValue();
+ }
+
+ public int getDefinitelyUnsetIntBits() {
+ return ~getDefinitelySetIntBits();
+ }
+
public double getDoubleValue() {
return Double.longBitsToDouble(value);
}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
index 0a5ebca..3afb79b 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
@@ -439,13 +439,14 @@
public static IRBuilder create(
ProgramMethod method, AppView<?> appView, SourceCode source, Origin origin) {
+ GraphLens codeLens = method.getDefinition().getCode().getCodeLens(appView);
return new IRBuilder(
method,
appView,
- method.getDefinition().getCode().getCodeLens(appView),
+ codeLens,
source,
origin,
- lookupPrototypeChanges(appView, method),
+ lookupPrototypeChanges(appView, method, codeLens),
new NumberGenerator());
}
@@ -462,8 +463,10 @@
}
public static RewrittenPrototypeDescription lookupPrototypeChanges(
- AppView<?> appView, ProgramMethod method) {
- return appView.graphLens().lookupPrototypeChangesForMethodDefinition(method.getReference());
+ AppView<?> appView, ProgramMethod method, GraphLens codeLens) {
+ return appView
+ .graphLens()
+ .lookupPrototypeChangesForMethodDefinition(method.getReference(), codeLens);
}
private IRBuilder(
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index 5b22d0e..cd7af3b 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -756,7 +756,7 @@
new ArrayConstructionSimplifier(appView).run(code, timing);
new MoveResultRewriter(appView).run(code, timing);
new StringBuilderAppendOptimizer(appView).run(code, timing);
- new SparseConditionalConstantPropagation(appView, code).run(code, timing);
+ new SparseConditionalConstantPropagation(appView).run(code, timing);
new ThrowCatchOptimizer(appView).run(code, timing);
if (new BranchSimplifier(appView)
.run(code, timing)
@@ -767,7 +767,7 @@
}
new SplitBranch(appView).run(code, timing);
new RedundantConstNumberRemover(appView).run(code, timing);
- new RedundantFieldLoadAndStoreElimination(appView, code).run(code, timing);
+ new RedundantFieldLoadAndStoreElimination(appView).run(code, timing);
new BinopRewriter(appView).run(code, timing);
timing.begin("Optimize class initializers");
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/PrimaryR8IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/PrimaryR8IRConverter.java
index 729a2e5..93ce2a2 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/PrimaryR8IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/PrimaryR8IRConverter.java
@@ -16,6 +16,7 @@
import com.android.tools.r8.graph.lens.GraphLens;
import com.android.tools.r8.ir.analysis.fieldaccess.TrivialFieldAccessReprocessor;
import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.optimize.DeadCodeRemover;
import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackDelayed;
import com.android.tools.r8.lightir.LirCode;
import com.android.tools.r8.optimize.argumentpropagation.ArgumentPropagator;
@@ -55,7 +56,6 @@
private DexApplication internalOptimize(
AppView<AppInfoWithLiveness> appView, ExecutorService executorService)
throws ExecutionException {
- appView.testing().enterLirSupportedPhase();
// Desugaring happens in the enqueuer.
assert instructionDesugaring.isEmpty();
@@ -217,30 +217,37 @@
// Assure that no more optimization feedback left after post processing.
assert feedback.noUpdatesLeft();
- finalizeLirToOutputFormat(timing, executorService);
return appView.appInfo().app();
}
- private void finalizeLirToOutputFormat(Timing timing, ExecutorService executorService)
+ public static void finalizeLirToOutputFormat(
+ AppView<?> appView, Timing timing, ExecutorService executorService)
throws ExecutionException {
appView.testing().exitLirSupportedPhase();
- if (!options.testing.canUseLir(appView)) {
+ if (!appView.testing().canUseLir(appView)) {
return;
}
- String output = options.isGeneratingClassFiles() ? "CF" : "DEX";
+ DeadCodeRemover deadCodeRemover = new DeadCodeRemover(appView);
+ String output = appView.options().isGeneratingClassFiles() ? "CF" : "DEX";
timing.begin("LIR->IR->" + output);
ThreadUtils.processItems(
appView.appInfo().classes(),
- clazz -> clazz.forEachProgramMethod(this::finalizeLirMethodToOutputFormat),
+ clazz ->
+ clazz.forEachProgramMethod(
+ m -> finalizeLirMethodToOutputFormat(m, deadCodeRemover, appView)),
executorService);
appView
.getSyntheticItems()
.getPendingSyntheticClasses()
- .forEach(clazz -> clazz.forEachProgramMethod(this::finalizeLirMethodToOutputFormat));
+ .forEach(
+ clazz ->
+ clazz.forEachProgramMethod(
+ m -> finalizeLirMethodToOutputFormat(m, deadCodeRemover, appView)));
timing.end();
}
- void finalizeLirMethodToOutputFormat(ProgramMethod method) {
+ private static void finalizeLirMethodToOutputFormat(
+ ProgramMethod method, DeadCodeRemover deadCodeRemover, AppView<?> appView) {
Code code = method.getDefinition().getCode();
if (!(code instanceof LirCode)) {
return;
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/ArrayConstructionSimplifier.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/ArrayConstructionSimplifier.java
index 3176d29..b8a54fb 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/ArrayConstructionSimplifier.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/ArrayConstructionSimplifier.java
@@ -94,14 +94,16 @@
@Override
protected CodeRewriterResult rewriteCode(IRCode code) {
+ boolean hasChanged = false;
WorkList<BasicBlock> worklist = WorkList.newIdentityWorkList(code.blocks);
while (worklist.hasNext()) {
BasicBlock block = worklist.next();
- simplifyArrayConstructionBlock(block, worklist, code, appView.options());
+ hasChanged |= simplifyArrayConstructionBlock(block, worklist, code, appView.options());
}
- // Do only when the rewriter pass has changed something.
- code.removeRedundantBlocks();
- return CodeRewriterResult.NONE;
+ if (hasChanged) {
+ code.removeRedundantBlocks();
+ }
+ return CodeRewriterResult.hasChanged(hasChanged);
}
@Override
@@ -109,8 +111,9 @@
return appView.options().isGeneratingDex();
}
- private void simplifyArrayConstructionBlock(
+ private boolean simplifyArrayConstructionBlock(
BasicBlock block, WorkList<BasicBlock> worklist, IRCode code, InternalOptions options) {
+ boolean hasChanged = false;
RewriteArrayOptions rewriteOptions = options.rewriteArrayOptions();
InstructionListIterator it = block.listIterator(code);
while (it.hasNext()) {
@@ -199,7 +202,9 @@
// The above has invalidated the block iterator so reset it and continue.
it = block.listIterator(code, instructionAfterCandidate);
+ hasChanged = true;
}
+ return hasChanged;
}
private short[] computeArrayFilledData(Value[] values, int size, int elementSize) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/BinopRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/BinopRewriter.java
index 70c64f1..aed22c2 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/BinopRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/BinopRewriter.java
@@ -252,6 +252,7 @@
@Override
public CodeRewriterResult rewriteCode(IRCode code) {
+ boolean hasChanged = false;
InstructionListIterator iterator = code.instructionListIterator();
while (iterator.hasNext()) {
Instruction next = iterator.next();
@@ -262,39 +263,42 @@
BinopDescriptor binopDescriptor = descriptors.get(binop.getClass());
assert binopDescriptor != null;
if (identityAbsorbingSimplification(iterator, binop, binopDescriptor)) {
+ hasChanged = true;
continue;
}
- successiveSimplification(iterator, binop, binopDescriptor, code);
+ hasChanged |= successiveSimplification(iterator, binop, binopDescriptor, code);
}
}
}
- code.removeAllDeadAndTrivialPhis();
- code.removeRedundantBlocks();
+ if (hasChanged) {
+ code.removeAllDeadAndTrivialPhis();
+ code.removeRedundantBlocks();
+ }
assert code.isConsistentSSA(appView);
- return CodeRewriterResult.NONE;
+ return CodeRewriterResult.hasChanged(hasChanged);
}
- private void successiveSimplification(
+ private boolean successiveSimplification(
InstructionListIterator iterator, Binop binop, BinopDescriptor binopDescriptor, IRCode code) {
if (binop.outValue().hasDebugUsers()) {
- return;
+ return false;
}
ConstNumber constBLeft = getConstNumber(binop.leftValue());
ConstNumber constBRight = getConstNumber(binop.rightValue());
if ((constBLeft != null && constBRight != null)
|| (constBLeft == null && constBRight == null)) {
- return;
+ return false;
}
Value otherValue = constBLeft == null ? binop.leftValue() : binop.rightValue();
if (otherValue.isPhi() || !otherValue.getDefinition().isBinop()) {
- return;
+ return false;
}
Binop prevBinop = otherValue.getDefinition().asBinop();
ConstNumber constALeft = getConstNumber(prevBinop.leftValue());
ConstNumber constARight = getConstNumber(prevBinop.rightValue());
if ((constALeft != null && constARight != null)
|| (constALeft == null && constARight == null)) {
- return;
+ return false;
}
ConstNumber constB = constBLeft == null ? constBRight : constBLeft;
ConstNumber constA = constALeft == null ? constARight : constALeft;
@@ -306,11 +310,13 @@
assert binop.isCommutative();
Value newConst = addNewConstNumber(code, iterator, constB, constA, binopDescriptor);
replaceBinop(iterator, code, input, newConst, binopDescriptor);
+ return true;
} else if (binopDescriptor.isShift()) {
// x shift: a shift: b => x shift: (a + b) where a + b is a constant.
if (constBRight != null && constARight != null) {
Value newConst = addNewConstNumber(code, iterator, constB, constA, BinopDescriptor.ADD);
replaceBinop(iterator, code, input, newConst, binopDescriptor);
+ return true;
}
} else if (binop.isSub() && constBRight != null) {
// a - x - b => (a - b) - x where (a - b) is a constant.
@@ -319,9 +325,11 @@
if (constARight == null) {
Value newConst = addNewConstNumber(code, iterator, constA, constB, BinopDescriptor.SUB);
replaceBinop(iterator, code, newConst, input, BinopDescriptor.SUB);
+ return true;
} else {
Value newConst = addNewConstNumber(code, iterator, constB, constA, BinopDescriptor.ADD);
replaceBinop(iterator, code, input, newConst, BinopDescriptor.SUB);
+ return true;
}
}
} else {
@@ -331,18 +339,22 @@
// We ignore b - (x + a) and b - (a + x) with constBRight != null.
Value newConst = addNewConstNumber(code, iterator, constA, constB, BinopDescriptor.SUB);
replaceBinop(iterator, code, newConst, input, BinopDescriptor.ADD);
+ return true;
} else if (binop.isAdd() && prevBinop.isSub()) {
// x - a + b => x - (a - b) where (a - b) is a constant.
// a - x + b => (a + b) - x where (a + b) is a constant.
if (constALeft == null) {
Value newConst = addNewConstNumber(code, iterator, constA, constB, BinopDescriptor.SUB);
replaceBinop(iterator, code, input, newConst, BinopDescriptor.SUB);
+ return true;
} else {
Value newConst = addNewConstNumber(code, iterator, constB, constA, BinopDescriptor.ADD);
replaceBinop(iterator, code, newConst, input, BinopDescriptor.SUB);
+ return true;
}
}
}
+ return false;
}
private void replaceBinop(
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/CommonSubexpressionElimination.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/CommonSubexpressionElimination.java
index 7057abc..33ec433 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/CommonSubexpressionElimination.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/CommonSubexpressionElimination.java
@@ -41,6 +41,7 @@
@Override
protected CodeRewriterResult rewriteCode(IRCode code) {
+ boolean hasChanged = false;
int noCandidate = code.reserveMarkingColor();
if (hasCSECandidate(code, noCandidate)) {
final ListMultimap<Wrapper<Instruction>, Value> instructionToValue =
@@ -65,6 +66,7 @@
instruction.outValue().replaceUsers(candidate);
candidate.uniquePhiUsers().forEach(Phi::removeTrivialPhi);
eliminated = true;
+ hasChanged = true;
iterator.removeOrReplaceByDebugLocalRead();
break; // Don't try any more candidates.
}
@@ -78,9 +80,11 @@
}
}
code.returnMarkingColor(noCandidate);
- code.removeRedundantBlocks();
+ if (hasChanged) {
+ code.removeRedundantBlocks();
+ }
assert code.isConsistentSSA(appView);
- return CodeRewriterResult.NONE;
+ return CodeRewriterResult.hasChanged(hasChanged);
}
private static class CSEExpressionEquivalence extends Equivalence<Instruction> {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/NaturalIntLoopRemover.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/NaturalIntLoopRemover.java
index 96b52dc..2666be2 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/NaturalIntLoopRemover.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/NaturalIntLoopRemover.java
@@ -53,7 +53,7 @@
code.removeRedundantBlocks();
assert code.isConsistentSSA(appView);
}
- return CodeRewriterResult.NONE;
+ return CodeRewriterResult.hasChanged(loopRemoved);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/RedundantConstNumberRemover.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/RedundantConstNumberRemover.java
index 70402cc..99caca6 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/RedundantConstNumberRemover.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/RedundantConstNumberRemover.java
@@ -52,22 +52,16 @@
@Override
protected boolean shouldRewriteCode(IRCode code) {
+ if (appView.options().canHaveDalvikIntUsedAsNonIntPrimitiveTypeBug()
+ && !appView.options().testing.forceRedundantConstNumberRemoval) {
+ // See also b/124152497.
+ return false;
+ }
return options.enableRedundantConstNumberOptimization && code.metadata().mayHaveConstNumber();
}
@Override
protected CodeRewriterResult rewriteCode(IRCode code) {
- redundantConstNumberRemoval(code);
- return CodeRewriterResult.NONE;
- }
-
- public void redundantConstNumberRemoval(IRCode code) {
- if (appView.options().canHaveDalvikIntUsedAsNonIntPrimitiveTypeBug()
- && !appView.options().testing.forceRedundantConstNumberRemoval) {
- // See also b/124152497.
- return;
- }
-
LazyBox<Long2ReferenceMap<List<ConstNumber>>> constantsByValue =
new LazyBox<>(() -> getConstantsByValue(code));
LazyBox<DominatorTree> dominatorTree = new LazyBox<>(() -> new DominatorTree(code));
@@ -169,6 +163,7 @@
code.removeAllDeadAndTrivialPhis();
}
assert code.isConsistentSSA(appView);
+ return CodeRewriterResult.hasChanged(changed);
}
private static Long2ReferenceMap<List<ConstNumber>> getConstantsByValue(IRCode code) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/SplitBranch.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/SplitBranch.java
index 2defd76..6ceb56d 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/SplitBranch.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/SplitBranch.java
@@ -56,11 +56,11 @@
protected CodeRewriterResult rewriteCode(IRCode code) {
List<BasicBlock> candidates = computeCandidates(code);
if (candidates.isEmpty()) {
- return CodeRewriterResult.NONE;
+ return CodeRewriterResult.NO_CHANGE;
}
Map<Goto, BasicBlock> newTargets = findGotosToRetarget(candidates);
if (newTargets.isEmpty()) {
- return CodeRewriterResult.NONE;
+ return CodeRewriterResult.NO_CHANGE;
}
retargetGotos(newTargets);
Set<Value> affectedValues = Sets.newIdentityHashSet();
@@ -74,7 +74,7 @@
}
code.removeRedundantBlocks();
assert code.isConsistentSSA(appView);
- return CodeRewriterResult.NONE;
+ return CodeRewriterResult.HAS_CHANGED;
}
private void retargetGotos(Map<Goto, BasicBlock> newTargets) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/passes/ThrowCatchOptimizer.java b/src/main/java/com/android/tools/r8/ir/conversion/passes/ThrowCatchOptimizer.java
index fd79613..920417a 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/passes/ThrowCatchOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/passes/ThrowCatchOptimizer.java
@@ -59,15 +59,15 @@
@Override
protected CodeRewriterResult rewriteCode(IRCode code) {
- optimizeAlwaysThrowingInstructions(code);
+ boolean hasChanged = optimizeAlwaysThrowingInstructions(code);
if (!isDebugMode(code.context())) {
- rewriteThrowNullPointerException(code);
+ hasChanged |= rewriteThrowNullPointerException(code);
}
- return CodeRewriterResult.NONE;
+ return CodeRewriterResult.hasChanged(hasChanged);
}
// Rewrite 'throw new NullPointerException()' to 'throw null'.
- private void rewriteThrowNullPointerException(IRCode code) {
+ private boolean rewriteThrowNullPointerException(IRCode code) {
boolean hasChanged = false;
boolean shouldRemoveUnreachableBlocks = false;
for (BasicBlock block : code.blocks) {
@@ -209,17 +209,19 @@
code.removeRedundantBlocks();
}
assert code.isConsistentSSA(appView);
+ return hasChanged;
}
// Find all instructions that always throw, split the block after each such instruction and follow
// it with a block throwing a null value (which should result in NPE). Note that this throw is not
// expected to be ever reached, but is intended to satisfy verifier.
- private void optimizeAlwaysThrowingInstructions(IRCode code) {
+ private boolean optimizeAlwaysThrowingInstructions(IRCode code) {
Set<Value> affectedValues = Sets.newIdentityHashSet();
Set<BasicBlock> blocksToRemove = Sets.newIdentityHashSet();
ListIterator<BasicBlock> blockIterator = code.listIterator();
ProgramMethod context = code.context();
boolean hasUnlinkedCatchHandlers = false;
+ boolean hasChanged = false;
// For cyclic phis we sometimes do not propagate the dynamic upper type after rewritings.
// The inValue.isAlwaysNull(appView) check below will not recompute the dynamic type of phi's
// so we recompute all phis here if they are always null.
@@ -287,6 +289,7 @@
}
instructionIterator.replaceCurrentInstructionWithThrowNull(
appView, code, blockIterator, blocksToRemove, affectedValues);
+ hasChanged = true;
continue;
}
}
@@ -324,6 +327,7 @@
instructionIterator.replaceCurrentInstructionWithThrowNull(
appView, code, blockIterator, blocksToRemove, affectedValues);
instructionIterator.unsetInsertionPosition();
+ hasChanged = true;
}
}
}
@@ -335,8 +339,11 @@
if (!affectedValues.isEmpty()) {
new TypeAnalysis(appView).narrowing(affectedValues);
}
- code.removeRedundantBlocks();
+ if (hasChanged) {
+ code.removeRedundantBlocks();
+ }
assert code.isConsistentSSA(appView);
+ return hasChanged;
}
// Find any case where we have a catch followed immediately and only by a rethrow. This is extra
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java b/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java
index 5b45fd5..b2b0782 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadAndStoreElimination.java
@@ -44,6 +44,7 @@
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.conversion.passes.CodeRewriterPass;
import com.android.tools.r8.ir.conversion.passes.result.CodeRewriterResult;
+import com.android.tools.r8.ir.optimize.RedundantFieldLoadAndStoreElimination.RedundantFieldLoadAndStoreEliminationOnCode.ExistingValue;
import com.android.tools.r8.ir.optimize.info.field.InstanceFieldInitializationInfoCollection;
import com.android.tools.r8.ir.optimize.info.initializer.InstanceInitializerInfo;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
@@ -71,29 +72,8 @@
private static final int MAX_CAPACITY = 10000;
private static final int MIN_CAPACITY_PER_BLOCK = 50;
- private final ProgramMethod method;
- private final IRCode code;
- private final int maxCapacityPerBlock;
- private final boolean release;
-
- // Values that may require type propagation.
- private final Set<Value> affectedValues = Sets.newIdentityHashSet();
-
- // Maps keeping track of fields that have an already loaded value at basic block entry.
- private final BlockStates activeStates = new BlockStates();
-
- // Maps keeping track of fields with already loaded values for the current block during
- // elimination.
- private BlockState activeState;
-
- private final Map<BasicBlock, Set<Instruction>> instructionsToRemove = new IdentityHashMap<>();
-
- public RedundantFieldLoadAndStoreElimination(AppView<?> appView, IRCode code) {
+ public RedundantFieldLoadAndStoreElimination(AppView<?> appView) {
super(appView);
- this.method = code.context();
- this.code = code;
- this.maxCapacityPerBlock = Math.max(MIN_CAPACITY_PER_BLOCK, MAX_CAPACITY / code.blocks.size());
- this.release = !appView.options().debug;
}
@Override
@@ -111,8 +91,7 @@
@Override
protected CodeRewriterResult rewriteCode(IRCode code) {
- run();
- return CodeRewriterResult.NONE;
+ return new RedundantFieldLoadAndStoreEliminationOnCode(code).run();
}
private interface FieldValue {
@@ -126,80 +105,6 @@
TypeElement getType(AppView<?> appView, TypeElement outType);
}
- private class ExistingValue implements FieldValue {
-
- private final Value value;
-
- private ExistingValue(Value value) {
- this.value = value;
- }
-
- @Override
- public ExistingValue asExistingValue() {
- return this;
- }
-
- @Override
- public void eliminateRedundantRead(InstructionListIterator it, Instruction redundant) {
- affectedValues.addAll(redundant.outValue().affectedValues());
- redundant.outValue().replaceUsers(value);
- it.removeOrReplaceByDebugLocalRead();
- value.uniquePhiUsers().forEach(Phi::removeTrivialPhi);
- }
-
- @Override
- public TypeElement getType(AppView<?> appView, TypeElement outType) {
- return value.getType();
- }
-
- public Value getValue() {
- return value;
- }
-
- @Override
- public String toString() {
- return "ExistingValue(v" + value.getNumber() + ")";
- }
- }
-
- private class MaterializableValue implements FieldValue {
-
- private final SingleValue value;
-
- private MaterializableValue(SingleValue value) {
- assert value.isMaterializableInContext(appView.withLiveness(), method);
- this.value = value;
- }
-
- @Override
- public void eliminateRedundantRead(InstructionListIterator it, Instruction redundant) {
- affectedValues.addAll(redundant.outValue().affectedValues());
- it.replaceCurrentInstruction(
- value.createMaterializingInstruction(appView.withClassHierarchy(), code, redundant));
- }
-
- @Override
- public TypeElement getType(AppView<?> appView, TypeElement outType) {
- DexItemFactory dexItemFactory = appView.dexItemFactory();
- if (value.isSingleStringValue() || value.isSingleDexItemBasedStringValue()) {
- return dexItemFactory.stringType.toTypeElement(
- RedundantFieldLoadAndStoreElimination.this.appView, Nullability.definitelyNotNull());
- }
- if (value.isSingleFieldValue()) {
- return value.asSingleFieldValue().getField().getTypeElement(appView);
- }
- // For numbers (and null), we don't encode the type along with the value. Therefore, we
- // fallback to the existing out type in this case.
- assert value.isSingleNumberValue();
- if (outType.isReferenceType()) {
- assert value.isNull();
- return TypeElement.getNull();
- }
- assert outType.isPrimitiveType();
- return outType;
- }
- }
-
private abstract static class ArraySlot {
protected final Value array;
@@ -294,6 +199,7 @@
}
private static class FieldAndObject {
+
private final DexField field;
private final Value object;
@@ -318,578 +224,693 @@
}
}
- public boolean isFinal(DexClassAndField field) {
- if (field.isProgramField()) {
- // Treat this field as being final if it is declared final or we have determined a constant
- // value for it.
- return field.getDefinition().isFinal()
- || field.getDefinition().getOptimizationInfo().getAbstractValue().isSingleValue();
- }
- return appView.libraryMethodOptimizer().isFinalLibraryField(field.getDefinition());
- }
+ class RedundantFieldLoadAndStoreEliminationOnCode {
- private DexClassAndField resolveField(DexField field) {
- if (appView.enableWholeProgramOptimizations()) {
- SingleFieldResolutionResult resolutionResult =
- appView.appInfo().withLiveness().resolveField(field).asSingleFieldResolutionResult();
- return resolutionResult != null ? resolutionResult.getResolutionPair() : null;
- }
- if (field.getHolderType() == method.getHolderType()) {
- return method.getHolder().lookupProgramField(field);
- }
- return null;
- }
+ private final ProgramMethod method;
+ private final IRCode code;
+ private final int maxCapacityPerBlock;
+ private final boolean release;
- public void run() {
- Reference2IntMap<BasicBlock> pendingNormalSuccessors = new Reference2IntOpenHashMap<>();
- for (BasicBlock block : code.blocks) {
- if (!block.hasUniqueNormalSuccessor()) {
- pendingNormalSuccessors.put(block, block.numberOfNormalSuccessors());
+ // Values that may require type propagation.
+ private final Set<Value> affectedValues = Sets.newIdentityHashSet();
+
+ // Maps keeping track of fields that have an already loaded value at basic block entry.
+ private final BlockStates activeStates = new BlockStates();
+
+ // Maps keeping track of fields with already loaded values for the current block during
+ // elimination.
+ private BlockState activeState;
+
+ private final Map<BasicBlock, Set<Instruction>> instructionsToRemove = new IdentityHashMap<>();
+
+ private boolean hasChanged = false;
+
+ private RedundantFieldLoadAndStoreEliminationOnCode(IRCode code) {
+ this.method = code.context();
+ this.code = code;
+ this.maxCapacityPerBlock =
+ Math.max(MIN_CAPACITY_PER_BLOCK, MAX_CAPACITY / code.blocks.size());
+ this.release = !appView.options().debug;
+ }
+
+ class ExistingValue implements FieldValue {
+
+ private final Value value;
+
+ private ExistingValue(Value value) {
+ this.value = value;
+ }
+
+ @Override
+ public ExistingValue asExistingValue() {
+ return this;
+ }
+
+ @Override
+ public void eliminateRedundantRead(InstructionListIterator it, Instruction redundant) {
+ affectedValues.addAll(redundant.outValue().affectedValues());
+ redundant.outValue().replaceUsers(value);
+ it.removeOrReplaceByDebugLocalRead();
+ value.uniquePhiUsers().forEach(Phi::removeTrivialPhi);
+ hasChanged = true;
+ }
+
+ @Override
+ public TypeElement getType(AppView<?> appView, TypeElement outType) {
+ return value.getType();
+ }
+
+ public Value getValue() {
+ return value;
+ }
+
+ @Override
+ public String toString() {
+ return "ExistingValue(v" + value.getNumber() + ")";
}
}
- AssumeRemover assumeRemover = new AssumeRemover(appView, code, affectedValues);
- for (BasicBlock head : code.topologicallySortedBlocks()) {
- if (head.hasUniquePredecessor() && head.getUniquePredecessor().hasUniqueNormalSuccessor()) {
- // Already visited.
- continue;
+ private class MaterializableValue implements FieldValue {
+
+ private final SingleValue value;
+
+ private MaterializableValue(SingleValue value) {
+ assert value.isMaterializableInContext(appView.withLiveness(), method);
+ this.value = value;
}
- activeState = activeStates.computeActiveStateOnBlockEntry(head, maxCapacityPerBlock);
- activeStates.removeDeadBlockExitStates(head, pendingNormalSuccessors);
- BasicBlock block = head;
- BasicBlock end = null;
- do {
- InstructionListIterator it = block.listIterator(code);
- while (it.hasNext()) {
- Instruction instruction = it.next();
- if (instruction.isArrayAccess()) {
- if (instruction.isArrayGet()) {
- handleArrayGet(it, instruction.asArrayGet());
+
+ @Override
+ public void eliminateRedundantRead(InstructionListIterator it, Instruction redundant) {
+ affectedValues.addAll(redundant.outValue().affectedValues());
+ it.replaceCurrentInstruction(
+ value.createMaterializingInstruction(appView.withClassHierarchy(), code, redundant));
+ hasChanged = true;
+ }
+
+ @Override
+ public TypeElement getType(AppView<?> appView, TypeElement outType) {
+ DexItemFactory dexItemFactory = appView.dexItemFactory();
+ if (value.isSingleStringValue() || value.isSingleDexItemBasedStringValue()) {
+ return dexItemFactory.stringType.toTypeElement(
+ RedundantFieldLoadAndStoreElimination.this.appView, Nullability.definitelyNotNull());
+ }
+ if (value.isSingleFieldValue()) {
+ return value.asSingleFieldValue().getField().getTypeElement(appView);
+ }
+ // For numbers (and null), we don't encode the type along with the value. Therefore, we
+ // fallback to the existing out type in this case.
+ assert value.isSingleNumberValue();
+ if (outType.isReferenceType()) {
+ assert value.isNull();
+ return TypeElement.getNull();
+ }
+ assert outType.isPrimitiveType();
+ return outType;
+ }
+ }
+
+ public boolean isFinal(DexClassAndField field) {
+ if (field.isProgramField()) {
+ // Treat this field as being final if it is declared final or we have determined a constant
+ // value for it.
+ return field.getDefinition().isFinal()
+ || field.getDefinition().getOptimizationInfo().getAbstractValue().isSingleValue();
+ }
+ return appView.libraryMethodOptimizer().isFinalLibraryField(field.getDefinition());
+ }
+
+ private DexClassAndField resolveField(DexField field) {
+ if (appView.enableWholeProgramOptimizations()) {
+ SingleFieldResolutionResult resolutionResult =
+ appView.appInfo().withLiveness().resolveField(field).asSingleFieldResolutionResult();
+ return resolutionResult != null ? resolutionResult.getResolutionPair() : null;
+ }
+ if (field.getHolderType() == method.getHolderType()) {
+ return method.getHolder().lookupProgramField(field);
+ }
+ return null;
+ }
+
+ public CodeRewriterResult run() {
+ Reference2IntMap<BasicBlock> pendingNormalSuccessors = new Reference2IntOpenHashMap<>();
+ for (BasicBlock block : code.blocks) {
+ if (!block.hasUniqueNormalSuccessor()) {
+ pendingNormalSuccessors.put(block, block.numberOfNormalSuccessors());
+ }
+ }
+
+ AssumeRemover assumeRemover = new AssumeRemover(appView, code, affectedValues);
+ for (BasicBlock head : code.topologicallySortedBlocks()) {
+ if (head.hasUniquePredecessor() && head.getUniquePredecessor().hasUniqueNormalSuccessor()) {
+ // Already visited.
+ continue;
+ }
+ activeState = activeStates.computeActiveStateOnBlockEntry(head, maxCapacityPerBlock);
+ activeStates.removeDeadBlockExitStates(head, pendingNormalSuccessors);
+ BasicBlock block = head;
+ BasicBlock end = null;
+ do {
+ InstructionListIterator it = block.listIterator(code);
+ while (it.hasNext()) {
+ Instruction instruction = it.next();
+ if (instruction.isArrayAccess()) {
+ if (instruction.isArrayGet()) {
+ handleArrayGet(it, instruction.asArrayGet());
+ } else {
+ assert instruction.isArrayPut();
+ handleArrayPut(instruction.asArrayPut());
+ }
+ } else if (instruction.isFieldInstruction()) {
+ DexField reference = instruction.asFieldInstruction().getField();
+ DexClassAndField field = resolveField(reference);
+ if (field == null || field.getDefinition().isVolatile()) {
+ killAllNonFinalActiveFields();
+ continue;
+ }
+
+ if (instruction.isInstanceGet()) {
+ handleInstanceGet(it, instruction.asInstanceGet(), field, assumeRemover);
+ } else if (instruction.isInstancePut()) {
+ handleInstancePut(instruction.asInstancePut(), field);
+ } else if (instruction.isStaticGet()) {
+ handleStaticGet(it, instruction.asStaticGet(), field, assumeRemover);
+ } else if (instruction.isStaticPut()) {
+ handleStaticPut(instruction.asStaticPut(), field);
+ }
+ } else if (instruction.isAssume()) {
+ assumeRemover.removeIfMarked(instruction.asAssume(), it);
+ } else if (instruction.isInitClass()) {
+ handleInitClass(it, instruction.asInitClass());
+ } else if (instruction.isMonitor()) {
+ if (instruction.asMonitor().isEnter()) {
+ killAllNonFinalActiveFields();
+ }
+ } else if (instruction.isInvokeDirect()) {
+ handleInvokeDirect(instruction.asInvokeDirect());
+ } else if (instruction.isInvokeStatic()) {
+ handleInvokeStatic(instruction.asInvokeStatic());
+ } else if (instruction.isInvokeMethod() || instruction.isInvokeCustom()) {
+ killAllNonFinalActiveFields();
+ } else if (instruction.isNewInstance()) {
+ handleNewInstance(instruction.asNewInstance());
} else {
- assert instruction.isArrayPut();
- handleArrayPut(instruction.asArrayPut());
- }
- } else if (instruction.isFieldInstruction()) {
- DexField reference = instruction.asFieldInstruction().getField();
- DexClassAndField field = resolveField(reference);
- if (field == null || field.getDefinition().isVolatile()) {
- killAllNonFinalActiveFields();
- continue;
- }
+ // If the current instruction could trigger a method invocation, it could also cause
+ // field values to change. In that case, it must be handled above.
+ assert !instruction.instructionMayTriggerMethodInvocation(appView, method);
- if (instruction.isInstanceGet()) {
- handleInstanceGet(it, instruction.asInstanceGet(), field, assumeRemover);
- } else if (instruction.isInstancePut()) {
- handleInstancePut(instruction.asInstancePut(), field);
- } else if (instruction.isStaticGet()) {
- handleStaticGet(it, instruction.asStaticGet(), field, assumeRemover);
- } else if (instruction.isStaticPut()) {
- handleStaticPut(instruction.asStaticPut(), field);
- }
- } else if (instruction.isAssume()) {
- assumeRemover.removeIfMarked(instruction.asAssume(), it);
- } else if (instruction.isInitClass()) {
- handleInitClass(it, instruction.asInitClass());
- } else if (instruction.isMonitor()) {
- if (instruction.asMonitor().isEnter()) {
- killAllNonFinalActiveFields();
- }
- } else if (instruction.isInvokeDirect()) {
- handleInvokeDirect(instruction.asInvokeDirect());
- } else if (instruction.isInvokeStatic()) {
- handleInvokeStatic(instruction.asInvokeStatic());
- } else if (instruction.isInvokeMethod() || instruction.isInvokeCustom()) {
- killAllNonFinalActiveFields();
- } else if (instruction.isNewInstance()) {
- handleNewInstance(instruction.asNewInstance());
- } else {
- // If the current instruction could trigger a method invocation, it could also cause
- // field values to change. In that case, it must be handled above.
- assert !instruction.instructionMayTriggerMethodInvocation(appView, method);
+ // Clear the field writes.
+ if (instruction.instructionInstanceCanThrow(appView, method)) {
+ activeState.clearMostRecentFieldWrites();
+ activeState.clearMostRecentInitClass();
+ }
- // Clear the field writes.
- if (instruction.instructionInstanceCanThrow(appView, method)) {
- activeState.clearMostRecentFieldWrites();
- activeState.clearMostRecentInitClass();
+ // If this assertion fails for a new instruction we need to determine if that
+ // instruction has side-effects that can change the value of fields. If so, it must be
+ // handled above. If not, it can be safely added to the assert.
+ assert instruction.isArgument()
+ || instruction.isArrayGet()
+ || instruction.isArrayLength()
+ || instruction.isArrayPut()
+ || instruction.isAssume()
+ || instruction.isBinop()
+ || instruction.isCheckCast()
+ || instruction.isConstClass()
+ || instruction.isConstMethodHandle()
+ || instruction.isConstMethodType()
+ || instruction.isConstNumber()
+ || instruction.isConstString()
+ || instruction.isDebugInstruction()
+ || instruction.isDexItemBasedConstString()
+ || instruction.isGoto()
+ || instruction.isIf()
+ || instruction.isInstanceOf()
+ || instruction.isInvokeMultiNewArray()
+ || instruction.isInvokeNewArray()
+ || instruction.isMoveException()
+ || instruction.isNewArrayEmpty()
+ || instruction.isNewArrayFilledData()
+ || instruction.isReturn()
+ || instruction.isSwitch()
+ || instruction.isThrow()
+ || instruction.isUnop()
+ || instruction.isRecordFieldValues()
+ : "Unexpected instruction of type " + instruction.getClass().getTypeName();
}
-
- // If this assertion fails for a new instruction we need to determine if that
- // instruction has side-effects that can change the value of fields. If so, it must be
- // handled above. If not, it can be safely added to the assert.
- assert instruction.isArgument()
- || instruction.isArrayGet()
- || instruction.isArrayLength()
- || instruction.isArrayPut()
- || instruction.isAssume()
- || instruction.isBinop()
- || instruction.isCheckCast()
- || instruction.isConstClass()
- || instruction.isConstMethodHandle()
- || instruction.isConstMethodType()
- || instruction.isConstNumber()
- || instruction.isConstString()
- || instruction.isDebugInstruction()
- || instruction.isDexItemBasedConstString()
- || instruction.isGoto()
- || instruction.isIf()
- || instruction.isInstanceOf()
- || instruction.isInvokeMultiNewArray()
- || instruction.isInvokeNewArray()
- || instruction.isMoveException()
- || instruction.isNewArrayEmpty()
- || instruction.isNewArrayFilledData()
- || instruction.isReturn()
- || instruction.isSwitch()
- || instruction.isThrow()
- || instruction.isUnop()
- || instruction.isRecordFieldValues()
- : "Unexpected instruction of type " + instruction.getClass().getTypeName();
}
- }
- if (block.hasUniqueNormalSuccessorWithUniquePredecessor()) {
- block = block.getUniqueNormalSuccessor();
- } else {
- end = block;
- block = null;
- }
- } while (block != null);
- assert end != null;
- activeStates.recordActiveStateOnBlockExit(end, activeState);
+ if (block.hasUniqueNormalSuccessorWithUniquePredecessor()) {
+ block = block.getUniqueNormalSuccessor();
+ } else {
+ end = block;
+ block = null;
+ }
+ } while (block != null);
+ assert end != null;
+ activeStates.recordActiveStateOnBlockExit(end, activeState);
+ }
+ processInstructionsToRemove();
+ assumeRemover.removeMarkedInstructions().finish();
+ if (hasChanged) {
+ code.removeRedundantBlocks();
+ }
+ assert code.isConsistentSSA(appView);
+ return CodeRewriterResult.hasChanged(hasChanged);
}
- processInstructionsToRemove();
- assumeRemover.removeMarkedInstructions().finish();
- code.removeRedundantBlocks();
- assert code.isConsistentSSA(appView);
- }
- private void processInstructionsToRemove() {
- instructionsToRemove.forEach(
- (block, instructionsToRemoveInBlock) -> {
- assert instructionsToRemoveInBlock.stream()
- .allMatch(instruction -> instruction.getBlock() == block);
- InstructionListIterator instructionIterator = block.listIterator(code);
- while (instructionIterator.hasNext()) {
- Instruction instruction = instructionIterator.next();
- assert !instruction.isJumpInstruction();
- if (instructionsToRemoveInBlock.contains(instruction)) {
- instructionIterator.removeOrReplaceByDebugLocalRead();
- instructionsToRemoveInBlock.remove(instruction);
- if (instructionsToRemoveInBlock.isEmpty()) {
- return;
+ private void processInstructionsToRemove() {
+ instructionsToRemove.forEach(
+ (block, instructionsToRemoveInBlock) -> {
+ assert instructionsToRemoveInBlock.stream()
+ .allMatch(instruction -> instruction.getBlock() == block);
+ InstructionListIterator instructionIterator = block.listIterator(code);
+ while (instructionIterator.hasNext()) {
+ Instruction instruction = instructionIterator.next();
+ assert !instruction.isJumpInstruction();
+ if (instructionsToRemoveInBlock.contains(instruction)) {
+ instructionIterator.removeOrReplaceByDebugLocalRead();
+ hasChanged = true;
+ instructionsToRemoveInBlock.remove(instruction);
+ if (instructionsToRemoveInBlock.isEmpty()) {
+ return;
+ }
}
}
- }
- });
- }
-
- private boolean verifyWasInstanceInitializer() {
- VerticallyMergedClasses verticallyMergedClasses = appView.verticallyMergedClasses();
- assert verticallyMergedClasses != null;
- assert verticallyMergedClasses.isMergeTarget(method.getHolderType())
- || appView.horizontallyMergedClasses().isMergeTarget(method.getHolderType());
- assert appView
- .dexItemFactory()
- .isConstructor(appView.graphLens().getOriginalMethodSignature(method.getReference()));
- assert method.getDefinition().getOptimizationInfo().forceInline();
- return true;
- }
-
- private void handleInvokeDirect(InvokeDirect invoke) {
- if (!appView.hasLiveness()) {
- killAllNonFinalActiveFields();
- return;
+ });
}
- AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
-
- DexClassAndMethod singleTarget = invoke.lookupSingleTarget(appView, method);
- if (singleTarget == null || !singleTarget.getDefinition().isInstanceInitializer()) {
- killAllNonFinalActiveFields();
- return;
+ private boolean verifyWasInstanceInitializer() {
+ VerticallyMergedClasses verticallyMergedClasses = appView.verticallyMergedClasses();
+ assert verticallyMergedClasses != null;
+ assert verticallyMergedClasses.isMergeTarget(method.getHolderType())
+ || appView.horizontallyMergedClasses().isMergeTarget(method.getHolderType());
+ assert appView
+ .dexItemFactory()
+ .isConstructor(appView.graphLens().getOriginalMethodSignature(method.getReference()));
+ assert method.getDefinition().getOptimizationInfo().forceInline();
+ return true;
}
- InstanceInitializerInfo instanceInitializerInfo =
- singleTarget.getDefinition().getOptimizationInfo().getInstanceInitializerInfo(invoke);
- if (instanceInitializerInfo.mayHaveOtherSideEffectsThanInstanceFieldAssignments()) {
- killAllNonFinalActiveFields();
- }
+ private void handleInvokeDirect(InvokeDirect invoke) {
+ if (!appView.hasLiveness()) {
+ killAllNonFinalActiveFields();
+ return;
+ }
- InstanceFieldInitializationInfoCollection fieldInitializationInfos =
- instanceInitializerInfo.fieldInitializationInfos();
- fieldInitializationInfos.forEachWithDeterministicOrder(
- appView,
- (field, info) -> {
- if (!appViewWithLiveness
- .appInfo()
- .mayPropagateValueFor(appViewWithLiveness, field.getReference())) {
- return;
- }
- if (info.isArgumentInitializationInfo()) {
- Value value =
- invoke.getArgument(info.asArgumentInitializationInfo().getArgumentIndex());
- Value object = invoke.getReceiver().getAliasedValue();
- FieldAndObject fieldAndObject = new FieldAndObject(field.getReference(), object);
- if (field.isFinalOrEffectivelyFinal(appViewWithLiveness)) {
- activeState.putFinalOrEffectivelyFinalInstanceField(
- fieldAndObject, new ExistingValue(value));
- } else {
- activeState.putNonFinalInstanceField(fieldAndObject, new ExistingValue(value));
+ AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
+
+ DexClassAndMethod singleTarget = invoke.lookupSingleTarget(appView, method);
+ if (singleTarget == null || !singleTarget.getDefinition().isInstanceInitializer()) {
+ killAllNonFinalActiveFields();
+ return;
+ }
+
+ InstanceInitializerInfo instanceInitializerInfo =
+ singleTarget.getDefinition().getOptimizationInfo().getInstanceInitializerInfo(invoke);
+ if (instanceInitializerInfo.mayHaveOtherSideEffectsThanInstanceFieldAssignments()) {
+ killAllNonFinalActiveFields();
+ }
+
+ InstanceFieldInitializationInfoCollection fieldInitializationInfos =
+ instanceInitializerInfo.fieldInitializationInfos();
+ fieldInitializationInfos.forEachWithDeterministicOrder(
+ appView,
+ (field, info) -> {
+ if (!appViewWithLiveness
+ .appInfo()
+ .mayPropagateValueFor(appViewWithLiveness, field.getReference())) {
+ return;
}
- } else if (info.isSingleValue()) {
- SingleValue value = info.asSingleValue();
- if (value.isMaterializableInContext(appViewWithLiveness, method)) {
+ if (info.isArgumentInitializationInfo()) {
+ Value value =
+ invoke.getArgument(info.asArgumentInitializationInfo().getArgumentIndex());
Value object = invoke.getReceiver().getAliasedValue();
FieldAndObject fieldAndObject = new FieldAndObject(field.getReference(), object);
if (field.isFinalOrEffectivelyFinal(appViewWithLiveness)) {
activeState.putFinalOrEffectivelyFinalInstanceField(
- fieldAndObject, new MaterializableValue(value));
+ fieldAndObject, new ExistingValue(value));
} else {
- activeState.putNonFinalInstanceField(
- fieldAndObject, new MaterializableValue(value));
+ activeState.putNonFinalInstanceField(fieldAndObject, new ExistingValue(value));
}
+ } else if (info.isSingleValue()) {
+ SingleValue value = info.asSingleValue();
+ if (value.isMaterializableInContext(appViewWithLiveness, method)) {
+ Value object = invoke.getReceiver().getAliasedValue();
+ FieldAndObject fieldAndObject = new FieldAndObject(field.getReference(), object);
+ if (field.isFinalOrEffectivelyFinal(appViewWithLiveness)) {
+ activeState.putFinalOrEffectivelyFinalInstanceField(
+ fieldAndObject, new MaterializableValue(value));
+ } else {
+ activeState.putNonFinalInstanceField(
+ fieldAndObject, new MaterializableValue(value));
+ }
+ }
+ } else {
+ assert info.isTypeInitializationInfo();
}
- } else {
- assert info.isTypeInitializationInfo();
- }
- });
- }
-
- private void handleInvokeStatic(InvokeStatic invoke) {
- if (appView.hasClassHierarchy()) {
- ProgramMethod resolvedMethod =
- appView
- .appInfo()
- .withClassHierarchy()
- .unsafeResolveMethodDueToDexFormatLegacy(invoke.getInvokedMethod())
- .getResolvedProgramMethod();
- if (resolvedMethod != null) {
- markClassAsInitialized(resolvedMethod.getHolderType());
- markMostRecentInitClassForRemoval(resolvedMethod.getHolderType());
- }
+ });
}
- killAllNonFinalActiveFields();
- }
-
- private void handleInitClass(InstructionListIterator instructionIterator, InitClass initClass) {
- assert !initClass.outValue().hasAnyUsers();
-
- killNonFinalActiveFields(initClass);
-
- // If the instruction can throw, we can't use any previous field stores for store-after-store
- // elimination.
- if (initClass.instructionInstanceCanThrow(appView, method)) {
- activeState.clearMostRecentFieldWrites();
- }
-
- DexType clazz = initClass.getClassValue();
- if (markClassAsInitialized(clazz)) {
- if (release) {
- activeState.setMostRecentInitClass(initClass);
- }
- } else {
- instructionIterator.removeOrReplaceByDebugLocalRead();
- }
- }
-
- private boolean markClassAsInitialized(DexType type) {
- return activeState.markClassAsInitialized(type);
- }
-
- private void markMostRecentInitClassForRemoval(DexType initializedType) {
- InitClass mostRecentInitClass = activeState.getMostRecentInitClass();
- if (mostRecentInitClass != null && mostRecentInitClass.getClassValue() == initializedType) {
- instructionsToRemove
- .computeIfAbsent(mostRecentInitClass.getBlock(), ignoreKey(Sets::newIdentityHashSet))
- .add(mostRecentInitClass);
- }
- }
-
- private void handleArrayGet(InstructionListIterator it, ArrayGet arrayGet) {
- if (arrayGet.array().hasLocalInfo()) {
- // The array may be modified through the debugger. Therefore subsequent reads of the same
- // array slot may not read this local.
- return;
- }
- if (arrayGet.outValue().hasLocalInfo()) {
- // This local may be modified through the debugger. Therefore subsequent reads of the same
- // array slot may not read this local.
- return;
- }
-
- Value array = arrayGet.array().getAliasedValue();
- Value index = arrayGet.index().getAliasedValue();
- ArraySlot arraySlot = ArraySlot.create(array, index, arrayGet.getMemberType());
- FieldValue replacement = activeState.getArraySlotValue(arraySlot);
- if (replacement != null) {
- TypeElement outType = arrayGet.outValue().getType();
- if (replacement.getType(appView, outType).lessThanOrEqual(outType, appView)) {
- replacement.eliminateRedundantRead(it, arrayGet);
- }
- return;
- }
- activeState.putArraySlotValue(arraySlot, new ExistingValue(arrayGet.outValue()));
- }
-
- private void handleArrayPut(ArrayPut arrayPut) {
- int index = arrayPut.getIndexOrDefault(-1);
- MemberType memberType = arrayPut.getMemberType();
-
- // An array-put instruction can potentially write the given array slot on all arrays because of
- // aliases.
- if (index < 0) {
- activeState.removeArraySlotValues(memberType);
- } else {
- activeState.removeArraySlotValues(memberType, index);
- }
-
- // Update the value of the field to allow redundant load elimination.
- Value array = arrayPut.array().getAliasedValue();
- Value indexValue = arrayPut.index().getAliasedValue();
- ArraySlot arraySlot = ArraySlot.create(array, indexValue, memberType);
- ExistingValue value = new ExistingValue(arrayPut.value());
- activeState.putArraySlotValue(arraySlot, value);
- }
-
- private void handleInstanceGet(
- InstructionListIterator it,
- InstanceGet instanceGet,
- DexClassAndField field,
- AssumeRemover assumeRemover) {
- if (instanceGet.outValue().hasLocalInfo()) {
- clearMostRecentInstanceFieldWrite(instanceGet, field);
- return;
- }
-
- Value object = instanceGet.object().getAliasedValue();
- FieldAndObject fieldAndObject = new FieldAndObject(field.getReference(), object);
- FieldValue replacement = activeState.getInstanceFieldValue(fieldAndObject);
- if (replacement != null) {
- if (isRedundantFieldLoadEliminationAllowed(field)) {
- markAssumeDynamicTypeUsersForRemoval(instanceGet, replacement, assumeRemover);
- replacement.eliminateRedundantRead(it, instanceGet);
- }
- return;
- }
-
- activeState.putNonFinalInstanceField(fieldAndObject, new ExistingValue(instanceGet.value()));
- activeState.clearMostRecentInitClass();
- clearMostRecentInstanceFieldWrite(instanceGet, field);
- }
-
- private boolean isRedundantFieldLoadEliminationAllowed(DexClassAndField field) {
- // Always allowed in D8 since D8 does not support @NoRedundantFieldLoadElimination.
- return !appView.enableWholeProgramOptimizations()
- || !field.isProgramField()
- || appView
- .getKeepInfo(field.asProgramField())
- .isRedundantFieldLoadEliminationAllowed(appView.options());
- }
-
- private void handleNewInstance(NewInstance newInstance) {
- markClassAsInitialized(newInstance.getType());
- markMostRecentInitClassForRemoval(newInstance.getType());
- if (newInstance.getType().classInitializationMayHaveSideEffectsInContext(appView, method)) {
- killAllNonFinalActiveFields();
- }
- }
-
- private void clearMostRecentInstanceFieldWrite(InstanceGet instanceGet, DexClassAndField field) {
- // If the instruction can throw, we need to clear all most-recent-writes, since subsequent field
- // writes (if any) are not guaranteed to be executed.
- if (instanceGet.instructionInstanceCanThrow(appView, method)) {
- activeState.clearMostRecentFieldWrites();
- } else {
- activeState.clearMostRecentInstanceFieldWrite(field.getReference());
- }
- }
-
- private void markAssumeDynamicTypeUsersForRemoval(
- FieldGet fieldGet, FieldValue replacement, AssumeRemover assumeRemover) {
- ExistingValue existingValue = replacement.asExistingValue();
- if (existingValue == null
- || !existingValue
- .getValue()
- .isDefinedByInstructionSatisfying(
- definition ->
- definition.isFieldGet()
- && definition.asFieldGet().getField().getType()
- == fieldGet.getField().getType())) {
- assumeRemover.markAssumeDynamicTypeUsersForRemoval(fieldGet.outValue());
- }
- }
-
- private void handleInstancePut(InstancePut instancePut, DexClassAndField field) {
- // An instance-put instruction can potentially write the given field on all objects because of
- // aliases.
- activeState.removeNonFinalInstanceFields(field.getReference());
-
- // If the instruction can throw, we can't use any previous field stores for store-after-store
- // elimination.
- if (instancePut.instructionInstanceCanThrow(appView, method)) {
- activeState.clearMostRecentFieldWrites();
- }
-
- // Update the value of the field to allow redundant load elimination.
- Value object = instancePut.object().getAliasedValue();
- FieldAndObject fieldAndObject = new FieldAndObject(field.getReference(), object);
- ExistingValue value = new ExistingValue(instancePut.value());
- if (field.isFinalOrEffectivelyFinal(appView)) {
- assert !field.getDefinition().isFinal()
- || method.getDefinition().isInstanceInitializer()
- || verifyWasInstanceInitializer();
- activeState.putFinalOrEffectivelyFinalInstanceField(fieldAndObject, value);
- } else {
- activeState.putNonFinalInstanceField(fieldAndObject, value);
- }
-
- // Record that this field is now most recently written by the current instruction.
- if (release) {
- InstancePut mostRecentInstanceFieldWrite =
- activeState.putMostRecentInstanceFieldWrite(fieldAndObject, instancePut);
- if (mostRecentInstanceFieldWrite != null) {
- instructionsToRemove
- .computeIfAbsent(
- mostRecentInstanceFieldWrite.getBlock(), ignoreKey(Sets::newIdentityHashSet))
- .add(mostRecentInstanceFieldWrite);
- }
- }
-
- activeState.clearMostRecentInitClass();
- }
-
- private void handleStaticGet(
- InstructionListIterator instructionIterator,
- StaticGet staticGet,
- DexClassAndField field,
- AssumeRemover assumeRemover) {
- markClassAsInitialized(field.getHolderType());
-
- if (staticGet.outValue().hasLocalInfo()) {
- killNonFinalActiveFields(staticGet);
- clearMostRecentStaticFieldWrite(staticGet, field);
- return;
- }
-
- FieldValue replacement = activeState.getStaticFieldValue(field.getReference());
- if (replacement != null) {
- markAssumeDynamicTypeUsersForRemoval(staticGet, replacement, assumeRemover);
- replacement.eliminateRedundantRead(instructionIterator, staticGet);
- return;
- }
-
- // A field get on a different class can cause <clinit> to run and change static field values.
- killNonFinalActiveFields(staticGet);
- clearMostRecentStaticFieldWrite(staticGet, field);
-
- FieldValue value = new ExistingValue(staticGet.value());
- if (field.isFinalOrEffectivelyFinal(appView)) {
- activeState.putFinalStaticField(field.getReference(), value);
- } else {
- activeState.putNonFinalStaticField(field.getReference(), value);
- }
-
- if (appView.hasLiveness()) {
- SingleFieldValue singleFieldValue =
- field.getDefinition().getOptimizationInfo().getAbstractValue().asSingleFieldValue();
- if (singleFieldValue != null) {
- applyObjectState(staticGet.outValue(), singleFieldValue.getObjectState());
- }
- }
-
- markMostRecentInitClassForRemoval(field.getHolderType());
- activeState.clearMostRecentInitClass();
- }
-
- private void clearMostRecentStaticFieldWrite(StaticGet staticGet, DexClassAndField field) {
- // If the instruction can throw, we need to clear all most-recent-writes, since subsequent field
- // writes (if any) are not guaranteed to be executed.
- if (staticGet.instructionInstanceCanThrow(appView, method)) {
- activeState.clearMostRecentFieldWrites();
- } else {
- activeState.clearMostRecentStaticFieldWrite(field.getReference());
- }
- }
-
- private void handleStaticPut(StaticPut staticPut, DexClassAndField field) {
- markClassAsInitialized(field.getHolderType());
-
- // A field put on a different class can cause <clinit> to run and change static field values.
- killNonFinalActiveFields(staticPut);
-
- // If the instruction can throw, we can't use any previous field stores for store-after-store
- // elimination.
- if (staticPut.instructionInstanceCanThrow(appView, method)) {
- activeState.clearMostRecentFieldWrites();
- }
-
- ExistingValue value = new ExistingValue(staticPut.value());
- if (field.isFinalOrEffectivelyFinal(appView)) {
- assert appView.checkForTesting(
- () -> !field.getDefinition().isFinal() || method.getDefinition().isClassInitializer());
- activeState.putFinalStaticField(field.getReference(), value);
- } else {
- activeState.putNonFinalStaticField(field.getReference(), value);
-
- if (release) {
- StaticPut mostRecentStaticFieldWrite =
- activeState.putMostRecentStaticFieldWrite(field.getReference(), staticPut);
- if (mostRecentStaticFieldWrite != null) {
- instructionsToRemove
- .computeIfAbsent(
- mostRecentStaticFieldWrite.getBlock(), ignoreKey(Sets::newIdentityHashSet))
- .add(mostRecentStaticFieldWrite);
+ private void handleInvokeStatic(InvokeStatic invoke) {
+ if (appView.hasClassHierarchy()) {
+ ProgramMethod resolvedMethod =
+ appView
+ .appInfo()
+ .withClassHierarchy()
+ .unsafeResolveMethodDueToDexFormatLegacy(invoke.getInvokedMethod())
+ .getResolvedProgramMethod();
+ if (resolvedMethod != null) {
+ markClassAsInitialized(resolvedMethod.getHolderType());
+ markMostRecentInitClassForRemoval(resolvedMethod.getHolderType());
}
}
+
+ killAllNonFinalActiveFields();
}
- markMostRecentInitClassForRemoval(field.getHolderType());
- activeState.clearMostRecentInitClass();
- }
+ private void handleInitClass(InstructionListIterator instructionIterator, InitClass initClass) {
+ assert !initClass.outValue().hasAnyUsers();
- private void applyObjectState(Value value, ObjectState objectState) {
- AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
- objectState.forEachAbstractFieldValue(
- (field, fieldValue) -> {
- if (appViewWithLiveness.appInfo().mayPropagateValueFor(appViewWithLiveness, field)
- && fieldValue.isSingleValue()) {
- SingleValue singleFieldValue = fieldValue.asSingleValue();
- if (singleFieldValue.isMaterializableInContext(appViewWithLiveness, method)) {
- activeState.putFinalOrEffectivelyFinalInstanceField(
- new FieldAndObject(field, value), new MaterializableValue(singleFieldValue));
- }
- }
- });
- }
+ killNonFinalActiveFields(initClass);
- private void killAllNonFinalActiveFields() {
- activeState.clearArraySlotValues();
- activeState.clearNonFinalInstanceFields();
- activeState.clearNonFinalStaticFields();
- activeState.clearMostRecentFieldWrites();
- activeState.clearMostRecentInitClass();
- }
+ // If the instruction can throw, we can't use any previous field stores for store-after-store
+ // elimination.
+ if (initClass.instructionInstanceCanThrow(appView, method)) {
+ activeState.clearMostRecentFieldWrites();
+ }
- private void killNonFinalActiveFields(Instruction instruction) {
- assert instruction.isInitClass() || instruction.isStaticFieldInstruction();
- if (instruction.isStaticPut()) {
- if (instruction.instructionMayTriggerMethodInvocation(appView, method)) {
- // Accessing a static field on a different object could cause <clinit> to run which
- // could modify any static field on any other object.
- activeState.clearNonFinalStaticFields();
+ DexType clazz = initClass.getClassValue();
+ if (markClassAsInitialized(clazz)) {
+ if (release) {
+ activeState.setMostRecentInitClass(initClass);
+ }
+ } else {
+ instructionIterator.removeOrReplaceByDebugLocalRead();
+ hasChanged = true;
+ }
+ }
+
+ private boolean markClassAsInitialized(DexType type) {
+ return activeState.markClassAsInitialized(type);
+ }
+
+ private void markMostRecentInitClassForRemoval(DexType initializedType) {
+ InitClass mostRecentInitClass = activeState.getMostRecentInitClass();
+ if (mostRecentInitClass != null && mostRecentInitClass.getClassValue() == initializedType) {
+ instructionsToRemove
+ .computeIfAbsent(mostRecentInitClass.getBlock(), ignoreKey(Sets::newIdentityHashSet))
+ .add(mostRecentInitClass);
+ }
+ }
+
+ private void handleArrayGet(InstructionListIterator it, ArrayGet arrayGet) {
+ if (arrayGet.array().hasLocalInfo()) {
+ // The array may be modified through the debugger. Therefore subsequent reads of the same
+ // array slot may not read this local.
+ return;
+ }
+ if (arrayGet.outValue().hasLocalInfo()) {
+ // This local may be modified through the debugger. Therefore subsequent reads of the same
+ // array slot may not read this local.
+ return;
+ }
+
+ Value array = arrayGet.array().getAliasedValue();
+ Value index = arrayGet.index().getAliasedValue();
+ ArraySlot arraySlot = ArraySlot.create(array, index, arrayGet.getMemberType());
+ FieldValue replacement = activeState.getArraySlotValue(arraySlot);
+ if (replacement != null) {
+ TypeElement outType = arrayGet.outValue().getType();
+ if (replacement.getType(appView, outType).lessThanOrEqual(outType, appView)) {
+ replacement.eliminateRedundantRead(it, arrayGet);
+ }
+ return;
+ }
+ activeState.putArraySlotValue(arraySlot, new ExistingValue(arrayGet.outValue()));
+ }
+
+ private void handleArrayPut(ArrayPut arrayPut) {
+ int index = arrayPut.getIndexOrDefault(-1);
+ MemberType memberType = arrayPut.getMemberType();
+
+ // An array-put instruction can potentially write the given array slot on all arrays because
+ // of
+ // aliases.
+ if (index < 0) {
+ activeState.removeArraySlotValues(memberType);
+ } else {
+ activeState.removeArraySlotValues(memberType, index);
+ }
+
+ // Update the value of the field to allow redundant load elimination.
+ Value array = arrayPut.array().getAliasedValue();
+ Value indexValue = arrayPut.index().getAliasedValue();
+ ArraySlot arraySlot = ArraySlot.create(array, indexValue, memberType);
+ ExistingValue value = new ExistingValue(arrayPut.value());
+ activeState.putArraySlotValue(arraySlot, value);
+ }
+
+ private void handleInstanceGet(
+ InstructionListIterator it,
+ InstanceGet instanceGet,
+ DexClassAndField field,
+ AssumeRemover assumeRemover) {
+ if (instanceGet.outValue().hasLocalInfo()) {
+ clearMostRecentInstanceFieldWrite(instanceGet, field);
+ return;
+ }
+
+ Value object = instanceGet.object().getAliasedValue();
+ FieldAndObject fieldAndObject = new FieldAndObject(field.getReference(), object);
+ FieldValue replacement = activeState.getInstanceFieldValue(fieldAndObject);
+ if (replacement != null) {
+ if (isRedundantFieldLoadEliminationAllowed(field)) {
+ markAssumeDynamicTypeUsersForRemoval(instanceGet, replacement, assumeRemover);
+ replacement.eliminateRedundantRead(it, instanceGet);
+ }
+ return;
+ }
+
+ activeState.putNonFinalInstanceField(fieldAndObject, new ExistingValue(instanceGet.value()));
+ activeState.clearMostRecentInitClass();
+ clearMostRecentInstanceFieldWrite(instanceGet, field);
+ }
+
+ private boolean isRedundantFieldLoadEliminationAllowed(DexClassAndField field) {
+ // Always allowed in D8 since D8 does not support @NoRedundantFieldLoadElimination.
+ return !appView.enableWholeProgramOptimizations()
+ || !field.isProgramField()
+ || appView
+ .getKeepInfo(field.asProgramField())
+ .isRedundantFieldLoadEliminationAllowed(appView.options());
+ }
+
+ private void handleNewInstance(NewInstance newInstance) {
+ markClassAsInitialized(newInstance.getType());
+ markMostRecentInitClassForRemoval(newInstance.getType());
+ if (newInstance.getType().classInitializationMayHaveSideEffectsInContext(appView, method)) {
+ killAllNonFinalActiveFields();
+ }
+ }
+
+ private void clearMostRecentInstanceFieldWrite(
+ InstanceGet instanceGet, DexClassAndField field) {
+ // If the instruction can throw, we need to clear all most-recent-writes, since subsequent
+ // field
+ // writes (if any) are not guaranteed to be executed.
+ if (instanceGet.instructionInstanceCanThrow(appView, method)) {
activeState.clearMostRecentFieldWrites();
} else {
- activeState.removeNonFinalStaticField(instruction.asStaticPut().getField());
+ activeState.clearMostRecentInstanceFieldWrite(field.getReference());
}
- } else if (instruction.isInitClass() || instruction.isStaticGet()) {
- if (instruction.instructionMayTriggerMethodInvocation(appView, method)) {
- // Accessing a static field on a different object could cause <clinit> to run which
- // could modify any static field on any other object.
- activeState.clearNonFinalStaticFields();
+ }
+
+ private void markAssumeDynamicTypeUsersForRemoval(
+ FieldGet fieldGet, FieldValue replacement, AssumeRemover assumeRemover) {
+ ExistingValue existingValue = replacement.asExistingValue();
+ if (existingValue == null
+ || !existingValue
+ .getValue()
+ .isDefinedByInstructionSatisfying(
+ definition ->
+ definition.isFieldGet()
+ && definition.asFieldGet().getField().getType()
+ == fieldGet.getField().getType())) {
+ assumeRemover.markAssumeDynamicTypeUsersForRemoval(fieldGet.outValue());
+ }
+ }
+
+ private void handleInstancePut(InstancePut instancePut, DexClassAndField field) {
+ // An instance-put instruction can potentially write the given field on all objects because of
+ // aliases.
+ activeState.removeNonFinalInstanceFields(field.getReference());
+
+ // If the instruction can throw, we can't use any previous field stores for store-after-store
+ // elimination.
+ if (instancePut.instructionInstanceCanThrow(appView, method)) {
activeState.clearMostRecentFieldWrites();
}
- } else if (instruction.isInstanceGet()) {
- throw new Unreachable();
+
+ // Update the value of the field to allow redundant load elimination.
+ Value object = instancePut.object().getAliasedValue();
+ FieldAndObject fieldAndObject = new FieldAndObject(field.getReference(), object);
+ ExistingValue value = new ExistingValue(instancePut.value());
+ if (field.isFinalOrEffectivelyFinal(appView)) {
+ assert !field.getDefinition().isFinal()
+ || method.getDefinition().isInstanceInitializer()
+ || verifyWasInstanceInitializer();
+ activeState.putFinalOrEffectivelyFinalInstanceField(fieldAndObject, value);
+ } else {
+ activeState.putNonFinalInstanceField(fieldAndObject, value);
+ }
+
+ // Record that this field is now most recently written by the current instruction.
+ if (release) {
+ InstancePut mostRecentInstanceFieldWrite =
+ activeState.putMostRecentInstanceFieldWrite(fieldAndObject, instancePut);
+ if (mostRecentInstanceFieldWrite != null) {
+ instructionsToRemove
+ .computeIfAbsent(
+ mostRecentInstanceFieldWrite.getBlock(), ignoreKey(Sets::newIdentityHashSet))
+ .add(mostRecentInstanceFieldWrite);
+ }
+ }
+
+ activeState.clearMostRecentInitClass();
+ }
+
+ private void handleStaticGet(
+ InstructionListIterator instructionIterator,
+ StaticGet staticGet,
+ DexClassAndField field,
+ AssumeRemover assumeRemover) {
+ markClassAsInitialized(field.getHolderType());
+
+ if (staticGet.outValue().hasLocalInfo()) {
+ killNonFinalActiveFields(staticGet);
+ clearMostRecentStaticFieldWrite(staticGet, field);
+ return;
+ }
+
+ FieldValue replacement = activeState.getStaticFieldValue(field.getReference());
+ if (replacement != null) {
+ markAssumeDynamicTypeUsersForRemoval(staticGet, replacement, assumeRemover);
+ replacement.eliminateRedundantRead(instructionIterator, staticGet);
+ return;
+ }
+
+ // A field get on a different class can cause <clinit> to run and change static field values.
+ killNonFinalActiveFields(staticGet);
+ clearMostRecentStaticFieldWrite(staticGet, field);
+
+ FieldValue value = new ExistingValue(staticGet.value());
+ if (field.isFinalOrEffectivelyFinal(appView)) {
+ activeState.putFinalStaticField(field.getReference(), value);
+ } else {
+ activeState.putNonFinalStaticField(field.getReference(), value);
+ }
+
+ if (appView.hasLiveness()) {
+ SingleFieldValue singleFieldValue =
+ field.getDefinition().getOptimizationInfo().getAbstractValue().asSingleFieldValue();
+ if (singleFieldValue != null) {
+ applyObjectState(staticGet.outValue(), singleFieldValue.getObjectState());
+ }
+ }
+
+ markMostRecentInitClassForRemoval(field.getHolderType());
+ activeState.clearMostRecentInitClass();
+ }
+
+ private void clearMostRecentStaticFieldWrite(StaticGet staticGet, DexClassAndField field) {
+ // If the instruction can throw, we need to clear all most-recent-writes, since subsequent
+ // field
+ // writes (if any) are not guaranteed to be executed.
+ if (staticGet.instructionInstanceCanThrow(appView, method)) {
+ activeState.clearMostRecentFieldWrites();
+ } else {
+ activeState.clearMostRecentStaticFieldWrite(field.getReference());
+ }
+ }
+
+ private void handleStaticPut(StaticPut staticPut, DexClassAndField field) {
+ markClassAsInitialized(field.getHolderType());
+
+ // A field put on a different class can cause <clinit> to run and change static field values.
+ killNonFinalActiveFields(staticPut);
+
+ // If the instruction can throw, we can't use any previous field stores for store-after-store
+ // elimination.
+ if (staticPut.instructionInstanceCanThrow(appView, method)) {
+ activeState.clearMostRecentFieldWrites();
+ }
+
+ ExistingValue value = new ExistingValue(staticPut.value());
+ if (field.isFinalOrEffectivelyFinal(appView)) {
+ assert appView.checkForTesting(
+ () -> !field.getDefinition().isFinal() || method.getDefinition().isClassInitializer());
+ activeState.putFinalStaticField(field.getReference(), value);
+ } else {
+ activeState.putNonFinalStaticField(field.getReference(), value);
+
+ if (release) {
+ StaticPut mostRecentStaticFieldWrite =
+ activeState.putMostRecentStaticFieldWrite(field.getReference(), staticPut);
+ if (mostRecentStaticFieldWrite != null) {
+ instructionsToRemove
+ .computeIfAbsent(
+ mostRecentStaticFieldWrite.getBlock(), ignoreKey(Sets::newIdentityHashSet))
+ .add(mostRecentStaticFieldWrite);
+ }
+ }
+ }
+
+ markMostRecentInitClassForRemoval(field.getHolderType());
+ activeState.clearMostRecentInitClass();
+ }
+
+ private void applyObjectState(Value value, ObjectState objectState) {
+ AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
+ objectState.forEachAbstractFieldValue(
+ (field, fieldValue) -> {
+ if (appViewWithLiveness.appInfo().mayPropagateValueFor(appViewWithLiveness, field)
+ && fieldValue.isSingleValue()) {
+ SingleValue singleFieldValue = fieldValue.asSingleValue();
+ if (singleFieldValue.isMaterializableInContext(appViewWithLiveness, method)) {
+ activeState.putFinalOrEffectivelyFinalInstanceField(
+ new FieldAndObject(field, value), new MaterializableValue(singleFieldValue));
+ }
+ }
+ });
+ }
+
+ private void killAllNonFinalActiveFields() {
+ activeState.clearArraySlotValues();
+ activeState.clearNonFinalInstanceFields();
+ activeState.clearNonFinalStaticFields();
+ activeState.clearMostRecentFieldWrites();
+ activeState.clearMostRecentInitClass();
+ }
+
+ private void killNonFinalActiveFields(Instruction instruction) {
+ assert instruction.isInitClass() || instruction.isStaticFieldInstruction();
+ if (instruction.isStaticPut()) {
+ if (instruction.instructionMayTriggerMethodInvocation(appView, method)) {
+ // Accessing a static field on a different object could cause <clinit> to run which
+ // could modify any static field on any other object.
+ activeState.clearNonFinalStaticFields();
+ activeState.clearMostRecentFieldWrites();
+ } else {
+ activeState.removeNonFinalStaticField(instruction.asStaticPut().getField());
+ }
+ } else if (instruction.isInitClass() || instruction.isStaticGet()) {
+ if (instruction.instructionMayTriggerMethodInvocation(appView, method)) {
+ // Accessing a static field on a different object could cause <clinit> to run which
+ // could modify any static field on any other object.
+ activeState.clearNonFinalStaticFields();
+ activeState.clearMostRecentFieldWrites();
+ }
+ } else if (instruction.isInstanceGet()) {
+ throw new Unreachable();
+ }
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
index 867c2dc..bf25b2d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingRewriter.java
@@ -46,6 +46,7 @@
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.InternalOptions;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collections;
@@ -150,7 +151,6 @@
return Sets.newIdentityHashSet();
}
assert code.isConsistentSSABeforeTypesAreCorrect(appView);
- ProgramMethod context = code.context();
EnumUnboxerMethodProcessorEventConsumer eventConsumer = methodProcessor.getEventConsumer();
Set<Phi> affectedPhis = Sets.newIdentityHashSet();
Map<Instruction, DexType> convertedEnums =
@@ -177,256 +177,42 @@
if (enumType != null) {
iterator.removeOrReplaceByDebugLocalRead();
}
- continue;
- }
-
- if (instruction.isIf()) {
- If ifInstruction = instruction.asIf();
- if (!ifInstruction.isZeroTest()) {
- for (int operandIndex = 0; operandIndex < 2; operandIndex++) {
- Value operand = ifInstruction.getOperand(operandIndex);
- DexType enumType = getEnumClassTypeOrNull(operand, convertedEnums);
- if (enumType != null) {
- int otherOperandIndex = 1 - operandIndex;
- Value otherOperand = ifInstruction.getOperand(otherOperandIndex);
- if (otherOperand.getType().isNullType()) {
- iterator.previous();
- ifInstruction.replaceValue(
- otherOperandIndex, iterator.insertConstIntInstruction(code, options, 0));
- iterator.next();
- break;
- }
- }
- }
- }
- }
-
- // Rewrites specific enum methods, such as ordinal, into their corresponding enum unboxed
- // counterpart. The rewriting (== or match) is based on the following:
- // - name, ordinal and compareTo are final and implemented only on java.lang.Enum,
- // - equals, hashCode are final and implemented in java.lang.Enum and java.lang.Object,
- // - getClass is final and implemented only in java.lang.Object,
- // - toString is non-final, implemented in java.lang.Object, java.lang.Enum and possibly
- // also in the unboxed enum class.
- if (instruction.isInvokeMethodWithReceiver()) {
- InvokeMethodWithReceiver invoke = instruction.asInvokeMethodWithReceiver();
- DexType enumType = getEnumClassTypeOrNull(invoke.getReceiver(), convertedEnums);
- DexMethod invokedMethod = invoke.getInvokedMethod();
- if (enumType != null) {
- if (invokedMethod == factory.enumMembers.ordinalMethod
- || invokedMethod.match(factory.enumMembers.hashCode)) {
- replaceEnumInvoke(
- iterator,
- invoke,
- getSharedUtilityClass().ensureOrdinalMethod(appView, context, eventConsumer));
- continue;
- } else if (invokedMethod.match(factory.enumMembers.equals)) {
- replaceEnumInvoke(
- iterator,
- invoke,
- getSharedUtilityClass().ensureEqualsMethod(appView, context, eventConsumer));
- continue;
- } else if (invokedMethod == factory.enumMembers.compareTo
- || invokedMethod == factory.enumMembers.compareToWithObject) {
- replaceEnumInvoke(
- iterator,
- invoke,
- getSharedUtilityClass().ensureCompareToMethod(appView, context, eventConsumer));
- continue;
- } else if (invokedMethod == factory.enumMembers.nameMethod) {
- rewriteNameMethod(iterator, invoke, enumType, context, eventConsumer);
- continue;
- } else if (invokedMethod.match(factory.enumMembers.toString)) {
- DexMethod reboundMethod =
- invokedMethod.withHolder(unboxedEnumsData.representativeType(enumType), factory);
- DexMethod lookupMethod =
- enumUnboxingLens
- .lookupMethod(
- reboundMethod,
- context.getReference(),
- invoke.getType(),
- enumUnboxingLens.getPrevious())
- .getReference();
- // If the SuperEnum had declared a toString() override, then the unboxer moves it to
- // the local utility class method corresponding to that override.
- // If a SubEnum had declared a toString() override, then the unboxer records a
- // synthetic move from SuperEnum.toString() to the dispatch method on the local
- // utility class.
- // When they are the same, then there are no overrides of toString().
- if (lookupMethod == reboundMethod) {
- rewriteNameMethod(iterator, invoke, enumType, context, eventConsumer);
- } else {
- DexClassAndMethod dexClassAndMethod = appView.definitionFor(lookupMethod);
- assert dexClassAndMethod != null;
- assert dexClassAndMethod.isProgramMethod();
- replaceEnumInvoke(iterator, invoke, dexClassAndMethod.asProgramMethod());
- }
- continue;
- } else if (invokedMethod == factory.objectMembers.getClass) {
- rewriteNullCheck(iterator, invoke, context, eventConsumer);
- continue;
- } else if (invoke.isInvokeVirtual() || invoke.isInvokeInterface()) {
- DexMethod refinedDispatchMethodReference =
- enumUnboxingLens.lookupRefinedDispatchMethod(
- invokedMethod,
- context.getReference(),
- invoke.getType(),
- enumUnboxingLens.getPrevious(),
- invoke.getArgument(0).getAbstractValue(appView, context),
- enumType);
- if (refinedDispatchMethodReference != null) {
- DexClassAndMethod refinedDispatchMethod =
- appView.definitionFor(refinedDispatchMethodReference);
- assert refinedDispatchMethod != null;
- assert refinedDispatchMethod.isProgramMethod();
- replaceEnumInvoke(iterator, invoke, refinedDispatchMethod.asProgramMethod());
- }
- continue;
- }
- } else if (invokedMethod == factory.stringBuilderMethods.appendObject
- || invokedMethod == factory.stringBufferMethods.appendObject) {
- // Rewrites stringBuilder.append(enumInstance) as if it was
- // stringBuilder.append(String.valueOf(unboxedEnumInstance));
- Value enumArg = invoke.getArgument(1);
- DexType enumArgType = getEnumClassTypeOrNull(enumArg, convertedEnums);
- if (enumArgType != null) {
- ProgramMethod stringValueOfMethod =
- getLocalUtilityClass(enumArgType)
- .ensureStringValueOfMethod(appView, context, eventConsumer);
- InvokeStatic toStringInvoke =
- InvokeStatic.builder()
- .setMethod(stringValueOfMethod)
- .setSingleArgument(enumArg)
- .setFreshOutValue(appView, code)
- .setPosition(invoke)
- .build();
- DexMethod newAppendMethod =
- invokedMethod == factory.stringBuilderMethods.appendObject
- ? factory.stringBuilderMethods.appendString
- : factory.stringBufferMethods.appendString;
- List<Value> arguments =
- ImmutableList.of(invoke.getReceiver(), toStringInvoke.outValue());
- InvokeVirtual invokeAppendString =
- new InvokeVirtual(newAppendMethod, invoke.clearOutValue(), arguments);
- invokeAppendString.setPosition(invoke.getPosition());
- iterator.replaceCurrentInstruction(toStringInvoke);
- if (block.hasCatchHandlers()) {
- iterator
- .splitCopyCatchHandlers(code, blocks, appView.options())
- .listIterator(code)
- .add(invokeAppendString);
- } else {
- iterator.add(invokeAppendString);
- }
- continue;
- }
- }
+ } else if (instruction.isIf()) {
+ rewriteIf(code, convertedEnums, iterator, instruction.asIf());
+ } else if (instruction.isInvokeMethodWithReceiver()) {
+ rewriteInvokeMethodWithReceiver(
+ code,
+ eventConsumer,
+ convertedEnums,
+ blocks,
+ block,
+ iterator,
+ instruction.asInvokeMethodWithReceiver());
} else if (instruction.isInvokeStatic()) {
rewriteInvokeStatic(
instruction.asInvokeStatic(),
code,
- context,
convertedEnums,
iterator,
affectedPhis,
eventConsumer);
- }
- if (instruction.isStaticGet()) {
- StaticGet staticGet = instruction.asStaticGet();
- DexField field = staticGet.getField();
- DexType holder = field.holder;
- if (!unboxedEnumsData.isUnboxedEnum(holder)) {
- continue;
- }
- if (staticGet.hasUnusedOutValue()) {
- iterator.removeOrReplaceByDebugLocalRead();
- continue;
- }
- affectedPhis.addAll(staticGet.outValue().uniquePhiUsers());
- if (unboxedEnumsData.matchesValuesField(field)) {
- // Load the size of this enum's $VALUES array before the current instruction.
- iterator.previous();
- Value sizeValue =
- iterator.insertConstIntInstruction(
- code, options, unboxedEnumsData.getValuesSize(holder));
- iterator.next();
-
- // Replace Enum.$VALUES by a call to: int[] SharedUtilityClass.values(int size).
- InvokeStatic invoke =
- InvokeStatic.builder()
- .setMethod(getSharedUtilityClass().getValuesMethod(context, eventConsumer))
- .setFreshOutValue(appView, code)
- .setSingleArgument(sizeValue)
- .build();
- iterator.replaceCurrentInstruction(invoke);
-
- convertedEnums.put(invoke, holder);
-
- // Check if the call to SharedUtilityClass.values(size) is followed by a call to
- // clone(). If so, remove it, since SharedUtilityClass.values(size) returns a fresh
- // array. This is needed because the javac generated implementation of MyEnum.values()
- // is implemented as `return $VALUES.clone()`.
- removeRedundantValuesArrayCloning(invoke, instructionsToRemove, seenBlocks);
- } else if (unboxedEnumsData.hasUnboxedValueFor(field)) {
- // Replace by ordinal + 1 for null check (null is 0).
- ConstNumber intConstant =
- code.createIntConstant(unboxedEnumsData.getUnboxedValue(field));
- iterator.replaceCurrentInstruction(intConstant);
- convertedEnums.put(intConstant, holder);
- } else {
- // Nothing to do, handled by lens code rewriting.
- }
- }
-
- if (instruction.isInstanceGet()) {
- InstanceGet instanceGet = instruction.asInstanceGet();
- DexType holder = instanceGet.getField().holder;
- if (unboxedEnumsData.isUnboxedEnum(holder)) {
- ProgramMethod fieldMethod =
- ensureInstanceFieldMethod(instanceGet.getField(), context, eventConsumer);
- Value rewrittenOutValue =
- code.createValue(
- TypeElement.fromDexType(fieldMethod.getReturnType(), maybeNull(), appView));
- Value in = instanceGet.object();
- if (in.getType().isNullType()) {
- iterator.previous();
- in = iterator.insertConstIntInstruction(code, options, 0);
- iterator.next();
- }
- InvokeStatic invoke =
- new InvokeStatic(
- fieldMethod.getReference(), rewrittenOutValue, ImmutableList.of(in));
- iterator.replaceCurrentInstruction(invoke);
- if (unboxedEnumsData.isUnboxedEnum(instanceGet.getField().type)) {
- convertedEnums.put(invoke, instanceGet.getField().type);
- }
- }
- }
-
- // Rewrite array accesses from MyEnum[] (OBJECT) to int[] (INT).
- if (instruction.isArrayAccess()) {
- ArrayAccess arrayAccess = instruction.asArrayAccess();
- DexType enumType = getEnumArrayTypeOrNull(arrayAccess, convertedEnums);
- if (enumType != null) {
- if (arrayAccess.hasOutValue()) {
- affectedPhis.addAll(arrayAccess.outValue().uniquePhiUsers());
- }
- arrayAccess = arrayAccess.withMemberType(MemberType.INT);
- iterator.replaceCurrentInstruction(arrayAccess);
- convertedEnums.put(arrayAccess, enumType);
- if (arrayAccess.isArrayPut()) {
- ArrayPut arrayPut = arrayAccess.asArrayPut();
- if (arrayPut.value().getType().isNullType()) {
- iterator.previous();
- arrayPut.replacePutValue(iterator.insertConstIntInstruction(code, options, 0));
- iterator.next();
- }
- }
- }
- assert validateArrayAccess(arrayAccess);
- }
-
- if (instruction.isNewUnboxedEnumInstance()) {
+ } else if (instruction.isStaticGet()) {
+ rewriteStaticGet(
+ code,
+ eventConsumer,
+ affectedPhis,
+ convertedEnums,
+ seenBlocks,
+ instructionsToRemove,
+ iterator,
+ instruction.asStaticGet());
+ } else if (instruction.isInstanceGet()) {
+ rewriteInstanceGet(
+ code, eventConsumer, convertedEnums, iterator, instruction.asInstanceGet());
+ } else if (instruction.isArrayAccess()) {
+ rewriteArrayAccess(
+ code, affectedPhis, convertedEnums, iterator, instruction.asArrayAccess());
+ } else if (instruction.isNewUnboxedEnumInstance()) {
NewUnboxedEnumInstance newUnboxedEnumInstance = instruction.asNewUnboxedEnumInstance();
assert unboxedEnumsData.isUnboxedEnum(newUnboxedEnumInstance.getType());
iterator.replaceCurrentInstruction(
@@ -440,14 +226,267 @@
return affectedPhis;
}
+ private void rewriteArrayAccess(
+ IRCode code,
+ Set<Phi> affectedPhis,
+ Map<Instruction, DexType> convertedEnums,
+ InstructionListIterator iterator,
+ ArrayAccess arrayAccess) {
+ // Rewrite array accesses from MyEnum[] (OBJECT) to int[] (INT).
+ DexType enumType = getEnumArrayTypeOrNull(arrayAccess, convertedEnums);
+ if (enumType != null) {
+ if (arrayAccess.hasOutValue()) {
+ affectedPhis.addAll(arrayAccess.outValue().uniquePhiUsers());
+ }
+ arrayAccess = arrayAccess.withMemberType(MemberType.INT);
+ iterator.replaceCurrentInstruction(arrayAccess);
+ convertedEnums.put(arrayAccess, enumType);
+ if (arrayAccess.isArrayPut()) {
+ ArrayPut arrayPut = arrayAccess.asArrayPut();
+ if (arrayPut.value().getType().isNullType()) {
+ iterator.previous();
+ arrayPut.replacePutValue(iterator.insertConstIntInstruction(code, options, 0));
+ iterator.next();
+ }
+ }
+ }
+ assert validateArrayAccess(arrayAccess);
+ }
+
+ private void rewriteIf(
+ IRCode code,
+ Map<Instruction, DexType> convertedEnums,
+ InstructionListIterator iterator,
+ If ifInstruction) {
+ if (!ifInstruction.isZeroTest()) {
+ for (int operandIndex = 0; operandIndex < 2; operandIndex++) {
+ Value operand = ifInstruction.getOperand(operandIndex);
+ DexType enumType = getEnumClassTypeOrNull(operand, convertedEnums);
+ if (enumType != null) {
+ int otherOperandIndex = 1 - operandIndex;
+ Value otherOperand = ifInstruction.getOperand(otherOperandIndex);
+ if (otherOperand.getType().isNullType()) {
+ iterator.previous();
+ ifInstruction.replaceValue(
+ otherOperandIndex, iterator.insertConstIntInstruction(code, options, 0));
+ iterator.next();
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ private void rewriteInstanceGet(
+ IRCode code,
+ EnumUnboxerMethodProcessorEventConsumer eventConsumer,
+ Map<Instruction, DexType> convertedEnums,
+ InstructionListIterator iterator,
+ InstanceGet instanceGet) {
+ DexType holder = instanceGet.getField().holder;
+ if (unboxedEnumsData.isUnboxedEnum(holder)) {
+ ProgramMethod fieldMethod =
+ ensureInstanceFieldMethod(instanceGet.getField(), code.context(), eventConsumer);
+ Value rewrittenOutValue =
+ code.createValue(
+ TypeElement.fromDexType(fieldMethod.getReturnType(), maybeNull(), appView));
+ Value in = instanceGet.object();
+ if (in.getType().isNullType()) {
+ iterator.previous();
+ in = iterator.insertConstIntInstruction(code, options, 0);
+ iterator.next();
+ }
+ InvokeStatic invoke =
+ new InvokeStatic(fieldMethod.getReference(), rewrittenOutValue, ImmutableList.of(in));
+ iterator.replaceCurrentInstruction(invoke);
+ if (unboxedEnumsData.isUnboxedEnum(instanceGet.getField().type)) {
+ convertedEnums.put(invoke, instanceGet.getField().type);
+ }
+ }
+ }
+
+ private void rewriteStaticGet(
+ IRCode code,
+ EnumUnboxerMethodProcessorEventConsumer eventConsumer,
+ Set<Phi> affectedPhis,
+ Map<Instruction, DexType> convertedEnums,
+ Set<BasicBlock> seenBlocks,
+ Set<Instruction> instructionsToRemove,
+ InstructionListIterator iterator,
+ StaticGet staticGet) {
+ DexField field = staticGet.getField();
+ DexType holder = field.holder;
+ if (!unboxedEnumsData.isUnboxedEnum(holder)) {
+ return;
+ }
+ if (staticGet.hasUnusedOutValue()) {
+ iterator.removeOrReplaceByDebugLocalRead();
+ return;
+ }
+ affectedPhis.addAll(staticGet.outValue().uniquePhiUsers());
+ if (unboxedEnumsData.matchesValuesField(field)) {
+ // Load the size of this enum's $VALUES array before the current instruction.
+ iterator.previous();
+ Value sizeValue =
+ iterator.insertConstIntInstruction(code, options, unboxedEnumsData.getValuesSize(holder));
+ iterator.next();
+
+ // Replace Enum.$VALUES by a call to: int[] SharedUtilityClass.values(int size).
+ InvokeStatic invoke =
+ InvokeStatic.builder()
+ .setMethod(getSharedUtilityClass().getValuesMethod(code.context(), eventConsumer))
+ .setFreshOutValue(appView, code)
+ .setSingleArgument(sizeValue)
+ .build();
+ iterator.replaceCurrentInstruction(invoke);
+
+ convertedEnums.put(invoke, holder);
+
+ // Check if the call to SharedUtilityClass.values(size) is followed by a call to
+ // clone(). If so, remove it, since SharedUtilityClass.values(size) returns a fresh
+ // array. This is needed because the javac generated implementation of MyEnum.values()
+ // is implemented as `return $VALUES.clone()`.
+ removeRedundantValuesArrayCloning(invoke, instructionsToRemove, seenBlocks);
+ } else if (unboxedEnumsData.hasUnboxedValueFor(field)) {
+ // Replace by ordinal + 1 for null check (null is 0).
+ ConstNumber intConstant = code.createIntConstant(unboxedEnumsData.getUnboxedValue(field));
+ iterator.replaceCurrentInstruction(intConstant);
+ convertedEnums.put(intConstant, holder);
+ } else {
+ // Nothing to do, handled by lens code rewriting.
+ }
+ }
+
+ // Rewrites specific enum methods, such as ordinal, into their corresponding enum unboxed
+ // counterpart. The rewriting (== or match) is based on the following:
+ // - name, ordinal and compareTo are final and implemented only on java.lang.Enum,
+ // - equals, hashCode are final and implemented in java.lang.Enum and java.lang.Object,
+ // - getClass is final and implemented only in java.lang.Object,
+ // - toString is non-final, implemented in java.lang.Object, java.lang.Enum and possibly
+ // also in the unboxed enum class.
+ private void rewriteInvokeMethodWithReceiver(
+ IRCode code,
+ EnumUnboxerMethodProcessorEventConsumer eventConsumer,
+ Map<Instruction, DexType> convertedEnums,
+ BasicBlockIterator blocks,
+ BasicBlock block,
+ InstructionListIterator iterator,
+ InvokeMethodWithReceiver invoke) {
+ ProgramMethod context = code.context();
+ // If the receiver is null, then the invoke is not rewritten even if the receiver is an
+ // unboxed enum, but we end up with null.ordinal() or similar which has the correct behavior.
+ DexType enumType = getEnumClassTypeOrNull(invoke.getReceiver(), convertedEnums);
+ DexMethod invokedMethod = invoke.getInvokedMethod();
+ if (enumType != null) {
+ if (invokedMethod == factory.enumMembers.ordinalMethod
+ || invokedMethod.match(factory.enumMembers.hashCode)) {
+ replaceEnumInvoke(
+ iterator,
+ invoke,
+ getSharedUtilityClass().ensureOrdinalMethod(appView, context, eventConsumer));
+ } else if (invokedMethod.match(factory.enumMembers.equals)) {
+ replaceEnumInvoke(
+ iterator,
+ invoke,
+ getSharedUtilityClass().ensureEqualsMethod(appView, context, eventConsumer));
+ } else if (invokedMethod == factory.enumMembers.compareTo
+ || invokedMethod == factory.enumMembers.compareToWithObject) {
+ replaceEnumInvoke(
+ iterator,
+ invoke,
+ getSharedUtilityClass().ensureCompareToMethod(appView, context, eventConsumer));
+ } else if (invokedMethod == factory.enumMembers.nameMethod) {
+ rewriteNameMethod(iterator, invoke, enumType, context, eventConsumer);
+ } else if (invokedMethod.match(factory.enumMembers.toString)) {
+ DexMethod reboundMethod =
+ invokedMethod.withHolder(unboxedEnumsData.representativeType(enumType), factory);
+ DexMethod lookupMethod =
+ enumUnboxingLens
+ .lookupMethod(
+ reboundMethod,
+ context.getReference(),
+ invoke.getType(),
+ enumUnboxingLens.getPrevious())
+ .getReference();
+ // If the SuperEnum had declared a toString() override, then the unboxer moves it to
+ // the local utility class method corresponding to that override.
+ // If a SubEnum had declared a toString() override, then the unboxer records a
+ // synthetic move from SuperEnum.toString() to the dispatch method on the local
+ // utility class.
+ // When they are the same, then there are no overrides of toString().
+ if (lookupMethod == reboundMethod) {
+ rewriteNameMethod(iterator, invoke, enumType, context, eventConsumer);
+ } else {
+ DexClassAndMethod dexClassAndMethod = appView.definitionFor(lookupMethod);
+ assert dexClassAndMethod != null;
+ assert dexClassAndMethod.isProgramMethod();
+ replaceEnumInvoke(iterator, invoke, dexClassAndMethod.asProgramMethod());
+ }
+ } else if (invokedMethod == factory.objectMembers.getClass) {
+ rewriteNullCheck(iterator, invoke, context, eventConsumer);
+ } else if (invoke.isInvokeVirtual() || invoke.isInvokeInterface()) {
+ DexMethod refinedDispatchMethodReference =
+ enumUnboxingLens.lookupRefinedDispatchMethod(
+ invokedMethod,
+ context.getReference(),
+ invoke.getType(),
+ enumUnboxingLens.getPrevious(),
+ invoke.getArgument(0).getAbstractValue(appView, context),
+ enumType);
+ if (refinedDispatchMethodReference != null) {
+ DexClassAndMethod refinedDispatchMethod =
+ appView.definitionFor(refinedDispatchMethodReference);
+ assert refinedDispatchMethod != null;
+ assert refinedDispatchMethod.isProgramMethod();
+ replaceEnumInvoke(iterator, invoke, refinedDispatchMethod.asProgramMethod());
+ }
+ }
+ } else if (invokedMethod == factory.stringBuilderMethods.appendObject
+ || invokedMethod == factory.stringBufferMethods.appendObject) {
+ // Rewrites stringBuilder.append(enumInstance) as if it was
+ // stringBuilder.append(String.valueOf(unboxedEnumInstance));
+ Value enumArg = invoke.getArgument(1);
+ DexType enumArgType = getEnumClassTypeOrNull(enumArg, convertedEnums);
+ if (enumArgType != null) {
+ ProgramMethod stringValueOfMethod =
+ getLocalUtilityClass(enumArgType)
+ .ensureStringValueOfMethod(appView, context, eventConsumer);
+ InvokeStatic toStringInvoke =
+ InvokeStatic.builder()
+ .setMethod(stringValueOfMethod)
+ .setSingleArgument(enumArg)
+ .setFreshOutValue(appView, code)
+ .setPosition(invoke)
+ .build();
+ DexMethod newAppendMethod =
+ invokedMethod == factory.stringBuilderMethods.appendObject
+ ? factory.stringBuilderMethods.appendString
+ : factory.stringBufferMethods.appendString;
+ List<Value> arguments = ImmutableList.of(invoke.getReceiver(), toStringInvoke.outValue());
+ InvokeVirtual invokeAppendString =
+ new InvokeVirtual(newAppendMethod, invoke.clearOutValue(), arguments);
+ invokeAppendString.setPosition(invoke.getPosition());
+ iterator.replaceCurrentInstruction(toStringInvoke);
+ if (block.hasCatchHandlers()) {
+ iterator
+ .splitCopyCatchHandlers(code, blocks, appView.options())
+ .listIterator(code)
+ .add(invokeAppendString);
+ } else {
+ iterator.add(invokeAppendString);
+ }
+ }
+ }
+ }
+
private void rewriteInvokeStatic(
InvokeStatic invoke,
IRCode code,
- ProgramMethod context,
Map<Instruction, DexType> convertedEnums,
InstructionListIterator instructionIterator,
Set<Phi> affectedPhis,
EnumUnboxerMethodProcessorEventConsumer eventConsumer) {
+ ProgramMethod context = code.context();
DexClassAndMethod singleTarget = invoke.lookupSingleTarget(appView, context);
if (singleTarget == null) {
return;
@@ -508,13 +547,28 @@
rewriteStringValueOf(invoke, context, convertedEnums, instructionIterator, eventConsumer);
} else if (invokedMethod == factory.objectsMethods.equals) {
assert invoke.arguments().size() == 2;
- Value argument = invoke.getFirstArgument();
- DexType enumType = getEnumClassTypeOrNull(argument, convertedEnums);
- if (enumType != null) {
+ if (Iterables.any(
+ invoke.arguments(), arg -> getEnumClassTypeOrNull(arg, convertedEnums) != null)) {
+ // If any of the input is null, replace it by const 0.
+ // If both inputs are null, no rewriting happen here.
+ List<Value> newArguments = new ArrayList<>(invoke.arguments().size());
+ for (Value arg : invoke.arguments()) {
+ if (arg.getType().isNullType()) {
+ Value constZero = insertConstZero(code);
+ newArguments.add(constZero);
+ } else {
+ assert getEnumClassTypeOrNull(arg, convertedEnums) != null;
+ newArguments.add(arg);
+ }
+ }
replaceEnumInvoke(
instructionIterator,
invoke,
- getSharedUtilityClass().ensureObjectsEqualsMethod(appView, context, eventConsumer));
+ getSharedUtilityClass().ensureObjectsEqualsMethod(appView, context, eventConsumer),
+ newArguments);
+ } else {
+ assert invoke.getArgument(0).getType().isReferenceType();
+ assert invoke.getArgument(1).getType().isReferenceType();
}
}
return;
@@ -687,11 +741,19 @@
private void replaceEnumInvoke(
InstructionListIterator iterator, InvokeMethod invoke, ProgramMethod method) {
+ replaceEnumInvoke(iterator, invoke, method, invoke.arguments());
+ }
+
+ private void replaceEnumInvoke(
+ InstructionListIterator iterator,
+ InvokeMethod invoke,
+ ProgramMethod method,
+ List<Value> arguments) {
InvokeStatic replacement =
new InvokeStatic(
method.getReference(),
invoke.hasUnusedOutValue() ? null : invoke.outValue(),
- invoke.arguments());
+ arguments);
assert !replacement.hasOutValue()
|| !replacement.getInvokedMethod().getReturnType().isVoidType();
iterator.replaceCurrentInstruction(replacement);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderAppendOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderAppendOptimizer.java
index 5ed16f7..2bc3346 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderAppendOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/string/StringBuilderAppendOptimizer.java
@@ -117,6 +117,8 @@
}
}
code.removeAllDeadAndTrivialPhis();
+ code.removeRedundantBlocks();
+ assert code.isConsistentSSA(appView);
return CodeRewriterResult.HAS_CHANGED;
}
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/RecordCfCodeProvider.java b/src/main/java/com/android/tools/r8/ir/synthetic/RecordCfCodeProvider.java
index 6602826..5abcb38 100644
--- a/src/main/java/com/android/tools/r8/ir/synthetic/RecordCfCodeProvider.java
+++ b/src/main/java/com/android/tools/r8/ir/synthetic/RecordCfCodeProvider.java
@@ -8,6 +8,7 @@
import com.android.tools.r8.cf.code.CfCheckCast;
import com.android.tools.r8.cf.code.CfConstNumber;
import com.android.tools.r8.cf.code.CfFrame;
+import com.android.tools.r8.cf.code.CfIf;
import com.android.tools.r8.cf.code.CfIfCmp;
import com.android.tools.r8.cf.code.CfInstanceFieldRead;
import com.android.tools.r8.cf.code.CfInstruction;
@@ -153,6 +154,9 @@
@Override
public CfCode generateCfCode() {
// This generates something along the lines of:
+ // if (other == null) {
+ // return false;
+ // }
// if (this.getClass() != other.getClass()) {
// return false;
// }
@@ -160,10 +164,22 @@
// recordInstance.getFieldsAsObjects(),
// ((RecordClass) other).getFieldsAsObjects());
DexItemFactory factory = appView.dexItemFactory();
- List<CfInstruction> instructions = new ArrayList<>();
+ int numberOfInstructions = 22;
+ List<CfInstruction> instructions = new ArrayList<>(numberOfInstructions);
+ CfLabel notNullLabel = new CfLabel();
CfLabel fieldCmp = new CfLabel();
ValueType recordType = ValueType.fromDexType(getHolder());
ValueType objectType = ValueType.fromDexType(factory.objectType);
+ instructions.add(new CfLoad(objectType, 1));
+ instructions.add(new CfIf(IfType.NE, ValueType.OBJECT, notNullLabel));
+ instructions.add(new CfConstNumber(0, ValueType.INT));
+ instructions.add(new CfReturn(ValueType.INT));
+ instructions.add(notNullLabel);
+ instructions.add(
+ CfFrame.builder()
+ .appendLocal(FrameType.initialized(getHolder()))
+ .appendLocal(FrameType.initialized(appView.dexItemFactory().objectType))
+ .build());
instructions.add(new CfLoad(recordType, 0));
instructions.add(new CfInvoke(Opcodes.INVOKEVIRTUAL, factory.objectMembers.getClass, false));
instructions.add(new CfLoad(objectType, 1));
@@ -186,6 +202,7 @@
new CfInvoke(
Opcodes.INVOKESTATIC, factory.javaUtilArraysMethods.equalsObjectArray, false));
instructions.add(new CfReturn(ValueType.INT));
+ assert instructions.size() == numberOfInstructions;
return standardCfCodeFromInstructions(instructions);
}
}
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteClassTypeParameterState.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteClassTypeParameterState.java
index fab9f6f..43da39b 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteClassTypeParameterState.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcreteClassTypeParameterState.java
@@ -105,15 +105,11 @@
DexType parameterType,
Action onChangedAction) {
assert parameterType.isClassType();
- boolean allowNullOrAbstractValue = true;
- boolean allowNonConstantNumbers = false;
AbstractValue oldAbstractValue = abstractValue;
abstractValue =
- abstractValue.join(
- parameterState.getAbstractValue(appView),
- appView.abstractValueFactory(),
- allowNullOrAbstractValue,
- allowNonConstantNumbers);
+ appView
+ .getAbstractValueParameterJoiner()
+ .join(abstractValue, parameterState.getAbstractValue(appView), parameterType);
DynamicType oldDynamicType = dynamicType;
DynamicType joinedDynamicType = dynamicType.join(appView, parameterState.getDynamicType());
DynamicType widenedDynamicType =
diff --git a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcretePrimitiveTypeParameterState.java b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcretePrimitiveTypeParameterState.java
index 429e514..3b3f3cb 100644
--- a/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcretePrimitiveTypeParameterState.java
+++ b/src/main/java/com/android/tools/r8/optimize/argumentpropagation/codescanner/ConcretePrimitiveTypeParameterState.java
@@ -56,15 +56,11 @@
DexType parameterType,
Action onChangedAction) {
assert parameterType.isPrimitiveType();
- boolean allowNullOrAbstractValue = false;
- boolean allowNonConstantNumbers = false;
AbstractValue oldAbstractValue = abstractValue;
abstractValue =
- abstractValue.join(
- parameterState.abstractValue,
- appView.abstractValueFactory(),
- allowNullOrAbstractValue,
- allowNonConstantNumbers);
+ appView
+ .getAbstractValueParameterJoiner()
+ .join(abstractValue, parameterState.abstractValue, parameterType);
if (abstractValue.isUnknown()) {
return unknown();
}
diff --git a/src/main/java/com/android/tools/r8/optimize/redundantbridgeremoval/RedundantBridgeRemover.java b/src/main/java/com/android/tools/r8/optimize/redundantbridgeremoval/RedundantBridgeRemover.java
index ad329a1..85e7fdd 100644
--- a/src/main/java/com/android/tools/r8/optimize/redundantbridgeremoval/RedundantBridgeRemover.java
+++ b/src/main/java/com/android/tools/r8/optimize/redundantbridgeremoval/RedundantBridgeRemover.java
@@ -135,31 +135,27 @@
// Collect all redundant bridges to remove.
ProgramMethodSet bridgesToRemove = removeRedundantBridgesConcurrently(executorService);
- if (bridgesToRemove.isEmpty()) {
- timing.end();
- return;
- }
+ if (!bridgesToRemove.isEmpty()) {
+ pruneApp(bridgesToRemove, executorService, timing);
- pruneApp(bridgesToRemove, executorService, timing);
+ if (!lensBuilder.isEmpty()) {
+ appView.setGraphLens(lensBuilder.build(appView));
+ }
- if (!lensBuilder.isEmpty()) {
- appView.setGraphLens(lensBuilder.build(appView));
- }
-
- if (memberRebindingIdentityLens != null) {
- for (ProgramMethod bridgeToRemove : bridgesToRemove) {
- DexClassAndMethod resolvedMethod =
- appView
- .appInfo()
- .resolveMethodOn(bridgeToRemove.getHolder(), bridgeToRemove.getReference())
- .getResolutionPair();
- memberRebindingIdentityLens.addNonReboundMethodReference(
- bridgeToRemove.getReference(), resolvedMethod.getReference());
+ if (memberRebindingIdentityLens != null) {
+ for (ProgramMethod bridgeToRemove : bridgesToRemove) {
+ DexClassAndMethod resolvedMethod =
+ appView
+ .appInfo()
+ .resolveMethodOn(bridgeToRemove.getHolder(), bridgeToRemove.getReference())
+ .getResolutionPair();
+ memberRebindingIdentityLens.addNonReboundMethodReference(
+ bridgeToRemove.getReference(), resolvedMethod.getReference());
+ }
}
}
-
appView.notifyOptimizationFinishedForTesting();
- appView.appInfo().notifyRedundantBridgeRemoverFinished(true);
+ appView.appInfo().notifyRedundantBridgeRemoverFinished(memberRebindingIdentityLens == null);
timing.end();
}
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 1ea86b5..4bbc625 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -80,6 +80,7 @@
import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
import com.android.tools.r8.graph.NestMemberClassAttribute;
import com.android.tools.r8.graph.ObjectAllocationInfoCollectionImpl;
+import com.android.tools.r8.graph.PermittedSubclassAttribute;
import com.android.tools.r8.graph.ProgramDefinition;
import com.android.tools.r8.graph.ProgramDerivedContext;
import com.android.tools.r8.graph.ProgramField;
@@ -2098,6 +2099,23 @@
}
}
+ // Mark types in permitted-subclasses attributes referenced.
+ List<PermittedSubclassAttribute> permittedSubclassAttributes =
+ clazz.getPermittedSubclassAttributes();
+ if (!permittedSubclassAttributes.isEmpty()) {
+ BiConsumer<DexType, ProgramDerivedContext> missingClassConsumer =
+ options.reportMissingClassesInPermittedSubclassesAttributes
+ ? this::reportMissingClass
+ : this::ignoreMissingClass;
+ for (PermittedSubclassAttribute permittedSubclassAttribute : permittedSubclassAttributes) {
+ recordTypeReference(
+ permittedSubclassAttribute.getPermittedSubclass(),
+ clazz,
+ this::recordNonProgramClass,
+ missingClassConsumer);
+ }
+ }
+
KeepReason reason = KeepReason.reachableFromLiveType(clazz.type);
for (DexType iface : clazz.getInterfaces()) {
diff --git a/src/main/java/com/android/tools/r8/shaking/EnqueuerDeferredTracingRewriter.java b/src/main/java/com/android/tools/r8/shaking/EnqueuerDeferredTracingRewriter.java
index 48312bd..7d25797 100644
--- a/src/main/java/com/android/tools/r8/shaking/EnqueuerDeferredTracingRewriter.java
+++ b/src/main/java/com/android/tools/r8/shaking/EnqueuerDeferredTracingRewriter.java
@@ -69,6 +69,7 @@
// Rewrite field instructions that reference a pruned field.
Set<Value> affectedValues = Sets.newIdentityHashSet();
BasicBlockIterator blockIterator = code.listIterator();
+ boolean hasChanged = false;
while (blockIterator.hasNext()) {
BasicBlock block = blockIterator.next();
InstructionListIterator instructionIterator = block.listIterator(code);
@@ -76,34 +77,38 @@
Instruction instruction = instructionIterator.next();
switch (instruction.opcode()) {
case INSTANCE_GET:
- rewriteInstanceGet(
- code,
- instructionIterator,
- instruction.asInstanceGet(),
- affectedValues,
- prunedFields);
+ hasChanged |=
+ rewriteInstanceGet(
+ code,
+ instructionIterator,
+ instruction.asInstanceGet(),
+ affectedValues,
+ prunedFields);
break;
case INSTANCE_PUT:
- rewriteInstancePut(instructionIterator, instruction.asInstancePut(), prunedFields);
+ hasChanged |=
+ rewriteInstancePut(instructionIterator, instruction.asInstancePut(), prunedFields);
break;
case STATIC_GET:
- rewriteStaticGet(
- code,
- instructionIterator,
- instruction.asStaticGet(),
- affectedValues,
- context,
- initializedClassesWithContexts,
- prunedFields);
+ hasChanged |=
+ rewriteStaticGet(
+ code,
+ instructionIterator,
+ instruction.asStaticGet(),
+ affectedValues,
+ context,
+ initializedClassesWithContexts,
+ prunedFields);
break;
case STATIC_PUT:
- rewriteStaticPut(
- code,
- instructionIterator,
- instruction.asStaticPut(),
- context,
- initializedClassesWithContexts,
- prunedFields);
+ hasChanged |=
+ rewriteStaticPut(
+ code,
+ instructionIterator,
+ instruction.asStaticPut(),
+ context,
+ initializedClassesWithContexts,
+ prunedFields);
break;
default:
break;
@@ -113,9 +118,12 @@
if (!affectedValues.isEmpty()) {
new TypeAnalysis(appView).narrowing(affectedValues);
}
+ if (hasChanged) {
+ code.removeRedundantBlocks();
+ }
}
- private void rewriteInstanceGet(
+ private boolean rewriteInstanceGet(
IRCode code,
InstructionListIterator instructionIterator,
InstanceGet instanceGet,
@@ -123,27 +131,29 @@
Map<DexField, ProgramField> prunedFields) {
ProgramField prunedField = prunedFields.get(instanceGet.getField());
if (prunedField == null) {
- return;
+ return false;
}
insertDefaultValueForFieldGet(
code, instructionIterator, instanceGet, affectedValues, prunedField);
removeOrReplaceInstanceFieldInstructionWithNullCheck(instructionIterator, instanceGet);
+ return true;
}
- private void rewriteInstancePut(
+ private boolean rewriteInstancePut(
InstructionListIterator instructionIterator,
InstancePut instancePut,
Map<DexField, ProgramField> prunedFields) {
ProgramField prunedField = prunedFields.get(instancePut.getField());
if (prunedField == null) {
- return;
+ return false;
}
removeOrReplaceInstanceFieldInstructionWithNullCheck(instructionIterator, instancePut);
+ return true;
}
- private void rewriteStaticGet(
+ private boolean rewriteStaticGet(
IRCode code,
InstructionListIterator instructionIterator,
StaticGet staticGet,
@@ -153,16 +163,17 @@
Map<DexField, ProgramField> prunedFields) {
ProgramField prunedField = prunedFields.get(staticGet.getField());
if (prunedField == null) {
- return;
+ return false;
}
insertDefaultValueForFieldGet(
code, instructionIterator, staticGet, affectedValues, prunedField);
removeOrReplaceStaticFieldInstructionByInitClass(
code, instructionIterator, context, initializedClassesWithContexts, prunedField);
+ return true;
}
- private void rewriteStaticPut(
+ private boolean rewriteStaticPut(
IRCode code,
InstructionListIterator instructionIterator,
StaticPut staticPut,
@@ -171,11 +182,12 @@
Map<DexField, ProgramField> prunedFields) {
ProgramField prunedField = prunedFields.get(staticPut.getField());
if (prunedField == null) {
- return;
+ return false;
}
removeOrReplaceStaticFieldInstructionByInitClass(
code, instructionIterator, context, initializedClassesWithContexts, prunedField);
+ return true;
}
private void insertDefaultValueForFieldGet(
diff --git a/src/main/java/com/android/tools/r8/shaking/KeepClassInfo.java b/src/main/java/com/android/tools/r8/shaking/KeepClassInfo.java
index 9898d34..c199247 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepClassInfo.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepClassInfo.java
@@ -257,6 +257,11 @@
return self();
}
+ public Joiner allowPermittedSubclassesRemoval() {
+ builder.allowPermittedSubclassesRemoval();
+ return self();
+ }
+
@Override
public Joiner asClassJoiner() {
return this;
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
index bec7ae6..9d98730 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
@@ -1050,6 +1050,8 @@
builder.getModifiersBuilder().setAllowsAccessModification(true);
} else if (acceptString("repackage")) {
builder.getModifiersBuilder().setAllowsRepackaging(true);
+ } else if (acceptString("permittedsubclassesremoval")) {
+ builder.getModifiersBuilder().setAllowsPermittedSubclassesRemoval(true);
} else if (options.isTestingOptionsEnabled()) {
if (acceptString("annotationremoval")) {
builder.getModifiersBuilder().setAllowsAnnotationRemoval(true);
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardKeepRuleModifiers.java b/src/main/java/com/android/tools/r8/shaking/ProguardKeepRuleModifiers.java
index ec825c3..6073953 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardKeepRuleModifiers.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardKeepRuleModifiers.java
@@ -15,6 +15,7 @@
private boolean allowsOptimization = false;
private boolean allowsObfuscation = false;
private boolean includeDescriptorClasses = false;
+ private boolean allowsPermittedSubclassesRemoval = false;
private Builder() {}
@@ -61,6 +62,11 @@
return this;
}
+ public Builder setAllowsPermittedSubclassesRemoval(boolean allowsPermittedSubclassesRemoval) {
+ this.allowsPermittedSubclassesRemoval = allowsPermittedSubclassesRemoval;
+ return this;
+ }
+
public void setIncludeDescriptorClasses(boolean includeDescriptorClasses) {
this.includeDescriptorClasses = includeDescriptorClasses;
}
@@ -73,7 +79,8 @@
allowsShrinking,
allowsOptimization,
allowsObfuscation,
- includeDescriptorClasses);
+ includeDescriptorClasses,
+ allowsPermittedSubclassesRemoval);
}
}
@@ -84,6 +91,7 @@
public final boolean allowsOptimization;
public final boolean allowsObfuscation;
public final boolean includeDescriptorClasses;
+ public final boolean allowsPermittedSubclassesRemoval;
private ProguardKeepRuleModifiers(
boolean allowsAccessModification,
@@ -92,7 +100,8 @@
boolean allowsShrinking,
boolean allowsOptimization,
boolean allowsObfuscation,
- boolean includeDescriptorClasses) {
+ boolean includeDescriptorClasses,
+ boolean allowsPermittedSubclassesRemoval) {
this.allowsAccessModification = allowsAccessModification;
this.allowsAnnotationRemoval = allowsAnnotationRemoval;
this.allowsRepackaging = allowsRepackaging;
@@ -100,6 +109,7 @@
this.allowsOptimization = allowsOptimization;
this.allowsObfuscation = allowsObfuscation;
this.includeDescriptorClasses = includeDescriptorClasses;
+ this.allowsPermittedSubclassesRemoval = allowsPermittedSubclassesRemoval;
}
/**
@@ -116,7 +126,8 @@
&& allowsObfuscation
&& allowsOptimization
&& allowsShrinking
- && !includeDescriptorClasses;
+ && !includeDescriptorClasses
+ && allowsPermittedSubclassesRemoval;
}
@Override
@@ -131,7 +142,8 @@
&& allowsShrinking == that.allowsShrinking
&& allowsOptimization == that.allowsOptimization
&& allowsObfuscation == that.allowsObfuscation
- && includeDescriptorClasses == that.includeDescriptorClasses;
+ && includeDescriptorClasses == that.includeDescriptorClasses
+ && allowsPermittedSubclassesRemoval == that.allowsPermittedSubclassesRemoval;
}
@Override
@@ -143,7 +155,8 @@
allowsShrinking,
allowsOptimization,
allowsObfuscation,
- includeDescriptorClasses);
+ includeDescriptorClasses,
+ allowsPermittedSubclassesRemoval);
}
@Override
@@ -156,6 +169,7 @@
appendWithComma(builder, allowsShrinking, "allowshrinking");
appendWithComma(builder, allowsOptimization, "allowoptimization");
appendWithComma(builder, includeDescriptorClasses, "includedescriptorclasses");
+ appendWithComma(builder, allowsPermittedSubclassesRemoval, "allowpermittedsubclassesremoval");
return builder.toString();
}
diff --git a/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java b/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java
index 8678717..afe4006 100644
--- a/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java
+++ b/src/main/java/com/android/tools/r8/shaking/RootSetUtils.java
@@ -1665,6 +1665,16 @@
includeDescriptorClasses(item, keepRule, preconditionEvent);
context.markAsUsed();
}
+
+ if (item.isProgramClass()
+ && appView.options().isKeepPermittedSubclassesEnabled()
+ && !modifiers.allowsPermittedSubclassesRemoval) {
+ dependentMinimumKeepInfo
+ .getOrCreateMinimumKeepInfoFor(preconditionEvent, item.getReference())
+ .asClassJoiner()
+ .disallowPermittedSubclassesRemoval();
+ context.markAsUsed();
+ }
}
private boolean isRepackagingDisallowed(
diff --git a/src/main/java/com/android/tools/r8/shaking/TreePruner.java b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
index 3688415..ec15263 100644
--- a/src/main/java/com/android/tools/r8/shaking/TreePruner.java
+++ b/src/main/java/com/android/tools/r8/shaking/TreePruner.java
@@ -21,6 +21,7 @@
import com.android.tools.r8.graph.EnclosingMethodAttribute;
import com.android.tools.r8.graph.InnerClassAttribute;
import com.android.tools.r8.graph.NestMemberClassAttribute;
+import com.android.tools.r8.graph.PermittedSubclassAttribute;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.graph.PrunedItems;
import com.android.tools.r8.graph.RecordComponentInfo;
@@ -226,6 +227,7 @@
PredicateUtils.not(isReachableInstanceField(reachableInstanceFields)));
}
}
+ clazz.removePermittedSubclassAttribute(this::isAttributeReferencingPrunedType);
unusedItemsPrinter.visited();
assert verifyNoDeadFields(clazz);
}
@@ -319,6 +321,10 @@
return context == null || isTypeMissing(context) || !isTypeLive(context);
}
+ private boolean isAttributeReferencingPrunedType(PermittedSubclassAttribute attr) {
+ return !isTypeLive(attr.getPermittedSubclass());
+ }
+
private <D extends DexEncodedMember<D, R>, R extends DexMember<D, R>> int firstUnreachableIndex(
List<D> items, Predicate<D> live) {
for (int i = 0; i < items.size(); i++) {
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index c284670..d49b405 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -141,7 +141,15 @@
public enum LineNumberOptimization {
OFF,
- ON
+ ON;
+
+ public boolean isOff() {
+ return this == OFF;
+ }
+
+ public boolean isOn() {
+ return this == ON;
+ }
}
public enum DesugarState {
@@ -876,6 +884,7 @@
public boolean ignoreMissingClasses = false;
public boolean reportMissingClassesInEnclosingMethodAttribute = false;
public boolean reportMissingClassesInInnerClassAttributes = false;
+ public boolean reportMissingClassesInPermittedSubclassesAttributes = false;
public boolean disableGenericSignatureValidation = false;
public boolean disableInnerClassSeparatorValidationWhenRepackaging = false;
@@ -2585,7 +2594,7 @@
}
public boolean canUseDexPc2PcAsDebugInformation() {
- return isGeneratingDex() && lineNumberOptimization == LineNumberOptimization.ON;
+ return isGeneratingDex() && lineNumberOptimization.isOn();
}
// Debug entries may be dropped only if the source file content allows being omitted from
diff --git a/src/main/java/com/android/tools/r8/utils/collections/DexClassAndMemberMap.java b/src/main/java/com/android/tools/r8/utils/collections/DexClassAndMemberMap.java
index 2a044e5..bbc27a2 100644
--- a/src/main/java/com/android/tools/r8/utils/collections/DexClassAndMemberMap.java
+++ b/src/main/java/com/android/tools/r8/utils/collections/DexClassAndMemberMap.java
@@ -5,8 +5,10 @@
package com.android.tools.r8.utils.collections;
import com.android.tools.r8.graph.DexClassAndMember;
+import com.android.tools.r8.utils.TriPredicate;
import com.google.common.base.Equivalence.Wrapper;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
@@ -77,6 +79,12 @@
.removeIf(entry -> predicate.test(entry.getKey().get(), entry.getValue()));
}
+ public boolean removeIf(TriPredicate<K, V, Entry<?, V>> predicate) {
+ return backing
+ .entrySet()
+ .removeIf(entry -> predicate.test(entry.getKey().get(), entry.getValue(), entry));
+ }
+
public int size() {
return backing.size();
}
diff --git a/src/main/java/com/android/tools/r8/utils/positions/DexPositionToNoPcMappedRangeMapper.java b/src/main/java/com/android/tools/r8/utils/positions/DexPositionToNoPcMappedRangeMapper.java
index a6a2a06..e80a0a7 100644
--- a/src/main/java/com/android/tools/r8/utils/positions/DexPositionToNoPcMappedRangeMapper.java
+++ b/src/main/java/com/android/tools/r8/utils/positions/DexPositionToNoPcMappedRangeMapper.java
@@ -26,7 +26,6 @@
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.code.Position;
import com.android.tools.r8.ir.code.Position.SourcePosition;
-import com.android.tools.r8.utils.InternalOptions.LineNumberOptimization;
import java.util.ArrayList;
import java.util.List;
@@ -176,7 +175,7 @@
public DexPositionToNoPcMappedRangeMapper(AppView<?> appView) {
this.appView = appView;
- isIdentityMapping = appView.options().lineNumberOptimization == LineNumberOptimization.OFF;
+ isIdentityMapping = appView.options().lineNumberOptimization.isOff();
}
public List<MappedPosition> optimizeDexCodePositions(
diff --git a/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java b/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java
index 7fe3d32..487ac5f 100644
--- a/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java
+++ b/src/main/java/com/android/tools/r8/utils/positions/MappedPositionToClassNameMapperBuilder.java
@@ -1,4 +1,3 @@
-// Copyright (c) 2022, 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.
@@ -45,7 +44,6 @@
import com.android.tools.r8.synthesis.SyntheticItems;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.IntBox;
-import com.android.tools.r8.utils.InternalOptions.LineNumberOptimization;
import com.android.tools.r8.utils.ListUtils;
import com.android.tools.r8.utils.OneShotCollectionConsumer;
import com.android.tools.r8.utils.OriginalSourceFiles;
@@ -56,6 +54,7 @@
import it.unimi.dsi.fastutil.ints.Int2IntSortedMap;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Comparator;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
@@ -79,7 +78,7 @@
PositionRangeAllocator.createCardinalPositionRangeAllocator();
private final NonCardinalPositionRangeAllocator nonCardinalRangeCache =
PositionRangeAllocator.createNonCardinalPositionRangeAllocator();
- private final int maxGap = 1000;
+ private final int maxGap;
private MappedPositionToClassNameMapperBuilder(
AppView<?> appView, OriginalSourceFiles originalSourceFiles) {
@@ -88,6 +87,7 @@
classNameMapperBuilder = ClassNameMapper.builder();
classNameMapperBuilder.setCurrentMapVersion(
appView.options().getMapFileVersion().toMapVersionMappingInformation());
+ maxGap = appView.options().lineNumberOptimization.isOn() ? 1000 : 0;
}
public static String getPrunedInlinedClassObfuscatedPrefix() {
@@ -246,7 +246,7 @@
residualMethod,
originalMethod,
originalType)) {
- assert appView.options().lineNumberOptimization == LineNumberOptimization.OFF
+ assert appView.options().lineNumberOptimization.isOff()
|| hasAtMostOnePosition(appView, definition)
|| appView.isCfByteCodePassThrough(definition);
return this;
@@ -290,6 +290,8 @@
methodSpecificMappingInformation.add(OutlineMappingInformation.builder().build());
}
+ mappedPositions.sort(Comparator.comparing(MappedPosition::getObfuscatedLine));
+
// Update memberNaming with the collected positions, merging multiple positions into a
// single region whenever possible.
for (int i = 0; i < mappedPositions.size(); /* updated in body */ ) {
@@ -317,14 +319,7 @@
|| firstMappedPosition.getPosition().getOutlineCallee() != null) {
break;
}
- // The mapped positions are not guaranteed to be in order, so maintain first and last
- // position.
- if (firstMappedPosition.getObfuscatedLine() > currentMappedPosition.getObfuscatedLine()) {
- firstMappedPosition = currentMappedPosition;
- }
- if (lastMappedPosition.getObfuscatedLine() < currentMappedPosition.getObfuscatedLine()) {
- lastMappedPosition = currentMappedPosition;
- }
+ lastMappedPosition = currentMappedPosition;
}
Range obfuscatedRange =
nonCardinalRangeCache.get(
@@ -385,9 +380,7 @@
}
i = j;
}
- // TODO(b/287210793): Enable assertion again.
- assert true
- || mappedPositions.size() <= 1
+ assert mappedPositions.size() <= 1
|| getBuilder().hasNoOverlappingRangesForSignature(residualSignature);
return this;
}
diff --git a/src/main/java/com/android/tools/r8/utils/positions/PositionRemapper.java b/src/main/java/com/android/tools/r8/utils/positions/PositionRemapper.java
index 3f0288f..861c9dc 100644
--- a/src/main/java/com/android/tools/r8/utils/positions/PositionRemapper.java
+++ b/src/main/java/com/android/tools/r8/utils/positions/PositionRemapper.java
@@ -20,7 +20,6 @@
import com.android.tools.r8.utils.CfLineToMethodMapper;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.InternalOptions.LineNumberOptimization;
import com.android.tools.r8.utils.Pair;
import java.util.IdentityHashMap;
import java.util.Map;
@@ -34,8 +33,7 @@
static PositionRemapper getPositionRemapper(
AppView<?> appView, CfLineToMethodMapper cfLineToMethodMapper) {
- boolean identityMapping =
- appView.options().lineNumberOptimization == LineNumberOptimization.OFF;
+ boolean identityMapping = appView.options().lineNumberOptimization.isOff();
PositionRemapper positionRemapper =
identityMapping
? new IdentityPositionRemapper()
diff --git a/src/test/examplesJava17/records/SimpleRecord.java b/src/test/examplesJava17/records/SimpleRecord.java
index 1f8fca4..3f908dc 100644
--- a/src/test/examplesJava17/records/SimpleRecord.java
+++ b/src/test/examplesJava17/records/SimpleRecord.java
@@ -14,5 +14,22 @@
System.out.println(janeDoe.age);
System.out.println(janeDoe.name());
System.out.println(janeDoe.age());
+
+ // Test equals with self.
+ System.out.println(janeDoe.equals(janeDoe));
+
+ // Test equals with structurally equals Person.
+ Person otherJaneDoe = new Person("Jane Doe", 42);
+ System.out.println(janeDoe.equals(otherJaneDoe));
+ System.out.println(otherJaneDoe.equals(janeDoe));
+
+ // Test equals with not-structually equals Person.
+ Person johnDoe = new Person("John Doe", 42);
+ System.out.println(janeDoe.equals(johnDoe));
+ System.out.println(johnDoe.equals(janeDoe));
+
+ // Test equals with Object and null.
+ System.out.println(janeDoe.equals(new Object()));
+ System.out.println(janeDoe.equals(null));
}
}
diff --git a/src/test/java/com/android/tools/r8/KotlinTestBase.java b/src/test/java/com/android/tools/r8/KotlinTestBase.java
index 35e20e9..f314547 100644
--- a/src/test/java/com/android/tools/r8/KotlinTestBase.java
+++ b/src/test/java/com/android/tools/r8/KotlinTestBase.java
@@ -91,8 +91,7 @@
}
protected Path getJavaJarFile(String folder) {
- return Paths.get(ToolHelper.TESTS_BUILD_DIR, RSRC,
- targetVersion.getFolderName(), folder + ".java" + FileUtils.JAR_EXTENSION);
+ return Paths.get(ToolHelper.TESTS_BUILD_DIR, RSRC, folder + FileUtils.JAR_EXTENSION);
}
protected Path getMappingfile(String folder, String mappingFileName) {
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index ec3a345..3bad712 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -80,8 +80,6 @@
import com.android.tools.r8.utils.ListUtils;
import com.android.tools.r8.utils.Pair;
import com.android.tools.r8.utils.PreloadedClassFileProvider;
-import com.android.tools.r8.utils.ReflectiveBuildPathUtils;
-import com.android.tools.r8.utils.ReflectiveBuildPathUtils.ExamplesClass;
import com.android.tools.r8.utils.Reporter;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.TestDescriptionWatcher;
@@ -1688,18 +1686,6 @@
return clazz.getTypeName();
}
- public static ClassReference examplesClassReference(Class<? extends ExamplesClass> clazz) {
- return Reference.classFromTypeName(examplesTypeName(clazz));
- }
-
- public static String examplesTypeName(Class<? extends ExamplesClass> clazz) {
- try {
- return ReflectiveBuildPathUtils.resolveClassName(clazz);
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
- }
-
public static AndroidApiLevel apiLevelWithDefaultInterfaceMethodsSupport() {
return AndroidApiLevel.N;
}
diff --git a/src/test/java/com/android/tools/r8/TestBaseBuilder.java b/src/test/java/com/android/tools/r8/TestBaseBuilder.java
index 63b1982..c9740c3 100644
--- a/src/test/java/com/android/tools/r8/TestBaseBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestBaseBuilder.java
@@ -10,8 +10,6 @@
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.ListUtils;
-import com.android.tools.r8.utils.ReflectiveBuildPathUtils;
-import com.android.tools.r8.utils.ReflectiveBuildPathUtils.ExamplesRootPackage;
import com.google.common.collect.ImmutableMap;
import java.nio.file.Path;
import java.util.Arrays;
@@ -56,12 +54,6 @@
return self();
}
- public T addExamplesProgramFiles(Class<? extends ExamplesRootPackage> rootPackage)
- throws Exception {
- Collection<Path> files = ReflectiveBuildPathUtils.allClassFiles(rootPackage);
- return addProgramFiles(files);
- }
-
public T addLibraryProvider(ClassFileResourceProvider provider) {
builder.addLibraryResourceProvider(provider);
return self();
diff --git a/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java b/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
index f27b3b8..9b4e4fd 100644
--- a/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
@@ -6,6 +6,7 @@
import com.android.tools.r8.TestBase.Backend;
import com.android.tools.r8.dexsplitter.SplitterTestBase.RunInterface;
+import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.MethodReference;
import com.android.tools.r8.references.TypeReference;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
@@ -314,6 +315,10 @@
return addKeepMainRule(mainClass.getTypeName());
}
+ public T addKeepMainRule(ClassReference mainClass) {
+ return addKeepMainRule(mainClass.getTypeName());
+ }
+
public T addKeepMainRules(Class<?>... mainClasses) {
for (Class<?> mainClass : mainClasses) {
this.addKeepMainRule(mainClass);
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index 42b728e..447399f 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -119,8 +119,8 @@
public static final String LIBS_DIR = BUILD_DIR + "libs/";
public static final String THIRD_PARTY_DIR = getProjectRoot() + "third_party/";
public static final String TOOLS_DIR = getProjectRoot() + "tools/";
- public static final String TESTS_DIR = "src/test/";
- public static final String TESTS_SOURCE_DIR = "src/test/java";
+ public static final String TESTS_DIR = getProjectRoot() + "src/test/";
+ public static final String TESTS_SOURCE_DIR = TESTS_DIR + "java/";
public static final String EXAMPLES_DIR = TESTS_DIR + "examples/";
public static final String EXAMPLES_ANDROID_N_DIR = TESTS_DIR + "examplesAndroidN/";
public static final String EXAMPLES_ANDROID_O_DIR = TESTS_DIR + "examplesAndroidO/";
@@ -140,7 +140,6 @@
public static final String GENERATED_PROTO_BUILD_DIR = GENERATED_TEST_BUILD_DIR + "proto/";
public static final String SMALI_BUILD_DIR = THIRD_PARTY_DIR + "smali/";
public static final String JAVA_CLASSES_DIR = BUILD_DIR + "classes/java/";
- public static final String JDK_11_TESTS_CLASSES_DIR = JAVA_CLASSES_DIR + "jdk11Tests/";
public static final String R8_TEST_BUCKET = "r8-test-results";
@@ -178,7 +177,7 @@
private static final String PROGUARD6_0_1 =
THIRD_PARTY_DIR + "proguard/proguard6.0.1/bin/proguard";
private static final String PROGUARD = PROGUARD5_2_1;
- public static final Path JACOCO_ROOT = Paths.get("third_party", "jacoco", "0.8.6");
+ public static final Path JACOCO_ROOT = Paths.get(THIRD_PARTY_DIR, "jacoco", "0.8.6");
public static final Path JACOCO_AGENT = JACOCO_ROOT.resolve(Paths.get("lib", "jacocoagent.jar"));
public static final Path JACOCO_CLI = JACOCO_ROOT.resolve(Paths.get("lib", "jacococli.jar"));
public static final String PROGUARD_SETTINGS_FOR_INTERNAL_APPS =
@@ -1322,11 +1321,6 @@
return getClassPathForTests().resolve(Paths.get("", parts.toArray(StringUtils.EMPTY_ARRAY)));
}
- public static String getJarEntryForTestPackage(Package pkg) {
- List<String> parts = getNamePartsForTestPackage(pkg);
- return String.join("/", parts);
- }
-
private static List<String> getNamePartsForTestClass(Class<?> clazz) {
List<String> parts = Lists.newArrayList(clazz.getTypeName().split("\\."));
parts.set(parts.size() - 1, parts.get(parts.size() - 1) + ".class");
diff --git a/src/test/java/com/android/tools/r8/benchmarks/appdumps/AppDumpBenchmarkBuilder.java b/src/test/java/com/android/tools/r8/benchmarks/appdumps/AppDumpBenchmarkBuilder.java
index 57d23d8..f69b30f 100644
--- a/src/test/java/com/android/tools/r8/benchmarks/appdumps/AppDumpBenchmarkBuilder.java
+++ b/src/test/java/com/android/tools/r8/benchmarks/appdumps/AppDumpBenchmarkBuilder.java
@@ -3,8 +3,10 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.benchmarks.appdumps;
+import com.android.tools.r8.LibraryDesugaringTestConfiguration;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestBase.Backend;
+import com.android.tools.r8.TestCompilerBuilder;
import com.android.tools.r8.benchmarks.BenchmarkBase;
import com.android.tools.r8.benchmarks.BenchmarkConfig;
import com.android.tools.r8.benchmarks.BenchmarkConfigError;
@@ -17,6 +19,7 @@
import com.android.tools.r8.dump.CompilerDump;
import com.android.tools.r8.dump.DumpOptions;
import java.io.IOException;
+import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
@@ -146,6 +149,15 @@
return CompilerDump.fromArchive(dump, environment.getTemp().newFolder().toPath());
}
+ private static void addDesugaredLibrary(
+ TestCompilerBuilder<?, ?, ?, ?, ?> builder, CompilerDump dump) {
+ Path config = dump.getDesugaredLibraryFile();
+ if (Files.exists(config)) {
+ builder.enableCoreLibraryDesugaring(
+ LibraryDesugaringTestConfiguration.forSpecification(config));
+ }
+ }
+
private static BenchmarkMethod runR8(AppDumpBenchmarkBuilder builder) {
return environment ->
BenchmarkBase.runner(environment.getConfig())
@@ -159,6 +171,7 @@
.addLibraryFiles(dump.getLibraryArchive())
.addKeepRuleFiles(dump.getProguardConfigFile())
.setMinApi(dumpProperties.getMinApi())
+ .apply(b -> addDesugaredLibrary(b, dump))
.allowUnnecessaryDontWarnWildcards()
.allowUnusedDontWarnPatterns()
.allowUnusedProguardConfigurationRules()
@@ -184,6 +197,7 @@
.addProgramFiles(dump.getProgramArchive())
.addLibraryFiles(dump.getLibraryArchive())
.setMinApi(dumpProperties.getMinApi())
+ .apply(b -> addDesugaredLibrary(b, dump))
.benchmarkCompile(results)
.benchmarkCodeSize(results);
});
@@ -219,6 +233,7 @@
.addClasspathFiles(dump.getProgramArchive())
.addLibraryFiles(dump.getLibraryArchive())
.setMinApi(dumpProperties.getMinApi())
+ .apply(b -> addDesugaredLibrary(b, dump))
.setIntermediate(true)
.benchmarkCompile(results.getSubResults(builder.nameForProgramPart()))
.writeToZip());
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NestClassMergingTestRunner.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NestClassMergingTestRunner.java
index 30b4939..f3ab716 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NestClassMergingTestRunner.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NestClassMergingTestRunner.java
@@ -4,6 +4,14 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.classmerging.horizontal.NestClassMergingTestRunner.HorizontalClassMergingTestSources.jar;
+import static com.android.tools.r8.classmerging.horizontal.NestClassMergingTestRunner.HorizontalClassMergingTestSources.nestClassMergingTest;
+import static com.android.tools.r8.classmerging.horizontal.NestClassMergingTestRunner.HorizontalClassMergingTestSources.nestHostA;
+import static com.android.tools.r8.classmerging.horizontal.NestClassMergingTestRunner.HorizontalClassMergingTestSources.nestHostA$NestMemberA;
+import static com.android.tools.r8.classmerging.horizontal.NestClassMergingTestRunner.HorizontalClassMergingTestSources.nestHostA$NestMemberB;
+import static com.android.tools.r8.classmerging.horizontal.NestClassMergingTestRunner.HorizontalClassMergingTestSources.nestHostB;
+import static com.android.tools.r8.classmerging.horizontal.NestClassMergingTestRunner.HorizontalClassMergingTestSources.nestHostB$NestMemberA;
+import static com.android.tools.r8.classmerging.horizontal.NestClassMergingTestRunner.HorizontalClassMergingTestSources.nestHostB$NestMemberB;
import static org.junit.Assert.assertEquals;
import static org.junit.Assume.assumeTrue;
@@ -12,17 +20,13 @@
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.TestRuntime.CfVm;
import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.classmerging.horizontal.NestClassMergingTestRunner.R.horizontalclassmerging.NestClassMergingTest;
-import com.android.tools.r8.classmerging.horizontal.NestClassMergingTestRunner.R.horizontalclassmerging.NestHostA;
-import com.android.tools.r8.classmerging.horizontal.NestClassMergingTestRunner.R.horizontalclassmerging.NestHostB;
+import com.android.tools.r8.examples.JavaExampleClassProxy;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.utils.ReflectiveBuildPathUtils.ExamplesClass;
-import com.android.tools.r8.utils.ReflectiveBuildPathUtils.ExamplesJava11RootPackage;
-import com.android.tools.r8.utils.ReflectiveBuildPathUtils.ExamplesPackage;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Streams;
+import java.nio.file.Path;
import java.util.Set;
import java.util.stream.Collectors;
import org.junit.Test;
@@ -30,21 +34,27 @@
public class NestClassMergingTestRunner extends HorizontalClassMergingTestBase {
- public static class R extends ExamplesJava11RootPackage {
- public static class horizontalclassmerging extends ExamplesPackage {
- public static class NestClassMergingTest extends ExamplesClass {}
+ public static class HorizontalClassMergingTestSources {
- public static class NestHostA extends ExamplesClass {
- public static class NestMemberA extends ExamplesClass {}
+ private static final String EXAMPLE_FILE = "examplesJava11";
- public static class NestMemberB extends ExamplesClass {}
- }
+ public static final JavaExampleClassProxy nestClassMergingTest =
+ new JavaExampleClassProxy(EXAMPLE_FILE, "horizontalclassmerging/NestClassMergingTest");
+ public static final JavaExampleClassProxy nestHostA =
+ new JavaExampleClassProxy(EXAMPLE_FILE, "horizontalclassmerging/NestHostA");
+ public static final JavaExampleClassProxy nestHostA$NestMemberA =
+ new JavaExampleClassProxy(EXAMPLE_FILE, "horizontalclassmerging/NestHostA$NestMemberA");
+ public static final JavaExampleClassProxy nestHostA$NestMemberB =
+ new JavaExampleClassProxy(EXAMPLE_FILE, "horizontalclassmerging/NestHostA$NestMemberB");
+ public static final JavaExampleClassProxy nestHostB =
+ new JavaExampleClassProxy(EXAMPLE_FILE, "horizontalclassmerging/NestHostB");
+ public static final JavaExampleClassProxy nestHostB$NestMemberA =
+ new JavaExampleClassProxy(EXAMPLE_FILE, "horizontalclassmerging/NestHostB$NestMemberA");
+ public static final JavaExampleClassProxy nestHostB$NestMemberB =
+ new JavaExampleClassProxy(EXAMPLE_FILE, "horizontalclassmerging/NestHostB$NestMemberB");
- public static class NestHostB extends ExamplesClass {
- public static class NestMemberA extends ExamplesClass {}
-
- public static class NestMemberB extends ExamplesClass {}
- }
+ public static Path jar() {
+ return JavaExampleClassProxy.examplesJar(EXAMPLE_FILE + "/horizontalclassmerging");
}
}
@@ -70,21 +80,21 @@
if (parameters.canUseNestBasedAccesses()) {
inspector
.assertIsCompleteMergeGroup(
- classRef(NestHostA.class),
- classRef(NestHostA.NestMemberA.class),
- classRef(NestHostA.NestMemberB.class))
+ nestHostA.getClassReference(),
+ nestHostA$NestMemberA.getClassReference(),
+ nestHostA$NestMemberB.getClassReference())
.assertIsCompleteMergeGroup(
- classRef(NestHostB.class),
- classRef(NestHostB.NestMemberA.class),
- classRef(NestHostB.NestMemberB.class));
+ nestHostB.getClassReference(),
+ nestHostB$NestMemberA.getClassReference(),
+ nestHostB$NestMemberB.getClassReference());
} else {
inspector.assertIsCompleteMergeGroup(
- classRef(NestHostA.class),
- classRef(NestHostA.NestMemberA.class),
- classRef(NestHostA.NestMemberB.class),
- classRef(NestHostB.class),
- classRef(NestHostB.NestMemberA.class),
- classRef(NestHostB.NestMemberB.class));
+ nestHostA.getClassReference(),
+ nestHostA$NestMemberA.getClassReference(),
+ nestHostA$NestMemberB.getClassReference(),
+ nestHostB.getClassReference(),
+ nestHostB$NestMemberA.getClassReference(),
+ nestHostB$NestMemberB.getClassReference());
}
}));
}
@@ -99,15 +109,17 @@
inspector ->
inspector
.assertIsCompleteMergeGroup(
- classRef(NestHostA.class), classRef(NestHostA.NestMemberA.class))
+ nestHostA.getClassReference(),
+ nestHostA$NestMemberA.getClassReference())
.assertIsCompleteMergeGroup(
- classRef(NestHostB.class), classRef(NestHostB.NestMemberA.class))
+ nestHostB.getClassReference(),
+ nestHostB$NestMemberA.getClassReference())
.assertClassReferencesNotMerged(
- classRef(NestHostA.NestMemberB.class),
- classRef(NestHostB.NestMemberB.class)))
+ nestHostA$NestMemberB.getClassReference(),
+ nestHostB$NestMemberB.getClassReference()))
.addNoHorizontalClassMergingRule(
- examplesTypeName(NestHostA.NestMemberB.class),
- examplesTypeName(NestHostB.NestMemberB.class))
+ nestHostA$NestMemberB.getClassReference().getTypeName(),
+ nestHostB$NestMemberB.getClassReference().getTypeName())
.addOptionsModification(
options -> {
options.testing.horizontalClassMergingTarget =
@@ -116,17 +128,17 @@
Streams.stream(canditates)
.map(DexClass::getClassReference)
.collect(Collectors.toSet());
- if (candidateClassReferences.contains(classRef(NestHostA.class))) {
+ if (candidateClassReferences.contains(nestHostA.getClassReference())) {
assertEquals(
ImmutableSet.of(
- classRef(NestHostA.class),
- classRef(NestHostA.NestMemberA.class)),
+ nestHostA.getClassReference(),
+ nestHostA$NestMemberA.getClassReference()),
candidateClassReferences);
} else {
assertEquals(
ImmutableSet.of(
- classRef(NestHostB.class),
- classRef(NestHostB.NestMemberA.class)),
+ nestHostB.getClassReference(),
+ nestHostB$NestMemberA.getClassReference()),
candidateClassReferences);
}
return Iterables.find(
@@ -134,9 +146,9 @@
candidate -> {
ClassReference classReference = candidate.getClassReference();
return classReference.equals(
- classRef(NestHostA.NestMemberA.class))
+ nestHostA$NestMemberA.getClassReference())
|| classReference.equals(
- classRef(NestHostB.NestMemberA.class));
+ nestHostB$NestMemberA.getClassReference());
});
};
}));
@@ -152,15 +164,17 @@
inspector ->
inspector
.assertIsCompleteMergeGroup(
- classRef(NestHostA.class), classRef(NestHostA.NestMemberB.class))
+ nestHostA.getClassReference(),
+ nestHostA$NestMemberB.getClassReference())
.assertIsCompleteMergeGroup(
- classRef(NestHostB.class), classRef(NestHostB.NestMemberB.class))
+ nestHostB.getClassReference(),
+ nestHostB$NestMemberB.getClassReference())
.assertClassReferencesNotMerged(
- classRef(NestHostA.NestMemberA.class),
- classRef(NestHostB.NestMemberA.class)))
+ nestHostA$NestMemberA.getClassReference(),
+ nestHostB$NestMemberA.getClassReference()))
.addNoHorizontalClassMergingRule(
- examplesTypeName(NestHostA.NestMemberA.class),
- examplesTypeName(NestHostB.NestMemberA.class))
+ nestHostA$NestMemberA.getClassReference().getTypeName(),
+ nestHostB$NestMemberA.getClassReference().getTypeName())
.addOptionsModification(
options -> {
options.testing.horizontalClassMergingTarget =
@@ -169,17 +183,17 @@
Streams.stream(canditates)
.map(DexClass::getClassReference)
.collect(Collectors.toSet());
- if (candidateClassReferences.contains(classRef(NestHostA.class))) {
+ if (candidateClassReferences.contains(nestHostA.getClassReference())) {
assertEquals(
ImmutableSet.of(
- classRef(NestHostA.class),
- classRef(NestHostA.NestMemberB.class)),
+ nestHostA.getClassReference(),
+ nestHostA$NestMemberB.getClassReference()),
candidateClassReferences);
} else {
assertEquals(
ImmutableSet.of(
- classRef(NestHostB.class),
- classRef(NestHostB.NestMemberB.class)),
+ nestHostB.getClassReference(),
+ nestHostB$NestMemberB.getClassReference()),
candidateClassReferences);
}
return Iterables.find(
@@ -187,9 +201,9 @@
candidate -> {
ClassReference classReference = candidate.getClassReference();
return classReference.equals(
- classRef(NestHostA.NestMemberB.class))
+ nestHostA$NestMemberB.getClassReference())
|| classReference.equals(
- classRef(NestHostB.NestMemberB.class));
+ nestHostB$NestMemberB.getClassReference());
});
};
}));
@@ -205,15 +219,17 @@
inspector ->
inspector
.assertIsCompleteMergeGroup(
- classRef(NestHostA.class), classRef(NestHostA.NestMemberA.class))
+ nestHostA.getClassReference(),
+ nestHostA$NestMemberA.getClassReference())
.assertIsCompleteMergeGroup(
- classRef(NestHostB.class), classRef(NestHostB.NestMemberA.class))
+ nestHostB.getClassReference(),
+ nestHostB$NestMemberA.getClassReference())
.assertClassReferencesNotMerged(
- classRef(NestHostA.NestMemberB.class),
- classRef(NestHostB.NestMemberB.class)))
+ nestHostA$NestMemberB.getClassReference(),
+ nestHostB$NestMemberB.getClassReference()))
.addNoHorizontalClassMergingRule(
- examplesTypeName(NestHostA.NestMemberB.class),
- examplesTypeName(NestHostB.NestMemberB.class))
+ nestHostA$NestMemberB.getClassReference().getTypeName(),
+ nestHostB$NestMemberB.getClassReference().getTypeName())
.addOptionsModification(
options -> {
options.testing.horizontalClassMergingTarget =
@@ -222,25 +238,25 @@
Streams.stream(canditates)
.map(DexClass::getClassReference)
.collect(Collectors.toSet());
- if (candidateClassReferences.contains(classRef(NestHostA.class))) {
+ if (candidateClassReferences.contains(nestHostA.getClassReference())) {
assertEquals(
ImmutableSet.of(
- classRef(NestHostA.class),
- classRef(NestHostA.NestMemberA.class)),
+ nestHostA.getClassReference(),
+ nestHostA$NestMemberA.getClassReference()),
candidateClassReferences);
} else {
assertEquals(
ImmutableSet.of(
- classRef(NestHostB.class),
- classRef(NestHostB.NestMemberA.class)),
+ nestHostB.getClassReference(),
+ nestHostB$NestMemberA.getClassReference()),
candidateClassReferences);
}
return Iterables.find(
canditates,
candidate -> {
ClassReference classReference = candidate.getClassReference();
- return classReference.equals(classRef(NestHostA.class))
- || classReference.equals(classRef(NestHostB.class));
+ return classReference.equals(nestHostA.getClassReference())
+ || classReference.equals(nestHostB.getClassReference());
});
};
}));
@@ -248,22 +264,18 @@
private void runTest(ThrowableConsumer<R8FullTestBuilder> configuration) throws Exception {
testForR8(parameters.getBackend())
- .addKeepMainRule(examplesTypeName(NestClassMergingTest.class))
- .addExamplesProgramFiles(R.class)
+ .addKeepMainRule(nestClassMergingTest.getClassReference())
+ .addProgramFiles(jar())
.apply(configuration)
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters)
.compile()
- .run(parameters.getRuntime(), examplesTypeName(NestClassMergingTest.class))
+ .run(parameters.getRuntime(), nestClassMergingTest.getClassReference().getTypeName())
.assertSuccessWithOutputLines(
"NestHostA$NestMemberA",
"NestHostA$NestMemberB",
"NestHostB$NestMemberA",
"NestHostB$NestMemberB");
}
-
- private static ClassReference classRef(Class<? extends ExamplesClass> clazz) {
- return examplesClassReference(clazz);
- }
}
diff --git a/src/test/java/com/android/tools/r8/compilerapi/CompilerApiTest.java b/src/test/java/com/android/tools/r8/compilerapi/CompilerApiTest.java
index 60ca0c6..a6dac7d 100644
--- a/src/test/java/com/android/tools/r8/compilerapi/CompilerApiTest.java
+++ b/src/test/java/com/android/tools/r8/compilerapi/CompilerApiTest.java
@@ -93,6 +93,11 @@
.resolve(Paths.get("third_party", "openjdk", "openjdk-rt-1.8", "rt.jar"));
}
+ public Path getAndroidJar() {
+ return getProjectRoot()
+ .resolve(Paths.get("third_party", "android_jar", "lib-v33", "android.jar"));
+ }
+
public List<String> getKeepMainRules(Class<?> clazz) {
return Collections.singletonList(
"-keep class " + clazz.getName() + " { public static void main(java.lang.String[]); }");
diff --git a/src/test/java/com/android/tools/r8/compilerapi/CompilerApiTestCollection.java b/src/test/java/com/android/tools/r8/compilerapi/CompilerApiTestCollection.java
index 9535f30..d2096f6 100644
--- a/src/test/java/com/android/tools/r8/compilerapi/CompilerApiTestCollection.java
+++ b/src/test/java/com/android/tools/r8/compilerapi/CompilerApiTestCollection.java
@@ -18,6 +18,7 @@
import com.android.tools.r8.compilerapi.diagnostics.UnsupportedFeaturesDiagnosticApiTest;
import com.android.tools.r8.compilerapi.extractmarker.ExtractMarkerApiTest;
import com.android.tools.r8.compilerapi.globalsynthetics.GlobalSyntheticsTest;
+import com.android.tools.r8.compilerapi.globalsyntheticsgenerator.GlobalSyntheticsGeneratorTest;
import com.android.tools.r8.compilerapi.inputdependencies.InputDependenciesTest;
import com.android.tools.r8.compilerapi.mapid.CustomMapIdTest;
import com.android.tools.r8.compilerapi.mockdata.MockClass;
@@ -63,7 +64,8 @@
SyntheticContextsConsumerTest.ApiTest.class,
ExtractMarkerApiTest.ApiTest.class,
PartitionMapCommandTest.ApiTest.class,
- CancelCompilationCheckerTest.ApiTest.class);
+ CancelCompilationCheckerTest.ApiTest.class,
+ GlobalSyntheticsGeneratorTest.ApiTest.class);
private static final List<Class<? extends CompilerApiTest>> CLASSES_PENDING_BINARY_COMPATIBILITY =
ImmutableList.of();
diff --git a/src/test/java/com/android/tools/r8/compilerapi/globalsyntheticsgenerator/GlobalSyntheticsGeneratorTest.java b/src/test/java/com/android/tools/r8/compilerapi/globalsyntheticsgenerator/GlobalSyntheticsGeneratorTest.java
new file mode 100644
index 0000000..6cab4d7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/compilerapi/globalsyntheticsgenerator/GlobalSyntheticsGeneratorTest.java
@@ -0,0 +1,54 @@
+// Copyright (c) 2023, 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 com.android.tools.r8.compilerapi.globalsyntheticsgenerator;
+
+import com.android.tools.r8.DexIndexedConsumer;
+import com.android.tools.r8.GlobalSyntheticsGenerator;
+import com.android.tools.r8.GlobalSyntheticsGeneratorCommand;
+import com.android.tools.r8.ProgramConsumer;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.compilerapi.CompilerApiTest;
+import com.android.tools.r8.compilerapi.CompilerApiTestRunner;
+import org.junit.Test;
+
+public class GlobalSyntheticsGeneratorTest extends CompilerApiTestRunner {
+
+ public GlobalSyntheticsGeneratorTest(TestParameters parameters) {
+ super(parameters);
+ }
+
+ @Override
+ public Class<? extends CompilerApiTest> binaryTestClass() {
+ return ApiTest.class;
+ }
+
+ @Test
+ public void testGlobalSynthetics() throws Exception {
+ new ApiTest(ApiTest.PARAMETERS)
+ .run(
+ new DexIndexedConsumer.ArchiveConsumer(
+ temp.newFolder().toPath().resolve("output.zip")));
+ }
+
+ public static class ApiTest extends CompilerApiTest {
+
+ public ApiTest(Object parameters) {
+ super(parameters);
+ }
+
+ public void run(ProgramConsumer programConsumer) throws Exception {
+ GlobalSyntheticsGenerator.run(
+ GlobalSyntheticsGeneratorCommand.builder()
+ .addLibraryFiles(getAndroidJar())
+ .setMinApiLevel(33)
+ .setProgramConsumer(programConsumer)
+ .build());
+ }
+
+ @Test
+ public void testGlobalSynthetics() throws Exception {
+ run(DexIndexedConsumer.emptyConsumer());
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordMergeTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordMergeTest.java
index fb80241..dfa8cd5 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/RecordMergeTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordMergeTest.java
@@ -42,7 +42,18 @@
private static final byte[][] PROGRAM_DATA_2 = RecordTestUtils.getProgramData(RECORD_NAME_2);
private static final String MAIN_TYPE_2 = RecordTestUtils.getMainType(RECORD_NAME_2);
private static final String EXPECTED_RESULT_2 =
- StringUtils.lines("Jane Doe", "42", "Jane Doe", "42");
+ StringUtils.lines(
+ "Jane Doe",
+ "42",
+ "Jane Doe",
+ "42",
+ "true",
+ "true",
+ "true",
+ "false",
+ "false",
+ "false",
+ "false");
private final TestParameters parameters;
diff --git a/src/test/java/com/android/tools/r8/desugar/records/SimpleRecordTest.java b/src/test/java/com/android/tools/r8/desugar/records/SimpleRecordTest.java
index 7dbeae0..e208949 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/SimpleRecordTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/SimpleRecordTest.java
@@ -29,7 +29,18 @@
private static final byte[][] PROGRAM_DATA = RecordTestUtils.getProgramData(RECORD_NAME);
private static final String MAIN_TYPE = RecordTestUtils.getMainType(RECORD_NAME);
private static final String EXPECTED_RESULT =
- StringUtils.lines("Jane Doe", "42", "Jane Doe", "42");
+ StringUtils.lines(
+ "Jane Doe",
+ "42",
+ "Jane Doe",
+ "42",
+ "true",
+ "true",
+ "true",
+ "false",
+ "false",
+ "false",
+ "false");
@Parameter(0)
public TestParameters parameters;
diff --git a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesEnumJdk17CompiledTest.java b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesEnumJdk17CompiledTest.java
index 07d4ef7..e00e194 100644
--- a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesEnumJdk17CompiledTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesEnumJdk17CompiledTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.desugar.sealed;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
import static junit.framework.Assert.assertEquals;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assume.assumeTrue;
@@ -18,7 +19,7 @@
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.android.tools.r8.utils.codeinspector.Matchers;
+import com.google.common.collect.ImmutableList;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -70,14 +71,15 @@
}
private void inspect(CodeInspector inspector) {
- ClassSubject clazz = inspector.clazz("enum_sealed.Enum");
- assertThat(clazz, Matchers.isPresentAndRenamed());
- if (!parameters.isCfRuntime()) {
- return;
- }
+ ClassSubject clazz = inspector.clazz(EnumSealed.Enum.typeName());
+ assertThat(clazz, isPresentAndRenamed());
+ ClassSubject sub1 = inspector.clazz(EnumSealed.EnumB.typeName());
+ assertThat(sub1, isPresentAndRenamed());
assertEquals(
- keepPermittedSubclassesAttribute ? 1 : 0,
- clazz.getFinalPermittedSubclassAttributes().size());
+ parameters.isCfRuntime() && keepPermittedSubclassesAttribute
+ ? ImmutableList.of(sub1.asTypeSubject())
+ : ImmutableList.of(),
+ clazz.getFinalPermittedSubclassAttributes());
}
@Test
@@ -90,6 +92,7 @@
keepPermittedSubclassesAttribute,
TestShrinkerBuilder::addKeepAttributePermittedSubclasses)
.addKeepMainRule(EnumSealed.Main.typeName())
+ .addKeepClassRulesWithAllowObfuscation(EnumSealed.Enum.typeName())
.compile()
.inspect(this::inspect)
.run(parameters.getRuntime(), EnumSealed.Main.typeName())
diff --git a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesExtendsVerticalMergeTest.java b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesExtendsVerticalMergeTest.java
new file mode 100644
index 0000000..fdd28aa
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesExtendsVerticalMergeTest.java
@@ -0,0 +1,110 @@
+// Copyright (c) 2023, 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 com.android.tools.r8.desugar.sealed;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static junit.framework.Assert.assertEquals;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestBuilder;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
+import com.google.common.collect.ImmutableList;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class SealedClassesExtendsVerticalMergeTest extends TestBase {
+
+ @Parameter(0)
+ public TestParameters parameters;
+
+ static final String EXPECTED = StringUtils.lines("Success!");
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+ }
+
+ private void addTestClasses(TestBuilder<?, ?> builder) throws Exception {
+ builder
+ .addProgramClasses(TestClass.class, Sub1.class, Sub2.class, SubSub.class)
+ .addProgramClassFileData(getTransformedClasses());
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject clazz = inspector.clazz(Super.class);
+ assertThat(clazz, isPresentAndRenamed());
+ ClassSubject sub2 = inspector.clazz(Sub2.class);
+ assertThat(sub2, isPresentAndRenamed());
+ ClassSubject subSub = inspector.clazz(SubSub.class);
+ assertThat(subSub, isPresentAndRenamed());
+ // TODO(b/227160052): Should be both subSub.asTypeSubject() and sub2.asTypeSubject().
+ assertEquals(
+ parameters.isCfRuntime() ? ImmutableList.of(sub2.asTypeSubject()) : ImmutableList.of(),
+ clazz.getFinalPermittedSubclassAttributes());
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ parameters.assumeR8TestParameters();
+ testForR8(parameters.getBackend())
+ .apply(this::addTestClasses)
+ .setMinApi(parameters)
+ .addKeepAttributePermittedSubclasses()
+ .addKeepPermittedSubclasses(Super.class)
+ .addKeepPermittedSubclasses(Sub2.class)
+ .addKeepMainRule(TestClass.class)
+ .addVerticallyMergedClassesInspector(
+ inspector -> {
+ inspector.assertMergedIntoSubtype(Sub1.class);
+ })
+ .addHorizontallyMergedClassesInspector(
+ HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .applyIf(
+ parameters.isDexRuntime(),
+ r -> r.assertSuccessWithOutput(EXPECTED),
+ parameters.isCfRuntime() && parameters.asCfRuntime().isNewerThanOrEqual(CfVm.JDK17),
+ r ->
+ r.assertFailureWithErrorThatMatches(
+ containsString("cannot inherit from sealed class")),
+ r -> r.assertFailureWithErrorThatThrows(UnsupportedClassVersionError.class));
+ }
+
+ public byte[] getTransformedClasses() throws Exception {
+ return transformer(Super.class)
+ .setPermittedSubclasses(Super.class, Sub1.class, Sub2.class)
+ .transform();
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ new SubSub();
+ System.out.println("Success!");
+ }
+ }
+
+ abstract static class Super /* permits Sub1, Sub2 */ {}
+
+ static class Sub1 extends Super {}
+
+ static class Sub2 extends Super {}
+
+ static class SubSub extends Sub1 {}
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesHorizontalMergeTest.java b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesHorizontalMergeTest.java
new file mode 100644
index 0000000..270637d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesHorizontalMergeTest.java
@@ -0,0 +1,99 @@
+// Copyright (c) 2023, 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 com.android.tools.r8.desugar.sealed;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static junit.framework.Assert.assertEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestBuilder;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class SealedClassesHorizontalMergeTest extends TestBase {
+
+ @Parameter(0)
+ public TestParameters parameters;
+
+ static final String EXPECTED = StringUtils.lines("Success!");
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+ }
+
+ private void addTestClasses(TestBuilder<?, ?> builder) throws Exception {
+ builder
+ .addProgramClasses(TestClass.class, Sub1.class, Sub2.class)
+ .addProgramClassFileData(getTransformedClasses());
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject clazz = inspector.clazz(Super.class);
+ assertThat(clazz, isPresentAndRenamed());
+ ClassSubject sub1 = inspector.clazz(Sub1.class);
+ assertThat(sub1, isPresentAndRenamed());
+ assertEquals(
+ parameters.isCfRuntime() ? ImmutableList.of(sub1.asTypeSubject()) : ImmutableList.of(),
+ clazz.getFinalPermittedSubclassAttributes());
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ parameters.assumeR8TestParameters();
+ testForR8(parameters.getBackend())
+ .apply(this::addTestClasses)
+ .setMinApi(parameters)
+ .addKeepAttributePermittedSubclasses()
+ .addKeepClassRulesWithAllowObfuscation(Super.class)
+ .addKeepMainRule(TestClass.class)
+ .addHorizontallyMergedClassesInspector(
+ inspector -> {
+ inspector
+ .assertIsCompleteMergeGroup(Sub2.class, Sub1.class)
+ .assertNoOtherClassesMerged();
+ })
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .applyIf(
+ !parameters.isCfRuntime() || parameters.asCfRuntime().isNewerThanOrEqual(CfVm.JDK17),
+ r -> r.assertSuccessWithOutput(EXPECTED),
+ r -> r.assertFailureWithErrorThatThrows(UnsupportedClassVersionError.class));
+ }
+
+ public byte[] getTransformedClasses() throws Exception {
+ return transformer(Super.class)
+ .setPermittedSubclasses(Super.class, Sub1.class, Sub2.class)
+ .transform();
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ new Sub1();
+ new Sub2();
+ System.out.println("Success!");
+ }
+ }
+
+ abstract static class Super /* permits Sub1, Sub2 */ {}
+
+ static class Sub1 extends Super {}
+
+ static class Sub2 extends Super {}
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesIllegalSubclassMergedTest.java b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesIllegalSubclassMergedTest.java
new file mode 100644
index 0000000..b420268
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesIllegalSubclassMergedTest.java
@@ -0,0 +1,115 @@
+// Copyright (c) 2023, 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 com.android.tools.r8.desugar.sealed;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static junit.framework.Assert.assertEquals;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestBuilder;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import org.hamcrest.Matcher;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class SealedClassesIllegalSubclassMergedTest extends TestBase {
+
+ @Parameter(0)
+ public TestParameters parameters;
+
+ static final Matcher<String> EXPECTED = containsString("cannot inherit from sealed class");
+ static final String EXPECTED_WITHOUT_PERMITTED_SUBCLASSES_ATTRIBUTE_OR_FIXED_ATTRIBUTE =
+ StringUtils.lines("Success!");
+
+ @Parameters(name = "{0}, keepPermittedSubclasses = {1}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+ }
+
+ private void addTestClasses(TestBuilder<?, ?> builder) throws Exception {
+ builder
+ .addProgramClasses(TestClass.class, Sub1.class, Sub2.class)
+ .addProgramClassFileData(getTransformedClasses());
+ }
+
+ @Test
+ public void testJvm() throws Exception {
+ parameters.assumeJvmTestParameters();
+ assumeTrue(parameters.asCfRuntime().isNewerThanOrEqual(CfVm.JDK17));
+ testForJvm(parameters)
+ .apply(this::addTestClasses)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertFailureWithErrorThatMatches(EXPECTED);
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject clazz = inspector.clazz(Super.class);
+ assertThat(clazz, isPresentAndRenamed());
+ ClassSubject sub1 = inspector.clazz(Sub1.class);
+ assertThat(sub1, isPresentAndRenamed());
+ assertEquals(
+ parameters.isCfRuntime() ? ImmutableList.of(sub1.asTypeSubject()) : ImmutableList.of(),
+ clazz.getFinalPermittedSubclassAttributes());
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ parameters.assumeR8TestParameters();
+ testForR8(parameters.getBackend())
+ .apply(this::addTestClasses)
+ .setMinApi(parameters)
+ .addKeepAttributePermittedSubclasses()
+ .addKeepClassRulesWithAllowObfuscation(Super.class)
+ .addKeepMainRule(TestClass.class)
+ .addHorizontallyMergedClassesInspector(
+ inspector -> {
+ inspector
+ .assertIsCompleteMergeGroup(Sub2.class, Sub1.class)
+ .assertNoOtherClassesMerged();
+ })
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .applyIf(
+ !parameters.isCfRuntime() || parameters.asCfRuntime().isNewerThanOrEqual(CfVm.JDK17),
+ // On JDK 17 the class merging also prevents "cannot inherit from sealed class".
+ r ->
+ r.assertSuccessWithOutput(
+ EXPECTED_WITHOUT_PERMITTED_SUBCLASSES_ATTRIBUTE_OR_FIXED_ATTRIBUTE),
+ r -> r.assertFailureWithErrorThatThrows(UnsupportedClassVersionError.class));
+ }
+
+ public byte[] getTransformedClasses() throws Exception {
+ return transformer(Super.class).setPermittedSubclasses(Super.class, Sub1.class).transform();
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ new Sub1();
+ new Sub2();
+ System.out.println("Success!");
+ }
+ }
+
+ abstract static class Super /* permits Sub1 */ {}
+
+ static class Sub1 extends Super {}
+
+ static class Sub2 extends Super {}
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesIllegalSubclassTest.java b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesIllegalSubclassTest.java
index 03d9160..240b7a9 100644
--- a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesIllegalSubclassTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesIllegalSubclassTest.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.desugar.sealed;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
import static junit.framework.Assert.assertEquals;
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -20,7 +22,7 @@
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.android.tools.r8.utils.codeinspector.Matchers;
+import com.google.common.collect.ImmutableList;
import java.util.List;
import org.hamcrest.Matcher;
import org.junit.Test;
@@ -81,14 +83,19 @@
}
private void inspect(CodeInspector inspector) {
- ClassSubject clazz = inspector.clazz(C.class);
- assertThat(clazz, Matchers.isPresentAndRenamed());
- if (!parameters.isCfRuntime()) {
- return;
- }
+ ClassSubject clazz = inspector.clazz(Super.class);
+ assertThat(clazz, isPresentAndRenamed());
+ ClassSubject sub1 = inspector.clazz(Sub1.class);
+ ClassSubject sub2 = inspector.clazz(Sub2.class);
+ ClassSubject sub3 = inspector.clazz(Sub3.class);
+ assertThat(sub1, isPresentAndNotRenamed());
+ assertThat(sub2, isPresentAndNotRenamed());
+ assertThat(sub3, isPresentAndNotRenamed());
assertEquals(
- keepPermittedSubclassesAttribute ? 2 : 0,
- clazz.getFinalPermittedSubclassAttributes().size());
+ parameters.isCfRuntime() && keepPermittedSubclassesAttribute
+ ? ImmutableList.of(sub1.asTypeSubject(), sub2.asTypeSubject())
+ : ImmutableList.of(),
+ clazz.getFinalPermittedSubclassAttributes());
}
@Test
@@ -101,10 +108,8 @@
.applyIf(
keepPermittedSubclassesAttribute,
TestShrinkerBuilder::addKeepAttributePermittedSubclasses)
- // Keep the sealed class to ensure the PermittedSubclasses attribute stays live.
- .addKeepPermittedSubclasses(C.class)
- // Keep subclasses as the PermittedSubclasses attribute is not rewritten.
- .addKeepRules("-keep class * extends " + C.class.getTypeName())
+ .addKeepPermittedSubclasses(Super.class)
+ .addKeepRules("-keep class * extends " + Super.class.getTypeName())
.addKeepMainRule(TestClass.class)
.compile()
.inspect(this::inspect)
@@ -122,7 +127,9 @@
}
public byte[] getTransformedClasses() throws Exception {
- return transformer(C.class).setPermittedSubclasses(C.class, Sub1.class, Sub2.class).transform();
+ return transformer(Super.class)
+ .setPermittedSubclasses(Super.class, Sub1.class, Sub2.class)
+ .transform();
}
static class TestClass {
@@ -135,11 +142,11 @@
}
}
- abstract static class C /* permits Sub1, Sub2 */ {}
+ abstract static class Super /* permits Sub1, Sub2 */ {}
- static class Sub1 extends C {}
+ static class Sub1 extends Super {}
- static class Sub2 extends C {}
+ static class Sub2 extends Super {}
- static class Sub3 extends C {}
+ static class Sub3 extends Super {}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesImplementsVerticalMergeTest.java b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesImplementsVerticalMergeTest.java
new file mode 100644
index 0000000..43f4a41
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesImplementsVerticalMergeTest.java
@@ -0,0 +1,127 @@
+// Copyright (c) 2023, 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 com.android.tools.r8.desugar.sealed;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static junit.framework.Assert.assertEquals;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NoUnusedInterfaceRemoval;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestBuilder;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
+import com.android.tools.r8.utils.codeinspector.Matchers;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class SealedClassesImplementsVerticalMergeTest extends TestBase {
+
+ @Parameter(0)
+ public TestParameters parameters;
+
+ static final String EXPECTED = StringUtils.lines("Success!");
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+ }
+
+ private void addTestClasses(TestBuilder<?, ?> builder) throws Exception {
+ builder
+ .addProgramClasses(TestClass.class, Super.class, Sub1.class, Sub2.class, SubSub.class)
+ .addProgramClassFileData(getTransformedClasses());
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject iface1 = inspector.clazz(Iface1.class);
+ assertThat(iface1, isPresentAndRenamed());
+ ClassSubject iface2 = inspector.clazz(Iface2.class);
+ assertThat(iface2, isPresentAndRenamed());
+ ClassSubject sub2 = inspector.clazz(Sub2.class);
+ assertThat(sub2, isPresentAndRenamed());
+ ClassSubject subSub = inspector.clazz(SubSub.class);
+ assertThat(subSub, Matchers.isPresentAndRenamed());
+ for (ClassSubject clazz : ImmutableList.of(iface1, iface2)) {
+ assertEquals(
+ // TODO(b/227160052): Should be both subSub.asTypeSubject() and sub2.asTypeSubject().
+ parameters.isCfRuntime() ? ImmutableList.of(sub2.asTypeSubject()) : ImmutableList.of(),
+ clazz.getFinalPermittedSubclassAttributes());
+ }
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ parameters.assumeR8TestParameters();
+ testForR8(parameters.getBackend())
+ .apply(this::addTestClasses)
+ .setMinApi(parameters)
+ .addKeepAttributePermittedSubclasses()
+ .addKeepPermittedSubclasses(Super.class, Iface1.class, Iface2.class, Sub2.class)
+ .addKeepMainRule(TestClass.class)
+ .addVerticallyMergedClassesInspector(
+ inspector -> {
+ inspector.assertMergedIntoSubtype(Sub1.class);
+ })
+ .addHorizontallyMergedClassesInspector(
+ HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ .enableNoUnusedInterfaceRemovalAnnotations()
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .applyIf(
+ parameters.isDexRuntime(),
+ r -> r.assertSuccessWithOutput(EXPECTED),
+ parameters.isCfRuntime() && parameters.asCfRuntime().isNewerThanOrEqual(CfVm.JDK17),
+ r ->
+ r.assertFailureWithErrorThatMatches(
+ containsString("cannot implement sealed interface")),
+ r -> r.assertFailureWithErrorThatThrows(UnsupportedClassVersionError.class));
+ }
+
+ public List<byte[]> getTransformedClasses() throws Exception {
+ return ImmutableList.of(
+ transformer(Iface1.class)
+ .setPermittedSubclasses(Iface1.class, Sub1.class, Sub2.class)
+ .transform(),
+ transformer(Iface2.class)
+ .setPermittedSubclasses(Iface2.class, Sub1.class, Sub2.class)
+ .transform());
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ new SubSub();
+ System.out.println("Success!");
+ }
+ }
+
+ @NoUnusedInterfaceRemoval
+ interface Iface1 /* permits Sub1, Sub2 */ {}
+
+ @NoUnusedInterfaceRemoval
+ interface Iface2 /* permits Sub1, Sub2 */ {}
+
+ abstract static class Super {}
+
+ static class Sub1 extends Super implements Iface1, Iface2 {}
+
+ static class Sub2 extends Super implements Iface1 {}
+
+ static class SubSub extends Sub1 {}
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesJdk17CompiledTest.java b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesJdk17CompiledTest.java
index 2b7d981..c51bb03 100644
--- a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesJdk17CompiledTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesJdk17CompiledTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.desugar.sealed;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
import static junit.framework.Assert.assertEquals;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assume.assumeTrue;
@@ -18,7 +19,7 @@
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.android.tools.r8.utils.codeinspector.Matchers;
+import com.google.common.collect.ImmutableList;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -70,14 +71,17 @@
}
private void inspect(CodeInspector inspector) {
- ClassSubject clazz = inspector.clazz("sealed.Compiler");
- assertThat(clazz, Matchers.isPresentAndRenamed());
- if (!parameters.isCfRuntime()) {
- return;
- }
+ ClassSubject clazz = inspector.clazz(Sealed.Compiler.typeName());
+ assertThat(clazz, isPresentAndRenamed());
+ ClassSubject sub1 = inspector.clazz(Sealed.R8Compiler.typeName());
+ ClassSubject sub2 = inspector.clazz(Sealed.D8Compiler.typeName());
+ assertThat(sub1, isPresentAndRenamed());
+ assertThat(sub2, isPresentAndRenamed());
assertEquals(
- keepPermittedSubclassesAttribute ? 2 : 0,
- clazz.getFinalPermittedSubclassAttributes().size());
+ parameters.isCfRuntime() && keepPermittedSubclassesAttribute
+ ? ImmutableList.of(sub1.asTypeSubject(), sub2.asTypeSubject())
+ : ImmutableList.of(),
+ clazz.getFinalPermittedSubclassAttributes());
}
@Test
@@ -89,8 +93,8 @@
.applyIf(
keepPermittedSubclassesAttribute,
TestShrinkerBuilder::addKeepAttributePermittedSubclasses)
- // Keep the sealed class to ensure the PermittedSubclasses attribute stays live.
.addKeepPermittedSubclasses(Sealed.Compiler.typeName())
+ .addKeepRules("-keep,allowobfuscation class * extends " + Sealed.Compiler.typeName())
.addKeepMainRule(Sealed.Main.typeName())
.compile()
.inspect(this::inspect)
diff --git a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesMergeTest.java b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesMergeTest.java
new file mode 100644
index 0000000..bcd774a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesMergeTest.java
@@ -0,0 +1,99 @@
+// Copyright (c) 2023, 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 com.android.tools.r8.desugar.sealed;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static junit.framework.Assert.assertEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestBuilder;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class SealedClassesMergeTest extends TestBase {
+
+ @Parameter(0)
+ public TestParameters parameters;
+
+ static final String EXPECTED = StringUtils.lines("Success!");
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+ }
+
+ private void addTestClasses(TestBuilder<?, ?> builder) throws Exception {
+ builder
+ .addProgramClasses(TestClass.class, Sub1.class, Sub2.class)
+ .addProgramClassFileData(getTransformedClasses());
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject clazz = inspector.clazz(Super.class);
+ assertThat(clazz, isPresentAndRenamed());
+ ClassSubject sub1 = inspector.clazz(Sub1.class);
+ assertThat(sub1, isPresentAndRenamed());
+ assertEquals(
+ parameters.isCfRuntime() ? ImmutableList.of(sub1.asTypeSubject()) : ImmutableList.of(),
+ clazz.getFinalPermittedSubclassAttributes());
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ parameters.assumeR8TestParameters();
+ testForR8(parameters.getBackend())
+ .apply(this::addTestClasses)
+ .setMinApi(parameters)
+ .addKeepAttributePermittedSubclasses()
+ .addKeepClassRulesWithAllowObfuscation(Super.class)
+ .addKeepMainRule(TestClass.class)
+ .addHorizontallyMergedClassesInspector(
+ inspector -> {
+ inspector
+ .assertIsCompleteMergeGroup(Sub2.class, Sub1.class)
+ .assertNoOtherClassesMerged();
+ })
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .applyIf(
+ !parameters.isCfRuntime() || parameters.asCfRuntime().isNewerThanOrEqual(CfVm.JDK17),
+ r -> r.assertSuccessWithOutput(EXPECTED),
+ r -> r.assertFailureWithErrorThatThrows(UnsupportedClassVersionError.class));
+ }
+
+ public byte[] getTransformedClasses() throws Exception {
+ return transformer(Super.class)
+ .setPermittedSubclasses(Super.class, Sub1.class, Sub2.class)
+ .transform();
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ new Sub1();
+ new Sub2();
+ System.out.println("Success!");
+ }
+ }
+
+ abstract static class Super /* permits Sub1, Sub2 */ {}
+
+ static class Sub1 extends Super {}
+
+ static class Sub2 extends Super {}
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesShrinkingTest.java b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesShrinkingTest.java
new file mode 100644
index 0000000..1893e3b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesShrinkingTest.java
@@ -0,0 +1,92 @@
+// Copyright (c) 2023, 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 com.android.tools.r8.desugar.sealed;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static junit.framework.Assert.assertEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestBuilder;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class SealedClassesShrinkingTest extends TestBase {
+
+ @Parameter(0)
+ public TestParameters parameters;
+
+ static final String EXPECTED = StringUtils.lines("Success!");
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+ }
+
+ private void addTestClasses(TestBuilder<?, ?> builder) throws Exception {
+ builder
+ .addProgramClasses(TestClass.class, UsedSub.class, UnusedSub.class)
+ .addProgramClassFileData(getTransformedClasses());
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject clazz = inspector.clazz(Super.class);
+ assertThat(clazz, isPresentAndRenamed());
+ ClassSubject sub1 = inspector.clazz(UsedSub.class);
+ assertThat(sub1, isPresentAndRenamed());
+ assertEquals(
+ parameters.isCfRuntime() ? ImmutableList.of(sub1.asTypeSubject()) : ImmutableList.of(),
+ clazz.getFinalPermittedSubclassAttributes());
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ parameters.assumeR8TestParameters();
+ testForR8(parameters.getBackend())
+ .apply(this::addTestClasses)
+ .setMinApi(parameters)
+ .addKeepAttributePermittedSubclasses()
+ .addKeepClassRulesWithAllowObfuscation(Super.class, UsedSub.class)
+ .addKeepMainRule(TestClass.class)
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .applyIf(
+ !parameters.isCfRuntime() || parameters.asCfRuntime().isNewerThanOrEqual(CfVm.JDK17),
+ r -> r.assertSuccessWithOutput(EXPECTED),
+ r -> r.assertFailureWithErrorThatThrows(UnsupportedClassVersionError.class));
+ }
+
+ public byte[] getTransformedClasses() throws Exception {
+ return transformer(Super.class)
+ .setPermittedSubclasses(Super.class, UsedSub.class, UnusedSub.class)
+ .transform();
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ new UsedSub();
+ System.out.println("Success!");
+ }
+ }
+
+ abstract static class Super /* permits UsedSub, UnusedSub */ {}
+
+ static class UsedSub extends Super {}
+
+ static class UnusedSub extends Super {}
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesTest.java b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesTest.java
index 3aa1a38..997e4fb 100644
--- a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesTest.java
@@ -4,7 +4,9 @@
package com.android.tools.r8.desugar.sealed;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertTrue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assume.assumeTrue;
@@ -18,7 +20,7 @@
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.android.tools.r8.utils.codeinspector.Matchers;
+import com.google.common.collect.ImmutableList;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -35,12 +37,16 @@
@Parameter(1)
public boolean keepPermittedSubclassesAttribute;
+ @Parameter(2)
+ public boolean repackage;
+
static final String EXPECTED = StringUtils.lines("Success!");
- @Parameters(name = "{0}, keepPermittedSubclasses = {1}")
+ @Parameters(name = "{0}, keepPermittedSubclasses = {1}, repackage = {2}")
public static List<Object[]> data() {
return buildParameters(
getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build(),
+ BooleanUtils.values(),
BooleanUtils.values());
}
@@ -76,14 +82,22 @@
}
private void inspect(CodeInspector inspector) {
- ClassSubject clazz = inspector.clazz(C.class);
- assertThat(clazz, Matchers.isPresentAndRenamed());
- if (!parameters.isCfRuntime()) {
- return;
+ ClassSubject clazz = inspector.clazz(Super.class);
+ assertThat(clazz, isPresentAndRenamed());
+ ClassSubject sub1 = inspector.clazz(Sub1.class);
+ ClassSubject sub2 = inspector.clazz(Sub2.class);
+ assertThat(sub1, isPresentAndRenamed());
+ assertThat(sub2, isPresentAndRenamed());
+ if (repackage) {
+ assertEquals(-1, sub1.getFinalName().indexOf('.'));
+ } else {
+ assertTrue(sub1.getFinalName().startsWith(getClass().getPackage().getName()));
}
assertEquals(
- keepPermittedSubclassesAttribute ? 2 : 0,
- clazz.getFinalPermittedSubclassAttributes().size());
+ parameters.isCfRuntime() && keepPermittedSubclassesAttribute
+ ? ImmutableList.of(sub1.asTypeSubject(), sub2.asTypeSubject())
+ : ImmutableList.of(),
+ clazz.getFinalPermittedSubclassAttributes());
}
@Test
@@ -96,8 +110,9 @@
keepPermittedSubclassesAttribute,
TestShrinkerBuilder::addKeepAttributePermittedSubclasses)
// Keep the sealed class to ensure the PermittedSubclasses attribute stays live.
- .addKeepPermittedSubclasses(C.class)
+ .addKeepPermittedSubclasses(Super.class, Sub1.class, Sub2.class)
.addKeepMainRule(TestClass.class)
+ .applyIf(repackage, b -> b.addKeepRules("-repackageclasses"))
.compile()
.inspect(this::inspect)
.run(parameters.getRuntime(), TestClass.class)
@@ -108,7 +123,9 @@
}
public byte[] getTransformedClasses() throws Exception {
- return transformer(C.class).setPermittedSubclasses(C.class, Sub1.class, Sub2.class).transform();
+ return transformer(Super.class)
+ .setPermittedSubclasses(Super.class, Sub1.class, Sub2.class)
+ .transform();
}
static class TestClass {
@@ -120,9 +137,9 @@
}
}
- abstract static class C /* permits Sub1, Sub2 */ {}
+ public abstract static class Super /* permits Sub1, Sub2 */ {}
- static class Sub1 extends C {}
+ public static class Sub1 extends Super {}
- static class Sub2 extends C {}
+ public static class Sub2 extends Super {}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesTestAllowPermittedSubclassesRemovalTest.java b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesTestAllowPermittedSubclassesRemovalTest.java
new file mode 100644
index 0000000..c220e9d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/sealed/SealedClassesTestAllowPermittedSubclassesRemovalTest.java
@@ -0,0 +1,99 @@
+// Copyright (c) 2023, 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 com.android.tools.r8.desugar.sealed;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static junit.framework.Assert.assertEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestBuilder;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.Matchers;
+import com.google.common.collect.ImmutableList;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class SealedClassesTestAllowPermittedSubclassesRemovalTest extends TestBase {
+
+ @Parameter(0)
+ public TestParameters parameters;
+
+ static final String EXPECTED = StringUtils.lines("Success!");
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+ }
+
+ private void addTestClasses(TestBuilder<?, ?> builder) throws Exception {
+ builder
+ .addProgramClasses(TestClass.class, Sub1.class, Sub2.class)
+ .addProgramClassFileData(getTransformedClasses());
+ }
+
+ private void inspect(CodeInspector inspector) {
+ ClassSubject clazz = inspector.clazz(Super.class);
+ assertThat(clazz, Matchers.isPresentAndNotRenamed());
+ ClassSubject sub1 = inspector.clazz(Sub1.class);
+ ClassSubject sub2 = inspector.clazz(Sub2.class);
+ assertThat(sub1, isPresentAndRenamed());
+ assertThat(sub2, isPresentAndRenamed());
+ assertEquals(
+ parameters.isCfRuntime()
+ ? ImmutableList.of(sub1.asTypeSubject(), sub2.asTypeSubject())
+ : ImmutableList.of(),
+ clazz.getFinalPermittedSubclassAttributes());
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ parameters.assumeR8TestParameters();
+ testForR8(parameters.getBackend())
+ .apply(this::addTestClasses)
+ .setMinApi(parameters)
+ .addKeepAttributePermittedSubclasses()
+ .addKeepRules("-keep,allowpermittedsubclassesremoval class " + Super.class.getTypeName())
+ .addKeepClassRulesWithAllowObfuscation(Sub1.class, Sub2.class)
+ .addKeepMainRule(TestClass.class)
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .applyIf(
+ !parameters.isCfRuntime() || parameters.asCfRuntime().isNewerThanOrEqual(CfVm.JDK17),
+ r -> r.assertSuccessWithOutput(EXPECTED),
+ r -> r.assertFailureWithErrorThatThrows(UnsupportedClassVersionError.class));
+ }
+
+ public byte[] getTransformedClasses() throws Exception {
+ return transformer(Super.class)
+ .setPermittedSubclasses(Super.class, Sub1.class, Sub2.class)
+ .transform();
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ new Sub1();
+ new Sub2();
+ System.out.println("Success!");
+ }
+ }
+
+ abstract static class Super /* permits Sub1, Sub2 */ {}
+
+ static class Sub1 extends Super {}
+
+ static class Sub2 extends Super {}
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxNull2ArgumentTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxNull2ArgumentTest.java
new file mode 100644
index 0000000..1130986
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxNull2ArgumentTest.java
@@ -0,0 +1,85 @@
+// Copyright (c) 2023, 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 com.android.tools.r8.enumunboxing;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.util.Objects;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+/** This is a regression test for b/287193321. */
+@RunWith(Parameterized.class)
+public class EnumUnboxNull2ArgumentTest extends TestBase {
+
+ @Parameter() public TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(getClass())
+ .setMinApi(parameters)
+ .addKeepMainRule(Main.class)
+ .addOptionsModification(options -> options.testing.disableLir())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("true", "null");
+ }
+
+ public enum MyEnum {
+ FOO("1"),
+ BAR("2");
+
+ final String value;
+
+ MyEnum(String value) {
+ this.value = value;
+ }
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ // Delay observing that arguments to bar is null until we've inlined foo() and getEnum().
+ String foo = foo();
+ String[] bar = bar(getEnum(), foo);
+ // To ensure bar(MyEnum,String) is not inlined in the first round we add a few additional
+ // calls that will be stripped during IR-processing of main.
+ if (foo != null) {
+ bar(MyEnum.FOO, foo);
+ bar(MyEnum.BAR, foo);
+ }
+ for (String b : bar) {
+ System.out.println(b);
+ }
+ }
+
+ public static String[] bar(MyEnum myEnum, String foo) {
+ if (System.currentTimeMillis() > 1) {
+ MyEnum e = System.currentTimeMillis() > 1 ? null : MyEnum.FOO;
+ // Ensure that the construction is in a separate block than entry() to have constant
+ // canonicalization align the two null values into one.
+ return new String[] {Objects.toString(Objects.equals(myEnum, e)), foo};
+ }
+ return new String[] {};
+ }
+
+ public static MyEnum getEnum() {
+ return null;
+ }
+
+ public static String foo() {
+ return null;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/enummerging/CrossEnumMergingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/enummerging/CrossEnumMergingTest.java
new file mode 100644
index 0000000..5c6518b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/enummerging/CrossEnumMergingTest.java
@@ -0,0 +1,93 @@
+// Copyright (c) 2023, 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 com.android.tools.r8.enumunboxing.enummerging;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.enumunboxing.EnumUnboxingTestBase;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class CrossEnumMergingTest extends EnumUnboxingTestBase {
+
+ private final TestParameters parameters;
+ private final boolean enumValueOptimization;
+ private final EnumKeepRules enumKeepRules;
+
+ @Parameters(name = "{0} valueOpt: {1} keep: {2}")
+ public static List<Object[]> data() {
+ return enumUnboxingTestParameters();
+ }
+
+ public CrossEnumMergingTest(
+ TestParameters parameters, boolean enumValueOptimization, EnumKeepRules enumKeepRules) {
+ this.parameters = parameters;
+ this.enumValueOptimization = enumValueOptimization;
+ this.enumKeepRules = enumKeepRules;
+ }
+
+ @Test
+ public void testEnumUnboxing() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(CrossEnumMergingTest.class)
+ .addKeepMainRule(Main.class)
+ .addKeepRules(enumKeepRules.getKeepRules())
+ .addEnumUnboxingInspector(
+ inspector -> inspector.assertUnboxed(TestEnumReturn.class, TestEnumArg.class))
+ .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+ .setMinApi(parameters)
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("TEST2", "TEST1", "1", "2", "2", "3");
+ }
+
+ public enum TestEnumReturn {
+ TEST1 {
+ @Override
+ public TestEnumReturn other() {
+ return TEST2;
+ }
+ },
+ TEST2 {
+ @Override
+ public TestEnumReturn other() {
+ return TEST1;
+ }
+ };
+
+ public abstract TestEnumReturn other();
+ }
+
+ public enum TestEnumArg {
+ TEST1 {
+ @Override
+ public void print(TestEnumArg arg) {
+ System.out.println(arg.ordinal() + 1);
+ }
+ },
+ TEST2 {
+ @Override
+ public void print(TestEnumArg arg) {
+ System.out.println(arg.ordinal() + 2);
+ }
+ };
+
+ public abstract void print(TestEnumArg arg);
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ System.out.println(TestEnumReturn.TEST1.other().toString());
+ System.out.println(TestEnumReturn.TEST2.other().toString());
+
+ TestEnumArg.TEST1.print(TestEnumArg.TEST1);
+ TestEnumArg.TEST1.print(TestEnumArg.TEST2);
+ TestEnumArg.TEST2.print(TestEnumArg.TEST1);
+ TestEnumArg.TEST2.print(TestEnumArg.TEST2);
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
index 0ff1942..e74dd87 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
@@ -4,7 +4,7 @@
package com.android.tools.r8.kotlin;
-
+import com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion;
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.kotlin.TestKotlinClass.Visibility;
@@ -131,6 +131,16 @@
.addKeepRules(keepClassMethod(mainClassName, testMethodSignature))
.addOptionsModification(o -> o.testing.enableLir())
.addOptionsModification(disableClassInliner))
- .inspect(inspector -> checkClassIsRemoved(inspector, TEST_DATA_CLASS.getClassName()));
+ .inspect(
+ inspector -> {
+ // This changes depending on when we dead-code eliminate.
+ if (kotlinParameters.is(KotlinCompilerVersion.KOTLINC_1_5_0)
+ || kotlinParameters.is(KotlinCompilerVersion.KOTLINC_1_6_0)
+ || testParameters.isDexRuntime()) {
+ checkClassIsRemoved(inspector, TEST_DATA_CLASS.getClassName());
+ } else {
+ checkClassIsKept(inspector, TEST_DATA_CLASS.getClassName());
+ }
+ });
}
}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromPermittedSubclassesAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromPermittedSubclassesAttributeTest.java
new file mode 100644
index 0000000..af6954b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromPermittedSubclassesAttributeTest.java
@@ -0,0 +1,152 @@
+// Copyright (c) 2023, 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 com.android.tools.r8.missingclasses;
+
+import static com.android.tools.r8.utils.codeinspector.AssertUtils.assertFailsCompilationIf;
+import static junit.framework.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.R8TestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.diagnostic.DefinitionContext;
+import com.android.tools.r8.diagnostic.internal.DefinitionClassContextImpl;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runners.Parameterized.Parameters;
+
+public class MissingClassReferencedFromPermittedSubclassesAttributeTest
+ extends MissingClassesTestBase {
+
+ private static final DefinitionContext referencedFrom =
+ DefinitionClassContextImpl.builder()
+ .setClassContext(Reference.classFromClass(Super.class))
+ .setOrigin(getOrigin(Super.class))
+ .build();
+
+ @Parameters(name = "{1}, report: {0}")
+ public static List<Object[]> refinedData() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
+ }
+
+ private final boolean reportMissingClassesInPermittedSubclassesAttributes;
+
+ public MissingClassReferencedFromPermittedSubclassesAttributeTest(
+ boolean reportMissingClassesInPermittedSubclassesAttributes, TestParameters parameters) {
+ super(parameters);
+ this.reportMissingClassesInPermittedSubclassesAttributes =
+ reportMissingClassesInPermittedSubclassesAttributes;
+ }
+
+ private void inspect(CodeInspector inspector) {
+ // Missing classes stays in the PermittedSubclasses attribute.
+ assertEquals(
+ parameters.isCfRuntime()
+ ? ImmutableList.of(
+ inspector.clazz(Sub.class).asTypeSubject(),
+ inspector.getTypeSubject(MissingSub.class.getTypeName()))
+ : ImmutableList.of(),
+ inspector.clazz(Super.class).getFinalPermittedSubclassAttributes());
+ }
+
+ @Test()
+ public void testNoRules() throws Exception {
+ assertFailsCompilationIf(
+ reportMissingClassesInPermittedSubclassesAttributes,
+ () ->
+ compileWithExpectedDiagnostics(
+ Main.class,
+ reportMissingClassesInPermittedSubclassesAttributes
+ ? diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom)
+ : TestDiagnosticMessages::assertNoMessages,
+ this::configure));
+ }
+
+ @Test
+ public void testDontWarnSuperClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addDontWarn(Super.class).andThen(this::configure))
+ .inspect(this::inspect);
+ }
+
+ @Test
+ public void testDontWarnMissingClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addDontWarn(MissingSub.class).andThen(this::configure))
+ .inspect(this::inspect);
+ }
+
+ @Test
+ public void testIgnoreWarnings() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ reportMissingClassesInPermittedSubclassesAttributes
+ ? diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom)
+ : TestDiagnosticMessages::assertNoMessages,
+ addIgnoreWarnings(reportMissingClassesInPermittedSubclassesAttributes)
+ .andThen(this::configure))
+ .inspect(this::inspect);
+ }
+
+ void configure(R8FullTestBuilder builder) {
+ try {
+ builder
+ .addKeepAttributePermittedSubclasses()
+ .addProgramClasses(Sub.class)
+ .addProgramClassFileData(getTransformedClasses())
+ .addKeepClassRulesWithAllowObfuscation(Super.class, Sub.class)
+ .addOptionsModification(
+ options -> {
+ // We do not report missing classes from permitted subclasses attributes by default.
+ assertFalse(options.reportMissingClassesInPermittedSubclassesAttributes);
+ options.reportMissingClassesInPermittedSubclassesAttributes =
+ reportMissingClassesInPermittedSubclassesAttributes;
+ })
+ .applyIf(
+ !reportMissingClassesInPermittedSubclassesAttributes,
+ // The -dontwarn Main and -dontwarn MissingClass tests will have unused -dontwarn
+ // rules.
+ R8TestBuilder::allowUnusedDontWarnPatterns);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ ClassReference getMissingClassReference() {
+ return Reference.classFromClass(MissingSub.class);
+ }
+
+ public byte[] getTransformedClasses() throws Exception {
+ return transformer(Super.class)
+ .setPermittedSubclasses(Super.class, Sub.class, MissingSub.class)
+ .transform();
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ new Sub();
+ System.out.println("Success!");
+ }
+ }
+
+ abstract static class Super /* permits Sub, MissingSub */ {}
+
+ static class Sub extends Super {}
+
+ static class MissingSub extends Super {}
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java
index 5cc5fe1..91c8722 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java
@@ -8,6 +8,7 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestCompilerBuilder.DiagnosticsConsumer;
import com.android.tools.r8.TestDiagnosticMessages;
@@ -75,27 +76,27 @@
compileWithExpectedDiagnostics(mainClass, diagnosticsConsumer, null);
}
- public void compileWithExpectedDiagnostics(
+ public R8TestCompileResult compileWithExpectedDiagnostics(
Class<?> mainClass,
DiagnosticsConsumer diagnosticsConsumer,
ThrowableConsumer<R8FullTestBuilder> configuration)
throws CompilationFailedException {
- internalCompileWithExpectedDiagnostics(
+ return internalCompileWithExpectedDiagnostics(
diagnosticsConsumer,
builder ->
builder.addProgramClasses(mainClass).addKeepMainRule(mainClass).apply(configuration));
}
- public void compileWithExpectedDiagnostics(
+ public R8TestCompileResult compileWithExpectedDiagnostics(
ThrowableConsumer<R8FullTestBuilder> configuration, DiagnosticsConsumer diagnosticsConsumer)
throws CompilationFailedException {
- internalCompileWithExpectedDiagnostics(diagnosticsConsumer, configuration);
+ return internalCompileWithExpectedDiagnostics(diagnosticsConsumer, configuration);
}
- private void internalCompileWithExpectedDiagnostics(
+ private R8TestCompileResult internalCompileWithExpectedDiagnostics(
DiagnosticsConsumer diagnosticsConsumer, ThrowableConsumer<R8FullTestBuilder> configuration)
throws CompilationFailedException {
- testForR8(parameters.getBackend())
+ return testForR8(parameters.getBackend())
.apply(configuration)
.setMinApi(parameters)
.compileWithExpectedDiagnostics(diagnosticsConsumer);
diff --git a/src/test/java/com/android/tools/r8/naming/retraceproguard/InliningRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retraceproguard/InliningRetraceTest.java
index 7f536a5..016d4ac 100644
--- a/src/test/java/com/android/tools/r8/naming/retraceproguard/InliningRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retraceproguard/InliningRetraceTest.java
@@ -56,7 +56,6 @@
@Test
public void testSourceFileAndLineNumberTable() throws Exception {
- assumeTrue("b/288405478", mode.isRelease());
runTest(
ImmutableList.of("-keepattributes SourceFile,LineNumberTable"),
(StackTrace actualStackTrace, StackTrace retracedStackTrace) -> {
@@ -68,7 +67,6 @@
@Test
public void testLineNumberTableOnly() throws Exception {
- assumeTrue("b/288405478", mode.isRelease());
assumeTrue(compat);
assumeTrue(parameters.isDexRuntime());
runTest(
@@ -81,7 +79,6 @@
@Test
public void testNoLineNumberTable() throws Exception {
- assumeTrue("b/288405478", mode.isRelease());
assumeTrue(compat);
assumeTrue(parameters.isDexRuntime());
runTest(
diff --git a/src/test/java/com/android/tools/r8/profile/art/completeness/RecordProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/completeness/RecordProfileRewritingTest.java
index 6d03704..2577312 100644
--- a/src/test/java/com/android/tools/r8/profile/art/completeness/RecordProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/completeness/RecordProfileRewritingTest.java
@@ -45,7 +45,18 @@
private static final String RECORD_NAME = "SimpleRecord";
private static final byte[][] PROGRAM_DATA = RecordTestUtils.getProgramData(RECORD_NAME);
private static final String EXPECTED_RESULT =
- StringUtils.lines("Jane Doe", "42", "Jane Doe", "42");
+ StringUtils.lines(
+ "Jane Doe",
+ "42",
+ "Jane Doe",
+ "42",
+ "true",
+ "true",
+ "true",
+ "false",
+ "false",
+ "false",
+ "false");
private static final ClassReference MAIN_REFERENCE =
Reference.classFromTypeName(RecordTestUtils.getMainType(RECORD_NAME));
diff --git a/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java b/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java
index b390f85..fb55a41 100644
--- a/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java
@@ -168,7 +168,10 @@
.enableProguardTestOptions()
.minification(minify.isMinify())
.setMinApi(parameters)
- .addKeepRuleFiles(ListUtils.map(keepRulesFiles, Paths::get))
+ .addKeepRuleFiles(
+ ListUtils.map(
+ keepRulesFiles,
+ keepRulesFile -> Paths.get(ToolHelper.getProjectRoot(), keepRulesFile)))
.addLibraryFiles(Paths.get(ToolHelper.EXAMPLES_BUILD_DIR + "shakinglib.jar"))
.addDefaultRuntimeLibrary(parameters)
.addOptionsModification(
diff --git a/src/test/java/com/android/tools/r8/utils/ReflectiveBuildPathUtils.java b/src/test/java/com/android/tools/r8/utils/ReflectiveBuildPathUtils.java
deleted file mode 100644
index ed991f2..0000000
--- a/src/test/java/com/android/tools/r8/utils/ReflectiveBuildPathUtils.java
+++ /dev/null
@@ -1,168 +0,0 @@
-// Copyright (c) 2020, 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 com.android.tools.r8.utils;
-
-import com.android.tools.r8.ToolHelper;
-import com.google.common.collect.Iterables;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-
-public class ReflectiveBuildPathUtils {
-
- public interface PackageUtils {
- String getPackageName() throws Exception;
-
- Path getPackagePath() throws Exception;
-
- PackageUtils getParentPackageUtils() throws Exception;
-
- Iterable<PackageUtils> getAllPackageUtils();
- }
-
- public interface ClassUtils {
- String getClassName() throws Exception;
-
- String getSimpleClassName() throws Exception;
-
- Path getClassPath() throws Exception;
- }
-
- public abstract static class ExamplesRootPackage implements PackageUtils {
- public abstract Path getPackagePath();
-
- @Override
- public String getPackageName() {
- return "";
- }
-
- @Override
- public PackageUtils getParentPackageUtils() {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public Iterable<PackageUtils> getAllPackageUtils() {
- return instantiateAllPackageUtils(getClass());
- }
- }
-
- public abstract static class ExamplesJava11RootPackage extends ExamplesRootPackage {
- @Override
- public Path getPackagePath() {
- return Paths.get(ToolHelper.EXAMPLES_JAVA11_BUILD_DIR);
- }
- }
-
- public abstract static class ExamplesPackage implements PackageUtils {
- public List<String> getName() {
- return Collections.singletonList(getClass().getSimpleName());
- }
-
- @Override
- public PackageUtils getParentPackageUtils() throws Exception {
- return (PackageUtils) getClass().getDeclaringClass().getConstructor().newInstance();
- }
-
- @Override
- public Path getPackagePath() throws Exception {
- Path path = getParentPackageUtils().getPackagePath();
- for (String folder : getName()) {
- path = path.resolve(folder);
- }
- return path;
- }
-
- @Override
- public String getPackageName() throws Exception {
- return getParentPackageUtils().getPackageName() + String.join(".", getName()) + ".";
- }
-
- @Override
- public Iterable<PackageUtils> getAllPackageUtils() {
- return instantiateAllPackageUtils(getClass());
- }
- }
-
- public static class ExamplesClass implements PackageUtils, ClassUtils {
- @Override
- public PackageUtils getParentPackageUtils() throws Exception {
- return (PackageUtils) getClass().getDeclaringClass().getConstructor().newInstance();
- }
-
- public String getSimpleClassName() throws Exception {
- Object parent = getClass().getDeclaringClass().getConstructor().newInstance();
- if (parent instanceof ClassUtils) {
- return ((ClassUtils) parent).getSimpleClassName() + "$" + getClass().getSimpleName();
- } else {
- return getClass().getSimpleName();
- }
- }
-
- @Override
- public String getClassName() throws Exception {
- return getParentPackageUtils().getPackageName() + getSimpleClassName();
- }
-
- @Override
- public Path getClassPath() throws Exception {
- return getParentPackageUtils().getPackagePath().resolve(getSimpleClassName() + ".class");
- }
-
- @Override
- public String getPackageName() throws Exception {
- return getParentPackageUtils().getPackageName();
- }
-
- @Override
- public Path getPackagePath() throws Exception {
- return getParentPackageUtils().getPackagePath();
- }
-
- @Override
- public Iterable<PackageUtils> getAllPackageUtils() {
- return instantiateAllPackageUtils(getClass());
- }
- }
-
- public static Iterable<PackageUtils> instantiateAllPackageUtils(Class<?> parentClazz) {
- Collection<PackageUtils> children = instantiatePackageUtils(parentClazz);
- return Iterables.concat(
- children,
- Iterables.concat(Iterables.transform(children, PackageUtils::getAllPackageUtils)));
- }
-
- public static Collection<PackageUtils> instantiatePackageUtils(Class<?> parentClazz) {
- Collection<PackageUtils> packageUtils = new ArrayList<>();
- for (Class<?> clazz : parentClazz.getDeclaredClasses()) {
- try {
- Object obj = clazz.getConstructor().newInstance();
- if (obj instanceof PackageUtils) {
- packageUtils.add((PackageUtils) obj);
- }
- } catch (Exception ex) {
- }
- }
- return packageUtils;
- }
-
- public static String resolveClassName(Class<? extends ExamplesClass> clazz) throws Exception {
- return clazz.getConstructor().newInstance().getClassName();
- }
-
- public static Collection<Path> allClassFiles(Class<? extends ExamplesRootPackage> clazz)
- throws Exception {
- Collection<Path> classFiles = new ArrayList<>();
- for (PackageUtils util : clazz.getConstructor().newInstance().getAllPackageUtils()) {
- if (util instanceof ClassUtils) {
- classFiles.add(((ClassUtils) util).getClassPath());
- }
- }
- return classFiles;
- }
-}
diff --git a/third_party/binary_compatibility_tests/compiler_api_tests.tar.gz.sha1 b/third_party/binary_compatibility_tests/compiler_api_tests.tar.gz.sha1
index 2133707..94616ba 100644
--- a/third_party/binary_compatibility_tests/compiler_api_tests.tar.gz.sha1
+++ b/third_party/binary_compatibility_tests/compiler_api_tests.tar.gz.sha1
@@ -1 +1 @@
-9d322829ca871ff117d24fb8d7cb30001552a3ed
\ No newline at end of file
+13ccbabcc23194ef50c8c3331bf4ef7cee364b75
\ No newline at end of file
diff --git a/third_party/kotlin/kotlin-compiler-1.3.11.tar.gz.sha1 b/third_party/kotlin/kotlin-compiler-1.3.11.tar.gz.sha1
deleted file mode 100644
index 05e8466..0000000
--- a/third_party/kotlin/kotlin-compiler-1.3.11.tar.gz.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b3ce5c6ba25ebbbbf62a49be56aad845eabae860
\ No newline at end of file
diff --git a/third_party/kotlin/kotlin-compiler-1.3.41.tar.gz.sha1 b/third_party/kotlin/kotlin-compiler-1.3.41.tar.gz.sha1
deleted file mode 100644
index e9de3b3..0000000
--- a/third_party/kotlin/kotlin-compiler-1.3.41.tar.gz.sha1
+++ /dev/null
@@ -1 +0,0 @@
-8d2ddeeaaf4366a419627a31ef3276a6f96afe40
\ No newline at end of file
diff --git a/third_party/kotlin/kotlin-compiler-1.5.0-M2.tar.gz.sha1 b/third_party/kotlin/kotlin-compiler-1.5.0-M2.tar.gz.sha1
deleted file mode 100644
index e0b251e..0000000
--- a/third_party/kotlin/kotlin-compiler-1.5.0-M2.tar.gz.sha1
+++ /dev/null
@@ -1 +0,0 @@
-7368d9ee73d01fc609d7ded1bf0506f72aa3ac66
\ No newline at end of file
diff --git a/tools/__init__.py b/tools/__init__.py
new file mode 100644
index 0000000..bb02b91
--- /dev/null
+++ b/tools/__init__.py
@@ -0,0 +1,3 @@
+# Copyright (c) 2023, 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.
diff --git a/tools/check-cherry-picks.py b/tools/check-cherry-picks.py
index adf763c..3d66d3c 100755
--- a/tools/check-cherry-picks.py
+++ b/tools/check-cherry-picks.py
@@ -139,7 +139,7 @@
is_cherry_pick = True
# If the change is in the release mappings check for holes.
if missing_from:
- found_errors = change_error(
+ found_errors |= change_error(
change,
'Error: missing Change-Id %s on branch %s. '
'Is present on %s and again on %s.' % (
@@ -150,7 +150,7 @@
# The change is not in the non-dev part of the branch, so we need to
# check that the fork from main included the change.
if not is_commit_in(commit_on_main, newer_branch):
- found_errors = change_error(
+ found_errors |= change_error(
change,
'Error: missing Change-Id %s on branch %s. '
'Is present on %s and on main as commit %s.' % (
