Merge "Split Rust crate builds into compile and link phases." (f5cd4778) · Commits · e / os / android_build_soong

apex/apex_test.go

+2 −2

Original line number	Diff line number	Diff line
		@@ -1001,7 +1001,7 @@ func TestApexWithStubs(t *testing.T) {
		// Ensure that stub dependency from a rust module is not included
		ensureNotContains(t, copyCmds, "image.apex/lib64/libfoo.shared_from_rust.so")
		// The rust module is linked to the stub cc library
		rustDeps := ctx.ModuleForTests("foo.rust", "android_arm64_armv8-a_apex10000").Rule("rustc").Args["linkFlags"]
		rustDeps := ctx.ModuleForTests("foo.rust", "android_arm64_armv8-a_apex10000").Rule("rustLink").Args["linkFlags"]
		ensureContains(t, rustDeps, "libfoo.shared_from_rust/android_arm64_armv8-a_shared_current/libfoo.shared_from_rust.so")
		ensureNotContains(t, rustDeps, "libfoo.shared_from_rust/android_arm64_armv8-a_shared/libfoo.shared_from_rust.so")

		@@ -1077,7 +1077,7 @@ func TestApexCanUsePrivateApis(t *testing.T) {
		mylibLdFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_shared_apex10000").Rule("ld").Args["libFlags"]
		ensureNotContains(t, mylibLdFlags, "mylib2/android_arm64_armv8-a_shared_current/mylib2.so")
		ensureContains(t, mylibLdFlags, "mylib2/android_arm64_armv8-a_shared/mylib2.so")
		rustDeps := ctx.ModuleForTests("foo.rust", "android_arm64_armv8-a_apex10000").Rule("rustc").Args["linkFlags"]
		rustDeps := ctx.ModuleForTests("foo.rust", "android_arm64_armv8-a_apex10000").Rule("rustLink").Args["linkFlags"]
		ensureNotContains(t, rustDeps, "libfoo.shared_from_rust/android_arm64_armv8-a_shared_current/libfoo.shared_from_rust.so")
		ensureContains(t, rustDeps, "libfoo.shared_from_rust/android_arm64_armv8-a_shared/libfoo.shared_from_rust.so")
		}

rust/binary.go

+5 −2

Original line number	Diff line number	Diff line
		@@ -72,11 +72,14 @@ func NewRustBinary(hod android.HostOrDeviceSupported) (Module, binaryDecorator
		func (binary *binaryDecorator) compilerFlags(ctx ModuleContext, flags Flags) Flags {
		flags = binary.baseCompiler.compilerFlags(ctx, flags)

		if ctx.Os().Linux() {
		flags.LinkFlags = append(flags.LinkFlags, "-Wl,--gc-sections")
		}

		if ctx.toolchain().Bionic() {
		// no-undefined-version breaks dylib compilation since __rust_alloc functions aren't defined,
		// but we can apply this to binaries.
		flags.LinkFlags = append(flags.LinkFlags,
		"-Wl,--gc-sections",
		"-Wl,-z,nocopyreloc",
		"-Wl,--no-undefined-version")

		@@ -136,7 +139,7 @@ func (binary *binaryDecorator) compile(ctx ModuleContext, flags Flags, deps Path

		flags.RustFlags = append(flags.RustFlags, deps.depFlags...)
		flags.LinkFlags = append(flags.LinkFlags, deps.depLinkFlags...)
		flags.LinkFlags = append(flags.LinkFlags, deps.linkObjects...)
		flags.LinkFlags = append(flags.LinkFlags, deps.linkObjects.Strings()...)

		if binary.stripper.NeedsStrip(ctx) {
		strippedOutputFile := outputFile

rust/binary_test.go

+4 −3

Original line number	Diff line number	Diff line
		@@ -123,7 +123,7 @@ func TestBootstrap(t *testing.T) {
		bootstrap: true,
		}`)

		foo := ctx.ModuleForTests("foo", "android_arm64_armv8-a").Rule("rustc")
		foo := ctx.ModuleForTests("foo", "android_arm64_armv8-a").Rule("rustLink")

		flag := "-Wl,-dynamic-linker,/system/bin/bootstrap/linker64"
		if !strings.Contains(foo.Args["linkFlags"], flag) {
		@@ -140,10 +140,11 @@ func TestStaticBinaryFlags(t *testing.T) {
		}`)

		fizzOut := ctx.ModuleForTests("fizz", "android_arm64_armv8-a").Rule("rustc")
		fizzOutLink := ctx.ModuleForTests("fizz", "android_arm64_armv8-a").Rule("rustLink")
		fizzMod := ctx.ModuleForTests("fizz", "android_arm64_armv8-a").Module().(*Module)

		flags := fizzOut.Args["rustcFlags"]
		linkFlags := fizzOut.Args["linkFlags"]
		linkFlags := fizzOutLink.Args["linkFlags"]
		if !strings.Contains(flags, "-C relocation-model=static") {
		t.Errorf("static binary missing '-C relocation-model=static' in rustcFlags, found: %#v", flags)
		}
		@@ -173,7 +174,7 @@ func TestLinkObjects(t *testing.T) {
		name: "libfoo",
		}`)

		fizzBuzz := ctx.ModuleForTests("fizz-buzz", "android_arm64_armv8-a").Rule("rustc")
		fizzBuzz := ctx.ModuleForTests("fizz-buzz", "android_arm64_armv8-a").Rule("rustLink")
		linkFlags := fizzBuzz.Args["linkFlags"]
		if !strings.Contains(linkFlags, "/libfoo.so") {
		t.Errorf("missing shared dependency 'libfoo.so' in linkFlags: %#v", linkFlags)

rust/builder.go

+52 −37

Original line number	Diff line number	Diff line
		@@ -26,14 +26,14 @@ import (

		var (
		_ = pctx.SourcePathVariable("rustcCmd", "${config.RustBin}/rustc")
		_ = pctx.SourcePathVariable("mkcraterspCmd", "build/soong/scripts/mkcratersp.py")
		rustc = pctx.AndroidStaticRule("rustc",
		blueprint.RuleParams{
		Command: "$envVars $rustcCmd " +
		"-C linker=${config.RustLinker} " +
		"-C link-args=\"${crtBegin} ${config.RustLinkerArgs} ${linkFlags} ${crtEnd}\" " +
		"-C linker=$mkcraterspCmd " +
		"--emit link -o $out --emit dep-info=$out.d.raw $in ${libFlags} $rustcFlags" +
		" && grep \"^$out:\" $out.d.raw > $out.d",
		CommandDeps: []string{"$rustcCmd"},
		CommandDeps: []string{"$rustcCmd", "$mkcraterspCmd"},
		// Rustc deps-info writes out make compatible dep files: https://github.com/rust-lang/rust/issues/7633
		// Rustc emits unneeded dependency lines for the .d and input .rs files.
		// Those extra lines cause ninja warning:
		@@ -42,7 +42,12 @@ var (
		Deps: blueprint.DepsGCC,
		Depfile: "$out.d",
		},
		"rustcFlags", "linkFlags", "libFlags", "crtBegin", "crtEnd", "envVars")
		"rustcFlags", "libFlags", "envVars")
		rustLink = pctx.AndroidStaticRule("rustLink",
		blueprint.RuleParams{
		Command: "${config.RustLinker} -o $out ${crtBegin} ${config.RustLinkerArgs} @$in ${linkFlags} ${crtEnd}",
		},
		"linkFlags", "crtBegin", "crtEnd")

		_ = pctx.SourcePathVariable("rustdocCmd", "${config.RustBin}/rustdoc")
		rustdoc = pctx.AndroidStaticRule("rustdoc",
		@@ -101,14 +106,13 @@ var (
		`KYTHE_CANONICALIZE_VNAME_PATHS=prefer-relative ` +
		`$rustExtractor $envVars ` +
		`$rustcCmd ` +
		`-C linker=${config.RustLinker} ` +
		`-C link-args="${crtBegin} ${config.RustLinkerArgs} ${linkFlags} ${crtEnd}" ` +
		`-C linker=true ` +
		`$in ${libFlags} $rustcFlags`,
		CommandDeps: []string{"$rustExtractor", "$kytheVnames"},
		Rspfile: "${out}.rsp",
		RspfileContent: "$in",
		},
		"rustcFlags", "linkFlags", "libFlags", "crtBegin", "crtEnd", "envVars")
		"rustcFlags", "libFlags", "envVars")
		)

		type buildOutput struct {
		@@ -220,11 +224,9 @@ func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, fl
		outputFile android.WritablePath, crateType string) buildOutput {

		var inputs android.Paths
		var implicits android.Paths
		var orderOnly android.Paths
		var implicits, linkImplicits, linkOrderOnly android.Paths
		var output buildOutput
		var rustcFlags, linkFlags []string
		var implicitOutputs android.WritablePaths

		output.outputFile = outputFile
		crateName := ctx.RustModule().CrateName()
		@@ -281,15 +283,15 @@ func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, fl
		implicits = append(implicits, rustLibsToPaths(deps.RLibs)...)
		implicits = append(implicits, rustLibsToPaths(deps.DyLibs)...)
		implicits = append(implicits, rustLibsToPaths(deps.ProcMacros)...)
		implicits = append(implicits, deps.StaticLibs...)
		implicits = append(implicits, deps.SharedLibDeps...)
		implicits = append(implicits, deps.srcProviderFiles...)
		implicits = append(implicits, deps.AfdoProfiles...)
		implicits = append(implicits, deps.srcProviderFiles...)
		implicits = append(implicits, deps.WholeStaticLibs...)

		implicits = append(implicits, deps.CrtBegin...)
		implicits = append(implicits, deps.CrtEnd...)
		linkImplicits = append(linkImplicits, deps.LibDeps...)
		linkImplicits = append(linkImplicits, deps.CrtBegin...)
		linkImplicits = append(linkImplicits, deps.CrtEnd...)

		orderOnly = append(orderOnly, deps.SharedLibs...)
		linkOrderOnly = append(linkOrderOnly, deps.linkObjects...)

		if len(deps.SrcDeps) > 0 {
		moduleGenDir := ctx.RustModule().compiler.CargoOutDir()
		@@ -328,16 +330,16 @@ func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, fl
		}
		}

		envVars = append(envVars, "AR=${cc_config.ClangBin}/llvm-ar")

		if flags.Clippy {
		clippyFile := android.PathForModuleOut(ctx, outputFile.Base()+".clippy")
		ctx.Build(pctx, android.BuildParams{
		Rule: clippyDriver,
		Description: "clippy " + main.Rel(),
		Output: clippyFile,
		ImplicitOutputs: nil,
		Inputs: inputs,
		Implicits: implicits,
		OrderOnly: orderOnly,
		Args: map[string]string{
		"rustcFlags": strings.Join(rustcFlags, " "),
		"libFlags": strings.Join(libFlags, " "),
		@@ -349,23 +351,40 @@ func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, fl
		implicits = append(implicits, clippyFile)
		}

		rustcOutputFile := outputFile
		usesLinker := crateType == "bin" \|\| crateType == "dylib" \|\| crateType == "cdylib" \|\| crateType == "proc-macro"
		if usesLinker {
		rustcOutputFile = android.PathForModuleOut(ctx, outputFile.Base()+".rsp")
		}

		ctx.Build(pctx, android.BuildParams{
		Rule: rustc,
		Description: "rustc " + main.Rel(),
		Output: outputFile,
		ImplicitOutputs: implicitOutputs,
		Output: rustcOutputFile,
		Inputs: inputs,
		Implicits: implicits,
		OrderOnly: orderOnly,
		Args: map[string]string{
		"rustcFlags": strings.Join(rustcFlags, " "),
		"linkFlags": strings.Join(linkFlags, " "),
		"libFlags": strings.Join(libFlags, " "),
		"envVars": strings.Join(envVars, " "),
		},
		})

		if usesLinker {
		ctx.Build(pctx, android.BuildParams{
		Rule: rustLink,
		Description: "rustLink " + main.Rel(),
		Output: outputFile,
		Inputs: android.Paths{rustcOutputFile},
		Implicits: linkImplicits,
		OrderOnly: linkOrderOnly,
		Args: map[string]string{
		"linkFlags": strings.Join(linkFlags, " "),
		"crtBegin": strings.Join(deps.CrtBegin.Strings(), " "),
		"crtEnd": strings.Join(deps.CrtEnd.Strings(), " "),
		"envVars": strings.Join(envVars, " "),
		},
		})
		}

		if flags.EmitXrefs {
		kytheFile := android.PathForModuleOut(ctx, outputFile.Base()+".kzip")
		@@ -375,13 +394,9 @@ func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, fl
		Output: kytheFile,
		Inputs: inputs,
		Implicits: implicits,
		OrderOnly: orderOnly,
		Args: map[string]string{
		"rustcFlags": strings.Join(rustcFlags, " "),
		"linkFlags": strings.Join(linkFlags, " "),
		"libFlags": strings.Join(libFlags, " "),
		"crtBegin": strings.Join(deps.CrtBegin.Strings(), " "),
		"crtEnd": strings.Join(deps.CrtEnd.Strings(), " "),
		"envVars": strings.Join(envVars, " "),
		},
		})

rust/coverage.go

+1 −1

Original line number	Diff line number	Diff line
		@@ -65,7 +65,7 @@ func (cov *coverage) flags(ctx ModuleContext, flags Flags, deps PathDeps) (Flags
		"-C instrument-coverage", "-g")
		flags.LinkFlags = append(flags.LinkFlags,
		profileInstrFlag, "-g", coverage.OutputFile().Path().String(), "-Wl,--wrap,open")
		deps.StaticLibs = append(deps.StaticLibs, coverage.OutputFile().Path())
		deps.LibDeps = append(deps.LibDeps, coverage.OutputFile().Path())

		// no_std modules are missing libprofiler_builtins which provides coverage, so we need to add it as a dependency.
		if rustModule, ok := ctx.Module().(*Module); ok && rustModule.compiler.noStdlibs() {