summaryrefslogtreecommitdiff
path: root/rust/builder.go
diff options
context:
space:
mode:
Diffstat (limited to 'rust/builder.go')
-rw-r--r--rust/builder.go396
1 files changed, 252 insertions, 144 deletions
diff --git a/rust/builder.go b/rust/builder.go
index 0aa2225f7..f469f56f8 100644
--- a/rust/builder.go
+++ b/rust/builder.go
@@ -21,19 +21,20 @@ import (
"github.com/google/blueprint"
"android/soong/android"
+ "android/soong/cc"
"android/soong/rust/config"
)
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"},
+ " && grep ^$out: $out.d.raw > $out.d",
+ 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 +43,7 @@ var (
Deps: blueprint.DepsGCC,
Depfile: "$out.d",
},
- "rustcFlags", "libFlags", "envVars")
- rustLink = pctx.AndroidStaticRule("rustLink",
- blueprint.RuleParams{
- Command: "${config.RustLinker} -o $out ${crtBegin} ${config.RustLinkerArgs} @$in ${linkFlags} ${crtEnd}",
- },
- "linkFlags", "crtBegin", "crtEnd")
+ "rustcFlags", "earlyLinkFlags", "linkFlags", "libFlags", "crtBegin", "crtEnd", "envVars")
_ = pctx.SourcePathVariable("rustdocCmd", "${config.RustBin}/rustdoc")
rustdoc = pctx.AndroidStaticRule("rustdoc",
@@ -66,7 +62,7 @@ var (
// Use the metadata output as it has the smallest footprint.
"--emit metadata -o $out --emit dep-info=$out.d.raw $in ${libFlags} " +
"$rustcFlags $clippyFlags" +
- " && grep \"^$out:\" $out.d.raw > $out.d",
+ " && grep ^$out: $out.d.raw > $out.d",
CommandDeps: []string{"$clippyCmd"},
Deps: blueprint.DepsGCC,
Depfile: "$out.d",
@@ -106,13 +102,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 {
@@ -122,42 +119,129 @@ type buildOutput struct {
func init() {
pctx.HostBinToolVariable("SoongZipCmd", "soong_zip")
+ cc.TransformRlibstoStaticlib = TransformRlibstoStaticlib
+}
+
+type transformProperties struct {
+ crateName string
+ targetTriple string
+ is64Bit bool
+ bootstrap bool
+ inRecovery bool
+ inRamdisk bool
+ inVendorRamdisk bool
+ cargoOutDir android.OptionalPath
+ synthetic bool
+ crateType string
+}
+
+// Populates a standard transformProperties struct for Rust modules
+func getTransformProperties(ctx ModuleContext, crateType string) transformProperties {
+ module := ctx.RustModule()
+ return transformProperties{
+ crateName: module.CrateName(),
+ is64Bit: ctx.toolchain().Is64Bit(),
+ targetTriple: ctx.toolchain().RustTriple(),
+ bootstrap: module.Bootstrap(),
+ inRecovery: module.InRecovery(),
+ inRamdisk: module.InRamdisk(),
+ inVendorRamdisk: module.InVendorRamdisk(),
+ cargoOutDir: module.compiler.cargoOutDir(),
+
+ // crateType indicates what type of crate to build
+ crateType: crateType,
+
+ // synthetic indicates whether this is an actual Rust module or not
+ synthetic: false,
+ }
}
func TransformSrcToBinary(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
outputFile android.WritablePath) buildOutput {
- flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
+ if ctx.RustModule().compiler.Thinlto() {
+ flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
+ }
- return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "bin")
+ return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, getTransformProperties(ctx, "bin"))
}
func TransformSrctoRlib(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
outputFile android.WritablePath) buildOutput {
- return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "rlib")
+ return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, getTransformProperties(ctx, "rlib"))
+}
+
+func TransformRlibstoStaticlib(ctx android.ModuleContext, mainSrc android.Path, deps []cc.RustRlibDep,
+ outputFile android.WritablePath) android.Path {
+
+ var rustPathDeps PathDeps
+ var rustFlags Flags
+
+ for _, rlibDep := range deps {
+ rustPathDeps.RLibs = append(rustPathDeps.RLibs, RustLibrary{Path: rlibDep.LibPath, CrateName: rlibDep.CrateName})
+ rustPathDeps.linkDirs = append(rustPathDeps.linkDirs, rlibDep.LinkDirs...)
+ }
+
+ ccModule := ctx.(cc.ModuleContext).Module().(*cc.Module)
+ toolchain := config.FindToolchain(ctx.Os(), ctx.Arch())
+ t := transformProperties{
+ // Crate name can be a predefined value as this is a staticlib and
+ // it does not need to be unique. The crate name is used for name
+ // mangling, but it is mixed with the metadata for that purpose, which we
+ // already set to the module name.
+ crateName: "generated_rust_staticlib",
+ is64Bit: toolchain.Is64Bit(),
+ targetTriple: toolchain.RustTriple(),
+ bootstrap: ccModule.Bootstrap(),
+ inRecovery: ccModule.InRecovery(),
+ inRamdisk: ccModule.InRamdisk(),
+ inVendorRamdisk: ccModule.InVendorRamdisk(),
+
+ // crateType indicates what type of crate to build
+ crateType: "staticlib",
+
+ // synthetic indicates whether this is an actual Rust module or not
+ synthetic: true,
+ }
+
+ rustFlags = CommonDefaultFlags(ctx, toolchain, rustFlags)
+ rustFlags = CommonLibraryCompilerFlags(ctx, rustFlags)
+ rustFlags.GlobalRustFlags = append(rustFlags.GlobalRustFlags, "-C lto=thin")
+
+ rustFlags.EmitXrefs = false
+
+ return transformSrctoCrate(ctx, mainSrc, rustPathDeps, rustFlags, outputFile, t).outputFile
}
func TransformSrctoDylib(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
outputFile android.WritablePath) buildOutput {
- flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
+ if ctx.RustModule().compiler.Thinlto() {
+ flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
+ }
- return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "dylib")
+ return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, getTransformProperties(ctx, "dylib"))
}
func TransformSrctoStatic(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
outputFile android.WritablePath) buildOutput {
- flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
- return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "staticlib")
+ if ctx.RustModule().compiler.Thinlto() {
+ flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
+ }
+
+ return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, getTransformProperties(ctx, "staticlib"))
}
func TransformSrctoShared(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
outputFile android.WritablePath) buildOutput {
- flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
- return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "cdylib")
+ if ctx.RustModule().compiler.Thinlto() {
+ flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
+ }
+
+ return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, getTransformProperties(ctx, "cdylib"))
}
func TransformSrctoProcMacro(ctx ModuleContext, mainSrc android.Path, deps PathDeps,
flags Flags, outputFile android.WritablePath) buildOutput {
- return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "proc-macro")
+ return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, getTransformProperties(ctx, "proc-macro"))
}
func rustLibsToPaths(libs RustLibraries) android.Paths {
@@ -189,18 +273,18 @@ func makeLibFlags(deps PathDeps) []string {
return libFlags
}
-func rustEnvVars(ctx ModuleContext, deps PathDeps) []string {
+func rustEnvVars(ctx android.ModuleContext, deps PathDeps, crateName string, cargoOutDir android.OptionalPath) []string {
var envVars []string
// libstd requires a specific environment variable to be set. This is
// not officially documented and may be removed in the future. See
// https://github.com/rust-lang/rust/blob/master/library/std/src/env.rs#L866.
- if ctx.RustModule().CrateName() == "std" {
- envVars = append(envVars, "STD_ENV_ARCH="+config.StdEnvArch[ctx.RustModule().Arch().ArchType])
+ if crateName == "std" {
+ envVars = append(envVars, "STD_ENV_ARCH="+config.StdEnvArch[ctx.Arch().ArchType])
}
- if len(deps.SrcDeps) > 0 {
- moduleGenDir := ctx.RustModule().compiler.CargoOutDir()
+ if len(deps.SrcDeps) > 0 && cargoOutDir.Valid() {
+ moduleGenDir := cargoOutDir
// We must calculate an absolute path for OUT_DIR since Rust's include! macro (which normally consumes this)
// assumes that paths are relative to the source file.
var outDirPrefix string
@@ -217,35 +301,66 @@ func rustEnvVars(ctx ModuleContext, deps PathDeps) []string {
envVars = append(envVars, "OUT_DIR=out")
}
+ envVars = append(envVars, "ANDROID_RUST_VERSION="+config.GetRustVersion(ctx))
+
+ if rustMod, ok := ctx.Module().(*Module); ok && rustMod.compiler.cargoEnvCompat() {
+ // We only emulate cargo environment variables for 3p code, which is only ever built
+ // by defining a Rust module, so we only need to set these for true Rust modules.
+ if bin, ok := rustMod.compiler.(*binaryDecorator); ok {
+ envVars = append(envVars, "CARGO_BIN_NAME="+bin.getStem(ctx))
+ }
+ envVars = append(envVars, "CARGO_CRATE_NAME="+crateName)
+ envVars = append(envVars, "CARGO_PKG_NAME="+crateName)
+ pkgVersion := rustMod.compiler.cargoPkgVersion()
+ if pkgVersion != "" {
+ envVars = append(envVars, "CARGO_PKG_VERSION="+pkgVersion)
+
+ // Ensure the version is in the form of "x.y.z" (approximately semver compliant).
+ //
+ // For our purposes, we don't care to enforce that these are integers since they may
+ // include other characters at times (e.g. sometimes the patch version is more than an integer).
+ if strings.Count(pkgVersion, ".") == 2 {
+ var semver_parts = strings.Split(pkgVersion, ".")
+ envVars = append(envVars, "CARGO_PKG_VERSION_MAJOR="+semver_parts[0])
+ envVars = append(envVars, "CARGO_PKG_VERSION_MINOR="+semver_parts[1])
+ envVars = append(envVars, "CARGO_PKG_VERSION_PATCH="+semver_parts[2])
+ }
+ }
+ }
+
+ if ctx.Darwin() {
+ envVars = append(envVars, "ANDROID_RUST_DARWIN=true")
+ }
+
return envVars
}
-func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, flags Flags,
- outputFile android.WritablePath, crateType string) buildOutput {
+func transformSrctoCrate(ctx android.ModuleContext, main android.Path, deps PathDeps, flags Flags,
+ outputFile android.WritablePath, t transformProperties) 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
output.outputFile = outputFile
- crateName := ctx.RustModule().CrateName()
- targetTriple := ctx.toolchain().RustTriple()
- envVars := rustEnvVars(ctx, deps)
+ envVars := rustEnvVars(ctx, deps, t.crateName, t.cargoOutDir)
inputs = append(inputs, main)
// Collect rustc flags
rustcFlags = append(rustcFlags, flags.GlobalRustFlags...)
rustcFlags = append(rustcFlags, flags.RustFlags...)
- rustcFlags = append(rustcFlags, "--crate-type="+crateType)
- if crateName != "" {
- rustcFlags = append(rustcFlags, "--crate-name="+crateName)
+ rustcFlags = append(rustcFlags, "--crate-type="+t.crateType)
+ if t.crateName != "" {
+ rustcFlags = append(rustcFlags, "--crate-name="+t.crateName)
}
- if targetTriple != "" {
- rustcFlags = append(rustcFlags, "--target="+targetTriple)
- linkFlags = append(linkFlags, "-target "+targetTriple)
+ if t.targetTriple != "" {
+ rustcFlags = append(rustcFlags, "--target="+t.targetTriple)
+ linkFlags = append(linkFlags, "-target "+t.targetTriple)
}
// Suppress an implicit sysroot
@@ -255,23 +370,29 @@ func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, fl
if ctx.Config().IsEnvTrue("SOONG_RUSTC_INCREMENTAL") {
incrementalPath := android.PathForOutput(ctx, "rustc").String()
- rustcFlags = append(rustcFlags, "-Cincremental="+incrementalPath)
+ rustcFlags = append(rustcFlags, "-C incremental="+incrementalPath)
+ } else {
+ rustcFlags = append(rustcFlags, "-C codegen-units=1")
}
// Disallow experimental features
- modulePath := android.PathForModuleSrc(ctx).String()
+ modulePath := ctx.ModuleDir()
if !(android.IsThirdPartyPath(modulePath) || strings.HasPrefix(modulePath, "prebuilts")) {
- rustcFlags = append(rustcFlags, "-Zallow-features=\"custom_inner_attributes,mixed_integer_ops\"")
+ rustcFlags = append(rustcFlags, "-Zallow-features=\"\"")
}
// Collect linker flags
+ if !ctx.Darwin() {
+ earlyLinkFlags = "-Wl,--as-needed"
+ }
+
linkFlags = append(linkFlags, flags.GlobalLinkFlags...)
linkFlags = append(linkFlags, flags.LinkFlags...)
// Check if this module needs to use the bootstrap linker
- if ctx.RustModule().Bootstrap() && !ctx.RustModule().InRecovery() && !ctx.RustModule().InRamdisk() && !ctx.RustModule().InVendorRamdisk() {
+ if t.bootstrap && !t.inRecovery && !t.inRamdisk && !t.inVendorRamdisk {
dynamicLinker := "-Wl,-dynamic-linker,/system/bin/bootstrap/linker"
- if ctx.toolchain().Is64Bit() {
+ if t.is64Bit {
dynamicLinker += "64"
}
linkFlags = append(linkFlags, dynamicLinker)
@@ -283,124 +404,108 @@ 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()
- var outputs android.WritablePaths
+ if !t.synthetic {
+ // Only worry about OUT_DIR for actual Rust modules.
+ // Libraries built from cc use generated source, and do not utilize OUT_DIR.
+ if len(deps.SrcDeps) > 0 {
+ var outputs android.WritablePaths
- for _, genSrc := range deps.SrcDeps {
- if android.SuffixInList(outputs.Strings(), genSubDir+genSrc.Base()) {
- ctx.PropertyErrorf("srcs",
- "multiple source providers generate the same filename output: "+genSrc.Base())
+ for _, genSrc := range deps.SrcDeps {
+ if android.SuffixInList(outputs.Strings(), genSubDir+genSrc.Base()) {
+ ctx.PropertyErrorf("srcs",
+ "multiple source providers generate the same filename output: "+genSrc.Base())
+ }
+ outputs = append(outputs, android.PathForModuleOut(ctx, genSubDir+genSrc.Base()))
}
- outputs = append(outputs, android.PathForModuleOut(ctx, genSubDir+genSrc.Base()))
- }
-
- ctx.Build(pctx, android.BuildParams{
- Rule: cp,
- Description: "cp " + moduleGenDir.Path().Rel(),
- Outputs: outputs,
- Inputs: deps.SrcDeps,
- Args: map[string]string{
- "outDir": moduleGenDir.String(),
- },
- })
- 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)
+ ctx.Build(pctx, android.BuildParams{
+ Rule: cp,
+ Description: "cp " + t.cargoOutDir.Path().Rel(),
+ Outputs: outputs,
+ Inputs: deps.SrcDeps,
+ Args: map[string]string{
+ "outDir": t.cargoOutDir.String(),
+ },
+ })
+ implicits = append(implicits, outputs.Paths()...)
}
}
- 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,
- Inputs: inputs,
- Implicits: implicits,
- Args: map[string]string{
- "rustcFlags": strings.Join(rustcFlags, " "),
- "libFlags": strings.Join(libFlags, " "),
- "clippyFlags": strings.Join(flags.ClippyFlags, " "),
- "envVars": strings.Join(envVars, " "),
- },
- })
- // Declare the clippy build as an implicit dependency of the original crate.
- 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")
+ if !t.synthetic {
+ // Only worry about clippy for actual Rust modules.
+ // Libraries built from cc use generated source, and don't need to run clippy.
+ 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, " "),
+ "clippyFlags": strings.Join(flags.ClippyFlags, " "),
+ "envVars": strings.Join(envVars, " "),
+ },
+ })
+ // Declare the clippy build as an implicit dependency of the original crate.
+ implicits = append(implicits, clippyFile)
+ }
}
ctx.Build(pctx, android.BuildParams{
Rule: rustc,
Description: "rustc " + main.Rel(),
- Output: rustcOutputFile,
+ 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{
- "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{
- Rule: kytheExtract,
- Description: "Xref Rust extractor " + main.Rel(),
- Output: kytheFile,
- Inputs: inputs,
- Implicits: implicits,
- Args: map[string]string{
- "rustcFlags": strings.Join(rustcFlags, " "),
- "libFlags": strings.Join(libFlags, " "),
- "envVars": strings.Join(envVars, " "),
- },
- })
- output.kytheFile = kytheFile
+ if !t.synthetic {
+ // Only emit xrefs for true Rust modules.
+ if flags.EmitXrefs {
+ kytheFile := android.PathForModuleOut(ctx, outputFile.Base()+".kzip")
+ ctx.Build(pctx, android.BuildParams{
+ Rule: kytheExtract,
+ Description: "Xref Rust extractor " + main.Rel(),
+ 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, " "),
+ },
+ })
+ output.kytheFile = kytheFile
+ }
}
return output
}
@@ -415,6 +520,9 @@ func Rustdoc(ctx ModuleContext, main android.Path, deps PathDeps,
// this flag.
rustdocFlags = append(rustdocFlags, "-Z", "unstable-options", "--enable-index-page")
+ // Ensure we use any special-case code-paths for Soong.
+ rustdocFlags = append(rustdocFlags, "--cfg", "soong")
+
targetTriple := ctx.toolchain().RustTriple()
// Collect rustc flags
@@ -429,7 +537,7 @@ func Rustdoc(ctx ModuleContext, main android.Path, deps PathDeps,
docTimestampFile := android.PathForModuleOut(ctx, "rustdoc.timestamp")
// Silence warnings about renamed lints for third-party crates
- modulePath := android.PathForModuleSrc(ctx).String()
+ modulePath := ctx.ModuleDir()
if android.IsThirdPartyPath(modulePath) {
rustdocFlags = append(rustdocFlags, " -A warnings")
}
@@ -450,7 +558,7 @@ func Rustdoc(ctx ModuleContext, main android.Path, deps PathDeps,
Args: map[string]string{
"rustdocFlags": strings.Join(rustdocFlags, " "),
"outDir": docDir.String(),
- "envVars": strings.Join(rustEnvVars(ctx, deps), " "),
+ "envVars": strings.Join(rustEnvVars(ctx, deps, crateName, ctx.RustModule().compiler.cargoOutDir()), " "),
},
})
generated by cgit v1.2.3-59-g8ed1b (git 2.39.0) at 2025-10-26 05:11:57 +0000