From 004bd3f526714343209397881c81f857212a6967 Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Mon, 2 Oct 2023 11:39:17 -0700 Subject: [PATCH] Revert "Split Rust crate builds into compile and link phases." This reverts commit e7c71c344d462cac998b37d551bd78baa892082d. The intermediates created by the separated rust compile steps are very large, on the order of 60GB. This is more than CI can support for now, revert the split into compile and link phases. This comes at the expense of incremental build time, especially when modifying C/C++ sources that are dependencies of rust modules. Bug: 293349612 Test: builds Change-Id: I81169e7d0727330c8de5e7688dcdc87fe7b8d3b5 --- apex/apex_test.go | 4 +- rust/binary.go | 7 +-- rust/binary_test.go | 7 +-- rust/builder.go | 119 +++++++++++++++-------------------- rust/builder_test.go | 9 --- rust/compiler.go | 5 +- rust/coverage.go | 2 +- rust/coverage_test.go | 22 +++---- rust/library.go | 3 +- rust/library_test.go | 2 +- rust/rust.go | 59 ++++++++--------- rust/rust_test.go | 13 ++-- rust/sanitize_test.go | 2 +- rust/vendor_snapshot_test.go | 4 +- scripts/mkcratersp.py | 85 ------------------------- 15 files changed, 111 insertions(+), 232 deletions(-) delete mode 100755 scripts/mkcratersp.py diff --git a/apex/apex_test.go b/apex/apex_test.go index 9475f5da3..90aec91c4 100644 --- a/apex/apex_test.go +++ b/apex/apex_test.go @@ -948,7 +948,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("rustLink").Args["linkFlags"] + rustDeps := ctx.ModuleForTests("foo.rust", "android_arm64_armv8-a_apex10000").Rule("rustc").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") @@ -1024,7 +1024,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("rustLink").Args["linkFlags"] + rustDeps := ctx.ModuleForTests("foo.rust", "android_arm64_armv8-a_apex10000").Rule("rustc").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") } diff --git a/rust/binary.go b/rust/binary.go index aee4da699..860dc948a 100644 --- a/rust/binary.go +++ b/rust/binary.go @@ -77,14 +77,11 @@ 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") @@ -149,7 +146,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.Strings()...) + flags.LinkFlags = append(flags.LinkFlags, deps.linkObjects...) if binary.stripper.NeedsStrip(ctx) { strippedOutputFile := outputFile diff --git a/rust/binary_test.go b/rust/binary_test.go index dff94ac95..ef9303768 100644 --- a/rust/binary_test.go +++ b/rust/binary_test.go @@ -150,7 +150,7 @@ func TestBootstrap(t *testing.T) { bootstrap: true, }`) - foo := ctx.ModuleForTests("foo", "android_arm64_armv8-a").Rule("rustLink") + foo := ctx.ModuleForTests("foo", "android_arm64_armv8-a").Rule("rustc") flag := "-Wl,-dynamic-linker,/system/bin/bootstrap/linker64" if !strings.Contains(foo.Args["linkFlags"], flag) { @@ -167,11 +167,10 @@ 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 := fizzOutLink.Args["linkFlags"] + linkFlags := fizzOut.Args["linkFlags"] if !strings.Contains(flags, "-C relocation-model=static") { t.Errorf("static binary missing '-C relocation-model=static' in rustcFlags, found: %#v", flags) } @@ -201,7 +200,7 @@ func TestLinkObjects(t *testing.T) { name: "libfoo", }`) - fizzBuzz := ctx.ModuleForTests("fizz-buzz", "android_arm64_armv8-a").Rule("rustLink") + fizzBuzz := ctx.ModuleForTests("fizz-buzz", "android_arm64_armv8-a").Rule("rustc") linkFlags := fizzBuzz.Args["linkFlags"] if !strings.Contains(linkFlags, "/libfoo.so") { t.Errorf("missing shared dependency 'libfoo.so' in linkFlags: %#v", linkFlags) diff --git a/rust/builder.go b/rust/builder.go index 9614d4f8f..bea8ff717 100644 --- a/rust/builder.go +++ b/rust/builder.go @@ -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=$mkcraterspCmd " + + "-C linker=${config.RustLinker} " + + "-C link-args=\"${crtBegin} ${earlyLinkFlags} ${linkFlags} ${crtEnd}\" " + "--emit link -o $out --emit dep-info=$out.d.raw $in ${libFlags} $rustcFlags" + " && grep \"^$out:\" $out.d.raw > $out.d", - CommandDeps: []string{"$rustcCmd", "$mkcraterspCmd"}, + CommandDeps: []string{"$rustcCmd"}, // 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,12 +42,7 @@ var ( Deps: blueprint.DepsGCC, Depfile: "$out.d", }, - "rustcFlags", "libFlags", "envVars") - rustLink = pctx.AndroidStaticRule("rustLink", - blueprint.RuleParams{ - Command: "${config.RustLinker} -o $out ${crtBegin} ${earlyLinkFlags} @$in ${linkFlags} ${crtEnd}", - }, - "earlyLinkFlags", "linkFlags", "crtBegin", "crtEnd") + "rustcFlags", "earlyLinkFlags", "linkFlags", "libFlags", "crtBegin", "crtEnd", "envVars") _ = pctx.SourcePathVariable("rustdocCmd", "${config.RustBin}/rustdoc") rustdoc = pctx.AndroidStaticRule("rustdoc", @@ -106,13 +101,14 @@ var ( `KYTHE_CANONICALIZE_VNAME_PATHS=prefer-relative ` + `$rustExtractor $envVars ` + `$rustcCmd ` + - `-C linker=true ` + + `-C linker=${config.RustLinker} ` + + `-C link-args="${crtBegin} ${linkFlags} ${crtEnd}" ` + `$in ${libFlags} $rustcFlags`, CommandDeps: []string{"$rustExtractor", "$kytheVnames"}, Rspfile: "${out}.rsp", RspfileContent: "$in", }, - "rustcFlags", "libFlags", "envVars") + "rustcFlags", "linkFlags", "libFlags", "crtBegin", "crtEnd", "envVars") ) type buildOutput struct { @@ -242,12 +238,6 @@ func rustEnvVars(ctx ModuleContext, deps PathDeps) []string { } } - envVars = append(envVars, "AR=${cc_config.ClangBin}/llvm-ar") - - if ctx.Darwin() { - envVars = append(envVars, "ANDROID_RUST_DARWIN=true") - } - return envVars } @@ -255,7 +245,8 @@ func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, fl outputFile android.WritablePath, crateType string) buildOutput { var inputs android.Paths - var implicits, linkImplicits, linkOrderOnly android.Paths + var implicits android.Paths + var orderOnly android.Paths var output buildOutput var rustcFlags, linkFlags []string var earlyLinkFlags string @@ -319,15 +310,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.AfdoProfiles...) + implicits = append(implicits, deps.StaticLibs...) + implicits = append(implicits, deps.SharedLibDeps...) implicits = append(implicits, deps.srcProviderFiles...) - implicits = append(implicits, deps.WholeStaticLibs...) + implicits = append(implicits, deps.AfdoProfiles...) - linkImplicits = append(linkImplicits, deps.LibDeps...) - linkImplicits = append(linkImplicits, deps.CrtBegin...) - linkImplicits = append(linkImplicits, deps.CrtEnd...) + implicits = append(implicits, deps.CrtBegin...) + implicits = append(implicits, deps.CrtEnd...) - linkOrderOnly = append(linkOrderOnly, deps.linkObjects...) + orderOnly = append(orderOnly, deps.SharedLibs...) if len(deps.SrcDeps) > 0 { moduleGenDir := ctx.RustModule().compiler.CargoOutDir() @@ -353,14 +344,29 @@ func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, fl implicits = append(implicits, outputs.Paths()...) } + envVars = append(envVars, "ANDROID_RUST_VERSION="+config.GetRustVersion(ctx)) + + if ctx.RustModule().compiler.CargoEnvCompat() { + if _, ok := ctx.RustModule().compiler.(*binaryDecorator); ok { + envVars = append(envVars, "CARGO_BIN_NAME="+strings.TrimSuffix(outputFile.Base(), outputFile.Ext())) + } + envVars = append(envVars, "CARGO_CRATE_NAME="+ctx.RustModule().CrateName()) + pkgVersion := ctx.RustModule().compiler.CargoPkgVersion() + if pkgVersion != "" { + envVars = append(envVars, "CARGO_PKG_VERSION="+pkgVersion) + } + } + if flags.Clippy { clippyFile := android.PathForModuleOut(ctx, outputFile.Base()+".clippy") ctx.Build(pctx, android.BuildParams{ - Rule: clippyDriver, - Description: "clippy " + main.Rel(), - Output: clippyFile, - Inputs: inputs, - Implicits: implicits, + 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, " "), @@ -372,49 +378,24 @@ func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, fl implicits = append(implicits, clippyFile) } - rustcOutputFile := outputFile - var rustcImplicitOutputs android.WritablePaths - usesLinker := crateType == "bin" || crateType == "dylib" || crateType == "cdylib" || crateType == "proc-macro" - if usesLinker { - rustcOutputFile = android.PathForModuleOut(ctx, outputFile.Base()+".rsp") - rustcImplicitOutputs = android.WritablePaths{ - android.PathForModuleOut(ctx, rustcOutputFile.Base()+".whole.a"), - android.PathForModuleOut(ctx, rustcOutputFile.Base()+".a"), - } - - } - ctx.Build(pctx, android.BuildParams{ - Rule: rustc, - Description: "rustc " + main.Rel(), - Output: rustcOutputFile, - Inputs: inputs, - Implicits: implicits, - ImplicitOutputs: rustcImplicitOutputs, + Rule: rustc, + Description: "rustc " + main.Rel(), + Output: outputFile, + Inputs: inputs, + Implicits: implicits, + OrderOnly: orderOnly, Args: map[string]string{ - "rustcFlags": strings.Join(rustcFlags, " "), - "libFlags": strings.Join(libFlags, " "), - "envVars": strings.Join(envVars, " "), + "rustcFlags": strings.Join(rustcFlags, " "), + "earlyLinkFlags": earlyLinkFlags, + "linkFlags": strings.Join(linkFlags, " "), + "libFlags": strings.Join(libFlags, " "), + "crtBegin": strings.Join(deps.CrtBegin.Strings(), " "), + "crtEnd": strings.Join(deps.CrtEnd.Strings(), " "), + "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{ - "earlyLinkFlags": earlyLinkFlags, - "linkFlags": strings.Join(linkFlags, " "), - "crtBegin": strings.Join(deps.CrtBegin.Strings(), " "), - "crtEnd": strings.Join(deps.CrtEnd.Strings(), " "), - }, - }) - } - if flags.EmitXrefs { kytheFile := android.PathForModuleOut(ctx, outputFile.Base()+".kzip") ctx.Build(pctx, android.BuildParams{ @@ -423,9 +404,13 @@ 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, " "), }, }) diff --git a/rust/builder_test.go b/rust/builder_test.go index 1fd675fb7..639f6d4d4 100644 --- a/rust/builder_test.go +++ b/rust/builder_test.go @@ -76,9 +76,6 @@ func TestCompilationOutputFiles(t *testing.T) { expectedFiles: []string{ "out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_dylib/libfizz_buzz.dylib.so", "out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_dylib/libfizz_buzz.dylib.so.clippy", - "out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_dylib/libfizz_buzz.dylib.so.rsp", - "out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_dylib/libfizz_buzz.dylib.so.rsp.a", - "out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_dylib/libfizz_buzz.dylib.so.rsp.whole.a", "out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_dylib/unstripped/libfizz_buzz.dylib.so", "out/soong/target/product/test_device/system/lib64/libfizz_buzz.dylib.so", "out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_dylib/meta_lic", @@ -112,9 +109,6 @@ func TestCompilationOutputFiles(t *testing.T) { expectedFiles: []string{ "out/soong/.intermediates/fizz_buzz/android_arm64_armv8-a/fizz_buzz", "out/soong/.intermediates/fizz_buzz/android_arm64_armv8-a/fizz_buzz.clippy", - "out/soong/.intermediates/fizz_buzz/android_arm64_armv8-a/fizz_buzz.rsp", - "out/soong/.intermediates/fizz_buzz/android_arm64_armv8-a/fizz_buzz.rsp.a", - "out/soong/.intermediates/fizz_buzz/android_arm64_armv8-a/fizz_buzz.rsp.whole.a", "out/soong/.intermediates/fizz_buzz/android_arm64_armv8-a/unstripped/fizz_buzz", "out/soong/target/product/test_device/system/bin/fizz_buzz", "out/soong/.intermediates/fizz_buzz/android_arm64_armv8-a/meta_lic", @@ -138,9 +132,6 @@ func TestCompilationOutputFiles(t *testing.T) { expectedFiles: []string{ "out/soong/.intermediates/librust_ffi/android_arm64_armv8-a_shared/librust_ffi.so", "out/soong/.intermediates/librust_ffi/android_arm64_armv8-a_shared/librust_ffi.so.clippy", - "out/soong/.intermediates/librust_ffi/android_arm64_armv8-a_shared/librust_ffi.so.rsp", - "out/soong/.intermediates/librust_ffi/android_arm64_armv8-a_shared/librust_ffi.so.rsp.a", - "out/soong/.intermediates/librust_ffi/android_arm64_armv8-a_shared/librust_ffi.so.rsp.whole.a", "out/soong/.intermediates/librust_ffi/android_arm64_armv8-a_shared/unstripped/librust_ffi.so", "out/soong/.intermediates/librust_ffi/android_arm64_armv8-a_shared/unstripped/librust_ffi.so.toc", "out/soong/.intermediates/librust_ffi/android_arm64_armv8-a_shared/meta_lic", diff --git a/rust/compiler.go b/rust/compiler.go index d6c52e8d4..6f61798be 100644 --- a/rust/compiler.go +++ b/rust/compiler.go @@ -328,12 +328,15 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags) Flag } if !ctx.toolchain().Bionic() && ctx.Os() != android.LinuxMusl && !ctx.Windows() { - // Add -ldl, -lpthread, -lm and -lrt to host builds to match the default behavior of device + // Add -lc, -lrt, -ldl, -lpthread, -lm, -lrt and -lgcc_s to host builds to match the default behavior of device // builds. This is irrelevant for the Windows target as these are Posix specific. flags.LinkFlags = append(flags.LinkFlags, + "-lc", + "-lrt", "-ldl", "-lpthread", "-lm", + "-lgcc_s", ) } return flags diff --git a/rust/coverage.go b/rust/coverage.go index 5216d6098..bc6504ddc 100644 --- a/rust/coverage.go +++ b/rust/coverage.go @@ -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.LibDeps = append(deps.LibDeps, coverage.OutputFile().Path()) + deps.StaticLibs = append(deps.StaticLibs, 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() { diff --git a/rust/coverage_test.go b/rust/coverage_test.go index 64077cf00..0f599d745 100644 --- a/rust/coverage_test.go +++ b/rust/coverage_test.go @@ -55,10 +55,6 @@ func TestCoverageFlags(t *testing.T) { libbarNoCov := ctx.ModuleForTests("libbar_nocov", "android_arm64_armv8-a_dylib").Rule("rustc") fizzCov := ctx.ModuleForTests("fizz_cov", "android_arm64_armv8-a_cov").Rule("rustc") buzzNoCov := ctx.ModuleForTests("buzzNoCov", "android_arm64_armv8-a").Rule("rustc") - libfooCovLink := ctx.ModuleForTests("libfoo_cov", "android_arm64_armv8-a_dylib_cov").Rule("rustLink") - libbarNoCovLink := ctx.ModuleForTests("libbar_nocov", "android_arm64_armv8-a_dylib").Rule("rustLink") - fizzCovLink := ctx.ModuleForTests("fizz_cov", "android_arm64_armv8-a_cov").Rule("rustLink") - buzzNoCovLink := ctx.ModuleForTests("buzzNoCov", "android_arm64_armv8-a").Rule("rustLink") rustcCoverageFlags := []string{"-C instrument-coverage", " -g "} for _, flag := range rustcCoverageFlags { @@ -84,17 +80,17 @@ func TestCoverageFlags(t *testing.T) { missingErrorStr := "missing rust linker flag '%s' for '%s' module with coverage enabled; rustcFlags: %#v" containsErrorStr := "contains rust linker flag '%s' for '%s' module with coverage disabled; rustcFlags: %#v" - if !strings.Contains(fizzCovLink.Args["linkFlags"], flag) { - t.Fatalf(missingErrorStr, flag, "fizz_cov", fizzCovLink.Args["linkFlags"]) + if !strings.Contains(fizzCov.Args["linkFlags"], flag) { + t.Fatalf(missingErrorStr, flag, "fizz_cov", fizzCov.Args["linkFlags"]) } - if !strings.Contains(libfooCovLink.Args["linkFlags"], flag) { - t.Fatalf(missingErrorStr, flag, "libfoo_cov dylib", libfooCovLink.Args["linkFlags"]) + if !strings.Contains(libfooCov.Args["linkFlags"], flag) { + t.Fatalf(missingErrorStr, flag, "libfoo_cov dylib", libfooCov.Args["linkFlags"]) } - if strings.Contains(buzzNoCovLink.Args["linkFlags"], flag) { - t.Fatalf(containsErrorStr, flag, "buzzNoCov", buzzNoCovLink.Args["linkFlags"]) + if strings.Contains(buzzNoCov.Args["linkFlags"], flag) { + t.Fatalf(containsErrorStr, flag, "buzzNoCov", buzzNoCov.Args["linkFlags"]) } - if strings.Contains(libbarNoCovLink.Args["linkFlags"], flag) { - t.Fatalf(containsErrorStr, flag, "libbar_cov", libbarNoCovLink.Args["linkFlags"]) + if strings.Contains(libbarNoCov.Args["linkFlags"], flag) { + t.Fatalf(containsErrorStr, flag, "libbar_cov", libbarNoCov.Args["linkFlags"]) } } @@ -107,7 +103,7 @@ func TestCoverageDeps(t *testing.T) { srcs: ["foo.rs"], }`) - fizz := ctx.ModuleForTests("fizz", "android_arm64_armv8-a_cov").Rule("rustLink") + fizz := ctx.ModuleForTests("fizz", "android_arm64_armv8-a_cov").Rule("rustc") if !strings.Contains(fizz.Args["linkFlags"], "libprofile-clang-extras.a") { t.Fatalf("missing expected coverage 'libprofile-clang-extras' dependency in linkFlags: %#v", fizz.Args["linkFlags"]) } diff --git a/rust/library.go b/rust/library.go index f4a2b5441..c59847365 100644 --- a/rust/library.go +++ b/rust/library.go @@ -525,7 +525,7 @@ func (library *libraryDecorator) compile(ctx ModuleContext, flags Flags, deps Pa flags.RustFlags = append(flags.RustFlags, deps.depFlags...) flags.LinkFlags = append(flags.LinkFlags, deps.depLinkFlags...) - flags.LinkFlags = append(flags.LinkFlags, deps.linkObjects.Strings()...) + flags.LinkFlags = append(flags.LinkFlags, deps.linkObjects...) if library.dylib() { // We need prefer-dynamic for now to avoid linking in the static stdlib. See: @@ -548,7 +548,6 @@ func (library *libraryDecorator) compile(ctx ModuleContext, flags Flags, deps Pa if library.rlib() || library.dylib() { library.flagExporter.exportLinkDirs(deps.linkDirs...) library.flagExporter.exportLinkObjects(deps.linkObjects...) - library.flagExporter.exportLibDeps(deps.LibDeps...) } if library.static() || library.shared() { diff --git a/rust/library_test.go b/rust/library_test.go index 30ef333b9..e03074dfe 100644 --- a/rust/library_test.go +++ b/rust/library_test.go @@ -148,7 +148,7 @@ func TestSharedLibrary(t *testing.T) { libfoo := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_shared") - libfooOutput := libfoo.Rule("rustLink") + libfooOutput := libfoo.Rule("rustc") if !strings.Contains(libfooOutput.Args["linkFlags"], "-Wl,-soname=libfoo.so") { t.Errorf("missing expected -Wl,-soname linker flag for libfoo shared lib, linkFlags: %#v", libfooOutput.Args["linkFlags"]) diff --git a/rust/rust.go b/rust/rust.go index 49a7ff353..ba63613a2 100644 --- a/rust/rust.go +++ b/rust/rust.go @@ -447,12 +447,13 @@ type Deps struct { } type PathDeps struct { - DyLibs RustLibraries - RLibs RustLibraries - LibDeps android.Paths - WholeStaticLibs android.Paths - ProcMacros RustLibraries - AfdoProfiles android.Paths + DyLibs RustLibraries + RLibs RustLibraries + SharedLibs android.Paths + SharedLibDeps android.Paths + StaticLibs android.Paths + ProcMacros RustLibraries + AfdoProfiles android.Paths // depFlags and depLinkFlags are rustc and linker (clang) flags. depFlags []string @@ -461,7 +462,7 @@ type PathDeps struct { // linkDirs are link paths passed via -L to rustc. linkObjects are objects passed directly to the linker. // Both of these are exported and propagate to dependencies. linkDirs []string - linkObjects android.Paths + linkObjects []string // Used by bindgen modules which call clang depClangFlags []string @@ -524,7 +525,7 @@ type compiler interface { type exportedFlagsProducer interface { exportLinkDirs(...string) - exportLinkObjects(...android.Path) + exportLinkObjects(...string) } type xref interface { @@ -533,27 +534,21 @@ type xref interface { type flagExporter struct { linkDirs []string - linkObjects android.Paths - libDeps android.Paths + linkObjects []string } func (flagExporter *flagExporter) exportLinkDirs(dirs ...string) { flagExporter.linkDirs = android.FirstUniqueStrings(append(flagExporter.linkDirs, dirs...)) } -func (flagExporter *flagExporter) exportLinkObjects(flags ...android.Path) { - flagExporter.linkObjects = android.FirstUniquePaths(append(flagExporter.linkObjects, flags...)) -} - -func (flagExporter *flagExporter) exportLibDeps(paths ...android.Path) { - flagExporter.libDeps = android.FirstUniquePaths(append(flagExporter.libDeps, paths...)) +func (flagExporter *flagExporter) exportLinkObjects(flags ...string) { + flagExporter.linkObjects = android.FirstUniqueStrings(append(flagExporter.linkObjects, flags...)) } func (flagExporter *flagExporter) setProvider(ctx ModuleContext) { ctx.SetProvider(FlagExporterInfoProvider, FlagExporterInfo{ LinkDirs: flagExporter.linkDirs, LinkObjects: flagExporter.linkObjects, - LibDeps: flagExporter.libDeps, }) } @@ -566,8 +561,7 @@ func NewFlagExporter() *flagExporter { type FlagExporterInfo struct { Flags []string LinkDirs []string // TODO: this should be android.Paths - LinkObjects android.Paths - LibDeps android.Paths + LinkObjects []string // TODO: this should be android.Paths } var FlagExporterInfoProvider = blueprint.NewProvider(FlagExporterInfo{}) @@ -1319,7 +1313,6 @@ func (mod *Module) depsToPaths(ctx android.ModuleContext) PathDeps { depPaths.linkDirs = append(depPaths.linkDirs, exportedInfo.LinkDirs...) depPaths.depFlags = append(depPaths.depFlags, exportedInfo.Flags...) depPaths.linkObjects = append(depPaths.linkObjects, exportedInfo.LinkObjects...) - depPaths.LibDeps = append(depPaths.LibDeps, exportedInfo.LibDeps...) } if depTag == dylibDepTag || depTag == rlibDepTag || depTag == procMacroDepTag { @@ -1375,7 +1368,6 @@ func (mod *Module) depsToPaths(ctx android.ModuleContext) PathDeps { depPaths.depLinkFlags = append(depPaths.depLinkFlags, []string{"-Wl,--whole-archive", linkObject.Path().String(), "-Wl,--no-whole-archive"}...) } else if libName, ok := libNameFromFilePath(linkObject.Path()); ok { depPaths.depFlags = append(depPaths.depFlags, "-lstatic="+libName) - depPaths.WholeStaticLibs = append(depPaths.WholeStaticLibs, linkObject.Path()) } else { ctx.ModuleErrorf("'%q' cannot be listed as a whole_static_library in Rust modules unless the output is prefixed by 'lib'", depName, ctx.ModuleName()) } @@ -1383,7 +1375,7 @@ func (mod *Module) depsToPaths(ctx android.ModuleContext) PathDeps { // Add this to linkObjects to pass the library directly to the linker as well. This propagates // to dependencies to avoid having to redeclare static libraries for dependents of the dylib variant. - depPaths.linkObjects = append(depPaths.linkObjects, linkObject.AsPaths()...) + depPaths.linkObjects = append(depPaths.linkObjects, linkObject.String()) depPaths.linkDirs = append(depPaths.linkDirs, linkPath) exportedInfo := ctx.OtherModuleProvider(dep, cc.FlagExporterInfoProvider).(cc.FlagExporterInfo) @@ -1417,7 +1409,7 @@ func (mod *Module) depsToPaths(ctx android.ModuleContext) PathDeps { linkPath = linkPathFromFilePath(linkObject.Path()) depPaths.linkDirs = append(depPaths.linkDirs, linkPath) - depPaths.linkObjects = append(depPaths.linkObjects, linkObject.AsPaths()...) + depPaths.linkObjects = append(depPaths.linkObjects, linkObject.String()) depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...) depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...) depPaths.depClangFlags = append(depPaths.depClangFlags, exportedInfo.Flags...) @@ -1443,9 +1435,7 @@ func (mod *Module) depsToPaths(ctx android.ModuleContext) PathDeps { // Make sure these dependencies are propagated if lib, ok := mod.compiler.(exportedFlagsProducer); ok && exportDep { lib.exportLinkDirs(linkPath) - if linkObject.Valid() { - lib.exportLinkObjects(linkObject.Path()) - } + lib.exportLinkObjects(linkObject.String()) } } else { switch { @@ -1479,16 +1469,19 @@ func (mod *Module) depsToPaths(ctx android.ModuleContext) PathDeps { procMacroDepFiles = append(procMacroDepFiles, RustLibrary{Path: dep.UnstrippedOutputFile(), CrateName: dep.CrateName()}) } - var libDepFiles android.Paths + var staticLibDepFiles android.Paths for _, dep := range directStaticLibDeps { - libDepFiles = append(libDepFiles, dep.OutputFile().Path()) + staticLibDepFiles = append(staticLibDepFiles, dep.OutputFile().Path()) } + var sharedLibFiles android.Paths + var sharedLibDepFiles android.Paths for _, dep := range directSharedLibDeps { + sharedLibFiles = append(sharedLibFiles, dep.SharedLibrary) if dep.TableOfContents.Valid() { - libDepFiles = append(libDepFiles, dep.TableOfContents.Path()) + sharedLibDepFiles = append(sharedLibDepFiles, dep.TableOfContents.Path()) } else { - libDepFiles = append(libDepFiles, dep.SharedLibrary) + sharedLibDepFiles = append(sharedLibDepFiles, dep.SharedLibrary) } } @@ -1504,13 +1497,15 @@ func (mod *Module) depsToPaths(ctx android.ModuleContext) PathDeps { depPaths.RLibs = append(depPaths.RLibs, rlibDepFiles...) depPaths.DyLibs = append(depPaths.DyLibs, dylibDepFiles...) - depPaths.LibDeps = append(depPaths.LibDeps, libDepFiles...) + depPaths.SharedLibs = append(depPaths.SharedLibs, sharedLibFiles...) + depPaths.SharedLibDeps = append(depPaths.SharedLibDeps, sharedLibDepFiles...) + depPaths.StaticLibs = append(depPaths.StaticLibs, staticLibDepFiles...) depPaths.ProcMacros = append(depPaths.ProcMacros, procMacroDepFiles...) depPaths.SrcDeps = append(depPaths.SrcDeps, srcProviderDepFiles...) // Dedup exported flags from dependencies depPaths.linkDirs = android.FirstUniqueStrings(depPaths.linkDirs) - depPaths.linkObjects = android.FirstUniquePaths(depPaths.linkObjects) + depPaths.linkObjects = android.FirstUniqueStrings(depPaths.linkObjects) depPaths.depFlags = android.FirstUniqueStrings(depPaths.depFlags) depPaths.depClangFlags = android.FirstUniqueStrings(depPaths.depClangFlags) depPaths.depIncludePaths = android.FirstUniquePaths(depPaths.depIncludePaths) diff --git a/rust/rust_test.go b/rust/rust_test.go index 835114c13..566b76b29 100644 --- a/rust/rust_test.go +++ b/rust/rust_test.go @@ -256,7 +256,6 @@ func TestDepsTracking(t *testing.T) { `) module := ctx.ModuleForTests("fizz-buzz", "linux_glibc_x86_64").Module().(*Module) rustc := ctx.ModuleForTests("librlib", "linux_glibc_x86_64_rlib_rlib-std").Rule("rustc") - rustLink := ctx.ModuleForTests("fizz-buzz", "linux_glibc_x86_64").Rule("rustLink") // Since dependencies are added to AndroidMk* properties, we can check these to see if they've been picked up. if !android.InList("librlib.rlib-std", module.Properties.AndroidMkRlibs) { @@ -279,16 +278,16 @@ func TestDepsTracking(t *testing.T) { t.Errorf("-lstatic flag not being passed to rustc for static library %#v", rustc.Args["rustcFlags"]) } - if !strings.Contains(rustLink.Args["linkFlags"], "cc_stubs_dep.so") { - t.Errorf("shared cc_library not being passed to rustc linkFlags %#v", rustLink.Args["linkFlags"]) + if !strings.Contains(rustc.Args["linkFlags"], "cc_stubs_dep.so") { + t.Errorf("shared cc_library not being passed to rustc linkFlags %#v", rustc.Args["linkFlags"]) } - if !android.SuffixInList(rustLink.OrderOnly.Strings(), "cc_stubs_dep.so") { - t.Errorf("shared cc dep not being passed as order-only to rustc %#v", rustLink.OrderOnly.Strings()) + if !android.SuffixInList(rustc.OrderOnly.Strings(), "cc_stubs_dep.so") { + t.Errorf("shared cc dep not being passed as order-only to rustc %#v", rustc.OrderOnly.Strings()) } - if !android.SuffixInList(rustLink.Implicits.Strings(), "cc_stubs_dep.so.toc") { - t.Errorf("shared cc dep TOC not being passed as implicit to rustc %#v", rustLink.Implicits.Strings()) + if !android.SuffixInList(rustc.Implicits.Strings(), "cc_stubs_dep.so.toc") { + t.Errorf("shared cc dep TOC not being passed as implicit to rustc %#v", rustc.Implicits.Strings()) } } diff --git a/rust/sanitize_test.go b/rust/sanitize_test.go index 43e95f477..d6a14b295 100644 --- a/rust/sanitize_test.go +++ b/rust/sanitize_test.go @@ -35,7 +35,7 @@ func checkHasMemtagNote(t *testing.T, m android.TestingModule, expected MemtagNo note_sync := "note_memtag_heap_sync" found := None - implicits := m.Rule("rustLink").Implicits + implicits := m.Rule("rustc").Implicits for _, lib := range implicits { if strings.Contains(lib.Rel(), note_async) { found = Async diff --git a/rust/vendor_snapshot_test.go b/rust/vendor_snapshot_test.go index 1e7e7d322..4f45799e6 100644 --- a/rust/vendor_snapshot_test.go +++ b/rust/vendor_snapshot_test.go @@ -1051,7 +1051,7 @@ func TestVendorSnapshotUse(t *testing.T) { ctx := testRustVndkFsVersions(t, "", mockFS, "30", "current", "31") // libclient uses libvndk.vndk.30.arm64, libvendor.vendor_static.30.arm64, libvendor_without_snapshot - libclientLdFlags := ctx.ModuleForTests("libclient", sharedVariant).Rule("rustLink").Args["linkFlags"] + libclientLdFlags := ctx.ModuleForTests("libclient", sharedVariant).Rule("rustc").Args["linkFlags"] for _, input := range [][]string{ []string{sharedVariant, "libvndk.vndk.30.arm64"}, []string{staticVariant, "libvendor.vendor_static.30.arm64"}, @@ -1119,7 +1119,7 @@ func TestVendorSnapshotUse(t *testing.T) { t.Errorf("Unexpected rust rlib name in AndroidMk: %q, expected: %q\n", rustVendorBinMkDylibName, expectedRustVendorSnapshotName) } - binWithoutSnapshotLdFlags := ctx.ModuleForTests("bin_without_snapshot", binaryVariant).Rule("rustLink").Args["linkFlags"] + binWithoutSnapshotLdFlags := ctx.ModuleForTests("bin_without_snapshot", binaryVariant).Rule("rustc").Args["linkFlags"] libVndkStaticOutputPaths := cc.GetOutputPaths(ctx, staticVariant, []string{"libvndk.vendor_static.30.arm64"}) if !strings.Contains(binWithoutSnapshotLdFlags, libVndkStaticOutputPaths[0].String()) { t.Errorf("libflags for bin_without_snapshot must contain %#v, but was %#v", diff --git a/scripts/mkcratersp.py b/scripts/mkcratersp.py deleted file mode 100755 index 6ef01ebcc..000000000 --- a/scripts/mkcratersp.py +++ /dev/null @@ -1,85 +0,0 @@ -#!/usr/bin/env python3 -# -# Copyright (C) 2023 The Android Open Source Project -# -# 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. -# - -""" -This script is used as a replacement for the Rust linker. It converts a linker -command line into a rspfile that can be used during the link phase. -""" - -import os -import shutil -import subprocess -import sys - -def create_archive(out, objects, archives): - mricmd = f'create {out}\n' - for o in objects: - mricmd += f'addmod {o}\n' - for a in archives: - mricmd += f'addlib {a}\n' - mricmd += 'save\nend\n' - subprocess.run([os.getenv('AR'), '-M'], encoding='utf-8', input=mricmd, check=True) - -objects = [] -archives = [] -linkdirs = [] -libs = [] -temp_archives = [] -version_script = None - -for i, arg in enumerate(sys.argv): - if arg == '-o': - out = sys.argv[i+1] - if arg == '-L': - linkdirs.append(sys.argv[i+1]) - if arg.startswith('-l') or arg == '-shared': - libs.append(arg) - if os.getenv('ANDROID_RUST_DARWIN') and (arg == '-dylib' or arg == '-dynamiclib'): - libs.append(arg) - if arg.startswith('-Wl,--version-script='): - version_script = arg[21:] - if arg[0] == '-': - continue - if arg.endswith('.o') or arg.endswith('.rmeta'): - objects.append(arg) - if arg.endswith('.rlib'): - if arg.startswith(os.getenv('TMPDIR')): - temp_archives.append(arg) - else: - archives.append(arg) - -create_archive(f'{out}.whole.a', objects, []) -create_archive(f'{out}.a', [], temp_archives) - -with open(out, 'w') as f: - if os.getenv("ANDROID_RUST_DARWIN"): - print(f'-force_load', file=f) - print(f'{out}.whole.a', file=f) - else: - print(f'-Wl,--whole-archive', file=f) - print(f'{out}.whole.a', file=f) - print(f'-Wl,--no-whole-archive', file=f) - print(f'{out}.a', file=f) - for a in archives: - print(a, file=f) - for linkdir in linkdirs: - print(f'-L{linkdir}', file=f) - for l in libs: - print(l, file=f) - if version_script: - shutil.copyfile(version_script, f'{out}.version_script') - print(f'-Wl,--version-script={out}.version_script', file=f)