builder.go 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459
  1. // Copyright 2019 The Android Open Source Project
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. // http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  14. package rust
  15. import (
  16. "path/filepath"
  17. "strings"
  18. "github.com/google/blueprint"
  19. "android/soong/android"
  20. "android/soong/rust/config"
  21. )
  22. var (
  23. _ = pctx.SourcePathVariable("rustcCmd", "${config.RustBin}/rustc")
  24. _ = pctx.SourcePathVariable("mkcraterspCmd", "build/soong/scripts/mkcratersp.py")
  25. rustc = pctx.AndroidStaticRule("rustc",
  26. blueprint.RuleParams{
  27. Command: "$envVars $rustcCmd " +
  28. "-C linker=$mkcraterspCmd " +
  29. "--emit link -o $out --emit dep-info=$out.d.raw $in ${libFlags} $rustcFlags" +
  30. " && grep \"^$out:\" $out.d.raw > $out.d",
  31. CommandDeps: []string{"$rustcCmd", "$mkcraterspCmd"},
  32. // Rustc deps-info writes out make compatible dep files: https://github.com/rust-lang/rust/issues/7633
  33. // Rustc emits unneeded dependency lines for the .d and input .rs files.
  34. // Those extra lines cause ninja warning:
  35. // "warning: depfile has multiple output paths"
  36. // For ninja, we keep/grep only the dependency rule for the rust $out file.
  37. Deps: blueprint.DepsGCC,
  38. Depfile: "$out.d",
  39. },
  40. "rustcFlags", "libFlags", "envVars")
  41. rustLink = pctx.AndroidStaticRule("rustLink",
  42. blueprint.RuleParams{
  43. Command: "${config.RustLinker} -o $out ${crtBegin} ${config.RustLinkerArgs} @$in ${linkFlags} ${crtEnd}",
  44. },
  45. "linkFlags", "crtBegin", "crtEnd")
  46. _ = pctx.SourcePathVariable("rustdocCmd", "${config.RustBin}/rustdoc")
  47. rustdoc = pctx.AndroidStaticRule("rustdoc",
  48. blueprint.RuleParams{
  49. Command: "$envVars $rustdocCmd $rustdocFlags $in -o $outDir && " +
  50. "touch $out",
  51. CommandDeps: []string{"$rustdocCmd"},
  52. },
  53. "rustdocFlags", "outDir", "envVars")
  54. _ = pctx.SourcePathVariable("clippyCmd", "${config.RustBin}/clippy-driver")
  55. clippyDriver = pctx.AndroidStaticRule("clippy",
  56. blueprint.RuleParams{
  57. Command: "$envVars $clippyCmd " +
  58. // Because clippy-driver uses rustc as backend, we need to have some output even during the linting.
  59. // Use the metadata output as it has the smallest footprint.
  60. "--emit metadata -o $out --emit dep-info=$out.d.raw $in ${libFlags} " +
  61. "$rustcFlags $clippyFlags" +
  62. " && grep \"^$out:\" $out.d.raw > $out.d",
  63. CommandDeps: []string{"$clippyCmd"},
  64. Deps: blueprint.DepsGCC,
  65. Depfile: "$out.d",
  66. },
  67. "rustcFlags", "libFlags", "clippyFlags", "envVars")
  68. zip = pctx.AndroidStaticRule("zip",
  69. blueprint.RuleParams{
  70. Command: "cat $out.rsp | tr ' ' '\\n' | tr -d \\' | sort -u > ${out}.tmp && ${SoongZipCmd} -o ${out} -C $$OUT_DIR -l ${out}.tmp",
  71. CommandDeps: []string{"${SoongZipCmd}"},
  72. Rspfile: "$out.rsp",
  73. RspfileContent: "$in",
  74. })
  75. cp = pctx.AndroidStaticRule("cp",
  76. blueprint.RuleParams{
  77. Command: "cp `cat $outDir.rsp` $outDir",
  78. Rspfile: "${outDir}.rsp",
  79. RspfileContent: "$in",
  80. },
  81. "outDir")
  82. // Cross-referencing:
  83. _ = pctx.SourcePathVariable("rustExtractor",
  84. "prebuilts/build-tools/${config.HostPrebuiltTag}/bin/rust_extractor")
  85. _ = pctx.VariableFunc("kytheCorpus",
  86. func(ctx android.PackageVarContext) string { return ctx.Config().XrefCorpusName() })
  87. _ = pctx.VariableFunc("kytheCuEncoding",
  88. func(ctx android.PackageVarContext) string { return ctx.Config().XrefCuEncoding() })
  89. _ = pctx.SourcePathVariable("kytheVnames", "build/soong/vnames.json")
  90. kytheExtract = pctx.AndroidStaticRule("kythe",
  91. blueprint.RuleParams{
  92. Command: `KYTHE_CORPUS=${kytheCorpus} ` +
  93. `KYTHE_OUTPUT_FILE=$out ` +
  94. `KYTHE_VNAMES=$kytheVnames ` +
  95. `KYTHE_KZIP_ENCODING=${kytheCuEncoding} ` +
  96. `KYTHE_CANONICALIZE_VNAME_PATHS=prefer-relative ` +
  97. `$rustExtractor $envVars ` +
  98. `$rustcCmd ` +
  99. `-C linker=true ` +
  100. `$in ${libFlags} $rustcFlags`,
  101. CommandDeps: []string{"$rustExtractor", "$kytheVnames"},
  102. Rspfile: "${out}.rsp",
  103. RspfileContent: "$in",
  104. },
  105. "rustcFlags", "libFlags", "envVars")
  106. )
  107. type buildOutput struct {
  108. outputFile android.Path
  109. kytheFile android.Path
  110. }
  111. func init() {
  112. pctx.HostBinToolVariable("SoongZipCmd", "soong_zip")
  113. }
  114. func TransformSrcToBinary(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
  115. outputFile android.WritablePath) buildOutput {
  116. flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
  117. return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "bin")
  118. }
  119. func TransformSrctoRlib(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
  120. outputFile android.WritablePath) buildOutput {
  121. return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "rlib")
  122. }
  123. func TransformSrctoDylib(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
  124. outputFile android.WritablePath) buildOutput {
  125. flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
  126. return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "dylib")
  127. }
  128. func TransformSrctoStatic(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
  129. outputFile android.WritablePath) buildOutput {
  130. flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
  131. return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "staticlib")
  132. }
  133. func TransformSrctoShared(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
  134. outputFile android.WritablePath) buildOutput {
  135. flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
  136. return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "cdylib")
  137. }
  138. func TransformSrctoProcMacro(ctx ModuleContext, mainSrc android.Path, deps PathDeps,
  139. flags Flags, outputFile android.WritablePath) buildOutput {
  140. return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "proc-macro")
  141. }
  142. func rustLibsToPaths(libs RustLibraries) android.Paths {
  143. var paths android.Paths
  144. for _, lib := range libs {
  145. paths = append(paths, lib.Path)
  146. }
  147. return paths
  148. }
  149. func makeLibFlags(deps PathDeps) []string {
  150. var libFlags []string
  151. // Collect library/crate flags
  152. for _, lib := range deps.RLibs {
  153. libFlags = append(libFlags, "--extern "+lib.CrateName+"="+lib.Path.String())
  154. }
  155. for _, lib := range deps.DyLibs {
  156. libFlags = append(libFlags, "--extern "+lib.CrateName+"="+lib.Path.String())
  157. }
  158. for _, proc_macro := range deps.ProcMacros {
  159. libFlags = append(libFlags, "--extern "+proc_macro.CrateName+"="+proc_macro.Path.String())
  160. }
  161. for _, path := range deps.linkDirs {
  162. libFlags = append(libFlags, "-L "+path)
  163. }
  164. return libFlags
  165. }
  166. func rustEnvVars(ctx ModuleContext, deps PathDeps) []string {
  167. var envVars []string
  168. // libstd requires a specific environment variable to be set. This is
  169. // not officially documented and may be removed in the future. See
  170. // https://github.com/rust-lang/rust/blob/master/library/std/src/env.rs#L866.
  171. if ctx.RustModule().CrateName() == "std" {
  172. envVars = append(envVars, "STD_ENV_ARCH="+config.StdEnvArch[ctx.RustModule().Arch().ArchType])
  173. }
  174. if len(deps.SrcDeps) > 0 {
  175. moduleGenDir := ctx.RustModule().compiler.CargoOutDir()
  176. // We must calculate an absolute path for OUT_DIR since Rust's include! macro (which normally consumes this)
  177. // assumes that paths are relative to the source file.
  178. var outDirPrefix string
  179. if !filepath.IsAbs(moduleGenDir.String()) {
  180. // If OUT_DIR is not absolute, we use $$PWD to generate an absolute path (os.Getwd() returns '/')
  181. outDirPrefix = "$$PWD/"
  182. } else {
  183. // If OUT_DIR is absolute, then moduleGenDir will be an absolute path, so we don't need to set this to anything.
  184. outDirPrefix = ""
  185. }
  186. envVars = append(envVars, "OUT_DIR="+filepath.Join(outDirPrefix, moduleGenDir.String()))
  187. } else {
  188. // TODO(pcc): Change this to "OUT_DIR=" after fixing crates to not rely on this value.
  189. envVars = append(envVars, "OUT_DIR=out")
  190. }
  191. envVars = append(envVars, "ANDROID_RUST_VERSION="+config.GetRustVersion(ctx))
  192. if ctx.RustModule().compiler.CargoEnvCompat() {
  193. if bin, ok := ctx.RustModule().compiler.(*binaryDecorator); ok {
  194. envVars = append(envVars, "CARGO_BIN_NAME="+bin.getStem(ctx))
  195. }
  196. envVars = append(envVars, "CARGO_CRATE_NAME="+ctx.RustModule().CrateName())
  197. envVars = append(envVars, "CARGO_PKG_NAME="+ctx.RustModule().CrateName())
  198. pkgVersion := ctx.RustModule().compiler.CargoPkgVersion()
  199. if pkgVersion != "" {
  200. envVars = append(envVars, "CARGO_PKG_VERSION="+pkgVersion)
  201. }
  202. }
  203. envVars = append(envVars, "AR=${cc_config.ClangBin}/llvm-ar")
  204. return envVars
  205. }
  206. func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, flags Flags,
  207. outputFile android.WritablePath, crateType string) buildOutput {
  208. var inputs android.Paths
  209. var implicits, linkImplicits, linkOrderOnly android.Paths
  210. var output buildOutput
  211. var rustcFlags, linkFlags []string
  212. output.outputFile = outputFile
  213. crateName := ctx.RustModule().CrateName()
  214. targetTriple := ctx.toolchain().RustTriple()
  215. envVars := rustEnvVars(ctx, deps)
  216. inputs = append(inputs, main)
  217. // Collect rustc flags
  218. rustcFlags = append(rustcFlags, flags.GlobalRustFlags...)
  219. rustcFlags = append(rustcFlags, flags.RustFlags...)
  220. rustcFlags = append(rustcFlags, "--crate-type="+crateType)
  221. if crateName != "" {
  222. rustcFlags = append(rustcFlags, "--crate-name="+crateName)
  223. }
  224. if targetTriple != "" {
  225. rustcFlags = append(rustcFlags, "--target="+targetTriple)
  226. linkFlags = append(linkFlags, "-target "+targetTriple)
  227. }
  228. // Suppress an implicit sysroot
  229. rustcFlags = append(rustcFlags, "--sysroot=/dev/null")
  230. // Enable incremental compilation if requested by user
  231. if ctx.Config().IsEnvTrue("SOONG_RUSTC_INCREMENTAL") {
  232. incrementalPath := android.PathForOutput(ctx, "rustc").String()
  233. rustcFlags = append(rustcFlags, "-Cincremental="+incrementalPath)
  234. }
  235. // Disallow experimental features
  236. modulePath := android.PathForModuleSrc(ctx).String()
  237. if !(android.IsThirdPartyPath(modulePath) || strings.HasPrefix(modulePath, "prebuilts")) {
  238. rustcFlags = append(rustcFlags, "-Zallow-features=\"\"")
  239. }
  240. // Collect linker flags
  241. linkFlags = append(linkFlags, flags.GlobalLinkFlags...)
  242. linkFlags = append(linkFlags, flags.LinkFlags...)
  243. // Check if this module needs to use the bootstrap linker
  244. if ctx.RustModule().Bootstrap() && !ctx.RustModule().InRecovery() && !ctx.RustModule().InRamdisk() && !ctx.RustModule().InVendorRamdisk() {
  245. dynamicLinker := "-Wl,-dynamic-linker,/system/bin/bootstrap/linker"
  246. if ctx.toolchain().Is64Bit() {
  247. dynamicLinker += "64"
  248. }
  249. linkFlags = append(linkFlags, dynamicLinker)
  250. }
  251. libFlags := makeLibFlags(deps)
  252. // Collect dependencies
  253. implicits = append(implicits, rustLibsToPaths(deps.RLibs)...)
  254. implicits = append(implicits, rustLibsToPaths(deps.DyLibs)...)
  255. implicits = append(implicits, rustLibsToPaths(deps.ProcMacros)...)
  256. implicits = append(implicits, deps.AfdoProfiles...)
  257. implicits = append(implicits, deps.srcProviderFiles...)
  258. implicits = append(implicits, deps.WholeStaticLibs...)
  259. linkImplicits = append(linkImplicits, deps.LibDeps...)
  260. linkImplicits = append(linkImplicits, deps.CrtBegin...)
  261. linkImplicits = append(linkImplicits, deps.CrtEnd...)
  262. linkOrderOnly = append(linkOrderOnly, deps.linkObjects...)
  263. if len(deps.SrcDeps) > 0 {
  264. moduleGenDir := ctx.RustModule().compiler.CargoOutDir()
  265. var outputs android.WritablePaths
  266. for _, genSrc := range deps.SrcDeps {
  267. if android.SuffixInList(outputs.Strings(), genSubDir+genSrc.Base()) {
  268. ctx.PropertyErrorf("srcs",
  269. "multiple source providers generate the same filename output: "+genSrc.Base())
  270. }
  271. outputs = append(outputs, android.PathForModuleOut(ctx, genSubDir+genSrc.Base()))
  272. }
  273. ctx.Build(pctx, android.BuildParams{
  274. Rule: cp,
  275. Description: "cp " + moduleGenDir.Path().Rel(),
  276. Outputs: outputs,
  277. Inputs: deps.SrcDeps,
  278. Args: map[string]string{
  279. "outDir": moduleGenDir.String(),
  280. },
  281. })
  282. implicits = append(implicits, outputs.Paths()...)
  283. }
  284. if flags.Clippy {
  285. clippyFile := android.PathForModuleOut(ctx, outputFile.Base()+".clippy")
  286. ctx.Build(pctx, android.BuildParams{
  287. Rule: clippyDriver,
  288. Description: "clippy " + main.Rel(),
  289. Output: clippyFile,
  290. Inputs: inputs,
  291. Implicits: implicits,
  292. Args: map[string]string{
  293. "rustcFlags": strings.Join(rustcFlags, " "),
  294. "libFlags": strings.Join(libFlags, " "),
  295. "clippyFlags": strings.Join(flags.ClippyFlags, " "),
  296. "envVars": strings.Join(envVars, " "),
  297. },
  298. })
  299. // Declare the clippy build as an implicit dependency of the original crate.
  300. implicits = append(implicits, clippyFile)
  301. }
  302. rustcOutputFile := outputFile
  303. usesLinker := crateType == "bin" || crateType == "dylib" || crateType == "cdylib" || crateType == "proc-macro"
  304. if usesLinker {
  305. rustcOutputFile = android.PathForModuleOut(ctx, outputFile.Base()+".rsp")
  306. }
  307. ctx.Build(pctx, android.BuildParams{
  308. Rule: rustc,
  309. Description: "rustc " + main.Rel(),
  310. Output: rustcOutputFile,
  311. Inputs: inputs,
  312. Implicits: implicits,
  313. Args: map[string]string{
  314. "rustcFlags": strings.Join(rustcFlags, " "),
  315. "libFlags": strings.Join(libFlags, " "),
  316. "envVars": strings.Join(envVars, " "),
  317. },
  318. })
  319. if usesLinker {
  320. ctx.Build(pctx, android.BuildParams{
  321. Rule: rustLink,
  322. Description: "rustLink " + main.Rel(),
  323. Output: outputFile,
  324. Inputs: android.Paths{rustcOutputFile},
  325. Implicits: linkImplicits,
  326. OrderOnly: linkOrderOnly,
  327. Args: map[string]string{
  328. "linkFlags": strings.Join(linkFlags, " "),
  329. "crtBegin": strings.Join(deps.CrtBegin.Strings(), " "),
  330. "crtEnd": strings.Join(deps.CrtEnd.Strings(), " "),
  331. },
  332. })
  333. }
  334. if flags.EmitXrefs {
  335. kytheFile := android.PathForModuleOut(ctx, outputFile.Base()+".kzip")
  336. ctx.Build(pctx, android.BuildParams{
  337. Rule: kytheExtract,
  338. Description: "Xref Rust extractor " + main.Rel(),
  339. Output: kytheFile,
  340. Inputs: inputs,
  341. Implicits: implicits,
  342. Args: map[string]string{
  343. "rustcFlags": strings.Join(rustcFlags, " "),
  344. "libFlags": strings.Join(libFlags, " "),
  345. "envVars": strings.Join(envVars, " "),
  346. },
  347. })
  348. output.kytheFile = kytheFile
  349. }
  350. return output
  351. }
  352. func Rustdoc(ctx ModuleContext, main android.Path, deps PathDeps,
  353. flags Flags) android.ModuleOutPath {
  354. rustdocFlags := append([]string{}, flags.RustdocFlags...)
  355. rustdocFlags = append(rustdocFlags, "--sysroot=/dev/null")
  356. // Build an index for all our crates. -Z unstable options is required to use
  357. // this flag.
  358. rustdocFlags = append(rustdocFlags, "-Z", "unstable-options", "--enable-index-page")
  359. targetTriple := ctx.toolchain().RustTriple()
  360. // Collect rustc flags
  361. if targetTriple != "" {
  362. rustdocFlags = append(rustdocFlags, "--target="+targetTriple)
  363. }
  364. crateName := ctx.RustModule().CrateName()
  365. rustdocFlags = append(rustdocFlags, "--crate-name "+crateName)
  366. rustdocFlags = append(rustdocFlags, makeLibFlags(deps)...)
  367. docTimestampFile := android.PathForModuleOut(ctx, "rustdoc.timestamp")
  368. // Silence warnings about renamed lints for third-party crates
  369. modulePath := android.PathForModuleSrc(ctx).String()
  370. if android.IsThirdPartyPath(modulePath) {
  371. rustdocFlags = append(rustdocFlags, " -A warnings")
  372. }
  373. // Yes, the same out directory is used simultaneously by all rustdoc builds.
  374. // This is what cargo does. The docs for individual crates get generated to
  375. // a subdirectory named for the crate, and rustdoc synchronizes writes to
  376. // shared pieces like the index and search data itself.
  377. // https://github.com/rust-lang/rust/blob/master/src/librustdoc/html/render/write_shared.rs#L144-L146
  378. docDir := android.PathForOutput(ctx, "rustdoc")
  379. ctx.Build(pctx, android.BuildParams{
  380. Rule: rustdoc,
  381. Description: "rustdoc " + main.Rel(),
  382. Output: docTimestampFile,
  383. Input: main,
  384. Implicit: ctx.RustModule().UnstrippedOutputFile(),
  385. Args: map[string]string{
  386. "rustdocFlags": strings.Join(rustdocFlags, " "),
  387. "outDir": docDir.String(),
  388. "envVars": strings.Join(rustEnvVars(ctx, deps), " "),
  389. },
  390. })
  391. return docTimestampFile
  392. }