blob: 7f1717095573cc198fb0249b3bd8a31584c8adf5 [file] [log] [blame]
// Copyright (c) 2017, 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;
import static com.android.tools.r8.D8Command.USAGE_MESSAGE;
import static com.android.tools.r8.utils.AssertionUtils.forTesting;
import static com.android.tools.r8.utils.ExceptionUtils.unwrapExecutionException;
import com.android.tools.r8.dex.ApplicationReader;
import com.android.tools.r8.dex.ApplicationWriter;
import com.android.tools.r8.dex.Marker;
import com.android.tools.r8.dex.Marker.Tool;
import com.android.tools.r8.graph.AppInfo;
import com.android.tools.r8.graph.AppServices;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexApplication;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.GraphLens;
import com.android.tools.r8.graph.InitClassLens;
import com.android.tools.r8.graph.LazyLoadedDexApplication;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.graph.analysis.ClassInitializerAssertionEnablingAnalysis;
import com.android.tools.r8.inspector.internal.InspectorImpl;
import com.android.tools.r8.ir.conversion.IRConverter;
import com.android.tools.r8.ir.desugar.PrefixRewritingMapper;
import com.android.tools.r8.ir.optimize.AssertionsRewriter;
import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackSimple;
import com.android.tools.r8.jar.CfApplicationWriter;
import com.android.tools.r8.kotlin.KotlinMetadataRewriter;
import com.android.tools.r8.naming.ClassNameMapper;
import com.android.tools.r8.naming.NamingLens;
import com.android.tools.r8.naming.PrefixRewritingNamingLens;
import com.android.tools.r8.naming.ProguardMapSupplier;
import com.android.tools.r8.naming.RecordRewritingNamingLens;
import com.android.tools.r8.naming.signature.GenericSignatureRewriter;
import com.android.tools.r8.origin.CommandLineOrigin;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.shaking.MainDexInfo;
import com.android.tools.r8.synthesis.SyntheticFinalization;
import com.android.tools.r8.synthesis.SyntheticItems;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.CfgPrinter;
import com.android.tools.r8.utils.ExceptionUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.InternalOptions.DesugarState;
import com.android.tools.r8.utils.LineNumberOptimizer;
import com.android.tools.r8.utils.StringDiagnostic;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.ThreadUtils;
import com.android.tools.r8.utils.Timing;
import com.google.common.collect.ImmutableList;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
/**
* The D8 dex compiler.
*
* <p>D8 performs modular compilation to DEX bytecode. It supports compilation of Java bytecode and
* Android DEX bytecode to DEX bytecode including merging a mix of these input formats.
*
* <p>The D8 dexer API is intentionally limited and should "do the right thing" given a command. If
* this API does not suffice please contact the D8/R8 team.
*
* <p>The compiler is invoked by calling {@link #run(D8Command) D8.run} with an appropriate {@link
* D8Command}. For example:
*
* <pre>
* D8.run(D8Command.builder()
* .addProgramFiles(inputPathA, inputPathB)
* .setOutput(outputPath, OutputMode.DexIndexed)
* .build());
* </pre>
*
* The above reads the input files denoted by {@code inputPathA} and {@code inputPathB}, compiles
* them to DEX bytecode (compiling from Java bytecode for such inputs and merging for DEX inputs),
* and then writes the result to the directory or zip archive specified by {@code outputPath}.
*/
@Keep
public final class D8 {
private D8() {}
/**
* Main API entry for the D8 dexer.
*
* @param command D8 command.
*/
public static void run(D8Command command) throws CompilationFailedException {
AndroidApp app = command.getInputApp();
InternalOptions options = command.getInternalOptions();
ExecutorService executor = ThreadUtils.getExecutorService(options);
ExceptionUtils.withD8CompilationHandler(
command.getReporter(),
() -> {
try {
run(app, options, executor);
} finally {
executor.shutdown();
}
});
}
/**
* Main API entry for the D8 dexer with a externally supplied executor service.
*
* @param command D8 command.
* @param executor executor service from which to get threads for multi-threaded processing.
*/
public static void run(D8Command command, ExecutorService executor)
throws CompilationFailedException {
AndroidApp app = command.getInputApp();
InternalOptions options = command.getInternalOptions();
ExceptionUtils.withD8CompilationHandler(
command.getReporter(),
() -> {
run(app, options, executor);
});
}
private static void run(String[] args) throws CompilationFailedException {
D8Command command = D8Command.parse(args, CommandLineOrigin.INSTANCE).build();
if (command.isPrintHelp()) {
System.out.println(USAGE_MESSAGE);
return;
}
if (command.isPrintVersion()) {
System.out.println("D8 " + Version.getVersionString());
return;
}
InternalOptions options = command.getInternalOptions();
AndroidApp app = command.getInputApp();
runForTesting(app, options);
}
/**
* Command-line entry to D8.
*
* <p>See {@link D8Command#USAGE_MESSAGE} or run {@code d8 --help} for usage information.
*/
public static void main(String[] args) {
if (args.length == 0) {
throw new RuntimeException(StringUtils.joinLines("Invalid invocation.", USAGE_MESSAGE));
}
ExceptionUtils.withMainProgramHandler(() -> run(args));
}
static void runForTesting(AndroidApp inputApp, InternalOptions options)
throws CompilationFailedException {
ExecutorService executor = ThreadUtils.getExecutorService(options);
ExceptionUtils.withD8CompilationHandler(
options.reporter,
() -> {
try {
run(inputApp, options, executor);
} finally {
executor.shutdown();
}
});
}
private static AppView<AppInfo> readApp(
AndroidApp inputApp, InternalOptions options, ExecutorService executor, Timing timing)
throws IOException {
PrefixRewritingMapper rewritePrefix =
options.desugaredLibraryConfiguration.getPrefixRewritingMapper();
ApplicationReader applicationReader = new ApplicationReader(inputApp, options, timing);
LazyLoadedDexApplication app = applicationReader.read(executor);
AppInfo appInfo = AppInfo.createInitialAppInfo(app, applicationReader.readMainDexClasses(app));
return AppView.createForD8(appInfo, rewritePrefix);
}
private static void run(AndroidApp inputApp, InternalOptions options, ExecutorService executor)
throws IOException {
Timing timing = Timing.create("D8", options);
try {
// Disable global optimizations.
options.disableGlobalOptimizations();
// Synthetic assertion to check that testing assertions works and can be enabled.
assert forTesting(options, () -> !options.testing.testEnableTestAssertions);
AppView<AppInfo> appView = readApp(inputApp, options, executor, timing);
SyntheticItems.collectSyntheticInputs(appView);
final CfgPrinter printer = options.printCfg ? new CfgPrinter() : null;
if (AssertionsRewriter.isEnabled(options)) {
// Run analysis to mark all <clinit> methods having the javac generated assertion
// enabling code.
ClassInitializerAssertionEnablingAnalysis analysis =
new ClassInitializerAssertionEnablingAnalysis(
appView.dexItemFactory(), OptimizationFeedbackSimple.getInstance());
ThreadUtils.processItems(
appView.appInfo().classes(),
clazz -> {
ProgramMethod classInitializer = clazz.getProgramClassInitializer();
if (classInitializer != null) {
analysis.processNewlyLiveMethod(classInitializer, clazz);
}
},
executor);
}
if (options.testing.enableD8ResourcesPassThrough) {
appView.setAppServices(AppServices.builder(appView).build());
}
new IRConverter(appView, timing, printer).convert(appView, executor);
if (options.printCfg) {
if (options.printCfgFile == null || options.printCfgFile.isEmpty()) {
System.out.print(printer.toString());
} else {
try (OutputStreamWriter writer =
new OutputStreamWriter(
new FileOutputStream(options.printCfgFile), StandardCharsets.UTF_8)) {
writer.write(printer.toString());
}
}
}
// Close any internal archive providers now the application is fully processed.
inputApp.closeInternalArchiveProviders();
// If a method filter is present don't produce output since the application is likely partial.
if (options.hasMethodsFilter()) {
System.out.println("Finished compilation with method filter: ");
options.methodsFilter.forEach((m) -> System.out.println(" - " + m));
}
// Preserve markers from input dex code and add a marker with the current version
// if there were class file inputs.
boolean hasClassResources = appView.appInfo().app().getFlags().hasReadProgramClassFromCf();
boolean hasDexResources = appView.appInfo().app().getFlags().hasReadProgramClassFromDex();
Marker marker = options.getMarker(Tool.D8);
Set<Marker> markers = new HashSet<>(appView.dexItemFactory().extractMarkers());
// TODO(b/166617364): Don't add an additional marker when desugaring is turned off.
if (hasClassResources
&& (options.desugarState != DesugarState.OFF
|| markers.isEmpty()
|| (markers.size() == 1 && markers.iterator().next().isL8()))) {
markers.add(marker);
}
Marker.checkCompatibleDesugaredLibrary(markers, options.reporter);
InspectorImpl.runInspections(options.outputInspections, appView.appInfo().classes());
NamingLens namingLens = NamingLens.getIdentityLens();
namingLens = PrefixRewritingNamingLens.createPrefixRewritingNamingLens(appView, namingLens);
namingLens = RecordRewritingNamingLens.createRecordRewritingNamingLens(appView, namingLens);
if (options.isGeneratingClassFiles()) {
ProguardMapSupplier proguardMapSupplier =
finalizeApplication(inputApp, appView, namingLens);
new CfApplicationWriter(
appView, marker, GraphLens.getIdentityLens(), namingLens, proguardMapSupplier)
.write(options.getClassFileConsumer());
} else {
if (!hasDexResources || !hasClassResources || !appView.rewritePrefix.isRewriting()) {
// All inputs are either dex or cf, or there is nothing to rewrite.
namingLens = hasDexResources ? NamingLens.getIdentityLens() : namingLens;
new GenericSignatureRewriter(appView, namingLens)
.run(appView.appInfo().classes(), executor);
new KotlinMetadataRewriter(appView, namingLens).runForD8(executor);
} else {
// There are both cf and dex inputs in the program, and rewriting is required for
// desugared library only on cf inputs. We cannot easily rewrite part of the program
// without iterating again the IR. We fall-back to writing one app with rewriting and
// merging it with the other app in rewriteNonDexInputs.
timing.begin("Rewrite non-dex inputs");
DexApplication app =
rewriteNonDexInputs(
appView,
inputApp,
options,
executor,
timing,
appView.appInfo().app(),
namingLens);
timing.end();
appView.setAppInfo(
new AppInfo(
appView.appInfo().getSyntheticItems().commit(app),
appView.appInfo().getMainDexInfo()));
namingLens = NamingLens.getIdentityLens();
}
// Since tracing is not lens aware, this needs to be done prior to synthetic finalization
// which will construct a graph lens.
if (!options.mainDexKeepRules.isEmpty()) {
appView.dexItemFactory().clearTypeElementsCache();
MainDexInfo mainDexInfo =
new GenerateMainDexList(options)
.traceMainDex(
executor, appView.appInfo().app(), appView.appInfo().getMainDexInfo());
appView.setAppInfo(appView.appInfo().rebuildWithMainDexInfo(mainDexInfo));
}
ProguardMapSupplier proguardMapSupplier =
finalizeApplication(inputApp, appView, namingLens);
new ApplicationWriter(
appView,
marker == null ? null : ImmutableList.copyOf(markers),
appView.graphLens(),
InitClassLens.getThrowingInstance(),
namingLens,
proguardMapSupplier)
.write(executor);
}
options.printWarnings();
} catch (ExecutionException e) {
throw unwrapExecutionException(e);
} finally {
options.signalFinishedToConsumers();
// Dump timings.
if (options.printTimes) {
timing.report();
}
}
}
private static ProguardMapSupplier finalizeApplication(
AndroidApp inputApp, AppView<AppInfo> appView, NamingLens namingLens) {
SyntheticFinalization.finalize(appView);
if (appView.options().proguardMapConsumer == null) {
return null;
}
ClassNameMapper classNameMapper =
LineNumberOptimizer.run(appView, appView.appInfo().app(), inputApp, namingLens);
return ProguardMapSupplier.create(classNameMapper, appView.options());
}
private static DexApplication rewriteNonDexInputs(
AppView<AppInfo> appView,
AndroidApp inputApp,
InternalOptions options,
ExecutorService executor,
Timing timing,
DexApplication app,
NamingLens desugaringLens)
throws IOException, ExecutionException {
// TODO(b/154575955): Remove the naming lens in D8.
appView
.options()
.reporter
.warning(
new StringDiagnostic(
"The compilation is slowed down due to a mix of class file and dex file inputs in"
+ " the context of desugared library. This can be fixed by pre-compiling to"
+ " dex the class file inputs and dex merging only dex files."));
List<DexProgramClass> dexProgramClasses = new ArrayList<>();
List<DexProgramClass> nonDexProgramClasses = new ArrayList<>();
for (DexProgramClass aClass : app.classes()) {
if (aClass.originatesFromDexResource()) {
dexProgramClasses.add(aClass);
} else {
nonDexProgramClasses.add(aClass);
}
}
DexApplication cfApp = app.builder().replaceProgramClasses(nonDexProgramClasses).build();
appView.setAppInfo(
new AppInfo(
appView.appInfo().getSyntheticItems().commit(cfApp),
appView.appInfo().getMainDexInfo()));
ConvertedCfFiles convertedCfFiles = new ConvertedCfFiles();
new GenericSignatureRewriter(appView, desugaringLens)
.run(appView.appInfo().classes(), executor);
new KotlinMetadataRewriter(appView, desugaringLens).runForD8(executor);
new ApplicationWriter(
appView,
null,
GraphLens.getIdentityLens(),
InitClassLens.getThrowingInstance(),
desugaringLens,
null,
convertedCfFiles)
.write(executor);
AndroidApp.Builder builder = AndroidApp.builder(inputApp);
builder.getProgramResourceProviders().clear();
builder.addProgramResourceProvider(convertedCfFiles);
AndroidApp newAndroidApp = builder.build();
DexApplication newApp = new ApplicationReader(newAndroidApp, options, timing).read(executor);
DexApplication.Builder<?> finalDexApp = newApp.builder();
for (DexProgramClass dexProgramClass : dexProgramClasses) {
finalDexApp.addProgramClass(dexProgramClass);
}
return finalDexApp.build();
}
static void optimize(
AppView<AppInfo> appView, InternalOptions options, Timing timing, ExecutorService executor)
throws IOException, ExecutionException {
final CfgPrinter printer = options.printCfg ? new CfgPrinter() : null;
new IRConverter(appView, timing, printer).convert(appView, executor);
if (options.printCfg) {
if (options.printCfgFile == null || options.printCfgFile.isEmpty()) {
System.out.print(printer.toString());
} else {
try (OutputStreamWriter writer =
new OutputStreamWriter(
new FileOutputStream(options.printCfgFile), StandardCharsets.UTF_8)) {
writer.write(printer.toString());
}
}
}
}
static class ConvertedCfFiles implements DexIndexedConsumer, ProgramResourceProvider {
private final List<ProgramResource> resources = new ArrayList<>();
@Override
public synchronized void accept(
int fileIndex, ByteDataView data, Set<String> descriptors, DiagnosticsHandler handler) {
// TODO(b/154106502): Map Origin information.
resources.add(
ProgramResource.fromBytes(
Origin.unknown(), ProgramResource.Kind.DEX, data.copyByteData(), descriptors));
}
@Override
public Collection<ProgramResource> getProgramResources() throws ResourceException {
return resources;
}
@Override
public void finished(DiagnosticsHandler handler) {}
}
}