123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459 |
- // Copyright 2019 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.
- package rust
- import (
- "path/filepath"
- "strings"
- "github.com/google/blueprint"
- "android/soong/android"
- "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 " +
- "--emit link -o $out --emit dep-info=$out.d.raw $in ${libFlags} $rustcFlags" +
- " && grep \"^$out:\" $out.d.raw > $out.d",
- 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:
- // "warning: depfile has multiple output paths"
- // For ninja, we keep/grep only the dependency rule for the rust $out file.
- 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")
- _ = pctx.SourcePathVariable("rustdocCmd", "${config.RustBin}/rustdoc")
- rustdoc = pctx.AndroidStaticRule("rustdoc",
- blueprint.RuleParams{
- Command: "$envVars $rustdocCmd $rustdocFlags $in -o $outDir && " +
- "touch $out",
- CommandDeps: []string{"$rustdocCmd"},
- },
- "rustdocFlags", "outDir", "envVars")
- _ = pctx.SourcePathVariable("clippyCmd", "${config.RustBin}/clippy-driver")
- clippyDriver = pctx.AndroidStaticRule("clippy",
- blueprint.RuleParams{
- Command: "$envVars $clippyCmd " +
- // Because clippy-driver uses rustc as backend, we need to have some output even during the linting.
- // 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",
- CommandDeps: []string{"$clippyCmd"},
- Deps: blueprint.DepsGCC,
- Depfile: "$out.d",
- },
- "rustcFlags", "libFlags", "clippyFlags", "envVars")
- zip = pctx.AndroidStaticRule("zip",
- blueprint.RuleParams{
- Command: "cat $out.rsp | tr ' ' '\\n' | tr -d \\' | sort -u > ${out}.tmp && ${SoongZipCmd} -o ${out} -C $$OUT_DIR -l ${out}.tmp",
- CommandDeps: []string{"${SoongZipCmd}"},
- Rspfile: "$out.rsp",
- RspfileContent: "$in",
- })
- cp = pctx.AndroidStaticRule("cp",
- blueprint.RuleParams{
- Command: "cp `cat $outDir.rsp` $outDir",
- Rspfile: "${outDir}.rsp",
- RspfileContent: "$in",
- },
- "outDir")
- // Cross-referencing:
- _ = pctx.SourcePathVariable("rustExtractor",
- "prebuilts/build-tools/${config.HostPrebuiltTag}/bin/rust_extractor")
- _ = pctx.VariableFunc("kytheCorpus",
- func(ctx android.PackageVarContext) string { return ctx.Config().XrefCorpusName() })
- _ = pctx.VariableFunc("kytheCuEncoding",
- func(ctx android.PackageVarContext) string { return ctx.Config().XrefCuEncoding() })
- _ = pctx.SourcePathVariable("kytheVnames", "build/soong/vnames.json")
- kytheExtract = pctx.AndroidStaticRule("kythe",
- blueprint.RuleParams{
- Command: `KYTHE_CORPUS=${kytheCorpus} ` +
- `KYTHE_OUTPUT_FILE=$out ` +
- `KYTHE_VNAMES=$kytheVnames ` +
- `KYTHE_KZIP_ENCODING=${kytheCuEncoding} ` +
- `KYTHE_CANONICALIZE_VNAME_PATHS=prefer-relative ` +
- `$rustExtractor $envVars ` +
- `$rustcCmd ` +
- `-C linker=true ` +
- `$in ${libFlags} $rustcFlags`,
- CommandDeps: []string{"$rustExtractor", "$kytheVnames"},
- Rspfile: "${out}.rsp",
- RspfileContent: "$in",
- },
- "rustcFlags", "libFlags", "envVars")
- )
- type buildOutput struct {
- outputFile android.Path
- kytheFile android.Path
- }
- func init() {
- pctx.HostBinToolVariable("SoongZipCmd", "soong_zip")
- }
- func TransformSrcToBinary(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, "bin")
- }
- func TransformSrctoRlib(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
- outputFile android.WritablePath) buildOutput {
- return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "rlib")
- }
- func TransformSrctoDylib(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, "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")
- }
- 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")
- }
- func TransformSrctoProcMacro(ctx ModuleContext, mainSrc android.Path, deps PathDeps,
- flags Flags, outputFile android.WritablePath) buildOutput {
- return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "proc-macro")
- }
- func rustLibsToPaths(libs RustLibraries) android.Paths {
- var paths android.Paths
- for _, lib := range libs {
- paths = append(paths, lib.Path)
- }
- return paths
- }
- func makeLibFlags(deps PathDeps) []string {
- var libFlags []string
- // Collect library/crate flags
- for _, lib := range deps.RLibs {
- libFlags = append(libFlags, "--extern "+lib.CrateName+"="+lib.Path.String())
- }
- for _, lib := range deps.DyLibs {
- libFlags = append(libFlags, "--extern "+lib.CrateName+"="+lib.Path.String())
- }
- for _, proc_macro := range deps.ProcMacros {
- libFlags = append(libFlags, "--extern "+proc_macro.CrateName+"="+proc_macro.Path.String())
- }
- for _, path := range deps.linkDirs {
- libFlags = append(libFlags, "-L "+path)
- }
- return libFlags
- }
- func rustEnvVars(ctx ModuleContext, deps PathDeps) []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 len(deps.SrcDeps) > 0 {
- moduleGenDir := ctx.RustModule().compiler.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
- if !filepath.IsAbs(moduleGenDir.String()) {
- // If OUT_DIR is not absolute, we use $$PWD to generate an absolute path (os.Getwd() returns '/')
- outDirPrefix = "$$PWD/"
- } else {
- // If OUT_DIR is absolute, then moduleGenDir will be an absolute path, so we don't need to set this to anything.
- outDirPrefix = ""
- }
- envVars = append(envVars, "OUT_DIR="+filepath.Join(outDirPrefix, moduleGenDir.String()))
- } else {
- // TODO(pcc): Change this to "OUT_DIR=" after fixing crates to not rely on this value.
- envVars = append(envVars, "OUT_DIR=out")
- }
- envVars = append(envVars, "ANDROID_RUST_VERSION="+config.GetRustVersion(ctx))
- if ctx.RustModule().compiler.CargoEnvCompat() {
- if bin, ok := ctx.RustModule().compiler.(*binaryDecorator); ok {
- envVars = append(envVars, "CARGO_BIN_NAME="+bin.getStem(ctx))
- }
- envVars = append(envVars, "CARGO_CRATE_NAME="+ctx.RustModule().CrateName())
- envVars = append(envVars, "CARGO_PKG_NAME="+ctx.RustModule().CrateName())
- pkgVersion := ctx.RustModule().compiler.CargoPkgVersion()
- if pkgVersion != "" {
- envVars = append(envVars, "CARGO_PKG_VERSION="+pkgVersion)
- }
- }
- envVars = append(envVars, "AR=${cc_config.ClangBin}/llvm-ar")
- return envVars
- }
- func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, flags Flags,
- outputFile android.WritablePath, crateType string) buildOutput {
- var inputs android.Paths
- var implicits, linkImplicits, linkOrderOnly android.Paths
- var output buildOutput
- var rustcFlags, linkFlags []string
- output.outputFile = outputFile
- crateName := ctx.RustModule().CrateName()
- targetTriple := ctx.toolchain().RustTriple()
- envVars := rustEnvVars(ctx, deps)
- 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)
- }
- if targetTriple != "" {
- rustcFlags = append(rustcFlags, "--target="+targetTriple)
- linkFlags = append(linkFlags, "-target "+targetTriple)
- }
- // Suppress an implicit sysroot
- rustcFlags = append(rustcFlags, "--sysroot=/dev/null")
- // Enable incremental compilation if requested by user
- if ctx.Config().IsEnvTrue("SOONG_RUSTC_INCREMENTAL") {
- incrementalPath := android.PathForOutput(ctx, "rustc").String()
- rustcFlags = append(rustcFlags, "-Cincremental="+incrementalPath)
- }
- // Disallow experimental features
- modulePath := android.PathForModuleSrc(ctx).String()
- if !(android.IsThirdPartyPath(modulePath) || strings.HasPrefix(modulePath, "prebuilts")) {
- rustcFlags = append(rustcFlags, "-Zallow-features=\"\"")
- }
- // Collect linker flags
- 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() {
- dynamicLinker := "-Wl,-dynamic-linker,/system/bin/bootstrap/linker"
- if ctx.toolchain().Is64Bit() {
- dynamicLinker += "64"
- }
- linkFlags = append(linkFlags, dynamicLinker)
- }
- libFlags := makeLibFlags(deps)
- // Collect dependencies
- 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.srcProviderFiles...)
- implicits = append(implicits, deps.WholeStaticLibs...)
- linkImplicits = append(linkImplicits, deps.LibDeps...)
- linkImplicits = append(linkImplicits, deps.CrtBegin...)
- linkImplicits = append(linkImplicits, deps.CrtEnd...)
- linkOrderOnly = append(linkOrderOnly, deps.linkObjects...)
- if len(deps.SrcDeps) > 0 {
- moduleGenDir := ctx.RustModule().compiler.CargoOutDir()
- 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())
- }
- 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()...)
- }
- 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")
- }
- ctx.Build(pctx, android.BuildParams{
- Rule: rustc,
- Description: "rustc " + main.Rel(),
- Output: rustcOutputFile,
- Inputs: inputs,
- Implicits: implicits,
- Args: map[string]string{
- "rustcFlags": strings.Join(rustcFlags, " "),
- "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(), " "),
- },
- })
- }
- 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
- }
- return output
- }
- func Rustdoc(ctx ModuleContext, main android.Path, deps PathDeps,
- flags Flags) android.ModuleOutPath {
- rustdocFlags := append([]string{}, flags.RustdocFlags...)
- rustdocFlags = append(rustdocFlags, "--sysroot=/dev/null")
- // Build an index for all our crates. -Z unstable options is required to use
- // this flag.
- rustdocFlags = append(rustdocFlags, "-Z", "unstable-options", "--enable-index-page")
- targetTriple := ctx.toolchain().RustTriple()
- // Collect rustc flags
- if targetTriple != "" {
- rustdocFlags = append(rustdocFlags, "--target="+targetTriple)
- }
- crateName := ctx.RustModule().CrateName()
- rustdocFlags = append(rustdocFlags, "--crate-name "+crateName)
- rustdocFlags = append(rustdocFlags, makeLibFlags(deps)...)
- docTimestampFile := android.PathForModuleOut(ctx, "rustdoc.timestamp")
- // Silence warnings about renamed lints for third-party crates
- modulePath := android.PathForModuleSrc(ctx).String()
- if android.IsThirdPartyPath(modulePath) {
- rustdocFlags = append(rustdocFlags, " -A warnings")
- }
- // Yes, the same out directory is used simultaneously by all rustdoc builds.
- // This is what cargo does. The docs for individual crates get generated to
- // a subdirectory named for the crate, and rustdoc synchronizes writes to
- // shared pieces like the index and search data itself.
- // https://github.com/rust-lang/rust/blob/master/src/librustdoc/html/render/write_shared.rs#L144-L146
- docDir := android.PathForOutput(ctx, "rustdoc")
- ctx.Build(pctx, android.BuildParams{
- Rule: rustdoc,
- Description: "rustdoc " + main.Rel(),
- Output: docTimestampFile,
- Input: main,
- Implicit: ctx.RustModule().UnstrippedOutputFile(),
- Args: map[string]string{
- "rustdocFlags": strings.Join(rustdocFlags, " "),
- "outDir": docDir.String(),
- "envVars": strings.Join(rustEnvVars(ctx, deps), " "),
- },
- })
- return docTimestampFile
- }
|