Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9bb9bfb3 authored by Colin Cross's avatar Colin Cross
Browse files

Don't pass static libs to r8 

r8 gets the static libs in the program jar, it shouldn't also get
them as library jars.  Keep a separate classpath for dexing that
includes libs but not static_libs.

Bug: 222468116
Test: m checkbuild
Test: TestD8
Test: TestR8
Change-Id: Icca3393f496cbcadcc633f3b156761e6c145f975
parent 3f57c6a2

java/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -81,6 +81,7 @@ bootstrap_go_package { 
        "app_test.go",

        "bootclasspath_fragment_test.go",

        "device_host_converter_test.go",

        "dex_test.go",

        "dexpreopt_test.go",

        "dexpreopt_bootjars_test.go",

        "droiddoc_test.go",

java/base.go

+11 −1
Original line number Diff line number Diff line
@@ -872,6 +872,7 @@ func (j *Module) collectBuilderFlags(ctx android.ModuleContext, deps deps) javaB 
	// classpath

	flags.bootClasspath = append(flags.bootClasspath, deps.bootClasspath...)

	flags.classpath = append(flags.classpath, deps.classpath...)

	flags.dexClasspath = append(flags.dexClasspath, deps.dexClasspath...)

	flags.java9Classpath = append(flags.java9Classpath, deps.java9Classpath...)

	flags.processorPath = append(flags.processorPath, deps.processorPath...)

	flags.errorProneProcessorPath = append(flags.errorProneProcessorPath, deps.errorProneProcessorPath...)
@@ -1090,6 +1091,8 @@ func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) { 
		flags.classpath = append(flags.classpath, deps.kotlinStdlib...)

		flags.classpath = append(flags.classpath, deps.kotlinAnnotations...)



		flags.dexClasspath = append(flags.dexClasspath, deps.kotlinAnnotations...)



		flags.kotlincClasspath = append(flags.kotlincClasspath, flags.bootClasspath...)

		flags.kotlincClasspath = append(flags.kotlincClasspath, flags.classpath...)
@@ -1118,6 +1121,8 @@ func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) { 
		// Jar kotlin classes into the final jar after javac

		if BoolDefault(j.properties.Static_kotlin_stdlib, true) {

			kotlinJars = append(kotlinJars, deps.kotlinStdlib...)

		} else {

			flags.dexClasspath = append(flags.dexClasspath, deps.kotlinStdlib...)

		}

	}
@@ -1842,6 +1847,7 @@ func (j *Module) collectDeps(ctx android.ModuleContext) deps { 
		} else if sdkDep.useFiles {

			// sdkDep.jar is actually equivalent to turbine header.jar.

			deps.classpath = append(deps.classpath, sdkDep.jars...)

			deps.dexClasspath = append(deps.dexClasspath, sdkDep.jars...)

			deps.aidlPreprocess = sdkDep.aidl

		} else {

			deps.aidlPreprocess = sdkDep.aidl
@@ -1866,7 +1872,9 @@ func (j *Module) collectDeps(ctx android.ModuleContext) deps { 
		if dep, ok := module.(SdkLibraryDependency); ok {

			switch tag {

			case libTag:

				deps.classpath = append(deps.classpath, dep.SdkHeaderJars(ctx, j.SdkVersion(ctx))...)

				depHeaderJars := dep.SdkHeaderJars(ctx, j.SdkVersion(ctx))

				deps.classpath = append(deps.classpath, depHeaderJars...)

				deps.dexClasspath = append(deps.dexClasspath, depHeaderJars...)

			case staticLibTag:

				ctx.ModuleErrorf("dependency on java_sdk_library %q can only be in libs", otherName)

			}
@@ -1885,6 +1893,7 @@ func (j *Module) collectDeps(ctx android.ModuleContext) deps { 
				deps.bootClasspath = append(deps.bootClasspath, dep.HeaderJars...)

			case libTag, instrumentationForTag:

				deps.classpath = append(deps.classpath, dep.HeaderJars...)

				deps.dexClasspath = append(deps.dexClasspath, dep.HeaderJars...)

				deps.aidlIncludeDirs = append(deps.aidlIncludeDirs, dep.AidlIncludeDirs...)

				addPlugins(&deps, dep.ExportedPlugins, dep.ExportedPluginClasses...)

				deps.disableTurbine = deps.disableTurbine || dep.ExportedPluginDisableTurbine
@@ -1952,6 +1961,7 @@ func (j *Module) collectDeps(ctx android.ModuleContext) deps { 
			case libTag:

				checkProducesJars(ctx, dep)

				deps.classpath = append(deps.classpath, dep.Srcs()...)

				deps.dexClasspath = append(deps.classpath, dep.Srcs()...)

			case staticLibTag:

				checkProducesJars(ctx, dep)

				deps.classpath = append(deps.classpath, dep.Srcs()...)

java/builder.go

+26 −9
Original line number Diff line number Diff line
@@ -248,9 +248,26 @@ func init() { 


type javaBuilderFlags struct {

	javacFlags string



	// bootClasspath is the list of jars that form the boot classpath (generally the java.* and

	// android.* classes) for tools that still use it.  javac targeting 1.9 or higher uses

	// systemModules and java9Classpath instead.

	bootClasspath classpath



	// classpath is the list of jars that form the classpath for javac and kotlinc rules.  It

	// contains header jars for all static and non-static dependencies.

	classpath classpath



	// dexClasspath is the list of jars that form the classpath for d8 and r8 rules.  It contains

	// header jars for all non-static dependencies.  Static dependencies have already been

	// combined into the program jar.

	dexClasspath classpath



	// java9Classpath is the list of jars that will be added to the classpath when targeting

	// 1.9 or higher.  It generally contains the android.* classes, while the java.* classes

	// are provided by systemModules.

	java9Classpath classpath



	processorPath classpath

	processors    []string

	systemModules *systemModules

java/dex.go

+4 −4
Original line number Diff line number Diff line
@@ -205,10 +205,10 @@ func (d *dexer) dexCommonFlags(ctx android.ModuleContext, 


func d8Flags(flags javaBuilderFlags) (d8Flags []string, d8Deps android.Paths) {

	d8Flags = append(d8Flags, flags.bootClasspath.FormRepeatedClassPath("--lib ")...)

	d8Flags = append(d8Flags, flags.classpath.FormRepeatedClassPath("--lib ")...)

	d8Flags = append(d8Flags, flags.dexClasspath.FormRepeatedClassPath("--lib ")...)



	d8Deps = append(d8Deps, flags.bootClasspath...)

	d8Deps = append(d8Deps, flags.classpath...)

	d8Deps = append(d8Deps, flags.dexClasspath...)



	return d8Flags, d8Deps

}
@@ -231,11 +231,11 @@ func (d *dexer) r8Flags(ctx android.ModuleContext, flags javaBuilderFlags) (r8Fl 


	r8Flags = append(r8Flags, proguardRaiseDeps.FormJavaClassPath("-libraryjars"))

	r8Flags = append(r8Flags, flags.bootClasspath.FormJavaClassPath("-libraryjars"))

	r8Flags = append(r8Flags, flags.classpath.FormJavaClassPath("-libraryjars"))

	r8Flags = append(r8Flags, flags.dexClasspath.FormJavaClassPath("-libraryjars"))



	r8Deps = append(r8Deps, proguardRaiseDeps...)

	r8Deps = append(r8Deps, flags.bootClasspath...)

	r8Deps = append(r8Deps, flags.classpath...)

	r8Deps = append(r8Deps, flags.dexClasspath...)



	flagFiles := android.Paths{

		android.PathForSource(ctx, "build/make/core/proguard.flags"),

java/dex_test.go

0 → 100644
+103 −0
Original line number Diff line number Diff line 
// Copyright 2022 Google Inc. All rights reserved.

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.



package java



import (

	"testing"



	"android/soong/android"

)



func TestR8(t *testing.T) {

	result := PrepareForTestWithJavaDefaultModulesWithoutFakeDex2oatd.RunTestWithBp(t, `

		android_app {

			name: "app",

			srcs: ["foo.java"],

			libs: ["lib"],

			static_libs: ["static_lib"],

			platform_apis: true,

		}



		java_library {

			name: "lib",

			srcs: ["foo.java"],

		}



		java_library {

			name: "static_lib",

			srcs: ["foo.java"],

		}

	`)



	app := result.ModuleForTests("app", "android_common")

	lib := result.ModuleForTests("lib", "android_common")

	staticLib := result.ModuleForTests("static_lib", "android_common")



	appJavac := app.Rule("javac")

	appR8 := app.Rule("r8")

	libHeader := lib.Output("turbine-combined/lib.jar").Output

	staticLibHeader := staticLib.Output("turbine-combined/static_lib.jar").Output



	android.AssertStringDoesContain(t, "expected lib header jar in app javac classpath",

		appJavac.Args["classpath"], libHeader.String())

	android.AssertStringDoesContain(t, "expected static_lib header jar in app javac classpath",

		appJavac.Args["classpath"], staticLibHeader.String())



	android.AssertStringDoesContain(t, "expected lib header jar in app r8 classpath",

		appR8.Args["r8Flags"], libHeader.String())

	android.AssertStringDoesNotContain(t, "expected no  static_lib header jar in app javac classpath",

		appR8.Args["r8Flags"], staticLibHeader.String())

}



func TestD8(t *testing.T) {

	result := PrepareForTestWithJavaDefaultModulesWithoutFakeDex2oatd.RunTestWithBp(t, `

		java_library {

			name: "foo",

			srcs: ["foo.java"],

			libs: ["lib"],

			static_libs: ["static_lib"],

			installable: true,

		}



		java_library {

			name: "lib",

			srcs: ["foo.java"],

		}



		java_library {

			name: "static_lib",

			srcs: ["foo.java"],

		}

	`)



	foo := result.ModuleForTests("foo", "android_common")

	lib := result.ModuleForTests("lib", "android_common")

	staticLib := result.ModuleForTests("static_lib", "android_common")



	fooJavac := foo.Rule("javac")

	fooD8 := foo.Rule("d8")

	libHeader := lib.Output("turbine-combined/lib.jar").Output

	staticLibHeader := staticLib.Output("turbine-combined/static_lib.jar").Output



	android.AssertStringDoesContain(t, "expected lib header jar in foo javac classpath",

		fooJavac.Args["classpath"], libHeader.String())

	android.AssertStringDoesContain(t, "expected static_lib header jar in foo javac classpath",

		fooJavac.Args["classpath"], staticLibHeader.String())



	android.AssertStringDoesContain(t, "expected lib header jar in foo d8 classpath",

		fooD8.Args["d8Flags"], libHeader.String())

	android.AssertStringDoesNotContain(t, "expected no  static_lib header jar in foo javac classpath",

		fooD8.Args["d8Flags"], staticLibHeader.String())

}